Fusion - the Fusion 360 Bridge

@@ -78,18 +78,26 @@ impl Sidecar {         best     } -    fn spawn(bind: &str) -> Option<Sidecar> {+    fn spawn(bind: &str, log_dir: &std::path::Path) -> Option<Sidecar> {         let py = Self::python_exe()?;         let here = std::env::current_exe().ok()?.parent()?.to_path_buf();         // The sidecar's server.py sits beside this exe in the bridge dir during the port.         let server_py = here.join("server.py");         if !server_py.exists() { return None; }         let port = pick_free_port();+        // The sidecar's own stdout/stderr land in <state>/sidecar.log so a startup failure is+        // readable (a null handle is how the first smoke test died silently).+        let _ = std::fs::create_dir_all(log_dir);+        let log = std::fs::OpenOptions::new().create(true).append(true).open(log_dir.join("sidecar.log")).ok();+        let (out, err): (Stdio, Stdio) = match log {+            Some(f) => (f.try_clone().map(Stdio::from).unwrap_or_else(|_| Stdio::null()), Stdio::from(f)),+            None => (Stdio::null(), Stdio::null()),+        };         let child = Command::new(py)             .arg(&server_py).arg("--port").arg(port.to_string())             .env("ADOM_BIND_HOST", bind)             .current_dir(&here)-            .stdin(Stdio::null()).stdout(Stdio::null()).stderr(Stdio::null())+            .stdin(Stdio::null()).stdout(out).stderr(err)             .spawn().ok()?;         Some(Sidecar { child: Some(child), port, started: Instant::now() })     }@@ -130,7 +138,14 @@ fn main() {     let bind = std::env::var("ADOM_BIND_HOST").unwrap_or_else(|_| "127.0.0.1".into());     let catalog = fusion_core::contract::load().expect("frozen verb catalog");     let h = host();-    let sidecar = Arc::new(Mutex::new(Sidecar::spawn(&bind)));+    let sidecar = Arc::new(Mutex::new(Sidecar::spawn(&bind, &h.bridge_state_dir())));+    // ab stops this bridge with a hard kill (bridge_install, supervisor respawn): the sidecar+    // must go with it, or every respawn leaves one more Python on a random port.+    if let Some(sc) = sidecar.lock().unwrap().as_ref() {+        if let Some(pid) = sc.child.as_ref().map(|c| c.id()) {+            if !h.tie_child_lifetime(pid) { eprintln!("[fusion-bridge] could not tie the sidecar (pid {pid}) to this process's lifetime"); }+        }+    }     let server = Server::http(format!("{bind}:{port}")).expect("bind loopback");     eprintln!("[fusion-bridge] v{VERSION} listening on {bind}:{port}; contract frozen {}; sidecar {}",               catalog.frozen,@@ -138,6 +153,9 @@ fn main() {      for mut req in server.incoming_requests() {         let path = req.url().split('?').next().unwrap_or("/").to_string();+        // A panic in a handler must cost one request (tiny_http answers 500 for the dropped+        // request), never the process: ab paints the chip red the moment the port goes dark.+        let outcome = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {         match (req.method(), path.as_str()) {             (Method::Get, "/status") | (Method::Get, "/health") => {                 // Prefer the sidecar's rich status (Fusion/add-in probe) while it exists;@@ -177,12 +195,16 @@ fn main() {             }             _ => { let _ = req.respond(json_response(404, &json!({"error": "not found"}))); }         }+        }));+        if outcome.is_err() { eprintln!("[fusion-bridge] a handler panicked on {path}; the shell stays up"); }     } }  /// Forward an unported verb to the Python sidecar, identity headers intact. fn proxy(sidecar: &Arc<Mutex<Option<Sidecar>>>, raw: &str, caller: &Caller) -> Value {-    let url = match sidecar.lock().unwrap().as_ref() { Some(s) => s.url("/command"), None => return json!({+    // ab routes the first verb the moment /status is 2xx, which is before the sidecar has+    // bound its port: wait out the sidecar's startup (bounded) instead of failing that verb.+    let (url, young) = match sidecar.lock().unwrap().as_ref() { Some(s) => (s.url("/command"), s.started.elapsed() < Duration::from_secs(45)), None => return json!({         "success": false, "errorCode": "sidecar_absent",         "error": "This verb is not ported yet and the Python sidecar is not running.",         "_hint": "Set ADOM_SIDECAR_PYTHON to ab's provisioned python.exe, or run the Python bridge directly until this verb is ported."}) };@@ -190,9 +212,18 @@ fn proxy(sidecar: &Arc<Mutex<Option<Sidecar>>>, raw: &str, caller: &Caller) -> V     if !caller.thread.is_empty() { r = r.set("X-Adom-Caller-Thread", &caller.thread); }     if !caller.container.is_empty() { r = r.set("X-Adom-Caller-Container", &caller.container); }     if !caller.reason.is_empty() { r = r.set("X-Adom-Caller-Reason", &caller.reason); }+    if young {+        let t0 = Instant::now();+        while t0.elapsed() < Duration::from_secs(45) {+            let base = url.trim_end_matches("/command").to_string();+            if ureq::get(&format!("{base}/status")).timeout(Duration::from_secs(2)).call().is_ok() { break; }+            std::thread::sleep(Duration::from_millis(400));+        }+    }     match r.send_string(raw) {         Ok(resp) => resp.into_json::<Value>().unwrap_or(json!({"success": false, "error": "sidecar returned non-JSON"})),         Err(ureq::Error::Status(code, resp)) => resp.into_json::<Value>().unwrap_or(json!({"success": false, "error": format!("sidecar HTTP {code}")})),-        Err(e) => json!({"success": false, "errorCode": "sidecar_unreachable", "error": e.to_string()}),+        Err(e) => json!({"success": false, "errorCode": "sidecar_unreachable", "error": e.to_string(),+                         "_hint": "The Python sidecar beside adom-fusion-bridge.exe is not answering. Read ~/.adom/fusion-bridge/sidecar.log; if ab's portable python is missing (~/.adom/adom-runtimes/python-*), install any python bridge (kicad) once so ab provisions it."}),     } }

@@ -1,31 +1,294 @@ //! Windows host: the audited Win32 exceptions and nothing more.-//!  - Toolhelp32 snapshot for the readiness poll (in-process, microseconds)-//!  - CreateProcess with CREATE_BREAKAWAY_FROM_JOB for the Fusion launch-//!  - IsUserAnAdmin for the installer decision-//!  - the webdeploy / FusionAddins / AppLogFile paths+//!  - Toolhelp32 snapshot for the readiness poll (in-process, microseconds, never a child+//!    process: a `tasklist` that stalled under a pegged CPU once launched a SECOND Fusion)+//!  - `cmd /c start "" /min <launcher>` with CREATE_BREAKAWAY_FROM_JOB for the Fusion launch,+//!    so a bridge respawn can never take Fusion down with it (issue #50: seven dead Fusions+//!    in one build matrix, every one a child of the bridge)+//!  - IsUserAnAdmin for the installer's --globalinstall decision+//!  - the webdeploy / FusionAddins / AppLogFile paths, ported 1:1 from fusion_detect.py,+//!    install_addin.py and server.py so the two shells agree during the overlap+//!+//! Everything here also compiles on Linux/macOS (the Win32 calls are cfg(windows)-gated and+//! answer "nothing running / not installed" elsewhere) so `tools/check-portable.sh` can+//! build and test the whole workspace on the dev container.+//!+//! AI hint: nothing in this crate may panic on a poll. A `todo!()` here once killed the+//! Rust shell on its very first /status request (tiny_http answered 500 for the request+//! dropped mid-unwind, then the port went dark). `tools/check-portable.sh` refuses `todo!`. -use fusion_core::{HostPaths, HostProcess}; use fusion_core::host::{FusionProcess, HostError};-use std::path::PathBuf;+use fusion_core::{HostPaths, HostProcess};+use std::path::{Path, PathBuf};+use std::time::{Duration, Instant};  pub struct WindowsHost; -impl HostProcess for WindowsHost {-    fn fusion_processes(&self) -> Vec<FusionProcess> {-        todo!("Phase 1: port _fusion_pids_toolhelp (fusion_detect.py)")+/// The ACTUAL app binary (~880 KB). Its presence at full size is the one reliable "installed"+/// signal: FusionLauncher.exe lands early mid-stream, and the launcher's .ini is absent from+/// the complete app dir, so neither of those may gate "installed".+const FUSION_APP_EXE: &str = "Fusion360.exe";+const MIN_APP_EXE_BYTES: u64 = 200_000;++fn env_dir(var: &str) -> Option<PathBuf> {+    std::env::var_os(var).map(PathBuf::from).filter(|p| !p.as_os_str().is_empty())+}++fn home() -> PathBuf {+    env_dir("USERPROFILE").or_else(|| env_dir("HOME")).unwrap_or_else(|| PathBuf::from("C:\\Users\\Default"))+}++fn local_app_data() -> PathBuf {+    env_dir("LOCALAPPDATA").unwrap_or_else(|| home().join("AppData").join("Local"))+}++fn roaming_app_data() -> PathBuf {+    env_dir("APPDATA").unwrap_or_else(|| home().join("AppData").join("Roaming"))+}++/// Every profile under the users root (the parent of the home dir, normally `C:\Users`), so a+/// bridge running as one user still finds a Fusion installed or logging as another (issue #326).+fn user_profiles() -> Vec<PathBuf> {+    let root = home().parent().map(Path::to_path_buf).unwrap_or_else(|| PathBuf::from("C:\\Users"));+    let mut out = Vec::new();+    if let Ok(rd) = std::fs::read_dir(&root) {+        for e in rd.flatten() {+            if e.path().is_dir() { out.push(e.path()); }+        }+    }+    out+}++/// `<base>\Autodesk\webdeploy\production` for every profile, then the env-rooted bases.+fn webdeploy_bases() -> Vec<PathBuf> {+    let mut bases: Vec<PathBuf> = user_profiles().into_iter()+        .map(|u| u.join("AppData").join("Local").join("Autodesk").join("webdeploy").join("production"))+        .collect();+    for var in ["LOCALAPPDATA", "ProgramFiles", "ProgramFiles(x86)", "ProgramW6432"] {+        if let Some(root) = env_dir(var) {+            let b = root.join("Autodesk").join("webdeploy").join("production");+            if !bases.contains(&b) { bases.push(b); }+        }+    }+    bases+}++fn app_dir_complete(sub: &Path) -> bool {+    std::fs::metadata(sub.join(FUSION_APP_EXE)).map(|m| m.is_file() && m.len() >= MIN_APP_EXE_BYTES).unwrap_or(false)+}++fn mtime_secs(p: &Path) -> u64 {+    std::fs::metadata(p).and_then(|m| m.modified())+        .ok().and_then(|t| t.duration_since(std::time::UNIX_EPOCH).ok())+        .map(|d| d.as_secs()).unwrap_or(0)+}++fn subdirs(base: &Path) -> Vec<PathBuf> {+    std::fs::read_dir(base).map(|rd| rd.flatten().map(|e| e.path()).filter(|p| p.is_dir()).collect()).unwrap_or_default()+}++/// Is Fusion installed at all: ANY hash dir holds a complete Fusion360.exe.+pub fn any_app_complete() -> bool {+    webdeploy_bases().iter().any(|b| subdirs(b).iter().any(|s| app_dir_complete(s)))+}++/// The FusionLauncher.exe to RUN, only once Fusion is actually installed. Two separate+/// questions (conflating them broke the launch once): "installed" is gated on Fusion360.exe;+/// "which launcher" prefers a FusionLauncher.exe WITH its .ini beside it (a bare launcher+/// throws Fusion's own "FusionLauncher.exe.ini is missing or incomplete"), then a bare+/// launcher, then the app exe itself. Newest mtime wins inside each pool.+fn find_fusion_launcher() -> Option<PathBuf> {+    if !any_app_complete() { return None; }+    let (mut runnable, mut bare, mut app_exes): (Vec<(u64, PathBuf)>, Vec<(u64, PathBuf)>, Vec<(u64, PathBuf)>) = (vec![], vec![], vec![]);+    for base in webdeploy_bases() {+        for sub in subdirs(&base) {+            let mt = mtime_secs(&sub);+            let launcher = sub.join("FusionLauncher.exe");+            if launcher.is_file() {+                if sub.join("FusionLauncher.exe.ini").is_file() { runnable.push((mt, launcher)); } else { bare.push((mt, launcher)); }+            }+            if app_dir_complete(&sub) { app_exes.push((mt, sub.join(FUSION_APP_EXE))); }+        }+    }+    for pool in [&mut runnable, &mut bare, &mut app_exes] {+        if !pool.is_empty() {+            pool.sort_by(|a, b| b.0.cmp(&a.0));+            return Some(pool[0].1.clone());+        }     }+    None+}++#[cfg(windows)]+fn snapshot_fusion() -> Vec<FusionProcess> {+    use windows_sys::Win32::Foundation::{CloseHandle, INVALID_HANDLE_VALUE};+    use windows_sys::Win32::System::Diagnostics::ToolHelp::{+        CreateToolhelp32Snapshot, Process32FirstW, Process32NextW, PROCESSENTRY32W, TH32CS_SNAPPROCESS,+    };+    let mut out = Vec::new();+    // SAFETY: plain Toolhelp32 walk over a snapshot handle we own and close; the entry struct+    // is zeroed and sized before the first call, as the API requires.+    unsafe {+        let snap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);+        if snap == INVALID_HANDLE_VALUE || snap.is_null() { return out; }+        let mut pe: PROCESSENTRY32W = std::mem::zeroed();+        pe.dwSize = std::mem::size_of::<PROCESSENTRY32W>() as u32;+        if Process32FirstW(snap, &mut pe) != 0 {+            loop {+                let len = pe.szExeFile.iter().position(|&c| c == 0).unwrap_or(pe.szExeFile.len());+                let name = String::from_utf16_lossy(&pe.szExeFile[..len]);+                if name.eq_ignore_ascii_case(FUSION_APP_EXE) {+                    out.push(FusionProcess { pid: pe.th32ProcessID, image: name, parent_pid: Some(pe.th32ParentProcessID) });+                }+                if Process32NextW(snap, &mut pe) == 0 { break; }+            }+        }+        CloseHandle(snap);+    }+    out+}++#[cfg(not(windows))]+fn snapshot_fusion() -> Vec<FusionProcess> { Vec::new() }++#[cfg(windows)]+fn start_shim(exe: &Path) -> Result<u32, HostError> {+    use std::os::windows::process::CommandExt;+    use std::process::{Command, Stdio};+    const CREATE_NO_WINDOW: u32 = 0x0800_0000;+    const DETACHED_PROCESS: u32 = 0x0000_0008;+    const CREATE_NEW_PROCESS_GROUP: u32 = 0x0000_0200;+    const CREATE_BREAKAWAY_FROM_JOB: u32 = 0x0100_0000;+    let base = CREATE_NO_WINDOW | DETACHED_PROCESS | CREATE_NEW_PROCESS_GROUP;+    // `start "" /min <exe>`: the empty "" is the window-title slot start expects first. cmd exits+    // at once, so the launcher's parent is gone and no tree walk from the bridge reaches Fusion.+    let spawn = |flags: u32| Command::new("cmd").args(["/c", "start", "", "/min"]).arg(exe)+        .creation_flags(flags).stdin(Stdio::null()).stdout(Stdio::null()).stderr(Stdio::null()).spawn();+    match spawn(base | CREATE_BREAKAWAY_FROM_JOB) {+        Ok(c) => Ok(c.id()),+        // The job forbids breakaway (ERROR_ACCESS_DENIED): still reparented via cmd.+        Err(_) => spawn(base).map(|c| c.id()).map_err(|e| HostError::Launch(e.to_string())),+    }+}++#[cfg(not(windows))]+fn start_shim(_exe: &Path) -> Result<u32, HostError> {+    Err(HostError::Launch("the Windows host only launches Fusion on Windows".into()))+}++impl HostProcess for WindowsHost {+    fn fusion_processes(&self) -> Vec<FusionProcess> { snapshot_fusion() }+     fn launch_fusion(&self) -> Result<FusionProcess, HostError> {-        todo!("Phase 1: port the CREATE_BREAKAWAY_FROM_JOB launch (fusion_detect.py)")+        let exe = self.fusion_executable().ok_or_else(|| HostError::NotInstalled(+            "no webdeploy hash dir holds a complete Fusion360.exe".into()))?;+        let shim = start_shim(&exe)?;+        // Fusion360.exe appears a few seconds after the launcher; report the real process+        // when it shows, else the shim pid so the caller can still poll.+        let t0 = Instant::now();+        while t0.elapsed() < Duration::from_secs(8) {+            if let Some(p) = snapshot_fusion().into_iter().next() { return Ok(p); }+            std::thread::sleep(Duration::from_millis(250));+        }+        Ok(FusionProcess { pid: shim, image: "cmd.exe (start shim; Fusion360.exe not visible yet)".into(), parent_pid: None })     }++    #[cfg(windows)]+    fn tie_child_lifetime(&self, pid: u32) -> bool {+        use windows_sys::Win32::Foundation::CloseHandle;+        use windows_sys::Win32::System::JobObjects::{+            AssignProcessToJobObject, CreateJobObjectW, JobObjectExtendedLimitInformation,+            SetInformationJobObject, JOBOBJECT_EXTENDED_LIMIT_INFORMATION,+            JOB_OBJECT_LIMIT_BREAKAWAY_OK, JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE,+        };+        use windows_sys::Win32::System::Threading::{OpenProcess, PROCESS_SET_QUOTA, PROCESS_TERMINATE};+        // SAFETY: a job handle we deliberately never close (its close is what kills the child+        // when THIS process dies), a zeroed limit struct sized for the call, a process handle+        // we close after the assignment.+        unsafe {+            let job = CreateJobObjectW(std::ptr::null(), std::ptr::null());+            if job.is_null() { return false; }+            let mut info: JOBOBJECT_EXTENDED_LIMIT_INFORMATION = std::mem::zeroed();+            info.BasicLimitInformation.LimitFlags = JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE | JOB_OBJECT_LIMIT_BREAKAWAY_OK;+            if SetInformationJobObject(job, JobObjectExtendedLimitInformation, &info as *const _ as *const _,+                                       std::mem::size_of::<JOBOBJECT_EXTENDED_LIMIT_INFORMATION>() as u32) == 0 { return false; }+            let ph = OpenProcess(PROCESS_SET_QUOTA | PROCESS_TERMINATE, 0, pid);+            if ph.is_null() { return false; }+            let ok = AssignProcessToJobObject(job, ph) != 0;+            CloseHandle(ph);+            ok+        }+    }++    #[cfg(windows)]     fn is_elevated(&self) -> bool {-        todo!("Phase 1: IsUserAnAdmin")+        // SAFETY: no arguments, no memory handed over; a plain BOOL answer.+        unsafe { windows_sys::Win32::UI::Shell::IsUserAnAdmin() != 0 }     }+    #[cfg(not(windows))]+    fn is_elevated(&self) -> bool { false } }  impl HostPaths for WindowsHost {-    fn fusion_executable(&self) -> Option<PathBuf> { todo!("Phase 1: newest webdeploy launcher by mtime") }-    fn addin_dirs(&self) -> Vec<PathBuf> { todo!("Phase 1: install_addin.py TARGET_CANDIDATES") }-    fn fusion_log_dir(&self) -> Option<PathBuf> { todo!("Phase 1: _fusion_log_path") }-    fn bridge_state_dir(&self) -> PathBuf { todo!("Phase 1: ~/.adom/fusion-bridge") }-    fn scratch_dir(&self) -> PathBuf { todo!("Phase 1: %TEMP%/adom-fusion") }+    fn fusion_executable(&self) -> Option<PathBuf> { find_fusion_launcher() }++    /// Newest convention first. Fusion MOVED this dir across versions and silently ignores the+    /// others (issue #63), so the installer writes to every one that exists.+    fn addin_dirs(&self) -> Vec<PathBuf> {+        let r = roaming_app_data().join("Autodesk");+        vec![+            r.join("FusionAddins"),+            r.join("Autodesk Fusion").join("API").join("AddIns"),+            r.join("Autodesk Fusion 360").join("API").join("AddIns"),+        ]+    }++    /// The `logs` dir holding the newest AppLogFile*.log across every profile's+    /// `Autodesk Fusion[ 360]` tree; None when Fusion has never logged here.+    fn fusion_log_dir(&self) -> Option<PathBuf> {+        let mut bases = vec![];+        for nm in ["Autodesk Fusion 360", "Autodesk Fusion"] {+            bases.push(local_app_data().join("Autodesk").join(nm));+        }+        for u in user_profiles() {+            for nm in ["Autodesk Fusion 360", "Autodesk Fusion"] {+                bases.push(u.join("AppData").join("Local").join("Autodesk").join(nm));+            }+        }+        let mut best: Option<(u64, PathBuf)> = None;+        for base in bases {+            for entry in subdirs(&base) {+                let logs = entry.join("logs");+                let Ok(rd) = std::fs::read_dir(&logs) else { continue };+                for f in rd.flatten() {+                    let name = f.file_name().to_string_lossy().to_string();+                    if name.starts_with("AppLogFile") && name.ends_with(".log") {+                        let m = mtime_secs(&f.path());+                        if best.as_ref().map(|b| m > b.0).unwrap_or(true) { best = Some((m, logs.clone())); }+                    }+                }+            }+        }+        best.map(|b| b.1)+    }++    fn bridge_state_dir(&self) -> PathBuf { home().join(".adom").join("fusion-bridge") }++    fn scratch_dir(&self) -> PathBuf {+        env_dir("TEMP").unwrap_or_else(|| local_app_data().join("Temp")).join("adom-fusion")+    }+}++#[cfg(test)]+mod tests {+    use super::*;+    #[test]+    fn paths_never_panic_off_windows() {+        let h = WindowsHost;+        let _ = h.fusion_executable();+        assert_eq!(h.addin_dirs().len(), 3);+        let _ = h.fusion_log_dir();+        assert!(h.bridge_state_dir().ends_with("fusion-bridge"));+        assert!(h.scratch_dir().ends_with("adom-fusion"));+        assert!(h.fusion_processes().is_empty() || cfg!(windows));+    } }