Web UI: Implement interactive tour explorer and server

Cargo.toml

@@ -10,7 +10,7 @@ resolver = "2"
 axum = "0.7"
 tokio = { version = "1", features = ["full"] }
 tower = "0.5"
-tower-http = { version = "0.5", features = ["trace"] }
+tower-http = { version = "0.5", features = ["trace", "set-header"] }
 tracing = "0.1"
 tracing-subscriber = { version = "0.3", features = ["env-filter", "json"] }
 serde = { version = "1", features = ["derive"] }
@@ -27,3 +27,6 @@ rusqlite = { version = "0.37", features = ["bundled"] }
 tree-sitter = "0.25"
 tempfile = "3"
 deadpool-sqlite = "0.12"
+rinja = "0.3"
+rinja_axum = "0.3"
+syntect = { version = "5", default-features = false, features = ["parsing", "html", "regex-fancy", "default-syntaxes", "plist-load"] }

codetours.toml.example

@@ -18,6 +18,10 @@ max_open_tenants = 256
 # Maximum allowed size for a SQLite pack upload in bytes. Default: 5MB
 max_pack_size = 5242880
 
+[ui]
+# Optional path to a custom CSS file to override Tailwind @theme variables.
+# theme_css = "/path/to/theme.css"
+
 [storage]
 # Number of SQLite connections in the pool per tenant. Default: 8
 pool_size = 8
@@ -30,6 +34,9 @@ mode = "stub"
 # Clients must provide this in the 'X-Tour-Token' header.
 dev_token = "dev-token"
 
+# Used in Phase 5 for "My Tours" local-dev mock before real auth lands.
+stub_user = "local-dev"
+
 
 # ------------------------------------------------------------------------------
 # Codemark CLI Client Configuration (~/.codemark/config.toml)

crates/codemark-cli/src/cli/handlers/pull.rs

@@ -28,6 +28,7 @@ pub async fn handle_pull(cli: &Cli, mode: &OutputMode, args: &PullArgs) -> Resul
         let client = build_pull_http_client()?;
         let response = client
             .get(format!("{}/tours", server_url))
+            .header(reqwest::header::ACCEPT, "application/json")
             .send()
             .await
             .map_err(|e| Error::Operation(format!("failed to query tours list: {e}")))?;

crates/codemark-cli/src/cli/handlers/tour.rs

