Pup - the AI's own browser

@@ -12,6 +12,11 @@ use std::sync::atomic::{AtomicBool, Ordering}; use std::sync::{Arc, Mutex}; use std::time::{Duration, Instant, SystemTime}; +pub mod ext_assets;++/// Chrome extension ids (deterministic from each manifest's `key`, so staging path does not matter).+pub const EXT_IDS: &[(&str, &str)] = &[("pup-extension", "liomcaladmooagjiebkfgegciadapnpi"), ("pup-annotate-extension", "ghadnmahlldiigemdbekmhcbfcpkmclg"), ("pup-identity-extension", "mngfopllhdfgomjphhejmcdimcohcgnf"), ("pup-identity-anon-extension", "mhoenaodccbppcinfbaifamkgfhbakbe")];+ /// The Chrome for Testing build pup drives. Same build id the Node build pinned through /// puppeteer 24.43, so both builds share one cache folder. Bump deliberately, with a ship note. pub const CFT_BUILD_ID: &str = "148.0.7778.97";@@ -344,10 +349,32 @@ fn run_unpack(cmd: &Path, args: &[String], dest: &Path, state: &Arc<Mutex<Instal  // ── profile + launch (Node: prepareCleanProfile + getOrLaunchBrowser) ────────────────── +/// Stage the embedded MV3 extensions under ~/.adom/<staged name> (Node: _stageExtDir) and write+/// the toolbar's port.json so the popup finds the live bridge. Returns the dirs to --load-extension,+/// in the order the toolbar shows them: annotate pen, toolbar, identity (adom-you) or anonymous tile.+pub fn stage_extensions(host: &dyn Host, port: u16, profile: &str, toolbar_on: bool) -> Vec<PathBuf> {+    if !toolbar_on { return Vec::new(); }+    let root = host.state_dir();+    let mut staged: std::collections::HashMap<&str, PathBuf> = std::collections::HashMap::new();+    for (src, dst, files) in ext_assets::EXTENSIONS {+        let dir = root.join(dst);+        if fs::create_dir_all(&dir).is_err() { continue; }+        for (name, bytes) in *files {+            let p = dir.join(name);+            let same = fs::metadata(&p).map(|m| m.len() == bytes.len() as u64).unwrap_or(false);+            if !same { let _ = fs::write(&p, bytes); }+        }+        if *src == "extension" { let _ = fs::write(dir.join("port.json"), format!("{{\"port\":{port},\"version\":\"{}\",\"shell\":\"rust\"}}", pup_core::version())); }+        staged.insert(dst, dir);+    }+    let identity = if profile == "adom-you" { "pup-identity-extension" } else { "pup-identity-anon-extension" };+    ["pup-annotate-extension", "pup-extension", identity].iter().filter_map(|k| staged.get(k).cloned()).collect()+}+ pub fn profiles_dir(host: &dyn Host) -> PathBuf { host.state_dir().join("pup-profiles") }  /// The switches every pup launch carries (server.js v2.0.293 merged form: ONE --disable-features).-pub fn chrome_switches(profile_dir: &Path, high_fps: bool, insecure_dev: bool) -> Vec<String> {+pub fn chrome_switches(profile_dir: &Path, high_fps: bool, insecure_dev: bool, extensions: &[PathBuf]) -> Vec<String> {     let mut v: Vec<String> = vec![         format!("--user-data-dir={}", profile_dir.display()),         "--remote-debugging-port=0".into(),@@ -362,12 +389,13 @@ pub fn chrome_switches(profile_dir: &Path, high_fps: bool, insecure_dev: bool) -     ];     if high_fps { v.extend(["--disable-background-timer-throttling", "--disable-backgrounding-occluded-windows", "--disable-renderer-backgrounding"].map(String::from)); }     if insecure_dev { v.push("--disable-web-security".into()); }+    if !extensions.is_empty() { v.push(format!("--load-extension={}", extensions.iter().map(|p| p.to_string_lossy().to_string()).collect::<Vec<_>>().join(","))); }     v.push("about:blank".into());     v }  /// Node: prepareCleanProfile (the Preferences the profile must carry before Chrome opens it).-pub fn prepare_profile(profile_dir: &Path) {+pub fn prepare_profile(profile_dir: &Path, pin_extensions: bool) {     let default = profile_dir.join("Default");     let _ = fs::create_dir_all(&default);     let prefs_path = default.join("Preferences");@@ -378,6 +406,18 @@ pub fn prepare_profile(profile_dir: &Path) {     prefs["webrtc"]["ip_handling_policy"] = json!("disable_non_proxied_udp");     prefs["webrtc"]["nonproxied_udp_enabled"] = json!(false);     prefs["webrtc"]["multiple_routes_enabled"] = json!(false);+    if pin_extensions {+        // the toolbar order IS the pinned_extensions array order (Node v2.0.150): foreign pins kept, ours appended in canonical order+        let ours: Vec<&str> = EXT_IDS.iter().map(|(_, id)| *id).collect();+        let prev: Vec<Value> = prefs["extensions"]["pinned_extensions"].as_array().cloned().unwrap_or_default();+        let mut pinned: Vec<Value> = prev.into_iter().filter(|x| x.as_str().map(|s| !ours.contains(&s)).unwrap_or(false)).collect();+        for (_, id) in EXT_IDS { pinned.push(json!(id)); }+        prefs["extensions"]["pinned_extensions"] = Value::Array(pinned);+    }+    prefs["browser"]["promotional_tabs_enabled"] = json!(false);+    prefs["session"]["restore_on_startup"] = json!(5);+    prefs["session"]["startup_urls"] = json!([]);+    prefs["profile"]["password_manager_leak_detection"] = json!(false);     prefs["credentials_enable_service"] = json!(false);   // pup runs its own vault; no Chrome save bubbles     prefs["profile"]["password_manager_enabled"] = json!(false);     let _ = fs::write(&prefs_path, serde_json::to_string(&prefs).unwrap_or_default());@@ -398,12 +438,14 @@ pub fn existing_port(profile_dir: &Path) -> Option<u16> {  /// Spawn-verified launch: the browser is started detached, the DevTools port is read from the /// profile's DevToolsActivePort (written by Chrome), and /json/version must answer.-pub fn launch(host: &dyn Host, cand: &Candidate, profile_dir: &Path, high_fps: bool, insecure_dev: bool) -> Result<Launched, String> {+pub fn launch(host: &dyn Host, cand: &Candidate, profile_dir: &Path, high_fps: bool, insecure_dev: bool, extensions: &[PathBuf]) -> Result<Launched, String> {     let _ = fs::create_dir_all(profile_dir);     let port_file = profile_dir.join("DevToolsActivePort");     let _ = fs::remove_file(&port_file);-    prepare_profile(profile_dir);-    let args = chrome_switches(profile_dir, high_fps, insecure_dev);+    // extensions ride ONLY Chrome for Testing (branded Chrome 137+ dropped --load-extension)+    let exts: Vec<PathBuf> = if cand.kind == "chrome-for-testing" { extensions.to_vec() } else { Vec::new() };+    prepare_profile(profile_dir, !exts.is_empty());+    let args = chrome_switches(profile_dir, high_fps, insecure_dev, &exts);     let t0 = Instant::now();     let pid = host.spawn_detached(&cand.executable_path, &args, None).map_err(|e| format!("spawn {}: {e}", cand.executable_path.display()))?;     while t0.elapsed() < Duration::from_secs(30) {@@ -445,11 +487,12 @@ mod tests {         let _ = fs::remove_dir_all(&tmp);     }     #[test] fn switches_have_one_disable_features() {-        let s = chrome_switches(Path::new("/tmp/p"), false, false);+        let s = chrome_switches(Path::new("/tmp/p"), false, false, &[]);         assert_eq!(s.iter().filter(|x| x.starts_with("--disable-features=")).count(), 1);         assert!(s.iter().any(|x| x == "--remote-debugging-port=0"));         assert!(!s.iter().any(|x| x == "--disable-web-security"));-        assert!(chrome_switches(Path::new("/tmp/p"), true, true).iter().any(|x| x == "--disable-web-security"));+        assert!(chrome_switches(Path::new("/tmp/p"), true, true, &[]).iter().any(|x| x == "--disable-web-security"));+        assert!(chrome_switches(Path::new("/tmp/p"), false, false, &[PathBuf::from("/a"), PathBuf::from("/b")]).iter().any(|x| x == "--load-extension=/a,/b"));     }     #[test] fn unpack_real_zip_and_reject_junk() {         let tmp = std::env::temp_dir().join(format!("pup-unpack-test-{}", std::process::id()));

