Fusion - the Fusion 360 Bridge

@@ -140,6 +140,10 @@ fn not_installed() -> Value {  /// `fusion_start`. pub fn start(ctx: &Ctx, _args: &Value) -> Value {+    if _args["_fromGate"].is_null() { let _ = std::fs::remove_file(autostart_path(&ctx.state_dir)); }+    if !running(ctx) {+        if let Some(problem) = ctx.fusion_exe.as_deref().and_then(fusion_core::install_check::launch_problem) { return broken_install_refusal(&problem); }+    }     let sd = ctx.state_dir.clone();     let Some(exe) = ctx.fusion_exe.clone() else { return not_installed() };     let exe_path = exe.to_string_lossy().replace('\\', "/");@@ -291,6 +295,40 @@ pub static SIDECAR_URL: std::sync::Mutex<Option<String>> = std::sync::Mutex::new /// This exe's own /command URL (set once it listens), for work that must outlive a request. pub static SELF_URL: std::sync::Mutex<Option<String>> = std::sync::Mutex::new(None); +/// A call that finds Fusion closed starts it. If it keeps dying straight after, that must not repeat: a poller+/// once relaunched a broken Fusion every minute, a fresh round of popups each time (2026-11-04). Two starts within+/// RESTART_WINDOW_SECS means it isn't staying up, so calls stop starting it for AUTOSTART_PAUSE_SECS and say why.+/// fusion_start, a person or an AI asking outright, always tries and clears this.+const RESTART_WINDOW_SECS: f64 = 300.0;+const AUTOSTART_PAUSE_SECS: f64 = 900.0;++fn autostart_path(state_dir: &std::path::Path) -> std::path::PathBuf { state_dir.join("autostart.json") }++fn autostart_record(state_dir: &std::path::Path) -> Value {+    std::fs::read_to_string(autostart_path(state_dir)).ok().and_then(|t| serde_json::from_str(&t).ok()).unwrap_or(json!({}))+}++/// Seconds left on the pause, or None to go ahead.+fn autostart_paused(state_dir: &std::path::Path, now: f64) -> Option<f64> {+    let r = autostart_record(state_dir);+    let last = r["lastStart"].as_f64()?;+    (r["strikes"].as_u64().unwrap_or(0) >= 2 && now - last < AUTOSTART_PAUSE_SECS).then(|| AUTOSTART_PAUSE_SECS - (now - last))+}++fn note_autostart(state_dir: &std::path::Path, now: f64) {+    let r = autostart_record(state_dir);+    let soon = r["lastStart"].as_f64().map(|l| now - l < RESTART_WINDOW_SECS).unwrap_or(false);+    let strikes = if soon { r["strikes"].as_u64().unwrap_or(0) + 1 } else { 1 };+    let _ = std::fs::create_dir_all(state_dir);+    let _ = std::fs::write(autostart_path(state_dir), json!({"lastStart": now, "strikes": strikes}).to_string());+}++fn broken_install_refusal(problem: &str) -> Value {+    json!({"success": false, "errorCode": "fusion_install_broken", "launchAttempted": false,+        "error": format!("Fusion can't start on this machine, so it wasn't launched: {problem}."),+        "_hint": "Launching it would only raise one Windows error popup per missing DLL. fusion_install_fusion repairs it with Autodesk's own installer (about 5 minutes, designs are in the cloud and aren't touched). Tell the user before starting it."})+}+ /// `_addin_preamble`: the gate every add-in-dependent verb passes. None means send it. pub fn gate(ctx: &Ctx, cmd: &str, args: &Value) -> Option<Value> {     let installed = ctx.fusion_exe.is_some();@@ -307,12 +345,28 @@ pub fn gate(ctx: &Ctx, cmd: &str, args: &Value) -> Option<Value> {         }     }     if !fusion_running && args["noAutoStart"].as_bool() != Some(true) {+        if let Some(problem) = ctx.fusion_exe.as_deref().and_then(fusion_core::install_check::launch_problem) {+            crate::fusion_prefs::action_ledger(&ctx.state_dir, "autostart_refused_broken_install", json!({"forCommand": cmd, "problem": problem}));+            return Some(broken_install_refusal(&problem));+        }+        if crate::maintenance::installer_running(ctx) {+            return Some(json!({"success": false, "errorCode": "fusion_updating", "launchAttempted": false, "error": "Fusion's installer is running, so Fusion wasn't launched: starting it mid-update can fail or disturb the update.",+                "_hint": "Wait for it to finish, then call again. fusion_readiness says when it's done."}));+        }+        let now = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).map(|d| d.as_secs_f64()).unwrap_or(0.0);+        if let Some(left) = autostart_paused(&ctx.state_dir, now) {+            return Some(json!({"success": false, "errorCode": "fusion_autostart_paused", "launchAttempted": false, "retryAfterSec": left.round(),+                "error": "Fusion was started twice in the last few minutes and closed again each time, so it wasn't started again.",+                "_hint": "It may have been closed by the user, or it may be failing to stay up: look before retrying. fusion_start tries again now."}));+        }+        note_autostart(&ctx.state_dir, now);         let t0 = Instant::now();         eprintln!("[fusion-bridge] {cmd} needs Fusion; it is closed - launching it (page issue #64)");-        let auto = start(ctx, &json!({"waitForAddin": true}));+        let auto = start(ctx, &json!({"waitForAddin": true, "_fromGate": true}));         let took = (t0.elapsed().as_secs_f64() * 10.0).round() / 10.0;-        crate::fusion_prefs::action_ledger(&ctx.state_dir, "fusion_auto_started", json!({"forCommand": cmd, "ok": auto["success"].as_bool().unwrap_or(false), "tookSec": took}));-        if auto["success"].as_bool() == Some(true) && running(ctx) { fusion_running = true; }+        let up = auto["success"].as_bool() == Some(true) && running(ctx);+        crate::fusion_prefs::action_ledger(&ctx.state_dir, "fusion_auto_started", json!({"forCommand": cmd, "ok": up, "tookSec": took}));+        if up { fusion_running = true; }         else {             return Some(json!({"success": false, "errorCode": "fusion_autostart_failed",                 "error": format!("Fusion was closed so the bridge tried to open it for you, and the launch did not come up: {}", auto["error"].as_str().unwrap_or("no error reported").chars().take(300).collect::<String>()),@@ -387,3 +441,25 @@ pub fn gate(ctx: &Ctx, cmd: &str, args: &Value) -> Option<Value> {         "documentsKnown": ri["documentsKnown"], "remedyVerb": "fusion_restart_for_addin", "toast": ri["toast"],         "_hint": "ASK THE USER, do not silently restart their Fusion: show userMessage, and if documentsKnown say how many documents are open. On yes, call fusion_restart_for_addin {save:true} - it saves open documents, restarts Fusion, waits for the add-in and reports back. An AI driving with no human present may call it directly. (Legacy callers: this was errorCode fusion_addin_not_responding.)"})) }++#[cfg(test)] mod autostart_tests {+    use super::*;+    fn dir(tag: &str) -> std::path::PathBuf { let d = std::env::temp_dir().join(format!("adom-autostart-{tag}-{}", std::process::id())); let _ = std::fs::remove_dir_all(&d); std::fs::create_dir_all(&d).unwrap(); d }+    #[test] fn a_first_start_goes_ahead_and_so_does_a_second() {+        let d = dir("two");+        assert!(autostart_paused(&d, 1000.0).is_none());+        note_autostart(&d, 1000.0);+        assert!(autostart_paused(&d, 1060.0).is_none());+    }+    #[test] fn a_third_start_within_minutes_is_paused_then_the_pause_ends() {+        let d = dir("three");+        note_autostart(&d, 1000.0); note_autostart(&d, 1060.0);+        assert!(autostart_paused(&d, 1120.0).is_some());+        assert!(autostart_paused(&d, 1060.0 + AUTOSTART_PAUSE_SECS + 1.0).is_none());+    }+    #[test] fn starts_far_apart_never_add_up() {+        let d = dir("apart");+        note_autostart(&d, 1000.0); note_autostart(&d, 1000.0 + RESTART_WINDOW_SECS + 1.0); note_autostart(&d, 1000.0 + 2.0 * RESTART_WINDOW_SECS + 2.0);+        assert!(autostart_paused(&d, 1000.0 + 2.0 * RESTART_WINDOW_SECS + 3.0).is_none());+    }+}

@@ -0,0 +1,83 @@+//! Can this Fusion install start at all? Windows answers a launch of a stripped install with one "System+//! Error" popup per missing DLL, and the launcher points wherever its .ini says, whatever else is on disk.+//! An interrupted update left exactly that: a launcher pointing at a folder with Fusion360.exe and almost+//! nothing else (2026-11-04). So it's checked from the disk first, and the popups are never raised.+use std::path::{Path, PathBuf};++/// A real Fusion app folder has hundreds of DLLs; the stripped one had 2.+const MIN_APP_DLLS: usize = 20;+const APP_EXE: &str = "Fusion360.exe";++/// The folder a FusionLauncher.exe.ini starts, from its `cmd = ""C:\...\Fusion360.exe" ...` line. The file is UTF-16.+pub fn ini_target(bytes: &[u8]) -> Option<PathBuf> {+    let text = if bytes.starts_with(&[0xff, 0xfe]) {+        String::from_utf16_lossy(&bytes[2..].chunks_exact(2).map(|c| u16::from_le_bytes([c[0], c[1]])).collect::<Vec<_>>())+    } else {+        String::from_utf8_lossy(bytes).into_owned()+    };+    let line = text.lines().find(|l| l.trim_start().to_lowercase().starts_with("cmd"))?;+    let at = line.to_lowercase().find(&APP_EXE.to_lowercase())?;+    let start = line[..at].rfind('"')? + 1;+    Some(PathBuf::from(line[start..at].replace('\\', "/")))+}++fn dll_count(dir: &Path) -> usize {+    std::fs::read_dir(dir).map(|d| d.flatten().filter(|e| e.path().extension().map(|x| x.eq_ignore_ascii_case("dll")).unwrap_or(false)).count()).unwrap_or(0)+}++/// Why this launcher can't start Fusion, or None. Says None when it can't tell: this must never stop a good install.+pub fn launch_problem(launcher: &Path) -> Option<String> {+    let name = launcher.file_name()?.to_string_lossy().to_lowercase();+    let dir = if name == APP_EXE.to_lowercase() {+        launcher.parent()?.to_path_buf()+    } else {+        ini_target(&std::fs::read(launcher.with_file_name("FusionLauncher.exe.ini")).ok()?)?+    };+    if !dir.is_dir() { return Some(format!("its launcher points at {}, which isn't there", dir.display())); }+    let dlls = dll_count(&dir);+    (dlls < MIN_APP_DLLS).then(|| format!("{} has only {dlls} DLLs, so the install is incomplete (an update that didn't finish)", dir.display()))+}++#[cfg(test)]+mod tests {+    use super::*;+    fn temp(tag: &str) -> PathBuf { let d = std::env::temp_dir().join(format!("adom-install-check-{tag}-{}", std::process::id())); let _ = std::fs::remove_dir_all(&d); std::fs::create_dir_all(&d).unwrap(); d }+    fn utf16(s: &str) -> Vec<u8> { let mut v = vec![0xff, 0xfe]; for u in s.encode_utf16() { v.extend(u.to_le_bytes()); } v }+    fn app(dir: &Path, dlls: usize) { std::fs::create_dir_all(dir).unwrap(); std::fs::write(dir.join(APP_EXE), b"x").unwrap(); for i in 0..dlls { std::fs::write(dir.join(format!("a{i}.dll")), b"x").unwrap(); } }+    fn launcher(root: &Path, target: &Path) -> PathBuf {+        let l = root.join("launcher"); std::fs::create_dir_all(&l).unwrap();+        std::fs::write(l.join("FusionLauncher.exe"), b"x").unwrap();+        std::fs::write(l.join("FusionLauncher.exe.ini"), utf16(&format!("[Launcher]\r\nstream = production\r\ncmd = \"\"{}/Fusion360.exe\" /arg\"\r\nglobal = False\r\n", target.display()))).unwrap();+        l.join("FusionLauncher.exe")+    }+    #[test] fn reads_the_folder_from_a_real_shaped_ini() {+        let b = utf16("[Launcher]\r\nstream = production\r\nauid = Autodesk\r\ncmd = \"\"C:\\Users\\me\\webdeploy\\production\\39e8\\Fusion360.exe\" /x\"\r\n");+        assert_eq!(ini_target(&b).unwrap(), PathBuf::from("C:/Users/me/webdeploy/production/39e8/"));+    }+    #[test] fn a_stripped_install_is_refused_and_a_full_one_is_not() {+        let r = temp("full");+        let (bad, good) = (r.join("bad"), r.join("good"));+        app(&bad, 2); app(&good, 300);+        assert!(launch_problem(&launcher(&r, &bad)).unwrap().contains("only 2 DLLs"));+        assert!(launch_problem(&launcher(&r, &good)).is_none());+        assert!(launch_problem(&bad.join(APP_EXE)).is_some());+        assert!(launch_problem(&good.join(APP_EXE)).is_none());+    }+    /// A real install, read-only: ADOM_REAL_INI=<FusionLauncher.exe.ini> ADOM_REAL_ROOT=<a path prefix that maps C:/ here>+    #[test] #[ignore] fn a_real_install_passes() {+        let ini = std::env::var("ADOM_REAL_INI").unwrap();+        let t = ini_target(&std::fs::read(&ini).unwrap()).expect("the ini names a folder");+        println!("target {}", t.display());+        let here = PathBuf::from(t.to_string_lossy().replace("C:/", &std::env::var("ADOM_REAL_ROOT").unwrap()));+        println!("dlls {}", dll_count(&here));+        assert!(dll_count(&here) >= MIN_APP_DLLS);+    }+    #[test] fn a_missing_target_is_a_problem_and_doubt_is_not() {+        let r = temp("doubt");+        assert!(launch_problem(&launcher(&r, &r.join("gone"))).unwrap().contains("isn't there"));+        let l = r.join("noini"); std::fs::create_dir_all(&l).unwrap();+        assert!(launch_problem(&l.join("FusionLauncher.exe")).is_none());+        std::fs::write(l.join("FusionLauncher.exe.ini"), b"[Launcher]\nstream = x\n").unwrap();+        assert!(launch_problem(&l.join("FusionLauncher.exe")).is_none());+    }+}