Got the web ui working e2e! Implements the sending and creates a basi…

…c web ui app

crates/turbopack-cli/js/package.json

@@ -8,7 +8,7 @@
     "check": "tsc --noEmit"
   },
   "dependencies": {
-    "@vercel/turbopack-ecmascript-runtime": "*"
+    "@vercel/turbopack-ecmascript-runtime": "workspace:*"
   },
   "devDependencies": {
     "@types/node": "^18.11.11"

crates/turborepo-lib/src/commands/run.rs

@@ -2,6 +2,7 @@ use std::future::Future;
 
 use tracing::error;
 use turborepo_telemetry::events::command::CommandEventBuilder;
+use turborepo_ui::sender::UISender;
 
 use crate::{commands::CommandBase, run, run::builder::RunBuilder, signal::SignalHandler};
 
@@ -52,12 +53,12 @@ pub async fn run(base: CommandBase, telemetry: CommandEventBuilder) -> Result<i3
             analytics_handle.close_with_timeout().await;
         }
 
-        if let (Some(handle), Some(sender)) = (handle, sender) {
-            //sender.stop();
-            if let Err(e) = handle.await.expect("render thread panicked") {
-                error!("error encountered rendering tui: {e}");
-            }
-        }
+        // if let (Some(handle), Some(sender)) = (handle, sender) {
+        //     //sender.stop();
+        //     if let Err(e) = handle.await.expect("render thread panicked") {
+        //         error!("error encountered rendering tui: {e}");
+        //     }
+        // }
 
         result
     };

crates/turborepo-ui/Cargo.toml

@@ -16,9 +16,9 @@ workspace = true
 
 [dependencies]
 atty = { workspace = true }
-base64 = "0.22"
 axum = { workspace = true, features = ["ws"] }
 axum-server = { workspace = true }
+base64 = "0.22"
 chrono = { workspace = true }
 console = { workspace = true }
 crossterm = "0.27.0"
@@ -31,6 +31,8 @@ serde = { workspace = true, features = ["derive"] }
 serde_json = { workspace = true }
 thiserror = { workspace = true }
 tokio = { workspace = true }
+
+tower-http = { version = "0.5.2", features = ["cors"] }
 tracing = { workspace = true }
 tui-term = { workspace = true }
 turbopath = { workspace = true }

crates/turborepo-ui/src/sender.rs

@@ -15,6 +15,8 @@ pub trait UISender: Clone + Send + Sync + 'static {
     fn set_stdin(&self, task: String, stdin: Box<dyn std::io::Write + Send>);
 
     fn output(&self, task: String, output: Vec<u8>) -> Result<(), Self::Error>;
+
+    /// Construct a sender configured for a specific task
     fn task(&self, task: String) -> TaskSender<Self>
     where
         Self: Sized;

crates/turborepo-ui/src/wui/mod.rs

@@ -8,12 +8,15 @@ use axum::{
         ws::{Message, WebSocket},
         State, WebSocketUpgrade,
     },
+    http::Method,
     response::IntoResponse,
     routing::get,
     Router,
 };
 use serde::Serialize;
 use thiserror::Error;