@@ -1,10 +1,30 @@-//! pup-dashboard: the HTTP routes that are not verbs. Phase 1: /health and /status (the chip-//! contract ab renders verbatim: led / summary / tooltip), built from what the verbs crate knows.-//! The dashboard page, its SSE feed and the Hydrogen proxy routes land in Phase 2 as embedded-//! assets (include_str!) behind the same function-per-route shape.+//! pup-dashboard: every HTTP route that is not a verb. /health and /status (the chip contract ab+//! renders verbatim), the live dashboard page (the Node build's single-file page, embedded) with+//! its SSE snapshot feed, its action and image routes, /api/status (the LED row), /identity, and+//! the embedded page assets. Each route is one function; the binary only maps paths here. +pub mod assets_gen;++use pup_core::{Caller}; use pup_verbs::Ctx; use serde_json::{json, Value};+use std::io::Read;+use std::time::{Duration, Instant};++pub const DASHBOARD_HTML: &str = include_str!("../assets/dashboard.html");+pub const ICON_SVG: &str = include_str!("../assets/icon.svg");+pub const SAY_PHRASES: &str = include_str!("../assets/say-phrases.json");++pub enum Reply { Json(u16, Value), Bytes(u16, String, Vec<u8>, Option<String>), Stream(Box<dyn Read + Send>) }++fn q(query: &str, key: &str) -> Option<String> {+    query.split('&').find_map(|kv| { let mut it = kv.splitn(2, '='); if it.next()? == key { Some(url_decode(it.next().unwrap_or(""))) } else { None } })+}+fn url_decode(s: &str) -> String {+    let b = s.as_bytes(); let mut out = Vec::with_capacity(b.len()); let mut i = 0;+    while i < b.len() { if b[i] == b'%' && i + 2 < b.len() { if let Ok(v) = u8::from_str_radix(std::str::from_utf8(&b[i + 1..i + 3]).unwrap_or("zz"), 16) { out.push(v); i += 3; continue; } } if b[i] == b'+' { out.push(b' '); } else { out.push(b[i]); } i += 1; }+    String::from_utf8_lossy(&out).to_string()+}  fn session_rows(ctx: &Ctx) -> Vec<Value> {     let active = ctx.sessions.active_id();@@ -32,8 +52,8 @@ pub fn status(ctx: &Ctx) -> Value {         ("red", "Chrome install failed".to_string(), format!("Puppeteer bridge v{v} (rust)\nChrome for Testing install FAILED: {}\nRetry pup_prewarm (usually a network/proxy or disk issue).", rd["lastError"].as_str().unwrap_or("?")))     } else if rd["installing"] == json!(true) {         let pct = rd["installProgressPct"].as_u64().unwrap_or(0);-        let phase = if rd["installPhase"] == json!("unpacking") { "Unpacking".to_string() } else { format!("Installing Chrome {pct}%") };-        ("yellow", phase.clone(), format!("Puppeteer bridge v{v} (rust)\n{} — pup not ready yet. Poll pup_readiness until ready.", if rd["installPhase"] == json!("unpacking") { "Unpacking Chrome for Testing".to_string() } else { format!("Downloading Chrome for Testing ({pct}%)") }))+        let unpack = rd["installPhase"] == json!("unpacking");+        ("yellow", if unpack { "Unpacking Chrome".to_string() } else { format!("Installing Chrome {pct}%") }, format!("Puppeteer bridge v{v} (rust)\n{} — pup not ready yet. Poll pup_readiness until ready.", if unpack { "Unpacking Chrome for Testing".to_string() } else { format!("Downloading Chrome for Testing ({pct}%)") }))     } else if rd["ready"] != json!(true) {         ("yellow", "No browser yet".to_string(), format!("Puppeteer bridge v{v} (rust)\nNo Chrome/Edge detected and Chrome for Testing not cached — pup will fetch CfT on first use (or call pup_prewarm)."))     } else {@@ -46,5 +66,162 @@ pub fn status(ctx: &Ctx) -> Value {         "led": led, "summary": summary, "tooltip": tooltip,         "sessionCount": n, "activeSession": ctx.sessions.active_id(), "sessions": list, "chrome": rd,         "adVersion": ctx.ad_version.lock().unwrap().clone(), "uptimeSec": ctx.started.elapsed().as_secs(),+        "pupshotUrl": format!("http://127.0.0.1:{}/dashboard", ctx.port),     }) }++/// The live snapshot the dashboard page renders (Node: dashboardSnapshot), same field names.+pub fn snapshot(ctx: &Ctx) -> Value {+    let now = pup_core::now_ms();+    let mut wins: Vec<Value> = Vec::new();+    let mut buttons: Vec<Value> = Vec::new();+    for s in ctx.sessions.all() {+        let states = ctx.tabstate.lock().unwrap();+        let tabs: Vec<Value> = s.tabs.iter().map(|t| { let st = states.get(&t.cdp_session); json!({ "tabId": t.tab_id, "url": t.url, "title": t.title, "active": s.active().map(|a| a.tab_id == t.tab_id).unwrap_or(false), "crashed": false, "crashReason": Value::Null, "opener": "agent", "errorCount": st.map(|x| x.errors.len()).unwrap_or(0), "fav": Value::Null }) }).collect();+        let errors: Vec<Value> = s.tabs.iter().flat_map(|t| states.get(&t.cdp_session).map(|x| x.errors.clone()).unwrap_or_default()).collect();+        drop(states);+        let badge_file = ctx.host.temp_dir().join("pup-badge-debug").join(format!("{}.png", pup_session::sanitize_sid(&s.id)));+        let painted = badge_file.exists();+        let overlay_led = if s.app_id.is_none() { "red" } else if painted { "green" } else { "amber" };+        let url = s.active().map(|t| t.url.clone()).unwrap_or_default();+        wins.push(json!({+            "sessionId": s.id, "profile": s.profile, "owner": s.owner, "ownerSource": if s.owner.is_some() { "caller-identity" } else { Value::Null.as_str().unwrap_or("none") }, "ownerThread": s.owner, "ownerContainer": s.owner_container, "lastThread": s.owner,+            "foreground": s.foreground, "foregroundReason": s.last_note, "foregroundAt": Value::Null, "foregroundVerb": Value::Null, "background": if s.foreground { "foreground" } else { "backgrounded" },+            "highFps": false, "highFpsMinutesLeft": 0, "openedAt": s.created_ms, "uptimeMs": now.saturating_sub(s.created_ms), "tabCount": s.tabs.len(), "tabs": tabs,+            "overlay": if painted { "page-favicon" } else { "none" }, "overlayWhy": { "at": if painted { now } else { 0 }, "why": if painted { "painted through ab desktop_taskbar" } else { "not painted yet" } },+            "_curAppId": s.app_id, "wiki": { "authed": Value::Null, "view": Value::Null, "isWiki": pup_identity::is_adom_url(&url) },+            "identityPending": false, "identityPendingMs": 0, "overlayLed": overlay_led, "hwnd": s.hwnd, "emulatedViewport": s.emulated, "lostBrowser": pup_verbs::browser_for(ctx, &s.profile).is_none(),+            "lastAgentUpdate": s.last_agent_update_ms, "errorCount": errors.len(), "recentErrors": errors.iter().rev().take(5).map(|e| json!({ "type": e["type"], "text": e["text"].as_str().unwrap_or("").chars().take(200).collect::<String>() })).collect::<Vec<_>>(), "flashCount": 0, "url": url,+        }));+        let (key, label, base_icon) = match &s.app_id { Some(a) => (format!("aumid:{a}"), s.id.clone(), format!("/dashboard/stampicon?session={}", s.id)), None => (format!("chrome-process:{}", s.profile), format!("Chrome ({})", s.profile), format!("/dashboard/baseicon?profile={}", s.profile)) };+        if let Some(b) = buttons.iter_mut().find(|b| b["key"] == json!(key)) { b["windows"].as_array_mut().unwrap().push(json!(s.id)); if b["led"] == json!("green") && overlay_led != "green" { b["led"] = json!(overlay_led); } }+        else { buttons.push(json!({ "key": key, "label": label, "kind": "process", "baseIcon": base_icon, "grouping": ctx.settings.get("taskbarGrouping", "split"), "windows": [s.id], "badgeSession": s.id, "badgeAt": now, "badgeVia": "newest-painted", "badgeLed": overlay_led, "led": overlay_led, "identityPending": 0, "ledWhy": match overlay_led { "green" => "every window wears its real page-favicon overlay — dashboard matches the taskbar", "amber" => "stamped, overlay not painted yet (or the page had no favicon)", _ => "a window under this button is not identity-stamped yet" } })); }+    }+    wins.sort_by(|a, b| b["openedAt"].as_u64().cmp(&a["openedAt"].as_u64()));+    let mut threads: Vec<String> = wins.iter().filter_map(|w| w["owner"].as_str().map(|s| s.to_string())).collect(); threads.sort(); threads.dedup();+    let mut profiles = serde_json::Map::new();+    for w in &wins { let p = w["profile"].as_str().unwrap_or("").to_string(); let n = profiles.get(&p).and_then(|v| v.as_u64()).unwrap_or(0); profiles.insert(p, json!(n + 1)); }+    let toasts: Vec<Value> = ctx.toasts.lock().unwrap().iter().filter(|t| now.saturating_sub(t["at"].as_u64().unwrap_or(0)) < 15000).cloned().collect();+    json!({+        "ts": now,+        "bridge": { "version": pup_core::version(), "shell": "rust", "platform": std::env::consts::OS, "uptimeMs": ctx.started.elapsed().as_millis() as u64, "depsOk": true, "minimalTouch": ctx.settings.get("minimalTouch", "on") == "on", "flashedPending": 0, "settings": pup_verbs::settings::snapshot(ctx), "win": { "inProcess": true, "why": Value::Null }, "loops": [], "abEnumLastMin": 0 },+        "counts": { "windows": wins.len(), "tabs": wins.iter().map(|w| w["tabCount"].as_u64().unwrap_or(0)).sum::<u64>(), "browsers": ctx.browsers.lock().unwrap().len(), "threads": threads.len() },+        "threads": threads, "profiles": profiles, "taskbarButtons": buttons, "untrackedWindows": [], "toasts": toasts, "regen": Value::Null, "windows": wins,+    })+}++/// The SSE feed: a snapshot every 2 s for as long as the client reads (Node: /dashboard/events).+struct SseReader { ctx: std::sync::Arc<Ctx>, buf: Vec<u8>, pos: usize, last: Option<Instant> }+impl Read for SseReader {+    fn read(&mut self, out: &mut [u8]) -> std::io::Result<usize> {+        if self.pos >= self.buf.len() {+            if let Some(t) = self.last { let el = t.elapsed(); if el < Duration::from_secs(2) { std::thread::sleep(Duration::from_secs(2) - el); } }+            let payload = match std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| snapshot(&self.ctx))) { Ok(v) => v.to_string(), Err(_) => json!({ "error": "snapshot panicked", "ts": pup_core::now_ms() }).to_string() };+            self.buf = format!("data: {payload}\n\n").into_bytes(); self.pos = 0; self.last = Some(Instant::now());+        }+        let n = (self.buf.len() - self.pos).min(out.len());+        out[..n].copy_from_slice(&self.buf[self.pos..self.pos + n]); self.pos += n;+        Ok(n)+    }+}++fn png_1x1() -> Vec<u8> { pup_cdp::base64_decode("iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==").unwrap_or_default() }++/// LED row for the dock card (Node: /api/status).+pub fn api_status(ctx: &Ctx) -> Value {+    let rd = ctx.installer.readiness(&*ctx.host, ctx.prefer_cft());+    let failed = rd["installPhase"] == json!("failed"); let installing = rd["installing"] == json!(true); let cft = rd["chromeForTestingInstalled"] == json!(true);+    let ready = rd["ready"] == json!(true);+    let leds = vec![+        json!({ "key": "chrome", "label": "Chrome for Testing", "state": if failed { "fail" } else if cft { "ok" } else { "warn" }, "detail": if failed { format!("install FAILED: {}", rd["lastError"].as_str().unwrap_or("?")) } else if installing { format!("downloading ({}%)", rd["installProgressPct"].as_u64().unwrap_or(0)) } else if cft { format!("installed, build {}", rd["chromeBuildId"].as_str().unwrap_or("")) } else { "not installed yet".into() }, "short": if cft { "installed" } else if installing { "installing" } else { "not installed" }, "_hint": if cft { Value::Null } else { json!("Run pup_prewarm to install and warm Chrome for Testing before the first window.") } }),+        json!({ "key": "bridge", "label": "Bridge", "state": "ok", "detail": format!("pup {} (rust) answering on port {}", pup_core::version(), ctx.port), "short": "answering", "_hint": Value::Null }),+        json!({ "key": "profile", "label": "Profile", "state": if ready { "ok" } else { "warn" }, "detail": format!("{} window(s) on the durable adom-you profile", ctx.sessions.for_profile("adom-you").len()), "short": if ready { "adom-you" } else { "waiting" }, "_hint": Value::Null }),+    ];+    json!({ "ok": true, "leds": leds, "version": pup_core::version(), "shell": "rust", "windows": ctx.sessions.count(), "sayPhrases": serde_json::from_str::<Value>(SAY_PHRASES).unwrap_or(json!([])) })+}++/// /identity: who the desktop user is (from ~/.adom/session.json + carbon), cached 10 min.+pub fn identity(ctx: &Ctx) -> Value {+    static CACHE: std::sync::Mutex<Option<(Instant, Value)>> = std::sync::Mutex::new(None);+    if let Some((t, v)) = CACHE.lock().unwrap().as_ref() { if t.elapsed() < Duration::from_secs(600) { return v.clone(); } }+    let sess: Value = std::fs::read_to_string(ctx.host.state_dir().join("session.json")).ok().and_then(|s| serde_json::from_str(&s).ok()).unwrap_or(json!({}));+    let token = sess["token"].as_str().or(sess["session_token"].as_str()).or(sess["access_token"].as_str()).or(sess["session"]["token"].as_str()).map(|s| s.to_string());+    let (mut user, mut orgs) = (Value::Null, Vec::new());+    if let Some(t) = &token {+        let agent = ureq::AgentBuilder::new().timeout(Duration::from_secs(6)).build();+        if let Ok(r) = agent.get("https://carbon.adom.inc/user").set("Authorization", &format!("Bearer {t}")).call() { user = r.into_json().unwrap_or(Value::Null); }+        if let Ok(r) = agent.get("https://carbon.adom.inc/user/orgs").set("Authorization", &format!("Bearer {t}")).call() { let j: Value = r.into_json().unwrap_or(json!([])); orgs = j.as_array().cloned().or_else(|| j["orgs"].as_array().cloned()).unwrap_or_default(); }+    }+    let u = if user.is_object() { user } else { sess["user"].clone() };+    let v = json!({ "ok": true, "displayName": u["display_name"].as_str().or(u["displayName"].as_str()).or(u["name"].as_str()), "username": u["name"].as_str().or(u["username"].as_str()), "email": u["email"], "avatarUrl": u["avatar_url"].as_str().or(u["avatarUrl"].as_str()), "avatarB64": ctx.settings.all().get("identityAvatarB64").cloned().unwrap_or(Value::Null), "isAdmin": u["is_admin"].as_bool().or(u["isAdmin"].as_bool()).unwrap_or(false), "orgs": orgs, "signedIn": token.is_some() });+    *CACHE.lock().unwrap() = Some((Instant::now(), v.clone()));+    v+}++fn action(ctx: &Ctx, caller: &Caller, body: &str) -> Value {+    let a: Value = serde_json::from_str(body).unwrap_or(json!({}));+    let act = a["action"].as_str().unwrap_or("");+    let user = Caller { thread: "user-dashboard".into(), reason: format!("dashboard action {act}"), ..caller.clone() };+    match act {+        "close-all" => { let ids: Vec<String> = ctx.sessions.all().iter().map(|s| s.id.clone()).collect(); for id in &ids { let _ = pup_verbs::close_window(ctx, &user, &json!({ "window": id, "takeover": true })); } json!({ "ok": true, "closed": ids.len() }) }+        "close-window" => { let sid = a["sessionId"].as_str().unwrap_or(""); let r = pup_verbs::close_window(ctx, &user, &json!({ "window": sid, "takeover": true })); json!({ "ok": r["ok"] == json!(true), "closed": sid }) }+        "close-tab" => { let r = pup_verbs::tabs::close_tab(ctx, &user, &json!({ "window": a["sessionId"], "tabId": a["tabId"], "takeover": true })); json!({ "ok": r["ok"] == json!(true), "closed": a["tabId"] }) }+        "set-setting" => { let r = pup_verbs::settings::configure(ctx, &json!({ a["key"].as_str().unwrap_or("").to_string(): a["value"].clone() })); json!({ "ok": r["rejected"].as_array().map(|x| x.is_empty()).unwrap_or(false), "settings": r["settings"], "rejected": r["rejected"] }) }+        "test-caption" => { let ms: u64 = ctx.settings.get("fgCaptionMs", "3500").parse().unwrap_or(3500); let _ = ctx.ab.call("desktop_caption", json!({ "text": "pup: this is what a foreground caption looks like", "duration": ms, "expiresInMs": ms, "position": "bottom", "size": "medium", "id": "pup-test-caption" }), &user, Duration::from_secs(6)); json!({ "ok": true, "ms": ms }) }+        "import-scan" | "import-run" => json!({ "ok": false, "error": "browser-login import is not in the Rust build yet (Phase 3)" }),+        _ => json!({ "ok": false, "error": format!("unknown action {act}") }),+    }+}++fn tile_for(ctx: &Ctx, sid: &str) -> Option<Vec<u8>> {+    let s = ctx.sessions.get(sid)?;+    let name = s.owner.clone().unwrap_or(s.id.clone());+    let tile = ctx.host.temp_dir().join("pup-thread-tiles").join(pup_identity::TILE_GEN).join(format!("{}.ico", pup_identity::thread_slug(&name)));+    std::fs::read(tile).ok()+}++/// One function per route; the binary only maps method+path here. None = 404.+pub fn route(ctx: &std::sync::Arc<Ctx>, caller: &Caller, method: &str, path: &str, query: &str, body: &str) -> Option<Reply> {+    let png = |b: Vec<u8>, cache: &str| Some(Reply::Bytes(200, "image/png".into(), b, Some(cache.into())));+    match (method, path) {+        ("GET", "/") | ("GET", "/dashboard") | ("GET", "/dashboard/") => {+            let html = DASHBOARD_HTML.replace("${BRIDGE_VERSION}", pup_core::version()).replace("${JSON.stringify(SAY_PHRASES)}", SAY_PHRASES);+            Some(Reply::Bytes(200, "text/html; charset=utf-8".into(), html.into_bytes(), Some("no-store".into())))+        }+        ("GET", "/dashboard/events") => Some(Reply::Stream(Box::new(SseReader { ctx: ctx.clone(), buf: Vec::new(), pos: 0, last: None }))),+        ("GET", "/dashboard/icon.svg") => Some(Reply::Bytes(200, "image/svg+xml".into(), ICON_SVG.as_bytes().to_vec(), Some("public, max-age=3600".into()))),+        ("GET", "/favicon.ico") => Some(Reply::Bytes(200, "image/svg+xml".into(), ICON_SVG.as_bytes().to_vec(), Some("public, max-age=3600".into()))),+        ("GET", "/dashboard/newbie-panel.js") => Some(Reply::Bytes(200, "application/javascript".into(), assets_gen::get("newbie-panel.js").map(|b| b.to_vec()).unwrap_or_default(), Some("public, max-age=600".into()))),+        ("GET", "/dashboard/example") => { let n = q(query, "name").unwrap_or_default(); assets_gen::get(&format!("icons/settings-ex/{n}.png")).map(|b| Reply::Bytes(200, "image/png".into(), b.to_vec(), Some("no-store".into()))) }+        ("GET", "/dashboard/sample-favicon") => { let n = q(query, "name").unwrap_or_default(); let (file, ct) = match n.as_str() { "wiki" => ("wiki.svg", "image/svg+xml"), "ti" => ("ti.ico", "image/x-icon"), "mouser" => ("mouser.ico", "image/x-icon"), "digikey" => ("digikey.svg", "image/svg+xml"), _ => return None }; assets_gen::get(&format!("icons/settings-samples/{file}")).map(|b| Reply::Bytes(200, ct.into(), b.to_vec(), Some("public, max-age=3600".into()))) }+        ("GET", "/dashboard/sample-cat") => { let n = q(query, "name").unwrap_or_default(); pup_identity::ICONS.iter().find(|(name, _)| *name == n || name.trim_end_matches(".ico") == n.trim_end_matches(".ico")).map(|(_, b)| Reply::Bytes(200, "image/x-icon".into(), b.to_vec(), Some("public, max-age=3600".into()))) }+        ("GET", "/dashboard/stampicon") => { let sid = q(query, "session").unwrap_or_default(); match tile_for(ctx, &sid) { Some(b) => Some(Reply::Bytes(200, "image/x-icon".into(), b, Some("public, max-age=60".into()))), None => Some(Reply::Bytes(200, "image/x-icon".into(), pup_identity::ICONS[1].1.to_vec(), Some("public, max-age=60".into()))) } }+        ("GET", "/dashboard/badge") | ("GET", "/dashboard/bestbadge") => { let sid = q(query, "session").unwrap_or_default(); let f = ctx.host.temp_dir().join("pup-badge-debug").join(format!("{}.png", pup_session::sanitize_sid(&sid))); match std::fs::read(f) { Ok(b) => png(b, "public, max-age=30"), Err(_) => png(png_1x1(), "no-store") } }+        ("GET", "/dashboard/baseicon") => Some(Reply::Bytes(200, "image/x-icon".into(), pup_identity::ICONS[0].1.to_vec(), Some("public, max-age=3600".into()))),+        ("GET", "/dashboard/favicon") => {+            let sid = q(query, "session").unwrap_or_default();+            let s = ctx.sessions.get(&sid)?; let t = q(query, "tab").and_then(|id| s.tab_by_id(&id).cloned()).or_else(|| s.active().cloned())?;+            let b = pup_verbs::browser_for(ctx, &s.profile)?;+            let js = r#"(async () => { const l = document.querySelector('link[rel~="icon"], link[rel="shortcut icon"]'); const href = (l && l.href) || (location.origin + '/favicon.ico'); try { const r = await fetch(href, { credentials: 'include' }); if (!r.ok) return null; const bl = await r.blob(); return await new Promise(res => { const fr = new FileReader(); fr.onload = () => res(fr.result); fr.onerror = () => res(null); fr.readAsDataURL(bl); }); } catch (e) { return null; } })()"#;+            let generic = || Some(Reply::Bytes(200, "image/svg+xml".into(), ICON_SVG.as_bytes().to_vec(), Some("public, max-age=60".into())));+            let Some(data) = b.cdp.evaluate(&t.cdp_session, js, Duration::from_secs(8)).ok().and_then(|v| v.as_str().map(|s| s.to_string())) else { return generic() };+            let Some((mime, b64)) = data.trim_start_matches("data:").split_once(";base64,") else { return generic() };+            match pup_cdp::base64_decode(b64) { Ok(bytes) if !bytes.is_empty() => Some(Reply::Bytes(200, mime.to_string(), bytes, Some("public, max-age=60".into()))), _ => generic() }+        }+        ("GET", "/dashboard/apply-progress") => Some(Reply::Json(200, json!({ "ok": true, "apply": Value::Null }))),+        ("POST", "/dashboard/toast") | ("POST", "/ui/toast") => {+            let b: Value = serde_json::from_str(body).unwrap_or(json!({}));+            let msg = b["msg"].as_str().or(b["message"].as_str()).unwrap_or("").chars().take(200).collect::<String>();+            if msg.is_empty() { return Some(Reply::Json(200, json!({ "ok": false, "error": "msg required" }))); }+            let mut t = ctx.toasts.lock().unwrap(); let id = t.len() as u64 + 1;+            t.push(json!({ "id": id, "msg": msg, "type": if ["success", "error", "info"].contains(&b["type"].as_str().unwrap_or("")) { b["type"].clone() } else { json!("info") }, "at": pup_core::now_ms() }));+            while t.len() > 20 { t.remove(0); }+            Some(Reply::Json(200, json!({ "ok": true })))+        }+        ("POST", "/dashboard/action") => Some(Reply::Json(200, action(ctx, caller, body))),+        ("GET", "/api/status") => Some(Reply::Json(200, api_status(ctx))),+        ("GET", "/identity") => Some(Reply::Json(200, identity(ctx))),+        ("POST", "/api/demo-send") | ("POST", "/ai-threads/run-prompt") | ("GET", "/ai-threads/run-prompt/status") => Some(Reply::Json(501, json!({ "success": false, "errorCode": "not_in_rust_yet", "error": "Send-to-AI (Hydrogen proxy) lands in Phase 3 of the Rust port" }))),+        _ => None,+    }+}