Bundle assets into binary & improve title bar (#246)

rcoh · web-flow · commit 95f2937a434e · 2026-04-17T20:37:50.000Z
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/dial9-viewer/Cargo.toml b/dial9-viewer/Cargo.toml
@@ -28,6 +28,8 @@ futures = "0.3"
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
 tokio = { version = "1", features = ["rt-multi-thread", "macros", "signal"] }
+rust-embed = { version = "8", features = ["mime-guess"] }
+mime_guess = "2"
 tower-http = { version = "0.6", features = ["fs"] }
 tracing = "0.1"
 tracing-subscriber = { version = "0.3", features = ["env-filter"] }
diff --git a/dial9-viewer/build.rs b/dial9-viewer/build.rs
@@ -18,6 +18,7 @@ fn main() {
 
     println!("cargo::rerun-if-changed=toolkit");
     println!("cargo::rerun-if-changed=skills");
+    println!("cargo::rerun-if-changed=ui");
 
     generate_toolkit(&manifest_dir, &out_dir);
     generate_skills(&manifest_dir, &out_dir);
diff --git a/dial9-viewer/src/bin/dev_server.rs b/dial9-viewer/src/bin/dev_server.rs
@@ -84,7 +84,8 @@ async fn main() -> anyhow::Result<()> {
     );
 
     let ui_dir = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("ui");
-    let app = dial9_viewer::server::router(state, &ui_dir);
+    let state = state.with_dev_ui_dir(ui_dir);
+    let app = dial9_viewer::server::router(state);
 
     let port: u16 = std::env::var("PORT")
         .ok()
diff --git a/dial9-viewer/src/main.rs b/dial9-viewer/src/main.rs
@@ -40,9 +40,9 @@ pub struct Cli {
     #[arg(long, global = true, conflicts_with = "bucket")]
     local_dir: Option<PathBuf>,
 
-    /// Directory containing UI static files (when running without a subcommand)
-    #[arg(long, default_value = "ui", global = true)]
-    ui_dir: PathBuf,
+    /// Dev mode: serve UI files from disk for faster iteration
+    #[arg(long, global = true)]
+    dev: bool,
 }
 
 #[derive(Subcommand, Debug)]
@@ -99,18 +99,35 @@ async fn main() -> anyhow::Result<()> {
             },
         },
         Some(Commands::Serve {}) | None => {
-            return serve(cli.port, cli.bucket, cli.prefix, cli.local_dir, cli.ui_dir).await;
+            return serve(cli.port, cli.bucket, cli.prefix, cli.local_dir, cli.dev).await;
         }
     }
     Ok(())
 }
 