+use tower_http::cors::{Any, CorsLayer};
+use tracing::log::warn;
 
 use crate::{
     sender::{TaskSender, UISender},
@@ -37,38 +40,58 @@ impl UISender for WebUISender {
     type Error = std::io::Error;
 
     fn start_task(&self, task: String, output_logs: OutputLogs) {
-        todo!()
+        self.tx
+            .send(WebUIEvent::StartTask { task, output_logs })
+            .ok();
     }
 
     fn end_task(&self, task: String, result: TaskResult) {
-        todo!()
+        self.tx.send(WebUIEvent::EndTask { task, result }).ok();
     }
 
     fn status(&self, task: String, status: String, result: CacheResult) {
-        todo!()
+        self.tx
+            .send(WebUIEvent::Status {
+                task,
+                status,
+                result,
+            })
+            .ok();
     }
 
     fn set_stdin(&self, task: String, stdin: Box<dyn Write + Send>) {
-        todo!()
+        warn!("stdin is not supported (yet) in web ui");
     }
 
     fn task(&self, task: String) -> TaskSender<Self>
     where
         Self: Sized,
     {
-        todo!()
+        TaskSender {
+            name: task,
+            handle: self.clone(),
+            logs: Default::default(),
+        }
     }
 
     fn stop(&self) {
-        todo!()
+        self.tx.send(WebUIEvent::Stop).ok();
     }
 
     fn update_tasks(&self, tasks: Vec<String>) -> Result<(), Self::Error> {
-        todo!()
+        self.tx
+            .send(WebUIEvent::UpdateTasks { tasks })
+            .map_err(|_| std::io::Error::new(std::io::ErrorKind::BrokenPipe, "WebUI is closed"))?;
+
+        Ok(())
     }
 
     fn output(&self, task: String, output: Vec<u8>) -> Result<(), Self::Error> {
-        todo!()
+        self.tx
+            .send(WebUIEvent::TaskOutput { task, output })
+            .map_err(|_| std::io::Error::new(std::io::ErrorKind::BrokenPipe, "WebUI is closed"))?;
+
+        Ok(())
     }
 }
 
@@ -96,29 +119,7 @@ pub enum WebUIEvent {
     UpdateTasks {
         tasks: Vec<String>,
     },
-}
-
-impl WebUIEvent {
-    fn from_event(event: Event) -> Option<Self> {
-        match event {
-            Event::StartTask { task, output_logs } => {
-                Some(WebUIEvent::StartTask { task, output_logs })
-            }
-            Event::TaskOutput { task, output } => Some(WebUIEvent::TaskOutput { task, output }),
-            Event::EndTask { task, result } => Some(WebUIEvent::EndTask { task, result }),
-            Event::Status {
-                task,
-                status,
-                result,
-            } => Some(WebUIEvent::Status {
-                task,
-                status,
-                result,
-            }),
-            Event::UpdateTasks { tasks } => Some(WebUIEvent::UpdateTasks { tasks }),
-            _ => None,
-        }
-    }
+    Stop,
 }
 
 struct AppState {
@@ -151,11 +152,19 @@ async fn handle_socket(mut socket: WebSocket, state: AppState) {
 pub async fn start_ws_server(
     rx: tokio::sync::broadcast::Receiver<WebUIEvent>,
 ) -> Result<(), Error> {
+    let cors = CorsLayer::new()
+        // allow `GET` and `POST` when accessing the resource
+        .allow_methods([Method::GET, Method::POST])
+        // allow requests from any origin
+        .allow_origin(Any);
+
     let app = Router::new()
         .route("/ws", get(handler))
+        .layer(cors)
         .with_state(AppState { rx });
 
-    let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await?;
+    let listener = tokio::net::TcpListener::bind("127.0.0.1:1337").await?;
+    println!("Web UI listening on port 1337");
     axum::serve(listener, app).await?;
 
     Ok(())

packages/turbo-repository/js/index.d.ts

@@ -3,7 +3,7 @@
 
 /* auto-generated by NAPI-RS */
 
-export class Package {
+export declare class Package {
   name: string;
   /** The absolute path to the package root. */
   readonly absolutePath: string;
@@ -14,17 +14,17 @@ export class Package {
  * Wrapper for dependents and dependencies.
  * Each are a list of package paths, relative to the workspace root.
  */
-export class PackageDetails {
+export declare class PackageDetails {
   /** the package's dependencies */
   readonly dependencies: Array<string>;
   /** the packages that depend on this package */
   readonly dependents: Array<string>;
 }
-export class PackageManager {
+export declare class PackageManager {
   /** The package manager name in lower case. */
   readonly name: string;
 }
-export class Workspace {
+export declare class Workspace {
   /** The absolute path to the workspace root. */
   readonly absolutePath: string;
   /** `true` when the workspace is a multi-package workspace. */