Merge pull request #24 from 100monkeys-ai/feat-dev-server-hmr-17194680974801638956

Initialize dev server with HMR and file watching

Author: Theaxiom

Cargo.lock

@@ -1,7 +1,9 @@
 //! `forge dev` — Start the development server and Forge Studio.
 
 use anyhow::Result;
+use camino::Utf8PathBuf;
 use clap::Args;
+use forge_runtime::dev::dev_server::{start_dev_server, DevServerConfig};
 
 #[derive(Debug, Args)]
 pub struct DevArgs {
@@ -16,6 +18,14 @@ pub struct DevArgs {
 pub async fn run(args: DevArgs) -> Result<()> {
     crate::output::info(&format!("Starting dev server on :{}", args.port));
     crate::output::info(&format!("Forge Studio on :{}", args.studio_port));
-    forge_runtime::dev::dev_server::start_dev_server(args.port, args.studio_port).await?;
+
+    let config = DevServerConfig {
+        port: args.port,
+        studio_port: args.studio_port,
+        project_root: Utf8PathBuf::from("."),
+    };
+
+    start_dev_server(config).await?;
+
     Ok(())
 }

cli/src/commands/dev.rs

@@ -27,3 +27,4 @@ futures = { workspace = true }
 notify = { workspace = true }
 uuid = { workspace = true }
 deno_core = { workspace = true }
+tokio-stream = { version = "0.1.18", features = ["sync"] }

runtime/Cargo.toml

@@ -3,10 +3,114 @@
 //! Starts the dev server with HMR and Forge Studio.
 //! Listens on port 3000 (app) and port 3001 (Studio) by default.
 
+use crate::dev::hot_reload::{hmr_router, HmrMessage, HmrState};
 use crate::error::RuntimeError;
+use axum::Router;
+use camino::Utf8PathBuf;
+use notify::{Config, RecommendedWatcher, RecursiveMode, Watcher};
+use tokio::net::TcpListener;
+use tokio::sync::mpsc;
+use tracing::{error, info};
+
+/// Configuration for the development server.
+#[derive(Debug, Clone)]
+pub struct DevServerConfig {
+    /// Port for the dev server (default: 3000)
+    pub port: u16,
+    /// Port for Forge Studio (default: 3001)
+    pub studio_port: u16,
+    /// The project root directory
+    pub project_root: Utf8PathBuf,
+}
+
+impl Default for DevServerConfig {
+    fn default() -> Self {
+        Self {
+            port: 3000,
+            studio_port: 3001,
+            project_root: Utf8PathBuf::from("."),
+        }
+    }
+}
 
 /// Start the development server.
-pub async fn start_dev_server(_port: u16, _studio_port: u16) -> Result<(), RuntimeError> {
-    // TODO: Initialize file watcher, incremental compiler, HMR, and Studio
+pub async fn start_dev_server(config: DevServerConfig) -> Result<(), RuntimeError> {
+    let hmr_state = HmrState::new();
+
+    // 1. Setup file watcher
+    let (tx, mut rx) = mpsc::channel(100);
+
+    let mut watcher = RecommendedWatcher::new(
+        move |res| {
+            let _ = tx.blocking_send(res);
+        },
+        Config::default(),
+    )
+    .map_err(|e| RuntimeError::Internal(format!("Failed to initialize watcher: {}", e)))?;
+
+    // Watch the src directory
+    let src_dir = config.project_root.join("src");
+    if src_dir.exists() {
+        watcher
+            .watch(src_dir.as_std_path(), RecursiveMode::Recursive)
+            .map_err(|e| RuntimeError::Internal(format!("Failed to watch src directory: {}", e)))?;
+        info!("Watching {} for changes", src_dir);
+    } else {
+        error!("src directory not found in {}", config.project_root);
+    }
+
+    // Spawn a background task to process file watcher events and trigger HMR
+    let hmr_state_clone = hmr_state.clone();
+    tokio::spawn(async move {
+        while let Some(res) = rx.recv().await {
+            match res {
+                Ok(event) => {
+                    // For now, we broadcast a reload on any change.
+                    // Later, this will trigger the incremental compiler and only push updates for changed modules.
+                    if event.kind.is_modify() || event.kind.is_create() || event.kind.is_remove() {
+                        info!("File changed, triggering HMR reload");
+                        hmr_state_clone.broadcast(HmrMessage::Reload);
+                    }
+                }
+                Err(e) => error!("Watch error: {:?}", e),
+            }
+        }
+        // Keep watcher alive by moving it into this task
+        let _watcher = watcher;
+    });
+
+    // 2. Main App Server (incorporates HMR router)
+    // TODO: Combine with the actual app router
+    let app = hmr_router(hmr_state.clone());
+    let addr = format!("0.0.0.0:{}", config.port);
+    let listener = TcpListener::bind(&addr).await.map_err(RuntimeError::Io)?;
+
+    // 3. Studio Server
+    let studio_app = Router::new().route(
+        "/",
+        axum::routing::get(|| async { "Forge Studio (Coming soon)" }),
+    );
+    let studio_addr = format!("0.0.0.0:{}", config.studio_port);
+    let studio_listener = TcpListener::bind(&studio_addr)
+        .await
+        .map_err(RuntimeError::Io)?;
+
+    info!("Dev server listening on {}", addr);
+    info!("Forge Studio listening on {}", studio_addr);
+
+    // Run both servers concurrently
+    tokio::try_join!(
+        async {
+            axum::serve(listener, app)
+                .await
+                .map_err(|e| RuntimeError::Http(e.to_string()))
+        },
+        async {
+            axum::serve(studio_listener, studio_app)
+                .await
+                .map_err(|e| RuntimeError::Http(e.to_string()))
+        }
+    )?;
+
     Ok(())
 }

runtime/src/dev/dev_server.rs

@@ -5,3 +5,83 @@
 //! 2. Pushes the new module source to connected browsers via a SSE stream
 //! 3. The browser's HMR runtime replaces the module in-place if possible,
 //!    or triggers a full reload if the module graph changed structurally
+
+use axum::{
+    extract::State,
+    response::sse::{Event, Sse},
+    routing::get,
+    Router,
+};
+use futures::stream::Stream;
+use std::convert::Infallible;
+use tokio::sync::broadcast;
+use tokio_stream::wrappers::BroadcastStream;
+use tokio_stream::StreamExt;
+
+/// Message sent over the HMR broadcast channel.
+#[derive(Debug, Clone, serde::Serialize)]
+#[serde(tag = "type", content = "payload")]
+pub enum HmrMessage {
+    /// A module was updated and should be re-evaluated.
+    Update {
+        /// The path of the module that was updated.
+        path: String,
+        /// The new module source code.
+        code: String,
+    },
+    /// The application needs a full reload (e.g. structural change).
+    Reload,
+}
+
+/// State shared across HMR SSE connections.
+#[derive(Clone)]
+pub struct HmrState {
+    /// Broadcast channel for pushing updates to connected clients.
+    pub tx: broadcast::Sender<HmrMessage>,
+}
+
+impl Default for HmrState {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl HmrState {
+    /// Create a new HmrState.
+    pub fn new() -> Self {
+        let (tx, _) = broadcast::channel(100);
+        Self { tx }
+    }
+
+    /// Broadcast an update to all connected clients.
+    pub fn broadcast(&self, message: HmrMessage) {
+        // Ignore send errors (happens when no clients are connected)
+        let _ = self.tx.send(message);
+    }
+}
+
+/// Create the axum router for the HMR endpoint.
+pub fn hmr_router(state: HmrState) -> Router {
+    Router::new()
+        .route("/_forge/hmr", get(hmr_endpoint))
+        .with_state(state)
+}
+
+/// SSE endpoint handler for HMR connections.
+async fn hmr_endpoint(
+    State(state): State<HmrState>,
+) -> Sse<impl Stream<Item = Result<Event, Infallible>>> {
+    let rx = state.tx.subscribe();
+    let stream = BroadcastStream::new(rx).filter_map(|msg| {
+        match msg {
+            Ok(msg) => {
+                let json = serde_json::to_string(&msg).unwrap_or_default();
+                Some(Ok(Event::default().data(json)))
+            }
+            // Ignore lag errors
+            Err(_) => None,
+        }
+    });
+
+    Sse::new(stream).keep_alive(axum::response::sse::KeepAlive::new())
+}

runtime/src/dev/hot_reload.rs

@@ -0,0 +1,40 @@
+cat << 'INNER_EOF' > /tmp/analyzer_diff.txt
+<<<<<<< SEARCH
+        // process.env access (shimmable → Forge.env())
+        Expression::StaticMemberExpression(member) => {
+            if member.property.name == "env" {
+                if let Expression::Identifier(obj) = &member.object {
+                    if obj.name == "process" {
+                        let line = line_number_at_offset(source, member.span.start);
+                        detected.push(DetectedApi {
+                            pattern: "process.env".into(),
+                            line,
+                            compatibility: Compatibility::Shimmable,
+                        });
+                    }
+                }
+            }
+            // __dirname, __filename as member access targets are covered below
+        }
+
+        // Standalone identifiers: __dirname, __filename, Buffer (as global)
+=======
+        // process.env access (shimmable → Forge.env())
+        Expression::StaticMemberExpression(member) if member.property.name == "env" => {
+            if let Expression::Identifier(obj) = &member.object {
+                if obj.name == "process" {
+                    let line = line_number_at_offset(source, member.span.start);
+                    detected.push(DetectedApi {
+                        pattern: "process.env".into(),
+                        line,
+                        compatibility: Compatibility::Shimmable,
+                    });
+                }
+            }
+            // __dirname, __filename as member access targets are covered below
+        }
+        Expression::StaticMemberExpression(_) => {}
+
+        // Standalone identifiers: __dirname, __filename, Buffer (as global)
+>>>>>>> REPLACE
+INNER_EOF