Fusion - the Fusion 360 Bridge

@@ -1107,6 +1107,7 @@ def _handle_window_info(fusion_info: dict, args: dict) -> dict:             result["blockingDialogs"] = classify_blocking_dialogs() or []         except Exception:             result["blockingDialogs"] = []+        _license_classify_extend(result["blockingDialogs"])         dialog_info = [f"  hwnd={d['hwnd']}: {d['title']}" for d in dialogs]         output_parts = [             f"Main: hwnd={result['hwnd']}, title='{result['title']}'",@@ -4345,6 +4346,37 @@ _DOC_SWITCHING_ADDIN = { }  +def _license_classify_extend(dialogs: list):+    """ab's #30 ask: the Autodesk seat modal ('Active Sessions Exceeded' / 'Suspend Remote+    Session') often carries a bare Win32 title, so the title-substring classifier files it+    as generic_modal - undecidable for a caller. find_licensing_dialog() detects it by+    OWNERSHIP + SHAPE instead, so when it fires, append the decidable category (mutates+    the passed list in place; never raises)."""+    try:+        if any(d.get("category") == "license_sessions_exceeded" for d in dialogs):+            return+        dlg = find_licensing_dialog()+        if not dlg:+            return+        auto = _seat_takeover_enabled()+        dialogs.append({+            "category": "license_sessions_exceeded",+            "title": dlg.get("title") or "",+            "hwnd": dlg.get("hwnd"),+            "resolution": (+                "Autodesk seat modal: this account's Fusion is active on another machine. "+                + ("Auto-takeover is ON - the bridge clicks Continue through both dialogs in the "+                   "background (~20s sweep; a fusion_start resolves it immediately). The other "+                   "machine's Fusion suspends RESUMABLY."+                   if auto else+                   "Auto-takeover is OPTED OUT (fusion_set_seat_takeover) - resolve the dialog "+                   "manually or free the seat with fusion_stop on the other machine.")),+            "autoHandled": auto,+        })+    except Exception:+        pass++ def _handle_fusion_state(fusion_info: dict, args: dict) -> dict:     """fusion_state - the render-me verb (#28; kicad_state is the reference shape). @@ -4372,6 +4404,7 @@ def _handle_fusion_state(fusion_info: dict, args: dict) -> dict:         result["blockingDialogs"] = classify_blocking_dialogs() or []     except Exception:         result["blockingDialogs"] = []+    _license_classify_extend(result["blockingDialogs"])     # Busy state (the add-in's own report; 3s budget, never blocks the state read).     busy = None     try:@@ -6149,6 +6182,64 @@ _DEMO_TOURS: dict = {} _DEMO_TOURS_LOCK = threading.Lock()  +def _demo_tour_dir():+    import pathlib+    d = pathlib.Path(os.path.expanduser("~")) / ".adom" / "fusion-bridge" / "tours"+    d.mkdir(parents=True, exist_ok=True)+    return d+++def _demo_tour_persist(state: dict):+    """Snapshot a FINISHED tour to disk (ab's #30 grace-window ask, 2026-08-16): their+    2.5s poller got 'unknown demoId' for the final frame because a bridge_install+    respawned this process between polls, wiping the in-memory dict - tours were never+    reaped, the PROCESS was. The disk snapshot makes the done frame (with its shots)+    pollable across respawns; keep the last 8, best-effort."""+    try:+        d = _demo_tour_dir()+        snap = {k: v for k, v in state.items() if k != "started"}+        (d / (str(state.get("demoId")) + ".json")).write_text(json.dumps(snap))+        old = sorted(d.glob("tour-*.json"), key=lambda p: p.stat().st_mtime)+        for p in old[:-8]:+            p.unlink()+    except Exception:+        pass+++def _demo_tour_load(demo_id: str):+    try:+        p = _demo_tour_dir() / (demo_id + ".json")+        if p.is_file():+            return json.loads(p.read_text())+    except Exception:+        pass+    return None+++def _shot_b64_small(path: str, max_w: int = 640):+    """Base64 evidence frame for ab's stepShot contract (~640px wide). PIL downscale when+    available; else the raw file if it is small enough for the relay envelope."""+    try:+        try:+            from PIL import Image+            import io+            import base64+            im = Image.open(path)+            if im.width > max_w:+                im = im.resize((max_w, max(1, int(im.height * max_w / im.width))))+            buf = io.BytesIO()+            im.convert("RGB").save(buf, format="PNG")+            return base64.b64encode(buf.getvalue()).decode()+        except ImportError:+            import base64+            raw = open(path, "rb").read()+            if len(raw) <= 1_500_000:+                return base64.b64encode(raw).decode()+    except Exception:+        pass+    return None++ def _demo_tour_sample_lbr():     """The bundled sample library staged into the wrap dir (self-sufficient demo data)."""     import os@@ -6247,6 +6338,7 @@ def _orchestrate_demo_tour(args: dict) -> dict:                 if key == "launch":                     dispatch_command("start", {})                     ready = False+                    seat_attempts = 0                     for _ in range(30):                         time.sleep(5)                         try:@@ -6255,6 +6347,37 @@ def _orchestrate_demo_tour(args: dict) -> dict:                                 break                         except Exception:                             pass+                        # ab's #30 fleet finding (2026-08-16): a single-seat account with Fusion+                        # signed in elsewhere wedges the cold start at 0% behind 'Active Sessions+                        # Exceeded'. Self-heal (take the seat, John's standing call) and REPORT it+                        # as its own state; if takeover cannot land (opt-out, or the UIA path is+                        # unavailable), fail FAST with the decidable classification instead of+                        # burning the whole 150s budget.+                        try:+                            if find_licensing_dialog():+                                if _seat_takeover_enabled():+                                    state.update(stepLabel="Taking over the Autodesk seat (another machine holds it)")+                                    r = _resolve_seat_dialog(max_clicks=3)+                                    seat_attempts += 1+                                    if r.get("clicks"):+                                        state["seatTakeover"] = True+                                        state.setdefault("warnings", []).append(+                                            "license_sessions_exceeded: took the seat over in the background "+                                            "(the other machine's Fusion suspended resumably)")+                                    if seat_attempts >= 3 and find_licensing_dialog():+                                        raise RuntimeError(+                                            "license_sessions_exceeded: the Autodesk seat is held on another "+                                            "machine and background takeover did not land. Free it there "+                                            "(fusion_stop on that box) and re-run the tour.")+                                else:+                                    raise RuntimeError(+                                        "license_sessions_exceeded: seat held on another machine and "+                                        "auto-takeover is opted out (fusion_set_seat_takeover). Resolve the "+                                        "'Active Sessions Exceeded' dialog or re-enable takeover, then re-run.")+                        except RuntimeError:+                            raise+                        except Exception:+                            pass                     if not ready:                         # Not ready usually means the SIGN-IN wall on a fresh box. Drive it as far                         # as code can (email typed, page advanced), toast the human at the exact@@ -6379,6 +6502,8 @@ def _orchestrate_demo_tour(args: dict) -> dict:             state.update(failed=True, done=True, error=str(e)[:300],                          narrate="Fusion tour stopped at '%s': %s" % (state.get("stepLabel"), str(e)[:120]),                          elapsedSec=int(time.time() - state["started"]))+        finally:+            _demo_tour_persist(state)      threading.Thread(target=_run, daemon=True, name="fusion-demo-tour").start()     return {"success": True, "demoId": demo_id, "estimatedSec": est,@@ -6398,20 +6523,68 @@ def _handle_demo_progress(args: dict) -> dict:         # a WRONG id must refuse (the suite's #unknown negative test enforces this).         if state is None and not demo_id and len(_DEMO_TOURS) == 1:             state = list(_DEMO_TOURS.values())[0]+    persisted = False+    if state is None and demo_id:+        # Respawn-survival (ab #30): finished tours are snapshotted to disk, so the final+        # frame stays pollable even after bridge_install replaced this process mid-poll.+        state = _demo_tour_load(demo_id)+        persisted = state is not None     if state is None:         return {"success": False, "error": "unknown demoId " + demo_id,-                "_hint": "Start a tour first: fusion_demo {\"mode\": \"tour\"}. Its response carries the demoId."}+                "_hint": "Start a tour first: fusion_demo {\"mode\": \"tour\"}. Its response carries the demoId. Finished tours stay pollable (disk snapshot) even across bridge respawns - an unknown id here means it never ran on this box."}     out = {"success": True}     out.update({k: v for k, v in state.items() if k != "started"})+    if persisted:+        out["fromSnapshot"] = True+    # ── stepShot: the DURING evidence (ab's exact contract, #30 2026-08-16): one shot per+    # completed step, riding the FIRST progress frame after that step completes, ~640px+    # wide base64 - the bridge knows the exact completion moment and surface, the page+    # does not. Delivery cursor lives in the tour state; encode failure still advances so+    # one unreadable file can never stall the stream. The final shots gallery (below and+    # at done:true) is unchanged - that is the AFTER evidence.+    if not persisted:+        _sent = int(state.get("stepShotSent") or 0)+        _all = list(state.get("shots") or [])+        if _sent < len(_all):+            s = _all[_sent]+            img = _shot_b64_small(s.get("path") or "")+            state["stepShotSent"] = _sent + 1+            if img:+                out["stepShot"] = {"step": s.get("label"), "title": s.get("title") or s.get("label"),+                                   "image": img}+    # ── Progressive per-step EVIDENCE (John, 2026-08-16): shots stream to the caller AS+    # each step completes, not only at done:true. Contract for a live evidence gallery:+    #   poll fusion_demo_progress {demoId, imagesAs:"base64", sinceShot:<count you have>}+    # -> shots = ONLY the new ones (each with .image base64), shotCount = total so far.+    # sinceShot keeps 1/sec polls cheap: unchanged evidence is never re-encoded/re-sent.+    # Shot dicts are COPIED before encoding - mutating state's own dicts embedded base64+    # into the shared tour state (memory bloat + every later poll re-shipping it all).+    shots = list(out.get("shots") or [])+    out["shotCount"] = len(shots)+    try:+        since = max(0, int(args.get("sinceShot") or 0))+    except Exception:+        since = 0+    if since:+        shots = shots[since:]     imgs = args.get("imagesAs") or ("base64" if state.get("done") else "paths")-    if imgs in ("base64", "both") and state.get("done"):+    if imgs in ("base64", "both"):         import base64-        for s in out.get("shots", []):+        encoded = []+        for s in shots:+            s = dict(s)             try:                 with open(s["path"], "rb") as f:                     s["image"] = base64.b64encode(f.read()).decode()             except Exception:                 pass+            encoded.append(s)+        shots = encoded+    out["shots"] = shots+    if not state.get("done"):+        out["_hint"] = ("Tour running (%s). shots[] carries evidence for every COMPLETED step "+                        "already - render it live; pass sinceShot=%d on the next poll to receive "+                        "only new shots." % (out.get("stepLabel"), out["shotCount"]))     return out