feat: add explorer flag and build folder

crates/katana/cli/Cargo.toml

@@ -28,6 +28,7 @@ tracing.workspace = true
 tracing-log.workspace = true
 tracing-subscriber.workspace = true
 url.workspace = true
+tiny_http = "0.12"
 
 [dev-dependencies]
 assert_matches.workspace = true

crates/katana/cli/src/args.rs

@@ -28,11 +28,13 @@ use tracing::{info, Subscriber};
 use tracing_log::LogTracer;
 use tracing_subscriber::{fmt, EnvFilter};
 use url::Url;
+use katana_rpc::cors::HeaderValue;
 
 use crate::file::NodeArgsConfig;
 use crate::options::*;
 use crate::utils;
 use crate::utils::{parse_seed, LogFormat};
+use crate::explorer::ExplorerServer;
 
 pub(crate) const LOG_TARGET: &str = "katana::cli";
 
@@ -110,11 +112,17 @@ pub struct NodeArgs {
     #[cfg(feature = "slot")]
     #[command(flatten)]
     pub slot: SlotOptions,
+
+    #[command(flatten)]
+    pub explorer: ExplorerOptions,
 }
 
 impl NodeArgs {
     pub async fn execute(&self) -> Result<()> {
+        // Initialize logging first
         self.init_logging()?;
+
+        // Finally start the node
         self.start_node().await
     }
 
@@ -130,6 +138,29 @@ impl NodeArgs {
         // Launch the node
         let handle = node.launch().await.context("failed to launch node")?;
 
+        // Then start the explorer if enabled
+        if self.explorer.explorer {
+            let build_dir = self.explorer.explorer_build_dir
+                .clone()
+                .unwrap_or_else(|| {
+                    PathBuf::from("crates/katana")
+                        .join("explorer")
+                        .join("build")
+                });
+
+            if !build_dir.exists() {
+                anyhow::bail!("Explorer build directory not found at {:?}. Please build the explorer first or specify a different path with --explorer-build-dir", build_dir);
+            }
+
+            let explorer = ExplorerServer::new(
+                self.explorer.explorer_port,
+                build_dir,
+            )?;
+
+            explorer.start()?;
+        }
+
+
         // Wait until an OS signal (ie SIGINT, SIGTERM) is received or the node is shutdown.
         tokio::select! {
             _ = dojo_utils::signal::wait_signals() => {
@@ -216,12 +247,22 @@ impl NodeArgs {
                 modules
             };
 
+            let mut cors_origins = self.server.http_cors_origins.clone();
+
+            // Add explorer URL to CORS origins if explorer is enabled
+            if self.explorer.explorer {
+                cors_origins.push(
+                    HeaderValue::from_str(&format!("http://127.0.0.1:{}", self.explorer.explorer_port))
+                        .context("Failed to create CORS header")?
+                );
+            }
+
             Ok(RpcConfig {
                 apis: modules,
                 port: self.server.http_port,
                 addr: self.server.http_addr,
                 max_connections: self.server.max_connections,
-                cors_origins: self.server.http_cors_origins.clone(),
+                cors_origins: cors_origins,
                 max_event_page_size: Some(self.server.max_event_page_size),
                 max_proof_keys: Some(self.server.max_proof_keys),
             })

crates/katana/cli/src/explorer.rs

@@ -0,0 +1,96 @@
+// crates/katana/cli/src/explorer.rs
+use std::path::PathBuf;
+use anyhow::{Result};
+use tiny_http::{Server, Response};
+use std::thread;
+use tracing::info;
+
+pub struct ExplorerServer {
+    port: u16,
+    build_dir: PathBuf,
+}
+
+impl ExplorerServer {
+    pub fn new(port: u16, build_dir: PathBuf) -> Result<Self> {
+        Ok(Self {
+            port,
+            build_dir,
+        })
+    }
+
+    pub fn start(&self) -> Result<()> {
+        // Create the server
+        let addr = format!("127.0.0.1:{}", self.port);
+        let server = Server::http(&addr)
+            .map_err(|e| anyhow::anyhow!("Failed to start explorer server: {}", e))?;
+
+        // Handle requests in a separate thread
+        let build_dir = self.build_dir.clone();
+        thread::spawn(move || {
+            info!(
+                target: "katana",
+                "Explorer server started. addr=http://{}", 
+                addr,
+            );
+
+            for request in server.incoming_requests() {
+                let path = request.url().to_string();
+                info!(
+                    target: "katana::explorer",
+                    "Received request for: {}", 
+                    path
+                );
+
+                let file_path = if path == "/" {
+                    build_dir.join("index.html")
+                } else {
+                    build_dir.join(&path[1..])
+                };
+
+                if let Ok(content) = std::fs::read(&file_path) {
+                    let content_type = match file_path.extension().and_then(|s| s.to_str()) {
+                        Some("html") => "text/html",
+                        Some("js") => "application/javascript",
+                        Some("css") => "text/css",
+                        Some("png") => "image/png",
+                        Some("svg") => "image/svg+xml",
+                        Some("json") => "application/json",
+                        _ => "application/octet-stream",
+                    };
+
+                    let response = Response::from_data(content)
+                        .with_header(tiny_http::Header {
+                            field: "Content-Type".parse().unwrap(),
+                            value: content_type.parse().unwrap(),
+                        })
+                        .with_header(tiny_http::Header {
+                            field: "Access-Control-Allow-Origin".parse().unwrap(),
+                            value: "*".parse().unwrap(),
+                        })
+                        .with_header(tiny_http::Header {
+                            field: "Access-Control-Allow-Methods".parse().unwrap(),
+                            value: "GET, POST, OPTIONS".parse().unwrap(),
+                        })
+                        .with_header(tiny_http::Header {
+                            field: "Access-Control-Allow-Headers".parse().unwrap(),
+                            value: "Content-Type".parse().unwrap(),
+                        });
+
+                    let _ = request.respond(response);
+                } else {
+                    // If file not found, serve index.html for SPA routing
+                    if let Ok(content) = std::fs::read(build_dir.join("index.html")) {
+                        let response = Response::from_data(content)
+                            .with_header(tiny_http::Header {
+                                field: "Content-Type".parse().unwrap(),
+                                value: "text/html".parse().unwrap(),
+                            });
+                        let _ = request.respond(response);
+                    }
+                }
+            }
+        });
+
+        Ok(())
+    }
+}

crates/katana/cli/src/lib.rs

@@ -4,6 +4,7 @@ pub mod args;
 pub mod file;
 pub mod options;
 pub mod utils;
+pub mod explorer;
 
 pub use args::NodeArgs;
 pub use options::*;

crates/katana/cli/src/options.rs

@@ -32,6 +32,7 @@ use url::Url;
 #[cfg(feature = "server")]
 use crate::utils::{deserialize_cors_origins, serialize_cors_origins};
 use crate::utils::{parse_block_hash_or_number, parse_genesis, LogFormat};
+use std::path::PathBuf;
 
 const DEFAULT_DEV_SEED: &str = "0";
 const DEFAULT_DEV_ACCOUNTS: u16 = 10;
@@ -357,6 +358,23 @@ pub struct SlotOptions {
     pub controller: bool,
 }
 
+#[derive(Debug, Args, Clone, Default,Serialize, Deserialize)]
+#[command(next_help_heading = "Explorer options")]
+pub struct ExplorerOptions {
+    /// Enable and launch the explorer frontend
+    #[arg(long)]
+    #[serde(default)]
+    pub explorer: bool,
+
+    /// The port to run the explorer frontend on
+    #[arg(long = "explorer-port", default_value_t = 3001)]
+    pub explorer_port: u16,
+
+    /// Path to the explorer's build directory
+    #[arg(long = "explorer-build-dir")]
+    pub explorer_build_dir: Option<PathBuf>,
+}
+
 // ** Default functions to setup serde of the configuration file **
 fn default_seed() -> String {
     DEFAULT_DEV_SEED.to_string()