Fusion - the Fusion 360 Bridge

@@ -141,6 +141,48 @@ pub fn kill(ctx: &Ctx, args: &Value) -> Value { }  /// `fusion_restart_for_addin`: save, stop (or kill when only bridge scratch is unsaved), start, wait.+/// Who owns a Fusion restart. "auto" (the default): the bridge restarts Fusion itself whenever+/// the add-in needs it, saving what can be saved and discarding the rest, because on an Adom box+/// the AI is the only thing driving Fusion and every open document is its own (John,+/// 2026-09-07: "you should literally know to just allow fully restarting fusion ... all the open+/// docs are just the ai's docs"). "ask" keeps the toast with the Save-and-restart choice for a+/// machine a person shares with the AI. Pref key `restartPolicy` in prefs.json, or the env+/// ADOM_FUSION_RESTART_POLICY.+pub fn restart_policy(state_dir: &std::path::Path) -> String {+    if let Ok(v) = std::env::var("ADOM_FUSION_RESTART_POLICY") { if !v.trim().is_empty() { return v.trim().to_lowercase(); } }+    crate::small_verbs::get_pref(state_dir, "restartPolicy").and_then(|v| v.as_str().map(|s| s.to_lowercase())).unwrap_or_else(|| "auto".into())+}++/// A plain informational toast on this machine (no buttons, nothing to answer).+pub fn notify_info(ctx: &Ctx, title: &str, body: &str) -> bool {+    match Loopback::from_env() {+        Some(ab) => { let r = ab.call("notify_user", json!({"title": title, "body": body, "level": "info"}), &ctx.caller, 15); r.is_ok() }+        None => false,+    }+}++/// When the add-in's main thread has been blocked by a modal since this instant (0 = not blocked).+static BLOCKED_SINCE: std::sync::Mutex<f64> = std::sync::Mutex::new(0.0);+/// How long a modal may hold the add-in before the bridge restarts Fusion itself (restartPolicy auto).+const BLOCKED_RESTART_AFTER_SECS: f64 = 90.0;++fn now_secs() -> f64 { std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).map(|d| d.as_secs_f64()).unwrap_or(0.0) }++/// Restart Fusion in the background because a modal nobody answers has held the add-in+/// (restartPolicy auto). Save is impossible (the add-in cannot answer), so this is a kill ++/// start; the ledger and the reply carry what was on screen.+fn begin_blocked_restart(ctx: &Ctx, blocking: &[Value], held: f64) -> bool {+    crate::fusion_prefs::action_ledger(&ctx.state_dir, "auto_restart_blocked_modal", json!({"heldSec": (held * 10.0).round() / 10.0,+        "dialogs": blocking.iter().map(|d| json!({"title": d["title"], "category": d["category"]})).collect::<Vec<_>>()}));+    let url = crate::launch::SELF_URL.lock().unwrap().clone().or_else(|| crate::launch::SIDECAR_URL.lock().unwrap().clone());+    let Some(u) = url else { return false; };+    std::thread::spawn(move || {+        let r = ureq::post(&u).timeout(Duration::from_secs(900)).send_json(json!({"command": "fusion_restart_for_addin", "args": {"save": false, "auto": true, "wait": true, "why": "modal blocked the add-in"}})).ok().and_then(|r| r.into_json::<Value>().ok()).unwrap_or(json!({}));+        eprintln!("[fusion-bridge] auto restart after a blocking modal: {{success: {}, errorCode: {}}}", r["success"], r["errorCode"]);+    });+    true+}+ pub fn restart_for_addin(ctx: &Ctx, args: &Value, pass: &dyn Fn(&str, Value) -> Value) -> Value {     let sd = ctx.state_dir.clone();     if args["decline"].as_bool() == Some(true) {@@ -166,8 +208,10 @@ pub fn restart_for_addin(ctx: &Ctx, args: &Value, pass: &dyn Fn(&str, Value) ->     }     let t0 = Instant::now();     let save = args["save"].as_bool().unwrap_or(true);+    let auto_policy = args["auto"].as_bool() == Some(true) || restart_policy(&sd) == "auto";     let mut steps: Vec<Value> = Vec::new();     let mut hard = false;+    let mut discarded: Vec<String> = Vec::new();     if save {         let sv = pass("close_all_documents", json!({"save": true}));         steps.push(json!({"step": "save", "ok": sv["success"].as_bool().unwrap_or(false), "closed": sv["data"]["closed"], "wouldPrompt": sv["data"]["wouldPrompt"]}));@@ -175,12 +219,25 @@ pub fn restart_for_addin(ctx: &Ctx, args: &Value, pass: &dyn Fn(&str, Value) ->         if !wp.is_empty() {             let users: Vec<&String> = wp.iter().filter(|n| { let bare = n.replace('*', "").split(" (").next().unwrap_or("").trim().to_lowercase(); !bare.is_empty() && crate::etiquette::bridge_doc_in(&sd, &bare).is_none() && !bare.starts_with("untitled") && !bare.ends_with("_3d") }).collect();             if users.is_empty() { steps.push(json!({"step": "discard-bridge-scratch", "docs": wp})); hard = true; }+            else if auto_policy {+                // restartPolicy auto: every open document is the AI's own; a never-saved one is+                // scratch, so it is discarded rather than left to block the restart+                discarded = users.iter().map(|s| s.to_string()).collect();+                crate::fusion_prefs::action_ledger(&sd, "restart_discarded_unsaved", json!({"docs": discarded}));+                steps.push(json!({"step": "discard-under-auto-policy", "docs": discarded})); hard = true;+            }             else {                 return json!({"success": false, "errorCode": "unsaved_named_document", "error": format!("Cannot restart safely: {} has never been saved, so Fusion would raise its Save box and block the restart.", users.iter().map(|n| fusion_lbr::py_repr_str(n)).collect::<Vec<_>>().join(", ")), "steps": steps,                     "_hint": "Ask the user where to save it (fusion_save_to_cloud {name, projectName}), then retry. Nothing was closed and no dialog was raised."});             }         }-        if sv["success"].as_bool() != Some(true) && sv["errorCode"].is_string() && sv["error"].as_str().map(|e| e.contains("Add-in request failed")).unwrap_or(false) {+        if sv["success"].as_bool() != Some(true) && auto_policy {+            // the add-in cannot save (it is the thing that is not answering): restart anyway,+            // hard, and say so; Fusion's own recovery keeps cloud documents' last autosave+            steps.push(json!({"step": "save-unavailable", "error": sv["error"].as_str().unwrap_or("").chars().take(160).collect::<String>()}));+            hard = true;+        }+        if sv["success"].as_bool() != Some(true) && !auto_policy && sv["errorCode"].is_string() && sv["error"].as_str().map(|e| e.contains("Add-in request failed")).unwrap_or(false) {             return json!({"success": false, "errorCode": "save_failed", "steps": steps, "error": format!("Refusing to restart because saving failed: {}", sv["error"].as_str().unwrap_or("").chars().take(200).collect::<String>()), "_hint": "Nothing was restarted; the user's documents are untouched."});         }     }@@ -190,7 +247,15 @@ pub fn restart_for_addin(ctx: &Ctx, args: &Value, pass: &dyn Fn(&str, Value) ->     let lr = crate::launch::start(ctx, &json!({"waitForAddin": true}));     steps.push(json!({"step": "start", "ok": lr["success"].as_bool().unwrap_or(false)}));     let ready = crate::launch::round_trip_ready_gap(6, 5.0);-    json!({"success": ready, "addinReady": ready, "tookSec": (t0.elapsed().as_secs_f64() * 10.0).round() / 10.0, "steps": steps, "errorCode": if ready { Value::Null } else { json!("addin_still_not_responding") },+    if auto_policy {+        let why = args["why"].as_str().unwrap_or("to load the Adom add-in");+        let body = format!("The bridge restarted Fusion {why} (restartPolicy auto: every open document is the AI's own). {}{}",+            if steps.iter().any(|s| s["step"] == "save") { "Documents were saved first. " } else { "Nothing could be saved first. " },+            if discarded.is_empty() { String::new() } else { format!("Discarded never-saved scratch: {}. ", discarded.join(", ")) });+        crate::fusion_prefs::action_ledger(&sd, "auto_restart_done", json!({"ready": ready, "why": why, "steps": steps, "discarded": discarded}));+        let _ = notify_info(ctx, "Fusion restarted by the bridge", &body);+    }+    json!({"success": ready, "addinReady": ready, "restartPolicy": if auto_policy { "auto" } else { "ask" }, "discarded": discarded, "tookSec": (t0.elapsed().as_secs_f64() * 10.0).round() / 10.0, "steps": steps, "errorCode": if ready { Value::Null } else { json!("addin_still_not_responding") },         "_hint": if ready { "Fusion restarted and the add-in answered - re-run the verb that failed." } else { "Fusion restarted but the add-in still is not answering. That is a real defect, not a user problem: check fusion_addin_status and file it." }}) } @@ -249,15 +314,31 @@ pub fn diagnose_addin_timeout(ctx: &Ctx, command: &str, original: &Value) -> Val                     if !st["walkProgress"].is_null() { resp["progress"] = st["walkProgress"].clone(); }                     return resp;                 }+                // restartPolicy auto: a modal nobody answers does not get to hold the AI's Fusion+                // for ever. Seat/sign-in dialogs heal through their own flows and are excluded.+                let policy = restart_policy(&ctx.state_dir);+                let self_healing = blocking.iter().any(|d| matches!(d["category"].as_str().unwrap_or(""), "license_sessions_exceeded" | "session_conflict_decision" | "session_suspend_confirm" | "session_suspended_regrab" | "signin_required" | "upload_in_progress"));+                let held = { let mut s = BLOCKED_SINCE.lock().unwrap(); let n = now_secs(); if *s == 0.0 || n - *s > 900.0 { *s = n; } n - *s };+                if policy == "auto" && !self_healing && held >= BLOCKED_RESTART_AFTER_SECS {+                    *BLOCKED_SINCE.lock().unwrap() = 0.0;+                    let started = begin_blocked_restart(ctx, &blocking, held);+                    let titles = blocking.iter().map(|d| format!("'{}' ({})", d["title"].as_str().unwrap_or(""), d["category"].as_str().unwrap_or(""))).collect::<Vec<_>>().join(", ");+                    return json!({"success": false, "errorCode": "fusion_auto_restarting", "restartStarted": started, "heldSec": (held * 10.0).round() / 10.0, "blockingDialogs": blocking,+                        "error": format!("A modal has held Fusion's main thread for {:.0}s ({}), so the bridge is restarting Fusion itself (restartPolicy auto). The verb '{command}' did not run.", held, if titles.is_empty() { "no classified dialog; see postOpenScreenshot".to_string() } else { titles }),+                        "data": {"command": command, "health": h, "blockingDialogs": blocking, "postOpenScreenshot": shots},+                        "_hint": "Poll fusion_readiness until ready:true (60-120 s), then re-run the verb. Unsaved edits since the last autosave are gone; every open document was the AI's own. If the dialog in postOpenScreenshot is one the bridge should answer itself, file it on the fusion-bridge page with the screenshot so it gets a dialog rule."});+                }+                let auto_note = if policy == "auto" { format!(" The bridge restarts Fusion itself if this stays blocked for {:.0}s (restartPolicy auto; blocked {:.0}s so far); re-poll rather than restarting.", BLOCKED_RESTART_AFTER_SECS, held) } else { " This is NOT an add-in crash; with restartPolicy ask the user decides on a restart.".to_string() };                 let message = if !blocking.is_empty() {                     let titles = blocking.iter().map(|d| format!("'{}' ({})", d["title"].as_str().unwrap_or(""), d["category"].as_str().unwrap_or(""))).collect::<Vec<_>>().join(", ");                     let mut seen = Vec::new(); for d in &blocking { let r = d["resolution"].as_str().unwrap_or("").to_string(); if !seen.contains(&r) { seen.push(r); } }-                    format!("The AdomBridge add-in is alive but its main thread is blocked by a modal dialog: {titles}. This is NOT an add-in crash — do not restart Fusion. {}", seen.join(" "))+                    format!("The AdomBridge add-in is alive but its main thread is blocked by a modal dialog: {titles}.{auto_note} {}", seen.join(" "))                 } else {                     format!("The AdomBridge add-in is alive but its main thread is not responding (status: {main_thread}, pending: {pending}). Fusion 360 likely has a modal dialog open (Document Recovery, error, or update prompt) that is blocking execution. READ the screenshots to identify the dialog, then dismiss with fusion_send_key {{\"key\": \"escape\"}} or fusion_send_key {{\"key\": \"tab\"}} + {{\"key\": \"enter\"}}.")                 };                 return json!({"success": false, "error": "addin_main_thread_blocked", "message": message, "blockingDialogs": blocking, "data": {"command": command, "health": h, "blockingDialogs": blocking, "postOpenScreenshot": shots}});             }+            *BLOCKED_SINCE.lock().unwrap() = 0.0;             return json!({"success": false, "error": "addin_command_timeout", "message": format!("Command '{command}' timed out but the add-in reports main thread is {main_thread}. The command may be long-running or stuck."), "data": {"command": command, "health": h, "postOpenScreenshot": shots}});         }     }