Fusion - the Fusion 360 Bridge

@@ -1,39 +1,49 @@  -# ── loading a .lbr for ADD / REPLACE (issue #135) ───────────────────────────────────────────────-# Fusion 2706 raises "PlacePartWorker.cpp, Line 23. Condition: assetAdded" on every ADD from a-# library file whose elements are not separated by line breaks (<packages><package ...> on one-# line), whatever the parts are; the same library with a line break between elements adds cleanly,-# with or without 3D packages (bisected live on 2706.1.14, 2026-10-31: one compact boundary in-# <devicesets> was enough). So a compact .lbr is rewritten in place with a line break between-# elements before USE. In place, because a copy at another path with the same library name makes-# Fusion ask which one to take (its Select Library dialog) once both have been USEd.+# ── loading a .lbr for ADD / REPLACE (issues #135, #136) ────────────────────────────────────────+# Fusion 2706's ADD reads the library file as text. It raises "PlacePartWorker.cpp, Line 23.+# Condition: assetAdded" on every ADD from a file that has (each bisected live on 2706.1.14,+# 2026-10-31 and 2026-11-01, on a library that adds cleanly otherwise):+#   - elements inside <library> with no line break between them (one is enough);+#   - a UTF-8 byte-order mark;+#   - attributes in single quotes.+# Fine as they are: indentation, tabs, CRLF, no XML declaration, a DOCTYPE, comments, non-ASCII+# text, apostrophes and escaped HTML in text, the EAGLE version, an unresolvable 3D package URN.+# So such a file is rewritten in place before USE, keeping its element tree exactly. In place,+# because a copy at another path with the same library name makes Fusion ask which one to take+# (its Select Library dialog) once both have been USEd.  def _lbr_shape(root):     return [(e.tag if isinstance(e.tag, str) else 'comment', sorted(e.attrib.items()), (e.text or '').strip(), (e.tail or '').strip())             for e in root.iter()]  -def lbr_needs_line_breaks(data):-    """True when two elements inside the file's <library> (bytes or text) touch with no line break-    between them. The header outside it may be compact: Fusion's own exports are, and add fine."""+def lbr_needs_rewrite(data):+    """True when the file (bytes or text) has anything Fusion 2706's ADD cannot read: a byte-order+    mark, single-quoted attributes, or two elements inside <library> with no line break between+    them. A compact header outside <library> and a single-quoted XML declaration are fine: Fusion's+    own exports have them."""     import re as _re     if isinstance(data, str): data = data.encode('utf-8')+    if data[:3] == b'\xef\xbb\xbf' or data[:2] in (b'\xff\xfe', b'\xfe\xff'): return True+    body = _re.sub(rb'^\s*<\?xml[^>]*\?>', b'', data, count=1)+    if _re.search(rb"""<[A-Za-z][^<>"']*\s[\w:.-]+\s*=\s*'""", body): return True     i = data.find(b'<library')     return i >= 0 and _re.search(rb'>[ \t]*<', data[i:]) is not None   def normalize_lbr(path):-    """Rewrite a compact .lbr in place with a line break between elements. Returns True when it-    rewrote the file. Only whitespace between elements changes: the element tree (tags, attributes,-    text, comments) is compared before and after, and nothing is written when it differs."""+    """Rewrite a .lbr Fusion 2706 cannot ADD from in place: no byte-order mark, double-quoted+    attributes, a line break between elements. Returns True when it rewrote the file. Only the file's+    formatting changes: the element tree (tags, attributes, text, comments) is compared before and+    after, and nothing is written when it differs."""     import os as _os     import re as _re     import xml.etree.ElementTree as _ET     from pathlib import Path as _P     p = _P(path)     raw = p.read_bytes()-    if not lbr_needs_line_breaks(raw):+    if not lbr_needs_rewrite(raw):         return False     # parsed from bytes, so the file's own declared encoding is honoured; written back as UTF-8     root = _ET.fromstring(raw, parser=_ET.XMLParser(target=_ET.TreeBuilder(insert_comments=True)))@@ -42,7 +52,7 @@ def normalize_lbr(path):     body = _ET.tostring(root, encoding='unicode')     again = _ET.fromstring(body, parser=_ET.XMLParser(target=_ET.TreeBuilder(insert_comments=True)))     if _lbr_shape(again) != before:-        raise RuntimeError('rewriting %s with line breaks would change more than whitespace' % p.name)+        raise RuntimeError('rewriting %s for Fusion would change more than its formatting' % p.name)     m = _re.search(r'<!DOCTYPE[^>]*>', raw[:2000].decode('latin-1'))     out = '<?xml version="1.0" encoding="utf-8"?>\n' + (m.group(0) + '\n' if m else '') + body + '\n'     tmp = p.with_name(p.name + '.adom-tmp')@@ -53,13 +63,13 @@ def normalize_lbr(path):  def use_library(app, path):     """USE a .lbr on this machine so ADD/REPLACE can take its devices, rewriting it first when-    Fusion 2706 would refuse it (see above). Returns True when the file was rewritten."""+    Fusion 2706 could not read it (see above). Returns True when the file was rewritten."""     from pathlib import Path as _P     try:         changed = normalize_lbr(path)     except PermissionError:-        raise RuntimeError('library_not_writable: %s has no line breaks between its elements, which Fusion 2706 cannot ADD from '-                           '(PlacePartWorker assetAdded), and this machine will not let the bridge rewrite it. Save it somewhere writable '-                           'and pass that path' % path)+        raise RuntimeError('library_not_writable: %s is formatted in a way Fusion 2706 cannot ADD from (PlacePartWorker assetAdded: '+                           'no line breaks between elements, a byte-order mark or single-quoted attributes), and this machine will not let '+                           'the bridge rewrite it. Save it somewhere writable and pass that path' % path)     app.executeTextCommand("Electron.run USE '%s';" % _P(path).as_posix())     return changed