@@ -44,6 +44,7 @@ pub async fn handle_tour_list(cli: &Cli, _mode: &OutputMode, args: &TourListArgs
     // 2. Query server
     let client = reqwest::Client::new();
     let mut headers = HeaderMap::new();
+    headers.insert(reqwest::header::ACCEPT, HeaderValue::from_static("application/json"));
     if let Some(t) = &token {
         headers.insert(
             "X-Tour-Token",

crates/codetours-server/Cargo.toml

@@ -27,8 +27,19 @@ uuid = { workspace = true }
 chrono = { workspace = true }
 rusqlite = { workspace = true }
 deadpool-sqlite = { workspace = true }
+rinja = { workspace = true }
+rinja_axum = { workspace = true }
+syntect = { workspace = true }
+syntect-assets = "0.23"
 futures-util = "0.3"
 zstd = "0.13"
+quick_cache = "0.6.21"
+xxhash-rust = { version = "0.8.15", features = ["xxh3"] }
 
 [dev-dependencies]
+criterion = "0.8.2"
 tempfile = { workspace = true }
+
+[[bench]]
+name = "highlight"
+harness = false

crates/codetours-server/benches/highlight.rs

@@ -0,0 +1,34 @@
+use codetours_server::highlight::{get_cache, highlight};
+use criterion::{Criterion, criterion_group, criterion_main};
+use std::hint::black_box;
+
+fn bench_highlight(c: &mut Criterion) {
+    let language = "rust";
+    let content = r#"
+        pub fn fibonacci(n: u32) -> u32 {
+            match n {
+                0 => 1,
+                1 => 1,
+                _ => fibonacci(n - 1) + fibonacci(n - 2),
+            }
+        }
+    "#;
+
+    // Warm up the cache
+    let _ = highlight(language, content);
+
+    c.bench_function("highlight_cached", |b| {
+        b.iter(|| highlight(black_box(language), black_box(content)));
+    });
+
+    c.bench_function("highlight_uncached", |b| {
+        b.iter(|| {
+            // clear the cache each iteration to simulate a miss
+            get_cache().clear();
+            highlight(black_box(language), black_box(content))
+        });
+    });
+}
+
+criterion_group!(benches, bench_highlight);
+criterion_main!(benches);

crates/codetours-server/build.rs

@@ -0,0 +1,48 @@
+use std::env;
+use std::process::Command;
+
+fn main() {
+    println!("cargo:rerun-if-changed=static/app.css");
+    println!("cargo:rerun-if-changed=templates/");
+
+    let out_dir = env::var("CARGO_MANIFEST_DIR").unwrap();
+    let input = format!("{}/static/app.css", out_dir);
+    let output = format!("{}/static/app.generated.css", out_dir);
+
+    let skip_tailwind = env::var("SKIP_TAILWIND_BUILD").unwrap_or_default() == "1";
+    if skip_tailwind {
+        println!("cargo:warning=SKIP_TAILWIND_BUILD is set, skipping regeneration.");
+        return;
+    }
+
+    let status = Command::new("tailwindcss")
+        .args(["-i", &input, "-o", &output, "--minify"])
+        .status()
+        .or_else(|_| {
+            Command::new("../../tailwindcss")
+                .args(["-i", &input, "-o", &output, "--minify"])
+                .status()
+        });
+
+    match status {
+        Ok(status) if status.success() => (),
+        Ok(status) => {
+            eprintln!("Fatal: tailwindcss exited with status {status}.");
+            std::process::exit(1);
+        }
+        Err(err) => {
+            eprintln!("Error: tailwindcss CLI not found or failed.");
+            eprintln!("Details: {err}");
+            eprintln!("Please install it via 'cargo binstall tailwindcss' or 'mise install'.");
+            // If the generated file already exists (e.g., committed in CI), allow the
+            // build to proceed with the stale artifact rather than blocking CI entirely.
+            let output_path = std::path::Path::new(&output);
+            if !output_path.exists() {
+                eprintln!("Fatal: {} does not exist. Cannot continue.", output);
+                std::process::exit(1);
+            } else {
+                eprintln!("Warning: using existing {} — CSS may be stale.", output);
+            }
+        }
+    }
+}

crates/codetours-server/examples/check_syntax.rs

@@ -0,0 +1,21 @@
+use syntect_assets::assets::HighlightingAssets;
+
+fn main() {
+    let assets = HighlightingAssets::from_binary();
+    let ss = assets.get_syntax_set().unwrap();
+    println!("Total syntaxes: {}", ss.syntaxes().len());
+
+    // Check for Swift
+    let swift_syntax = ss.find_syntax_by_name("Swift");
+    match swift_syntax {
+        Some(s) => println!("Found Swift: {} - extensions: {:?}", s.name, s.file_extensions),
+        None => println!("Swift NOT found in syntax set"),
+    }
+
+    // Check if we can find it by extension
+    let by_ext = ss.find_syntax_by_extension("swift");
+    match by_ext {
+        Some(s) => println!("Found by extension 'swift': {}", s.name),
+        None => println!("NOT found by extension 'swift'"),
+    }
+}

crates/codetours-server/rinja.toml

@@ -0,0 +1,2 @@
+[filter]
+tag_color_classes = "crate::web::filters::tag_color_classes"

crates/codetours-server/src/auth/extractor.rs

@@ -38,6 +38,16 @@ impl AuthContext {
         matches!(self, AuthContext::Authenticated { .. })
     }
 
+    /// Returns the active user_id for queries that need to key off "me".
+    /// PHASE 6 SWAP POINT: In M2, this falls back to the configured `stub_user` for anonymous callers.
+    /// In Phase 6, anonymous callers will return None, and only authenticated callers will return Some(user_id).
+    pub fn current_user(&self, config: &crate::config::Config) -> Option<String> {
+        match self {
+            AuthContext::Authenticated { user_id, .. } => Some(user_id.clone()),
+            AuthContext::Anonymous => Some(config.auth.stub_user.clone()),
+        }
+    }
+
     /// Returns true if the authenticated user has the specified scope.
     pub fn has_scope(&self, scope: Scope) -> bool {
         match self {
@@ -120,7 +130,7 @@ where
         }
 
         Ok(AuthContext::Authenticated {
-            user_id: "stub".to_string(),
+            user_id: state.config.auth.stub_user.clone(),
             scopes: vec![Scope::Publish, Scope::Read, Scope::Delete],
         })
     }

crates/codetours-server/src/cli.rs

@@ -10,6 +10,18 @@ pub struct Cli {
     #[arg(long, help = "Enable JSON structured logging")]
     pub json_logs: bool,
 
+    #[arg(
+        long,
+        help = "Enable registry mode: aggregate tours from all repositories in the global registry"
+    )]
+    pub registry_mode: bool,
+
+    #[arg(
+        long,
+        help = "Path to the registry database (only used with --registry-mode)"
+    )]
+    pub registry_path: Option<PathBuf>,
+
     #[command(subcommand)]
     pub command: Option<Command>,
 }

crates/codetours-server/src/config.rs

