Altium - the Altium Bridge

@@ -10,7 +10,7 @@ checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa"  [[package]] name = "altium-bridge"-version = "0.2.1"+version = "0.2.8" dependencies = [  "getrandom",  "serde",

@@ -1,6 +1,6 @@ [package] name = "altium-bridge"-version = "0.2.3"+version = "0.2.8" edition = "2021" description = "Adom altium-bridge — the bridge process, in Rust. Calls ab's verbs for the desktop; speaks file IPC to the resident DelphiScript agent inside Altium." license = "MIT"

@@ -99,6 +99,13 @@ fn snapshot() -> (Vec<Value>, Vec<Value>) {     (procs, windows) } +/// Every live X2.exe pid (main window or not) — the close watchdog needs "process alive,+/// window gone", which instances() alone cannot express.+pub fn x2_pids() -> Vec<u64> {+    let (procs, _) = snapshot();+    procs.iter().filter_map(|p| p.get("pid").and_then(|v| v.as_u64())).collect()+}+ pub fn invalidate_snapshot() {     if let Ok(mut g) = SNAP.lock() {         *g = None;

@@ -467,6 +467,22 @@ fn valid_lib_name(name: &str) -> bool { /// folder), install into the user's Installed Libraries, optionally return a proof frame. /// Hardened for untrusted zips: size caps, zip-slip refusal. pub fn install_library_bundle(args: &Value) -> Value {+    // One-click parity with the KiCad/Fusion lanes (Colby, adom/altium-bridge#5): from a cold+    // state, launch Altium first (measured cold start on the taskbar bar), then register. The+    // resident agent bootstraps on the first agent call. Safe to ship now that the close+    // watchdog (#4) exits the agent on a user-initiated close.+    let mut launched = Value::Null;+    if crate::instance::licence_state().get("running").and_then(|b| b.as_bool()) != Some(true) {+        let lr = crate::misc::launch(&json!({"waitSec": 240}));+        if lr.get("success").and_then(|b| b.as_bool()) != Some(true) {+            let mut out = lr;+            out["failedAt"] = json!("launch");+            out["_hint"] = json!("Altium was closed and could not be launched for the install — see error; altium_launch to retry.");+            return out;+        }+        launched = json!({"coldStartSec": lr.get("startedInSec"), "note": "Altium was closed; launched it for the install"});+        crate::instance::invalidate_snapshot();+    }     if let Some(g) = support::need_licensed() {         return g;     }@@ -570,7 +586,7 @@ pub fn install_library_bundle(args: &Value) -> Value {     let st = agent::call("state", &[], None, Duration::from_secs(30));     let running = st.get("windows").map(|w| !w.is_null()).unwrap_or(false)         || st.get("data").and_then(|d| d.get("windows")).map(|w| !w.is_null()).unwrap_or(false);-    let mut out = json!({"success": true,+    let mut out = json!({"success": true, "launched": launched,         "library": if name.is_empty() { stem } else { name },         "symbols": schlibs.len(), "footprints": pcblibs.len(), "intlibs": intlibs.len(),         "installed": installed, "altiumRunning": running, "restartNeeded": running,

@@ -570,6 +570,77 @@ pub fn launch(wait: Duration) -> Value { // NOTE: application close lives in misc::close (the seat-guarded verb); the old lifecycle-level // close was removed when it landed — one close path, one seat rule. +// ---- user-initiated-close watchdog (Colby Knox, adom/altium-bridge#4 + PR 74, ported) -------+//+// altium_close tears the agent down BEFORE its WM_CLOSE, but a user pressing the window X goes+// straight to Altium: shutdown then unloads the scripting engine under a LIVE agent loop, and the+// close can wedge — X2 lingered headless and hard-froze the desktop until it was killed+// (2026-09-02). Standing service: every 2 s, for every workspace with a live heartbeat, detect+// the CLOSING state (that instance's main window gone while an X2 process still lives) and drop+// the stop file THAT INSTANT so the loop's next tick exits it during the shutdown instead of+// wedging under it. Read-only detection plus a file drop: no Altium call, no focus. Honest limit:+// a 2 s poll race, not a guarantee — the complete fix is the agent noticing shutdown itself.++static CLOSE_WATCHDOG: std::sync::atomic::AtomicBool = std::sync::atomic::AtomicBool::new(false);++fn close_watch_once(seen: &mut std::collections::BTreeSet<String>) -> Vec<String> {+    let root = agent::cache_dir().join("agent");+    let mut workspaces: Vec<(String, PathBuf)> = vec![("legacy".into(), root.clone())];+    if let Ok(rd) = std::fs::read_dir(&root) {+        for e in rd.flatten() {+            if e.path().is_dir() {+                workspaces.push((e.file_name().to_string_lossy().to_string(), e.path()));+            }+        }+    }+    let live: Vec<(String, PathBuf)> = workspaces.into_iter().filter(|(_, ws)| {+        std::fs::metadata(ws.join("hb.txt")).and_then(|m| m.modified()).ok()+            .and_then(|t| std::time::SystemTime::now().duration_since(t).ok())+            .map(|d| d < Duration::from_secs(agent::ALIVE_SEC)).unwrap_or(false)+    }).collect();+    if live.is_empty() {+        return Vec::new();+    }+    crate::instance::invalidate_snapshot();+    let keys_with_windows: std::collections::BTreeSet<String> = crate::instance::instances().iter()+        .filter_map(|i| i.get("key").and_then(|k| k.as_str()).map(str::to_string)).collect();+    let any_x2 = !crate::instance::x2_pids().is_empty();+    let mut dropped = Vec::new();+    for (key, ws) in live {+        let has_window = if key == "legacy" { !keys_with_windows.is_empty() } else { keys_with_windows.contains(&key) };+        if has_window {+            seen.insert(key);+            continue;+        }+        // window gone. Only a workspace we have SEEN with a window counts as closing — a cold+        // start (pid up, window not yet created) must never fire this.+        if seen.contains(&key) && any_x2 {+            let _ = std::fs::write(ws.join("stop"), "1");+            seen.remove(&key);+            dropped.push(key);+        }+    }+    dropped+}++pub fn start_close_watchdog() -> bool {+    if CLOSE_WATCHDOG.swap(true, std::sync::atomic::Ordering::SeqCst) {+        return false;+    }+    std::thread::Builder::new().name("altium-agent-close-watchdog".into()).spawn(|| {+        let mut seen = std::collections::BTreeSet::new();+        loop {+            std::thread::sleep(Duration::from_secs(2));+            let _ = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {+                for key in close_watch_once(&mut seen) {+                    crate::dialogs::note_event(json!({"closeWatchdog": key,+                        "note": "main window gone while X2 still alive — stop file dropped so the resident agent exits during the shutdown instead of wedging under it (adom/altium-bridge#4)"}));+                }+            }));+        }+    }).is_ok()+}+ // ---- sha256 (no external crate) ----------------------------------------------  pub fn sha256_hex(data: &[u8]) -> String {

@@ -24,7 +24,7 @@ mod verbs; use std::time::Instant; use tiny_http::{Header, Method, Response, Server}; -pub const BRIDGE_VERSION: &str = "0.2.3";+pub const BRIDGE_VERSION: &str = "0.2.8";  fn json_response(status: u16, body: &serde_json::Value) -> Response<std::io::Cursor<Vec<u8>>> {     let data = serde_json::to_vec(body).unwrap_or_else(|_| b"{}".to_vec());@@ -50,6 +50,7 @@ fn main() {     // ever showing up"), the idle watcher clears the taskbar overlay after 5 quiet minutes.     dialogs::start_reaper();     taskbar::start_idle_watcher();+    lifecycle::start_close_watchdog(); // adom/altium-bridge#4: exit the agent the instant a user-initiated close begins     for mut req in server.incoming_requests() {         let t0 = Instant::now();         let path = req.url().to_string();

@@ -33,6 +33,7 @@ fn default_seconds(phase: &str) -> Option<f64> {         "run_outjob" => 60.0,         "export" => 8.0,         "demo" => 210.0,+        "demo_live_stage" => 12.0,         _ => return None,     }) }

@@ -357,9 +357,21 @@ pub fn foreground(args: &Value) -> Value {     };     let hwnd = mw.get("hwnd").cloned().unwrap_or(Value::Null);     let r = crate::ab::call("desktop_raise_window", json!({"hwnd": hwnd, "reason": reason}), &[], 15);+    // VERIFY, don't assume: a raise can "succeed" while another fullscreen window (the user's+    // chat window, a remote-desktop layer) still covers Altium — John watched a whole show that+    // never became visible because his Claude window was fullscreen on top (2026-09-02).+    let top = crate::ab::call("desktop_list_windows", json!({}), &[], 10);+    let top_hwnd = top.get("data").and_then(|d| d.get("windows")).or_else(|| top.get("windows"))+        .and_then(|w| w.as_array()).and_then(|a| a.first())+        .and_then(|w| w.get("hwnd")).cloned().unwrap_or(Value::Null);+    let visibly_on_top = top_hwnd == hwnd;     json!({"success": r.get("success").and_then(|b| b.as_bool()).unwrap_or(true),-        "hwnd": hwnd, "windowEtiquette": "foreground",-        "_hint": "Altium is now in front of the user. Hand their screen back when the show ends (their own window regains focus when they click; the bridge never needs to force it)."})+        "hwnd": hwnd, "windowEtiquette": "foreground", "visiblyOnTop": visibly_on_top,+        "_hint": if visibly_on_top {+            "Altium is now visibly in front of the user. Hand their screen back when the show ends (their own window regains focus when they click; the bridge never needs to force it)."+        } else {+            "The raise was issued but another window still covers Altium (often the user's own fullscreen chat window — if they are typing to YOU, your raise loses to their activity, correctly). Do not re-raise in a loop; TELL the user Altium is ready behind their current window."+        }}) }  /// One choreography step -> (process, params) for the given lane, or None for an unknown step.@@ -577,7 +589,17 @@ pub fn demo_live(args: &Value) -> Value {     for (proc_, params) in b.setup {         agent::call("run_process", &[("process", proc_.to_string()), ("params", params.to_string())], None, Duration::from_secs(60));     }-    foreground(&json!({"reason": "The user asked to WATCH this tour live — keeping Altium in front"}));+    // Foreground ONCE, at the first stop (John, 2026-09-02: "just foreground altium once. then+    // don't try to foreground again for the rest of the demo"). The opening raise is an+    // invitation; re-raising every stop would drag back a user who deliberately switched away+    // mid-show. Documents keep opening in Altium either way.+    let mut fg_note = Value::Null;+    if stage == 0 {+        let fg = foreground(&json!({"reason": "The user asked to WATCH this tour live — bringing Altium in front once, at the start"}));+        if fg.get("visiblyOnTop").and_then(|b| b.as_bool()) == Some(false) {+            fg_note = json!("Altium was raised but another window still covers it (often the user's own fullscreen chat window). Do NOT re-raise; tell the user the show is running behind their current window.");+        }+    }     let anim = animate_view(&json!({"lane": b.lane, "preset": b.preset}));     let next_stage = stage + 1;     let next_narrate = beats.get(next_stage).map(|nb| nb.narrate);@@ -586,6 +608,7 @@ pub fn demo_live(args: &Value) -> Value {         "nextNarrate": next_narrate,         "animation": {"preset": b.preset, "stepsRun": anim.get("stepsRun"), "elapsedSec": anim.get("elapsedSec")},         "elapsedSec": support::elapsed_round(t0), "windowEtiquette": "foreground",+        "foregroundNote": fg_note,         "nextCall": {"verb": "altium_demo", "args": {"live": true, "stage": next_stage}},         "_hint": "SYNC MODEL (best): pre-cache the whole narration once with `adom-tts load` (one marker per stop), then per stop fire `adom-tts cue <id> <n> --confirm` in the background and IMMEDIATELY make nextCall — the prefetched cue starts instantly and this verb's in-bridge choreography (~5-17s) runs under the voice; advance when BOTH finish. Fallback without 1.9.47: say --play detached per stop. On the last call (done:true) restore the user's own document."}) }

@@ -177,11 +177,19 @@ pub fn handle(command: &str, args: &Value, forwarded: &[(String, String)]) -> Va     let driving = !matches!(cmd, "readiness" | "status" | "describe" | "diagnostics" | "window_info"         | "check_dialogs" | "progress" | "agent_status" | "list_commands" | "state" | "instances" | "dialog_log")         && !cmd.starts_with("a365_");+    // The pacing phase: a live demo STAGE is a ~12s beat, not the 210s full background tour —+    // pacing it by the "demo" seed left the taskbar bar crawling 0→7% per stop, which John read+    // as no bar at all (2026-09-02).+    let phase = if cmd == "demo" && args.get("live").and_then(|b| b.as_bool()) == Some(true) {+        "demo_live_stage"+    } else {+        cmd+    };     let mut bar_started = false;     if driving {         taskbar::set_driving_badge();         taskbar::note_driving(); // feeds the 5-min idle clock that auto-clears the overlay-        let (est, conf) = progress::estimate(cmd, "warm");+        let (est, conf) = progress::estimate(phase, "warm");         if est >= 3.0 {             taskbar::start_activity_progress(cmd, Some(est), &conf);             bar_started = true;@@ -193,6 +201,11 @@ pub fn handle(command: &str, args: &Value, forwarded: &[(String, String)]) -> Va     progress::log_run(cmd, t0.elapsed().as_secs_f64(), ok);     if bar_started {         taskbar::end_activity_progress(cmd, !ok);+        if ok {+            // feed the SAME key the estimate reads, so bars converge on this machine's truth+            // (measured > typical > unknown — the ladder only climbs if we record here)+            progress::record(phase, t0.elapsed().as_secs_f64(), "warm");+        }     }     out }