Adom TTS: Text to Speech

@@ -42,7 +42,7 @@ const SERVER_MAX_TIMEOUT_SECS: u64 = 300; /// VSCODE_PROXY_URI) and builds an unreachable 127.0.0.1 player URL, killing /// playback for EVERY thread until superseded. So: every caller that HAS the /// good env persists it, and the drainer adopts whatever it's missing.-const SURFACE_ENV_VARS: &[&str] = &["VSCODE_PROXY_URI", "VSCODE_IPC_HOOK_CLI", "ADOM_DESKTOP_TARGET"];+const SURFACE_ENV_VARS: &[&str] = &["VSCODE_PROXY_URI", "VSCODE_IPC_HOOK_CLI", "ADOM_BRIDGE_TARGET", "ADOM_DESKTOP_TARGET"];  fn persist_surface_env() {     let Ok(home) = tts_home() else { return };@@ -55,7 +55,7 @@ fn persist_surface_env() {     // Persist if we captured anything useful — either the proxy env (Hydrogen)     // or the desktop target (pup). Merge into any existing snapshot so a pup     // shell doesn't wipe a Hydrogen shell's VSCODE_PROXY_URI and vice-versa.-    if map.contains_key("VSCODE_PROXY_URI") || map.contains_key("ADOM_DESKTOP_TARGET") {+    if map.contains_key("VSCODE_PROXY_URI") || map.contains_key("ADOM_BRIDGE_TARGET") || map.contains_key("ADOM_DESKTOP_TARGET") {         let _ = std::fs::create_dir_all(home.join(".adom/tts"));         let path = home.join(".adom/tts/env.json");         let mut merged: serde_json::Map<String, serde_json::Value> =@@ -241,7 +241,7 @@ pub fn show_status() -> Result<()> {                     // not "playing". This misled a reporting thread into thinking                     // its clip vanished while the surface was actually never open.                     playing_line = format!(-                        "  ⚠ STALLED{what} on :{port} — 0s / {dur:.0}s, no audio sink (player surface not open, {}s silent).\n  # hint: likely an unpinned pup target with >1 desktop, or a dead bridge. Fix:\n  #       export ADOM_DESKTOP_TARGET=<host> && adom-tts restart   (see `adom-tts logs`).",+                        "  ⚠ STALLED{what} on :{port} — 0s / {dur:.0}s, no audio sink (player surface not open, {}s silent).\n  # hint: likely an unpinned pup target with >1 Bridge machine, or Bridge itself down. Fix:\n  #       export ADOM_BRIDGE_TARGET=<host> && adom-tts restart   (see `adom-tts logs`).",                         poll_age / 1000);                 } else if paused {                     // The HUMAN paused — say so loudly; "now playing" here misled@@ -368,7 +368,7 @@ pub fn check_clip(clip: &str) -> Result<()> {                 println!("#       the live player page IS at: {url}  (open it, or `adom-tts reopen`)");             }             println!("# hint: the DEFAULT 'hydrogen' webview surface is reliable — re-send WITHOUT `--surface pup`.");-            println!("#       (For pup: export ADOM_DESKTOP_TARGET=<host> && adom-tts restart, then re-send.)");+            println!("#       (For pup: export ADOM_BRIDGE_TARGET=<host> && adom-tts restart, then re-send.)");             std::process::exit(5);         }         Some(v) if v == "stale-audio" => {@@ -963,7 +963,7 @@ pub fn drain(surface_cli: Option<Surface>) -> Result<()> {                                         if surface == Surface::Pup {                                             eprintln!("#   Open that URL in pup, OR retry WITHOUT `--surface pup` — the DEFAULT");                                             eprintln!("#   'hydrogen' webview surface is reliable and was live.");-                                            eprintln!("#   (To pin pup: export ADOM_DESKTOP_TARGET=<host> && adom-tts restart.)");+                                            eprintln!("#   (To pin pup: export ADOM_BRIDGE_TARGET=<host> && adom-tts restart.)");                                         } else {                                             eprintln!("#   Open that URL, or `adom-tts reopen` to re-surface; `adom-tts logs` for the open error.");                                         }@@ -1432,32 +1432,39 @@ fn find_panel_id_for_tab(name: &str) -> Result<Option<String>> {  fn close_pup_window(session: &str) -> Result<()> {     let payload = serde_json::json!({"sessionId": session}).to_string();-    let _ = Command::new("adom-desktop")-        .args(["browser_close_window", &payload])+    let _ = Command::new("adom-bridge-cli")+        .args(["pup_close_window", &payload])         .output();     Ok(()) } -/// Which Adom Desktop should pup open on? A drainer is long-lived and may have-/// started before ADOM_DESKTOP_TARGET was set, so RESOLVE FRESH every call:-/// live env (possibly adopted) -> the persisted env.json -> if exactly one-/// desktop is connected, that one. Returns (target, connected_count) so the-/// caller can raise a precise AMBIGUOUS error when >1 desktop and none pinned.-fn resolve_desktop_target() -> (Option<String>, usize) {-    if let Ok(t) = std::env::var("ADOM_DESKTOP_TARGET") {-        let t = t.trim().to_string();-        if !t.is_empty() { return (Some(t), 0); }+/// Which Bridge machine should pup open on? (Bridge = ab, the app formerly+/// named "Adom Desktop"; the 2026-08 cutover renamed the CLI to+/// `adom-bridge-cli` and every browser_* verb to pup_*.) A drainer is+/// long-lived and may have started before ADOM_BRIDGE_TARGET was set, so+/// RESOLVE FRESH every call: live env (possibly adopted) -> the persisted+/// env.json -> if exactly one machine is connected, that one. Returns+/// (target, connected_count) so the caller can raise a precise AMBIGUOUS+/// error when >1 machine and none pinned. ADOM_DESKTOP_TARGET is read as a+/// fallback so pre-rename shells keep working.+fn resolve_bridge_target() -> (Option<String>, usize) {+    for var in ["ADOM_BRIDGE_TARGET", "ADOM_DESKTOP_TARGET"] {+        if let Ok(t) = std::env::var(var) {+            let t = t.trim().to_string();+            if !t.is_empty() { return (Some(t), 0); }+        }     }     if let Ok(home) = tts_home() {         if let Some(t) = std::fs::read_to_string(home.join(".adom/tts/env.json")).ok()             .and_then(|r| serde_json::from_str::<serde_json::Value>(&r).ok())-            .and_then(|v| v.get("ADOM_DESKTOP_TARGET").and_then(|x| x.as_str()).map(str::to_string))+            .and_then(|v| ["ADOM_BRIDGE_TARGET", "ADOM_DESKTOP_TARGET"].iter()+                .find_map(|k| v.get(*k).and_then(|x| x.as_str()).map(str::to_string)))             .filter(|t| !t.is_empty()) {             return (Some(t), 0);         }     }-    // Ask the bridge how many desktops are connected.-    let names: Vec<String> = Command::new("adom-desktop").arg("targets").output().ok()+    // Ask Bridge how many machines are connected.+    let names: Vec<String> = Command::new("adom-bridge-cli").arg("targets").output().ok()         .filter(|o| o.status.success())         .and_then(|o| serde_json::from_slice::<serde_json::Value>(&o.stdout).ok())         .and_then(|v| v.get("targets").and_then(|t| t.as_array()).map(|a|@@ -1467,12 +1474,13 @@ fn resolve_desktop_target() -> (Option<String>, usize) { }  fn open_pup_window(url: &str, session: &str, profile: &str) -> Result<()> {-    // PIN THE TARGET. With >1 desktop connected and no target, browser_open_window-    // is ambiguous and fails silently — the wedge this whole path guards against.-    let (target, count) = resolve_desktop_target();+    // PIN THE TARGET. With >1 Bridge machine connected and no target,+    // pup_open_window is ambiguous and fails silently — the wedge this whole+    // path guards against.+    let (target, count) = resolve_bridge_target();     if target.is_none() && count > 1 {-        anyhow::bail!("AMBIGUOUS pup target: {count} Adom Desktops connected and no ADOM_DESKTOP_TARGET set. \-Pin it so the drainer knows which screen: `export ADOM_DESKTOP_TARGET=<host>` then `adom-tts restart`");+        anyhow::bail!("AMBIGUOUS pup target: {count} Bridge machines connected and no ADOM_BRIDGE_TARGET set. \+Pin it so the drainer knows which screen: `export ADOM_BRIDGE_TARGET=<host>` then `adom-tts restart`");     }     let with_target = |c: &mut Command| { if let Some(t) = &target { c.arg("--target").arg(t); } }; @@ -1488,15 +1496,15 @@ Pin it so the drainer knows which screen: `export ADOM_DESKTOP_TARGET=<host>` th         // root of the original "--surface pup never plays" field report.         "foreground": true,     }).to_string();-    let mut open_cmd = Command::new("adom-desktop");+    let mut open_cmd = Command::new("adom-bridge-cli");     with_target(&mut open_cmd);     let out = open_cmd-        .arg("browser_open_window")+        .arg("pup_open_window")         .arg(&open_args)         .output()-        .context("invoke adom-desktop browser_open_window")?;+        .context("invoke adom-bridge-cli pup_open_window")?;     if !out.status.success() {-        anyhow::bail!("adom-desktop browser_open_window failed: {}",+        anyhow::bail!("adom-bridge-cli pup_open_window failed: {}",             String::from_utf8_lossy(&out.stderr));     } @@ -1510,10 +1518,10 @@ Pin it so the drainer knows which screen: `export ADOM_DESKTOP_TARGET=<host>` th         "sessionId": session,         "expr": "(function(){var el=document.querySelector('audio');if(el&&el.paused&&!el.ended&&el.currentTime===0)el.play();})()",     }).to_string();-    let mut eval_cmd = Command::new("adom-desktop");+    let mut eval_cmd = Command::new("adom-bridge-cli");     with_target(&mut eval_cmd);     let _ = eval_cmd-        .arg("browser_eval")+        .arg("pup_eval")         .arg(&eval_args)         .output();     Ok(())@@ -2009,7 +2017,7 @@ pub fn reopen() -> Result<()> { /// re-offers the tab but keeps a broken player; this replaces the player. /// Queued clips survive (they live in the queue dir, not the drainer). pub fn restart(force: bool) -> Result<()> {-    persist_surface_env();   // capture THIS shell's env (incl ADOM_DESKTOP_TARGET)+    persist_surface_env();   // capture THIS shell's env (incl ADOM_BRIDGE_TARGET)     // PAUSE-IS-SACRED, RESTART EDITION. Field incident: the human paused a clip     // (their kid asked a question), an ops restart killed the drainer 81s later,     // and the paused clip was swept — they could never resume it. A clip that is@@ -2065,10 +2073,10 @@ pub fn restart(force: bool) -> Result<()> {         Some(p) => println!("→ restarted: killed stale drainer {p}; spawned a fresh {} player.", surface.as_str()),         None => println!("→ restarted: no drainer owned the lock; spawned a fresh {} player.", surface.as_str()),     }-    let (t, n) = resolve_desktop_target();+    let (t, n) = resolve_bridge_target();     match (surface, &t) {-        (Surface::Pup, Some(t)) => println!("  pinned to Adom Desktop target: {t}"),-        (Surface::Pup, None) if n > 1 => println!("  ⚠ {n} desktops connected and NO target set — export ADOM_DESKTOP_TARGET=<host> and restart again."),+        (Surface::Pup, Some(t)) => println!("  pinned to Bridge target: {t}"),+        (Surface::Pup, None) if n > 1 => println!("  ⚠ {n} Bridge machines connected and NO target set — export ADOM_BRIDGE_TARGET=<host> and restart again."),         _ => {}     }     println!("# hint: queued clips survive and drain in order on the fresh player.");