+async fn detect_bucket_region(bucket: &str) -> Option<String> {
+    let config = aws_config::load_defaults(aws_config::BehaviorVersion::latest()).await;
+    let client = aws_sdk_s3::Client::new(&config);
+    match client.head_bucket().bucket(bucket).send().await {
+        Ok(resp) => resp.bucket_region().map(|r| r.to_string()),
+        Err(err) => {
+            // HeadBucket errors include the x-amz-bucket-region header
+            let raw = err.raw_response();
+            raw.and_then(|r| {
+                r.headers()
+                    .get("x-amz-bucket-region")
+                    .map(|v| v.to_string())
+            })
+        }
+    }
+}
+
 async fn serve(
     port: u16,
     bucket: Option<String>,
     prefix: Option<String>,
     local_dir: Option<PathBuf>,
-    ui_dir: PathBuf,
+    dev: bool,
 ) -> anyhow::Result<()> {
     tracing_subscriber::fmt()
         .with_env_filter(
@@ -119,42 +136,89 @@ async fn serve(
         )
         .init();
 
-    let ui_dir = if ui_dir.exists() {
-        ui_dir
-    } else if let Ok(exe) = std::env::current_exe() {
-        let candidate = exe.parent().unwrap_or(exe.as_ref()).join(&ui_dir);
-        if candidate.exists() {
-            candidate
-        } else {
-            ui_dir
+    let dev_ui_dir = if dev {
+        // In dev mode, find the ui/ directory relative to the manifest or CWD
+        let candidates = [PathBuf::from("ui"), PathBuf::from("dial9-viewer/ui")];
+        let dir = candidates.into_iter().find(|p| p.exists());
+        match dir {
+            Some(d) => {
+                tracing::info!(path = %d.display(), "dev mode: serving UI from disk");
+                Some(d)
+            }
+            None => {
+                anyhow::bail!(
+                    "--dev: could not find ui/ directory. Run from the dial9-viewer/ or repo root directory."
+                );
+            }
         }
     } else {
-        ui_dir
+        None
     };
 
     let app_state = if let Some(dir) = &local_dir {
         let dir = std::fs::canonicalize(dir)?;
         tracing::info!(path = %dir.display(), "serving traces from local directory");
         let backend = dial9_viewer::storage::LocalBackend::new(&dir);
-        // Use a sentinel bucket so routes that require one don't fail.
-        dial9_viewer::server::AppState::new(
+        let mut state = dial9_viewer::server::AppState::new(
             std::sync::Arc::new(backend),
             Some("local".into()),
             prefix.clone(),
-        )
+        );
+        if let Some(d) = dev_ui_dir {
+            state = state.with_dev_ui_dir(d);
+        }
+        state
     } else {
-        let backend = dial9_viewer::storage::S3Backend::from_env().await;
-        dial9_viewer::server::AppState::new(
-            std::sync::Arc::new(backend),
-            bucket.clone(),
-            prefix.clone(),
-        )
+        // Detect bucket region if a bucket is provided
+        if let Some(bucket_name) = &bucket {
+            if let Some(region) = detect_bucket_region(bucket_name).await {
+                tracing::info!(%region, bucket = %bucket_name, "detected bucket region");
+                let config = aws_config::defaults(aws_config::BehaviorVersion::latest())
+                    .region(aws_sdk_s3::config::Region::new(region))
+                    .load()
+                    .await;
+                let client = aws_sdk_s3::Client::new(&config);
+                let backend = dial9_viewer::storage::S3Backend::from_client(client);
+                let mut state = dial9_viewer::server::AppState::new(
+                    std::sync::Arc::new(backend),
+                    bucket.clone(),
+                    prefix.clone(),
+                );
+                if let Some(d) = dev_ui_dir {
+                    state = state.with_dev_ui_dir(d);
+                }
+                state
+            } else {
+                tracing::warn!(bucket = %bucket_name, "could not detect bucket region, using default");
+                let backend = dial9_viewer::storage::S3Backend::from_env().await;
+                let mut state = dial9_viewer::server::AppState::new(
+                    std::sync::Arc::new(backend),
+                    bucket.clone(),
+                    prefix.clone(),
+                );
+                if let Some(d) = dev_ui_dir {
+                    state = state.with_dev_ui_dir(d);
+                }
+                state
+            }
+        } else {
+            let backend = dial9_viewer::storage::S3Backend::from_env().await;
+            let mut state = dial9_viewer::server::AppState::new(
+                std::sync::Arc::new(backend),
+                bucket.clone(),
+                prefix.clone(),
+            );
+            if let Some(d) = dev_ui_dir {
+                state = state.with_dev_ui_dir(d);
+            }
+            state
+        }
     };
 
-    let app = dial9_viewer::server::router(app_state, &ui_dir);
+    let app = dial9_viewer::server::router(app_state);
 
     let listener = tokio::net::TcpListener::bind(("0.0.0.0", port)).await?;
-    tracing::info!(port, ui_dir = %ui_dir.display(), "dial9-viewer listening");
+    tracing::info!(port, dev, "dial9-viewer listening");
     println!("\n  → http://localhost:{}\n", port);
     if let Some(dir) = &local_dir {
         tracing::info!(path = %dir.display(), "local directory mode");
diff --git a/dial9-viewer/src/server/mod.rs b/dial9-viewer/src/server/mod.rs
@@ -1,20 +1,29 @@
 use crate::storage::StorageBackend;
 use axum::Router;
-use std::path::Path;
+use axum::body::Body;
+use axum::http::{HeaderValue, StatusCode, header};
+use axum::response::{IntoResponse, Response};
+use rust_embed::Embed;
+use std::path::PathBuf;
 use std::sync::Arc;
-use tower_http::services::ServeDir;
 
 mod config;
 mod prefixes;
 mod search;
 mod trace;
 
+#[derive(Embed)]
+#[folder = "ui/"]
+struct UiAssets;
+
 #[derive(Clone)]
 #[non_exhaustive]
 pub struct AppState {
     pub backend: Arc<dyn StorageBackend>,
     pub default_bucket: Option<String>,
     pub default_prefix: Option<String>,
+    /// When set, serve UI files from disk instead of embedded assets.
+    pub dev_ui_dir: Option<PathBuf>,
 }
 
 impl AppState {
@@ -27,14 +36,47 @@ impl AppState {
             backend,
             default_bucket,
             default_prefix,
+            dev_ui_dir: None,
         }
     }
+
+    pub fn with_dev_ui_dir(mut self, dir: PathBuf) -> Self {
+        self.dev_ui_dir = Some(dir);
+        self
+    }
 }
 
-pub fn router(state: AppState, ui_dir: &Path) -> Router {
-    Router::new()
-        .nest("/api", api_router(state))
-        .fallback_service(ServeDir::new(ui_dir))
+pub fn router(state: AppState) -> Router {
+    if let Some(dir) = state.dev_ui_dir.clone() {
+        tracing::info!(path = %dir.display(), "serving UI from disk (dev mode)");
+        Router::new()
+            .nest("/api", api_router(state))
+            .fallback_service(tower_http::services::ServeDir::new(dir))
+    } else {
+        Router::new()
+            .nest("/api", api_router(state))
+            .fallback(serve_embedded)
+    }
+}
+
+async fn serve_embedded(uri: axum::http::Uri) -> Response {
+    let path = uri.path().trim_start_matches('/');
+    let path = if path.is_empty() { "index.html" } else { path };
+
+    match UiAssets::get(path) {
+        Some(file) => {
+            let mime = mime_guess::from_path(path).first_or_octet_stream();
+            Response::builder()
+                .header(
+                    header::CONTENT_TYPE,
+                    HeaderValue::from_str(mime.as_ref()).unwrap(),
+                )
+                .body(Body::from(file.data.to_vec()))
+                .unwrap()
+                .into_response()
+        }
+        None => (StatusCode::NOT_FOUND, "not found").into_response(),
+    }
 }
 
 fn api_router(state: AppState) -> Router {
diff --git a/dial9-viewer/tests/server_test.rs b/dial9-viewer/tests/server_test.rs
@@ -56,7 +56,8 @@ fn fake_s3_client(fs_root: &std::path::Path) -> aws_sdk_s3::Client {
 
 async fn start_server(state: AppState) -> String {
     let ui_dir = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("ui");
-    let app = router(state, &ui_dir);
+    let state = state.with_dev_ui_dir(ui_dir);
+    let app = router(state);
     let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
     let addr = listener.local_addr().unwrap();
     tokio::spawn(async move {
diff --git a/dial9-viewer/ui/index.html b/dial9-viewer/ui/index.html
diff --git a/dial9-viewer/ui/viewer.html b/dial9-viewer/ui/viewer.html