@@ -1258,6 +1258,50 @@ fn close_new_untitled(before: &[String], pass: &dyn Fn(&str, Value) -> Value) ->     closed } +/// Bumped by each import: a late-dialog watcher left by an earlier import stops when a new one starts,+/// so it can never close the new import's dialog.+static EAGLE_IMPORT_GEN: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(0);++/// The importer's Open dialog on this machine: by title in ab's window list, else any native file+/// dialog on Fusion's processes (a Windows that is not in English titles it differently: the common+/// dialog's File name box, control 1148, is what proves it). An ab failure is noted in `ab_error`.+fn eagle_open_dialog(ab: &dyn fusion_core::ab::AbClient, caller: &fusion_core::ab::Caller, pids: &[u32], ab_error: &std::cell::RefCell<Option<String>>) -> Option<i64> {+    match ab.call("desktop_list_windows", json!({}), caller, 10) {+        Ok(v) => {+            let found = v["data"]["windows"].as_array().or_else(|| v["windows"].as_array()).cloned().unwrap_or_default().iter()+                .find(|w| w["title"].as_str().unwrap_or("").trim().to_lowercase() == "open").and_then(|w| w["hwnd"].as_i64());+            if found.is_some() { return found; }+        }+        Err(e) => { *ab_error.borrow_mut() = Some(format!("desktop_list_windows: {e}")); }+    }+    crate::small_verbs::native_file_dialogs(ab, caller, pids).iter().find_map(|w| {+        let h = w["hwnd"].as_i64()?;+        if w["title"].as_str().unwrap_or("").trim().eq_ignore_ascii_case("open") { return Some(h); }+        ab.call("desktop_find_controls", json!({"hwnd": h}), caller, 10).ok().filter(|c| c.to_string().contains("1148")).map(|_| h)+    })+}++/// The import's command is queued and cannot be taken back, so when the bridge stops waiting Fusion may+/// still open the dialog later, with nobody left to fill it, blocking Fusion on the user's screen (#136).+/// For ten minutes this closes what that import opens (the .sch dialog, then the .brd one it chains to),+/// and stops at once if another import starts.+fn watch_for_late_open_dialog(state_dir: std::path::PathBuf, caller: fusion_core::ab::Caller, pids: Vec<u32>, wanted: String, gen: u64) {+    std::thread::spawn(move || {+        use std::sync::atomic::Ordering;+        let Some(ab) = fusion_core::ab::Loopback::from_env() else { return };+        let noted = std::cell::RefCell::new(None);+        let (mut closed, mut last_close) = (0, None::<std::time::Instant>);+        for _ in 0..200 {+            std::thread::sleep(Duration::from_secs(3));+            if EAGLE_IMPORT_GEN.load(Ordering::SeqCst) != gen { return; }+            if let Some(h) = eagle_open_dialog(&ab, &caller, &pids, &noted) {+                if crate::small_verbs::close_native_dialog(&ab, &caller, h).0 { closed += 1; last_close = Some(std::time::Instant::now()); }+            } else if last_close.map(|t| t.elapsed() > Duration::from_secs(30)).unwrap_or(false) { break; }+        }+        if closed > 0 { crate::fusion_prefs::action_ledger(&state_dir, "eagle_import_late_dialog_closed", json!({"wanted": wanted, "closed": closed})); }+    });+}+ pub fn new_electronics_from_eagle(ctx: &Ctx, args: &Value, pass: &dyn Fn(&str, Value) -> Value) -> Value {     // Async by contract (issue #90): the dialog-driven import outlives ab's relay budget, so the     // default returns a runId at once and the work runs on this exe's own thread; the caller@@ -1327,22 +1371,47 @@ pub fn new_electronics_from_eagle(ctx: &Ctx, args: &Value, pass: &dyn Fn(&str, V             "error": format!("Fusion raised '{}' during the import ({stage}); the import cannot finish, so the bridge stopped and cancelled its Open dialog.", dlg["title"].as_str().unwrap_or("a crash dialog")),             "_hint": format!("{} Save the open documents, restart Fusion (fusion_restart_for_addin {{save:true}}), then run the import again.", dlg["resolution"].as_str().unwrap_or(""))}))     };-    let find_open_dialog = || -> Option<i64> { ab.call("desktop_list_windows", json!({}), &ctx.caller, 10).ok().and_then(|v| v["data"]["windows"].as_array().or_else(|| v["windows"].as_array()).cloned()).unwrap_or_default().iter().find(|w| w["title"].as_str().unwrap_or("").trim().to_lowercase() == "open").and_then(|w| w["hwnd"].as_i64()) };+    let import_gen = EAGLE_IMPORT_GEN.fetch_add(1, std::sync::atomic::Ordering::SeqCst) + 1;+    let ab_error: std::cell::RefCell<Option<String>> = std::cell::RefCell::new(None);+    let find_open_dialog = || -> Option<i64> { eagle_open_dialog(&ab, &ctx.caller, &ctx.pids, &ab_error) };     let (sch_base, brd_base) = (sch.rsplit('/').next().unwrap_or("").to_string(), brd.rsplit('/').next().unwrap_or("").to_string());     // The Open dialogs are filled with UI Automation and keystrokes, which ab gates behind its shell     // approval even for a bridge (#133: on a PC with no grant every fill was refused, needs_approval).     // Ask BEFORE any dialog opens: the prompt shows in Adom Bridge (or Hydrogen), and the run waits up to     // five minutes for the click; no grant, no dialog.-    let approved = |st: &Value| { let s = &st["permissions"]["shell"]; let s = if s.is_object() { s } else { &st["data"]["permissions"]["shell"] }; s["autoApproved"].as_bool() == Some(true) };-    if !ab.call("status", json!({}), &ctx.caller, 10).map(|s| approved(&s)).unwrap_or(true) {+    let approved = |st: &Value| { let s = &st["permissions"]["shell"]; let s = if s.is_object() { s } else { &st["data"]["permissions"]["shell"] }; s["autoApproved"].as_bool() == Some(true) || s["willPrompt"].as_bool() == Some(false) };+    // a status that cannot be read is not an approval: every step of the import needs ab, so opening a+    // dialog now would leave it on the user's screen with nothing able to fill or close it (#136)+    let mut status_now = Err(String::new());+    for attempt in 0..3 {+        if attempt > 0 { std::thread::sleep(Duration::from_secs(3)); }+        status_now = ab.call("status", json!({}), &ctx.caller, 10).map_err(|e| format!("{e}"));+        if status_now.is_ok() { break; }+    }+    let status_now = match status_now {+        Ok(v) => v,+        Err(e) => return json!({"success": false, "errorCode": "ab_unreachable", "imported": [], "dialogOpened": false, "abError": e,+            "error": "Not started: the bridge could not reach Adom Bridge, which it needs to fill in and close Fusion's Open dialog. No dialog was opened.",+            "_hint": "Retry in a moment; if it keeps failing, check Adom Bridge is running (bridge_list) and let it respawn this bridge."}),+    };+    if !approved(&status_now) {         let tell = "Adom Bridge needs your OK to fill in Fusion's Open dialog for the EAGLE import: click Approve (1 hr, 24 hr or Auto) in the Adom Bridge window, on its notification, or in Hydrogen.";         if let Some(rid) = args["_runId"].as_str() {             let mut v = std::fs::read_to_string(eagle_run_path(&ctx.state_dir, rid)).ok().and_then(|t| serde_json::from_str::<Value>(&t).ok()).unwrap_or(json!({}));             v["stage"] = json!("waiting_for_approval"); v["tellUser"] = json!(tell);             eagle_run_write(&ctx.state_dir, rid, &v);         }+        let asked_at = std::time::Instant::now();         let g = ab.call("request_shell_approval", json!({"wait": true, "timeoutSec": 300, "reason": "Fill in Fusion's Open dialog with the EAGLE .sch and .brd paths for the design import"}), &ctx.caller, 320);-        let granted = g.as_ref().map(|v| v["granted"].as_bool() == Some(true) || v["data"]["granted"].as_bool() == Some(true)).unwrap_or(false);+        let mut granted = g.as_ref().map(|v| v["granted"].as_bool() == Some(true) || v["data"]["granted"].as_bool() == Some(true)).unwrap_or(false);+        // the wait itself can break (a 504 from ab, #136) while the prompt still stands: keep reading+        // the grant for the rest of the five minutes instead of giving up on a click still to come+        if !granted && g.is_err() {+            while asked_at.elapsed() < Duration::from_secs(300) {+                std::thread::sleep(Duration::from_secs(3));+                if ab.call("status", json!({}), &ctx.caller, 10).map(|s| approved(&s)).unwrap_or(false) { granted = true; break; }+            }+        }         if let Some(rid) = args["_runId"].as_str() {             let mut v = std::fs::read_to_string(eagle_run_path(&ctx.state_dir, rid)).ok().and_then(|t| serde_json::from_str::<Value>(&t).ok()).unwrap_or(json!({}));             v["stage"] = json!("started"); v["approval"] = json!({"granted": granted});@@ -1380,14 +1449,25 @@ pub fn new_electronics_from_eagle(ctx: &Ctx, args: &Value, pass: &dyn Fn(&str, V         // the queued import runs once Fusion's main thread is free (a new design still settling can         // hold it for half a minute), so wait up to 90 s for the first dialog, 30 s for the second         // never the dialog just answered: it can linger a moment while the board's dialog replaces it-        for i in 0..(if want == "sch" { 60 } else { 20 }) {+        // up to five minutes: a busy Fusion opened it after the old 90 s, with nobody left to fill it (#136)+        let first_wait = args["_openDialogWaitSec"].as_u64().map(|s| (s * 2 / 3).max(1)).unwrap_or(200);+        if want == "sch" { if let Some(rid) = args["_runId"].as_str() {+            let mut v = std::fs::read_to_string(eagle_run_path(&ctx.state_dir, rid)).ok().and_then(|t| serde_json::from_str::<Value>(&t).ok()).unwrap_or(json!({}));+            v["stage"] = json!("waiting_for_open_dialog");+            eagle_run_write(&ctx.state_dir, rid, &v);+        } }+        for i in 0..(if want == "sch" { first_wait } else { 40 }) {             std::thread::sleep(Duration::from_millis(1500)); dlg = find_open_dialog().filter(|h| Some(*h) != answered); if dlg.is_some() { break; }             if i % 4 == 3 { if let Some(c) = crash_dialog() { return crashed(c, None, &format!("waiting for the {want} Open dialog"), &picked); } }         }         if dlg.is_some() { restore_minimized(&|t: &str| t.trim().eq_ignore_ascii_case("open")); std::thread::sleep(Duration::from_millis(800)); }         let Some(h) = dlg else {             if want == "brd" && !picked.is_empty() { break; }-            return json!({"success": false, "error": format!("The '{want}' Open dialog never appeared."), "_hint": "Screenshot the Fusion hwnd + READ screenshots[] for a blocking modal; the importer may have errored on the EAGLE source. Verify the .sch/.brd are valid EAGLE.", "data": {"picked": picked}});+            watch_for_late_open_dialog(ctx.state_dir.clone(), ctx.caller.clone(), ctx.pids.clone(), base.to_string(), import_gen);+            let ab_note = ab_error.borrow().clone();+            return json!({"success": false, "errorCode": "open_dialog_not_seen", "imported": picked, "abError": ab_note, "lateDialogWatch": true,+                "error": format!("Fusion's '{want}' Open dialog did not appear in the time the bridge waits{}. Nothing was imported. Fusion may still open it: for the next ten minutes the bridge closes a late one, so it cannot stay on your screen.", if ab_note.is_some() { ", and Adom Bridge could not list the windows" } else { "" }),+                "_hint": "Fusion was most likely busy. Let it settle (fusion_get_app_state answers again), close any empty Untitled documents, and run the import again; starting a new import stops the watch. Autodesk errors on the EAGLE source would show as a dialog in fusion_check_dialogs."});         };         // the FULL path into "File name:": the dialog opens on whatever folder Fusion used last, so         // clicking the bare name only worked when that happened to be the file's folder (2026-10-05)