Fusion - the Fusion 360 Bridge

@@ -4,7 +4,9 @@ import ctypes import ctypes.wintypes import json import os+import re import subprocess+import threading import time import urllib.error import urllib.request@@ -283,6 +285,94 @@ def _dismiss_startup_dialogs():         pass  +# ── Background launch: NEVER steal the user's foreground ──────────────────────+# The bridge launches Fusion for AUTOMATION, on a machine the user is actively+# working on. Fusion normally opens its splash + main window in the FOREGROUND,+# yanking focus off whatever the user is doing. That is unacceptable (John, 2026-+# 07-06: "make sure new windows ALWAYS only open in the background"). So we (1)+# start the process MINIMIZED + NOT ACTIVATED via STARTUPINFO, and (2) run a short+# focus-guard thread that, whenever a Fusion window steals the foreground during+# the noisy startup window, minimizes it WITHOUT activating - returning focus to+# the user's work. The add-in still loads fully while minimized. To SHOW Fusion to+# the user later, a verb explicitly restores+foregrounds it (the ONLY time we ever+# foreground). See the fusion-bridge-dev skill "Background-launch invariant".+_SW_SHOWMINNOACTIVE = 7  # show minimized, do NOT activate/steal focus+++def _fusion_pids() -> set:+    """PIDs of running Fusion360.exe processes (via tasklist CSV). Empty on error."""+    try:+        cnw = subprocess.CREATE_NO_WINDOW if hasattr(subprocess, "CREATE_NO_WINDOW") else 0+        out = subprocess.check_output(+            ["tasklist", "/FI", "IMAGENAME eq Fusion360.exe", "/FO", "CSV", "/NH"],+            stdin=subprocess.DEVNULL, stderr=subprocess.DEVNULL, creationflags=cnw,+        ).decode("utf-8", "replace")+    except Exception:+        return set()+    return {int(p) for p in re.findall(r'"Fusion360\.exe","(\d+)"', out)}+++def _popen_fusion_background(exe_path: str):+    """Launch the Fusion launcher MINIMIZED + NOT ACTIVATED, console-less."""+    cnw = subprocess.CREATE_NO_WINDOW if hasattr(subprocess, "CREATE_NO_WINDOW") else 0+    startupinfo = None+    try:+        startupinfo = subprocess.STARTUPINFO()+        startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW+        startupinfo.wShowWindow = _SW_SHOWMINNOACTIVE+    except Exception:+        startupinfo = None+    return subprocess.Popen(+        [exe_path],+        stdin=subprocess.DEVNULL,+        stdout=subprocess.DEVNULL,+        stderr=subprocess.DEVNULL,+        creationflags=cnw,+        startupinfo=startupinfo,+    )+++def _focus_guard(seconds: float = 120.0):+    """For `seconds`, demote any Fusion window that steals the foreground.++    SURGICAL: only acts when the CURRENT foreground window belongs to a Fusion+    process (i.e. Fusion just grabbed focus). It minimizes that window without+    activating anything, so focus falls back to whatever the user was using. It+    does NOT touch Fusion when the user is in another app, so it never fights a+    user who deliberately opened Fusion. Best-effort; never raises."""+    try:+        user32 = ctypes.windll.user32+    except Exception:+        return+    end = time.time() + seconds+    pids = set()+    last_refresh = 0.0+    while time.time() < end:+        now = time.time()+        if now - last_refresh > 3.0:+            pids = _fusion_pids()+            last_refresh = now+        try:+            fg = user32.GetForegroundWindow()+            if fg and pids:+                wpid = ctypes.wintypes.DWORD(0)+                user32.GetWindowThreadProcessId(fg, ctypes.byref(wpid))+                if wpid.value in pids:+                    # minimize the focus-stealing Fusion window, no activation+                    user32.ShowWindowAsync(fg, _SW_SHOWMINNOACTIVE)+        except Exception:+            pass+        time.sleep(0.2)+++def _start_focus_guard(seconds: float = 120.0):+    """Fire-and-forget the focus guard on a daemon thread. Never raises."""+    try:+        threading.Thread(target=_focus_guard, args=(seconds,), daemon=True).start()+    except Exception:+        pass++ def ensure_fusion_running(fusion_info: dict, wait_addin: bool = False) -> dict | None:     """Launch Fusion 360 if not already running. @@ -312,17 +402,14 @@ def ensure_fusion_running(fusion_info: dict, wait_addin: bool = False) -> dict |         return {"success": False, "error": "Fusion 360 executable not found"}      try:-        # Explicit DEVNULL on all three std streams + CREATE_NO_WINDOW: the bridge-        # is itself a detached, console-less child of AD, so inherited handles are-        # invalid. Passing them through to the Fusion launcher risks a hang.-        _cnw = subprocess.CREATE_NO_WINDOW if hasattr(subprocess, "CREATE_NO_WINDOW") else 0-        subprocess.Popen(-            [exe_path],-            stdin=subprocess.DEVNULL,-            stdout=subprocess.DEVNULL,-            stderr=subprocess.DEVNULL,-            creationflags=_cnw,-        )+        # Launch MINIMIZED + NOT ACTIVATED so Fusion never yanks focus off the+        # user's work (see the background-launch block above). Explicit DEVNULL on+        # all three std streams + CREATE_NO_WINDOW: the bridge is itself a detached,+        # console-less child of AD, so inherited handles are invalid.+        _popen_fusion_background(exe_path)+        # Guard the noisy startup window: Fusion re-foregrounds itself several times+        # while its splash/main window come up, so STARTUPINFO alone isn't enough.+        _start_focus_guard(seconds=120.0)     except Exception as e:         return {"success": False, "error": f"Failed to launch Fusion 360: {e}"}