Fusion - the Fusion 360 Bridge

@@ -145,6 +145,57 @@ impl Sidecar {     } } +/// Phase 3 layer 1: the readiness SNAPSHOT, pure and in-process, the same shape as the+/// Python bridge's `_build_status()` (installed / running / add-in probe / chip fields).+/// The probes run at most every 5 s (a health poll must never stall: ab reaps a bridge+/// whose /status hangs, and that killed two ten-part imports once).+struct Snapshot { at: Instant, body: Value }+static SNAPSHOT: Mutex<Option<Snapshot>> = Mutex::new(None);++fn addin_probe() -> Value {+    ureq::get("http://127.0.0.1:8774/status").timeout(Duration::from_millis(1500)).call().ok()+        .and_then(|r| r.into_json::<Value>().ok()).unwrap_or(Value::Null)+}++fn native_status(h: &dyn HostBoth) -> Value {+    if let Some(s) = SNAPSHOT.lock().unwrap().as_ref() { if s.at.elapsed() < Duration::from_secs(5) { return s.body.clone(); } }+    let exe = h.fusion_executable();+    let installed = exe.is_some();+    let dirs = h.addin_dirs();+    let addins_dir = dirs.iter().find(|d| d.exists()).cloned().or_else(|| dirs.first().cloned());+    let addin_installed = dirs.iter().any(|d| d.join("AdomBridge").join("AdomBridge.py").is_file());+    let running = !h.fusion_processes().is_empty();+    let addin = if running { addin_probe() } else { Value::Null };+    let addin_ok = addin.is_object();+    // layer 2: the window facts, from ab (never local Win32)+    let facts = if running {+        match fusion_core::ab::Loopback::from_env() { Some(ab) => fusion_core::windows_facts::facts_from_ab(&ab, &Caller::default()), None => fusion_core::windows_facts::WindowFacts { degraded: true, ..Default::default() } }+    } else { fusion_core::windows_facts::WindowFacts::default() };+    let (led, summary, tooltip) = if !cfg!(windows) {+        ("yellow", "Unsupported OS", "Bridge running, but this host is not Windows. Fusion 360 verbs need a Windows host with Fusion 360 installed.")+    } else if !installed {+        ("yellow", "Fusion not installed", "Bridge running, but Fusion 360 is not installed. The AI can install it for the user (fusion-onboarding), then fusion_start.")+    } else if !running {+        ("yellow", "Fusion not running", "Fusion 360 is installed but not running. Call fusion_start to launch it.")+    } else if !addin_ok {+        ("yellow", "Add-in not connected", "Fusion 360 is running but the AdomBridge add-in isn't responding yet (still loading; if it persists the AI restarts Fusion via fusion_stop/start).")+    } else {+        ("green", "Fusion ready", "Fusion 360 running, AdomBridge add-in connected. All fusion_* verbs available.")+    };+    let body = json!({+        "status": "ok", "busy": false, "longOp": Value::Null,+        "led": led, "summary": summary, "tooltip": tooltip, "bridgeVersion": VERSION,+        "fusion": {"installed": installed, "exe_path": exe.map(|p| p.to_string_lossy().to_string()),+                   "addins_dir": addins_dir.map(|p| p.to_string_lossy().to_string()),+                   "addin_installed": addin_installed, "running": running},+        "addin": addin, "shell": "rust",+        "needsSignin": facts.needs_signin, "licensingDialog": facts.licensing_dialog.is_some(),+        "windowTitle": facts.main_title, "windowFactsDegraded": facts.degraded,+    });+    *SNAPSHOT.lock().unwrap() = Some(Snapshot { at: Instant::now(), body: body.clone() });+    body+}+ fn pick_free_port() -> u16 {     std::net::TcpListener::bind("127.0.0.1:0").and_then(|l| l.local_addr()).map(|a| a.port()).unwrap_or(8773) }@@ -200,14 +251,10 @@ fn main() {             (Method::Get, "/status") | (Method::Get, "/health") => {                 // Prefer the sidecar's rich status (Fusion/add-in probe) while it exists;                 // this process is up regardless, so the answer is ALWAYS 2xx.-                let mut body = json!({-                    "status": "ok", "busy": false, "led": "yellow",-                    "summary": "Fusion bridge (Rust shell) starting",-                    "tooltip": "The Rust bridge is up; its Python sidecar is still coming up.",-                    "bridgeVersion": VERSION, "shell": "rust",-                    "fusion": {"installed": h.fusion_executable().is_some(),-                               "running": !h.fusion_processes().is_empty()},-                });+                // Without a sidecar this IS the answer; with one, the sidecar's rich status+                // wins and the native snapshot rides beside it for parity checks.+                let native = native_status(h.as_ref());+                let mut body = native.clone();                 if let Some(sc) = sidecar.lock().unwrap().as_mut() {                     if let Some(code) = sc.exited() {                         body["led"] = json!("red"); body["status"] = json!("error");@@ -218,6 +265,8 @@ fn main() {                         if let Ok(mut v) = r.into_json::<Value>() {                             v["shell"] = json!("rust"); v["sidecarPort"] = json!(sc.port);                             v["sidecarUptimeSec"] = json!(sc.started.elapsed().as_secs());+                            v["nativeSnapshot"] = json!({"led": native["led"], "summary": native["summary"], "fusion": native["fusion"], "addinOk": native["addin"].is_object(),+                                                         "needsSignin": native["needsSignin"], "licensingDialog": native["licensingDialog"], "windowTitle": native["windowTitle"], "windowFactsDegraded": native["windowFactsDegraded"]});                             body = v;                         }                     }@@ -255,6 +304,7 @@ fn main() {                     "fusion_aps_download" | "aps_download" => native_aps_download(&parsed["args"]),                     "fusion_aps_create_folder" | "aps_create_folder" => native_aps_create_folder(&parsed["args"]),                     "fusion_aps_upload" | "aps_upload" => native_aps_upload(&parsed["args"]),+                    "fusion_aps_status" | "aps_status" => native_aps_status(&sidecar, &caller),                     "shell_info" => json!({"success": true, "shell": "rust", "bridgeVersion": VERSION,                                           "contractFrozen": catalog.frozen,                                           "_hint": "Rust plumbing shell; every catalogued verb is served, natively or via the Python sidecar."}),@@ -709,3 +759,39 @@ fn native_aps_upload(args: &Value) -> Value {     json!({"success": true, "output": format!("Uploaded '{fname}' ({pretty} bytes) as a new cloud file."),            "data": {"itemUrn": b["data"]["id"], "name": fname, "bytes": n, "projectId": pid, "folderId": fid}, "shell": "rust"}) }+++/// `fusion_aps_status`: configured / signed in (usable NOW, refreshed if needed) / who /+/// the never-charge meter. `signinPending` is the sidecar's in-memory sign-in state while+/// it still owns the PKCE flow, so it is asked for that one field.+fn native_aps_status(sidecar: &Arc<Mutex<Option<Sidecar>>>, caller: &Caller) -> Value {+    use fusion_core::aps::*;+    let store = ApsStore::default_location();+    let client_id = store.client_id();+    let tok = store.tokens();+    let has_at = tok["access_token"].as_str().map(|s| !s.is_empty()).unwrap_or(false);+    let now = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).map(|d| d.as_secs()).unwrap_or(0);+    let live = has_at && tok["expires_at"].as_u64().unwrap_or(0) > now;+    let usable = if live { true } else if has_at { store.valid_access_token().is_some() } else { false };+    let refresh_failed = has_at && !usable;+    let pending = if sidecar.lock().unwrap().is_some() {+        let r = proxy(sidecar, &json!({"command": "aps_status", "args": {}}).to_string(), caller);+        r["data"]["signinPending"].as_bool().unwrap_or(false)+    } else { false };+    let (month, calls) = store.usage();+    let data = json!({+        "configured": !client_id.is_empty(), "signedIn": usable,+        "signedInAs": if usable { user_info(&store) } else { Value::Null },+        "hasStoredToken": has_at, "refreshFailed": refresh_failed, "tokenLive": live,+        "tokenExpiresAt": tok["expires_at"], "scope": tok["scope"].as_str().unwrap_or(SCOPES),+        "signinPending": pending, "callbackUrls": all_registered_callbacks(),+        "usageMonth": month, "callsThisMonth": calls, "monthlyCap": MONTHLY_CALL_CAP, "capRemaining": store.cap_remaining(),+        "freeEndpointsOnly": FREE_PATH_PREFIXES, "neverCharge": true,+    });+    let (hint, summary) = if client_id.is_empty() {+        (format!("Not configured. Register a Desktop/PKCE app at https://aps.autodesk.com (enable Data Management API, set callbacks {}), then fusion_aps_set_client_id {{\"clientId\":\"...\"}} and fusion_aps_signin.", all_registered_callbacks().join(", ")), "APS not configured")+    } else if !has_at { ("Configured but not signed in. Call fusion_aps_signin (opens browser).".into(), "configured, not signed in") }+    else if !live { ("Token expired and refresh failed. Call fusion_aps_signin again.".into(), "signed in, token expired") }+    else { ("Ready. Use fusion_aps_search {\"query\":\"...\"}.".into(), "ready") };+    json!({"success": true, "output": summary, "data": data, "_hint": hint, "shell": "rust"})+}