@@ -20,13 +20,26 @@ pub struct Config {
     pub storage: StorageConfig,
     #[serde(default)]
     pub auth: AuthConfig,
+    #[serde(default)]
+    pub ui: UiConfig,
+}
+
+#[derive(Deserialize, Debug, Clone, Default)]
+#[serde(deny_unknown_fields)]
+pub struct UiConfig {
+    pub theme_css: Option<String>,
 }
 
 #[derive(Deserialize, Debug, Clone)]
 #[serde(deny_unknown_fields)]
 pub struct StorageConfig {
     #[serde(default = "default_pool_size")]
     pub pool_size: u32,
+    /// Enable registry mode for aggregating data from multiple repositories
+    #[serde(default)]
+    pub registry_mode: bool,
+    /// Path to the registry database (defaults to global config dir)
+    pub registry_path: Option<PathBuf>,
 }
 
 #[derive(Deserialize, Debug, Clone)]
@@ -36,6 +49,8 @@ pub struct AuthConfig {
     pub mode: String,
     #[serde(default)]
     pub dev_token: String,
+    #[serde(default = "default_stub_user")]
+    pub stub_user: String,
 }
 
 fn default_host() -> String {
@@ -70,6 +85,10 @@ fn default_auth_mode() -> String {
     "stub".to_string()
 }
 
+fn default_stub_user() -> String {
+    "local-dev".to_string()
+}
+
 impl Default for Config {
     fn default() -> Self {
         Self {
@@ -81,19 +100,20 @@ impl Default for Config {
             max_pack_size: default_max_pack_size(),
             storage: StorageConfig::default(),
             auth: AuthConfig::default(),
+            ui: UiConfig::default(),
         }
     }
 }
 
 impl Default for StorageConfig {
     fn default() -> Self {
-        Self { pool_size: default_pool_size() }
+        Self { pool_size: default_pool_size(), registry_mode: false, registry_path: None }
     }
 }
 
 impl Default for AuthConfig {
     fn default() -> Self {
-        Self { mode: default_auth_mode(), dev_token: String::new() }
+        Self { mode: default_auth_mode(), dev_token: String::new(), stub_user: default_stub_user() }
     }
 }
 

crates/codetours-server/src/handlers/config.rs

@@ -0,0 +1,92 @@
+use crate::web::NavItem;
+use crate::{auth::AuthContext, router::AppState};
+use axum::{
+    extract::{Form, State},
+    http::StatusCode,
+    response::IntoResponse,
+};
+use rinja::Template;
+use serde::Deserialize;
+
+#[derive(Template)]
+#[template(path = "config/index.html")]
+pub struct ConfigTemplate {
+    pub nav: NavItem,
+    pub repos: Vec<RepoView>,
+    pub prefs: PrefsView,
+}
+
+pub struct PrefsView {
+    pub theme: String,
+    pub font: String,
+}
+
+pub struct RepoView {
+    pub name: String,
+    pub path: String,
+    pub connected: bool,
+}
+
+#[derive(Deserialize)]
+pub struct PrefsForm {
+    pub theme: String,
+    pub font: String,
+}
+
+pub async fn page_handler(State(state): State<AppState>, _auth: AuthContext) -> impl IntoResponse {
+    let db = match state.storage.get_conn().await {
+        Ok(t) => t,
+        Err(_) => return StatusCode::INTERNAL_SERVER_ERROR.into_response(),
+    };
+
+    let repos = db
+        .interact(|conn| {
+            let mut stmt = conn
+                .prepare(
+                    "
+            SELECT DISTINCT repo_url 
+            FROM collections 
+            WHERE repo_url IS NOT NULL AND repo_url != ''
+        ",
+                )
+                .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;
+
+            let urls = stmt
+                .query_map([], |row| row.get::<_, String>(0))
+                .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?
+                .collect::<Result<Vec<_>, _>>()
+                .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;
+
+            let mut repos = Vec::new();
+            for url in urls {
+                let name = url.split('/').next_back().unwrap_or(&url).to_string();
+                repos.push(RepoView { name, path: url, connected: true });
+            }
+            Ok::<_, StatusCode>(repos)
+        })
+        .await
+        .unwrap_or(Err(StatusCode::INTERNAL_SERVER_ERROR));
+
+    match repos {
+        Ok(repos) => {
+            let prefs =
+                PrefsView { theme: "atom-one-dark".to_string(), font: "Fira Code".to_string() };
+            ConfigTemplate { nav: NavItem::Config, repos, prefs }.into_response()
+        }
+        Err(e) => e.into_response(),
+    }
+}
+
+pub async fn prefs_handler(
+    State(_state): State<AppState>,
+    _auth: AuthContext,
+    Form(_form): Form<PrefsForm>,
+) -> impl IntoResponse {
+    // TODO: Persist preferences in Phase 10
+    StatusCode::NOT_IMPLEMENTED.into_response()
+}
+
+pub async fn stub_handler() -> impl IntoResponse {
+    (StatusCode::NOT_IMPLEMENTED, "This feature will be available in Phase 10 or later.")
+        .into_response()
+}

crates/codetours-server/src/handlers/home.rs

@@ -0,0 +1,5 @@
+use axum::response::{IntoResponse, Redirect};
+
+pub async fn handler() -> impl IntoResponse {
+    Redirect::temporary("/tours")
+}