@@ -0,0 +1,111 @@+//! Phase 3 layer 2: the window facts readiness needs, from ab's `desktop_list_windows`+//! (owner, pid, image, rect per row), never local Win32. Ported rule-for-rule from+//! `fusion_detect.family_windows` / `find_licensing_dialog` and the sign-in title check+//! in `_handle_fusion_readiness`, with their hard-won comments kept short here:+//!+//! - The launch family is Fusion360.exe / FusionLauncher.exe / AdskIdentityManager.exe.+//! - `needsSignin`: the MAIN Fusion window's title says "Signing in" / "Welcome to Fusion"+//!   / "Sign in - Autodesk ... Fusion". Title of the PROCESS window, never a browser tab.+//! - The seat / licensing modal ("Active Sessions Exceeded", "Suspend Remote Session") is+//!   an OWNED popup of the main window, DIALOG-SHAPED: width >= 480, height >= 180,+//!   landscape (w >= 1.3 h), not a docked rail (h <= 0.60 of the app's height), and never+//!   larger than 0.85 of the app's area. Never the largest family window. Every threshold+//!   is a ratio on purpose: two absolute pixel gates each hid this dialog once.++use crate::ab::{AbClient, Caller};+use serde_json::{json, Value};++pub const FAMILY_IMAGES: [&str; 3] = ["Fusion360.exe", "FusionLauncher.exe", "AdskIdentityManager.exe"];++#[derive(Debug, Clone, Default, PartialEq, serde::Serialize)]+pub struct WindowFacts {+    /// The launch family's visible top-level rows (ab's shape, untouched).+    pub family: Vec<Value>,+    #[serde(rename = "mainTitle")] pub main_title: Option<String>,+    #[serde(rename = "mainHwnd")] pub main_hwnd: Option<i64>,+    #[serde(rename = "needsSignin")] pub needs_signin: bool,+    /// The seat / licensing modal row when one is up.+    #[serde(rename = "licensingDialog")] pub licensing_dialog: Option<Value>,+    /// ab could not be asked (loopback missing or refused): facts unknown, not "none".+    pub degraded: bool,+}++fn area(w: &Value) -> i64 { w["rect"]["width"].as_i64().unwrap_or(0) * w["rect"]["height"].as_i64().unwrap_or(0) }++/// The pure rule over ab's rows; `facts_from_ab` is the same after one verb call.+pub fn facts_from_rows(rows: &[Value]) -> WindowFacts {+    let family: Vec<Value> = rows.iter().filter(|w| {+        let img = w["image"].as_str().unwrap_or("");+        FAMILY_IMAGES.iter().any(|f| f.eq_ignore_ascii_case(img)) && !w["minimized"].as_bool().unwrap_or(false) || FAMILY_IMAGES.iter().any(|f| f.eq_ignore_ascii_case(img)) && w["kind"].as_str() == Some("normal")+    }).cloned().collect();+    let mut out = WindowFacts { family: family.clone(), ..Default::default() };+    let Some(main) = family.iter().max_by_key(|w| area(w)) else { return out };+    out.main_hwnd = main["hwnd"].as_i64();+    out.main_title = main["title"].as_str().map(str::to_string);+    let t = out.main_title.clone().unwrap_or_default().to_lowercase();+    out.needs_signin = t.contains("signing in") || t.contains("welcome to fusion") || (t.contains("sign in - autodesk") && t.contains("fusion"));+    let main_area = area(main).max(1);+    let main_h = main["rect"]["height"].as_i64().unwrap_or(0).max(1) as f64;+    let dialog_shaped = |w: &Value| -> bool {+        // a tool window (tray, palette, popup: Fusion's 640x196 message tray is one) is never a modal+        if w["kind"].as_str() == Some("toolwindow") || w["className"].as_str().map(|c| c.ends_with("ToolSaveBits")).unwrap_or(false) { return false; }+        let (ww, hh) = (w["rect"]["width"].as_i64().unwrap_or(0) as f64, w["rect"]["height"].as_i64().unwrap_or(0) as f64);+        if ww < 480.0 || hh < 180.0 { return false; }+        if ww < hh * 1.3 { return false; }+        if hh > 0.60 * main_h { return false; }+        (ww * hh) <= 0.85 * main_area as f64+    };+    let owned = family.iter().find(|w| w["hwnd"] != main["hwnd"] && w["owner"].as_i64().unwrap_or(0) != 0 && dialog_shaped(w));+    let fallback = || family.iter().find(|w| w["hwnd"] != main["hwnd"] && dialog_shaped(w)).cloned();+    out.licensing_dialog = owned.cloned().or_else(|| if family.iter().all(|w| w["owner"].as_i64().unwrap_or(0) == 0) { fallback() } else { None });+    out+}++/// One `desktop_list_windows` call, then the rule.+pub fn facts_from_ab(ab: &dyn AbClient, caller: &Caller) -> WindowFacts {+    match ab.call("desktop_list_windows", json!({}), caller, 10) {+        Ok(v) => {+            let rows = v["data"]["windows"].as_array().or_else(|| v["windows"].as_array()).cloned().unwrap_or_default();+            facts_from_rows(&rows)+        }+        Err(_) => WindowFacts { degraded: true, ..Default::default() },+    }+}++#[cfg(test)]+mod tests {+    use super::*;+    fn row(hwnd: i64, owner: i64, title: &str, w: i64, h: i64, kind: &str) -> Value {+        json!({"hwnd": hwnd, "owner": owner, "pid": 1, "image": "Fusion360.exe", "title": title, "kind": kind, "className": if kind == "toolwindow" { "Qt683QWindowToolSaveBits" } else { "Qt683QWindow" }, "minimized": false, "rect": {"width": w, "height": h}})+    }+    #[test]+    fn seat_dialog_shapes_from_the_field_notes() {+        let main = row(1, 0, "Untitled - Autodesk Fusion", 3866, 2090, "normal");+        for (w, h) in [(823, 262), (1235, 527), (1646, 702)] {+            let f = facts_from_rows(&[main.clone(), row(2, 1, "Fusion360", w, h, "normal")]);+            assert!(f.licensing_dialog.is_some(), "{w}x{h} is a seat dialog");+        }+        // the docked rail that false-fired twice: portrait, 78% of the app height+        let f = facts_from_rows(&[main.clone(), row(2, 1, "Fusion360", 600, 1620, "normal")]);+        assert!(f.licensing_dialog.is_none(), "portrait rail");+        // the message tray that false-fired for hours on ConfRoomROG (2026-09-03)+        let f = facts_from_rows(&[main.clone(), row(2, 1, "Fusion360", 640, 196, "toolwindow")]);+        assert!(f.licensing_dialog.is_none(), "tool window");+        // narrow side panels and toolbar strips+        let f = facts_from_rows(&[main.clone(), row(2, 1, "BROWSER", 440, 224, "toolwindow"), row(3, 1, "Fusion360", 640, 196, "toolwindow")]);+        assert!(f.licensing_dialog.is_none());+        assert!(!f.needs_signin);+    }+    #[test]+    fn sign_in_titles() {+        for t in ["Signing in - Autodesk Fusion", "Welcome to Fusion", "Sign in - Autodesk Fusion"] {+            assert!(facts_from_rows(&[row(1, 0, t, 1300, 820, "normal")]).needs_signin, "{t}");+        }+        assert!(!facts_from_rows(&[row(1, 0, "Home - Autodesk Fusion", 1300, 820, "normal")]).needs_signin);+    }+    #[test]+    fn a_non_maximized_main_is_never_the_dialog() {+        let f = facts_from_rows(&[row(1, 0, "Home - Autodesk Fusion", 1300, 820, "normal")]);+        assert!(f.licensing_dialog.is_none());+    }+}