Fusion - the Fusion 360 Bridge

@@ -13529,89 +13529,97 @@ def _human_secs(v: float) -> str:     return "%dm %02ds" % (m, sec) if sec else "%dm" % m  -_LIVE_FEED = {"thread": None, "stop": False, "frames": 0, "channel": None}+_LIVE_FEED = {"thread": None, "stop": False, "tick": 0, "frames": [], "startedAt": None}+_LIVE_FEED_MAX = 600      # ring buffer: ~10 min at 1 fps   def _handle_live_feed(fusion_info: dict, args: dict) -> dict:-    """A ~1 fps look INTO Fusion while the bridge drives it, published as three KINDS.--    John, 2026-08-28, after a chain restarted Fusion under him: "had you shown me a-    screenshot of fusion's interface i could have seen if there were any open tabs or not-    ... i literally should be getting screenshots like every 5 seconds during boot up ...-    or maybe each second, so like a 1 fps video." And: the frames need telling apart --    a Browser-panel popup, the main window, and a proof shot are three different things-    and a viewer must never have to guess which it is looking at.--    kind=main   the Fusion main window, the 1 fps video. One card per tick.-    kind=popup  every OWNED popup over it (dialogs, Browser/tool panels, the Adom banner),-                each tagged with the tick it belongs to. Fusion draws these as separate-                windows that a main-frame capture omits, so they ride alongside, never-                instead of, the main frame.-    kind=proof  is NOT produced here. Proof frames are the evidence the import chain-                captures (symbol / footprint / 3d / ganged) and they carry their own labels;-                the feed exists so the human can see what happened BETWEEN proofs.--    The wiki may choose not to render 1 fps; that is fine. The bridge owns the feed and-    publishes it to shotlog under `channel`, so a human always has somewhere to look.-    args: {action: start|stop|status, channel?, intervalSec? (default 1.0), maxSec? (600)}+    """A ~1 fps look INTO Fusion while the bridge drives it, as a box-side ring buffer.++    John, 2026-08-28: "i literally should be getting screenshots like every 5 seconds+    during boot up ... or maybe each second, so like a 1 fps video" - after a chain+    restarted Fusion under him and nothing ever showed him what was in it. And: a Browser+    panel popup, the main window, and a proof shot must never be confused.++    DESIGN, and why it is shaped this way. The first version (1.9.233) ran here on the+    Windows bridge and shelled out to `adom-shotlog` while reading `localSafePath` - a+    container tool and a container-side key. It reported running:true, frames:0 forever.+    The bridge can only ever produce BOX paths, so that is what it produces: each tick+    records the main-window capture and every owned popup (dialogs, Browser/tool panels,+    the Adom banner - Fusion draws these as separate windows a main capture omits) into a+    ring buffer, tagged. Something on the container side drains it with+    {action:"frames", since:<tick>}, read_file's the paths, and publishes them wherever a+    human is looking (shotlog, or the wiki if it chooses to render 1 fps). The bridge owns+    the feed; the presenter is pluggable.++    kind=main   the Fusion main window, one per tick (the video)+    kind=popup  each owned popup over it, tied to its tick+    kind=proof  NOT produced here: the import chain's evidence frames carry kind:"proof"+                and a step label, so the three are distinguishable at the source.++    args: {action: start|stop|status|frames, intervalSec? (default 1.0), maxSec? (600),+           since? (tick; frames newer than this)}     """-    import threading as _th, time as _t, subprocess as _sp+    import threading as _th, time as _t     action = str(args.get("action") or "status").lower()+    alive = bool(_LIVE_FEED["thread"] and _LIVE_FEED["thread"].is_alive())     if action == "status":-        return {"success": True, "running": bool(_LIVE_FEED["thread"] and _LIVE_FEED["thread"].is_alive()),-                "frames": _LIVE_FEED["frames"], "channel": _LIVE_FEED["channel"]}+        return {"success": True, "running": alive, "tick": _LIVE_FEED["tick"],+                "buffered": len(_LIVE_FEED["frames"]), "startedAt": _LIVE_FEED["startedAt"]}+    if action == "frames":+        since = int(args.get("since") or 0)+        fr = [f for f in _LIVE_FEED["frames"] if f["tick"] > since]+        return {"success": True, "running": alive, "tick": _LIVE_FEED["tick"],+                "frames": fr[-200:], "count": len(fr),+                "_hint": ("Each frame is a BOX path (this machine); read_file it from the "+                          "container and publish it. kind is main|popup; proof frames come "+                          "from fusion_prove_result evidence[] with kind:'proof'. Pass "+                          "since:<tick> to get only what you have not seen.")}     if action == "stop":         _LIVE_FEED["stop"] = True-        return {"success": True, "stopped": True, "frames": _LIVE_FEED["frames"]}-    if _LIVE_FEED["thread"] and _LIVE_FEED["thread"].is_alive():-        return {"success": True, "alreadyRunning": True, "channel": _LIVE_FEED["channel"],-                "frames": _LIVE_FEED["frames"]}-    channel = str(args.get("channel") or "fusion-live")+        return {"success": True, "stopped": True, "tick": _LIVE_FEED["tick"]}+    if alive:+        return {"success": True, "alreadyRunning": True, "tick": _LIVE_FEED["tick"]}     interval = max(0.5, float(args.get("intervalSec") or 1.0))     max_sec = min(3600.0, float(args.get("maxSec") or 600.0))-    _LIVE_FEED.update(stop=False, frames=0, channel=channel)--    def _inject(path, desc):-        try:-            _sp.run(["adom-shotlog", "inject", "-c", channel, "-d", desc, "-s",-                     "desktop_screenshot_window", "--native", path],-                    capture_output=True, text=True, timeout=20)-        except Exception:-            pass+    _LIVE_FEED.update(stop=False, tick=0, frames=[], startedAt=_t.time())      def _run():-        t0 = _t.time(); tick = 0+        t0 = _t.time()         while not _LIVE_FEED["stop"] and _t.time() - t0 < max_sec:-            tick += 1+            _LIVE_FEED["tick"] += 1+            tick = _LIVE_FEED["tick"]             try:                 info = get_fusion_window_info() or {}                 hwnd = info.get("hwnd") or (info.get("mainWindow") or {}).get("hwnd")                 if hwnd:                     shot = _ad_call("desktop_screenshot_window", {"hwnd": int(hwnd)}, timeout=20) or {}-                    main = shot.get("localSafePath")-                    pops = shot.get("screenshots") or []+                    # BOX paths: fullPath (main) and fullPathHost / localFullPath per popup.+                    main = shot.get("fullPath") or shot.get("fullPathHost") or shot.get("path")                     title = str(shot.get("title") or info.get("title") or "Fusion")[:60]+                    now = _t.time()                     if main:-                        _inject(main, "[main #%d] %s | %d popup(s)" % (tick, title, len(pops)))-                        _LIVE_FEED["frames"] += 1-                    for j, sp_ in enumerate(pops, 1):-                        if sp_.get("localSafePath"):-                            _inject(sp_["localSafePath"],-                                    "[popup #%d.%d] %s" % (tick, j, str(sp_.get("title") or "dialog")[:50]))+                        _LIVE_FEED["frames"].append({"tick": tick, "kind": "main", "at": now,+                                                     "path": main, "title": title,+                                                     "popups": len(shot.get("screenshots") or [])})+                    for k, sp_ in enumerate(shot.get("screenshots") or [], 1):+                        pth = sp_.get("fullPathHost") or sp_.get("fullPath") or sp_.get("path")+                        if pth:+                            _LIVE_FEED["frames"].append({"tick": tick, "kind": "popup", "at": now,+                                                         "index": k, "path": pth,+                                                         "title": str(sp_.get("title") or "dialog")[:50]})+                    if len(_LIVE_FEED["frames"]) > _LIVE_FEED_MAX:+                        del _LIVE_FEED["frames"][: len(_LIVE_FEED["frames"]) - _LIVE_FEED_MAX]             except Exception:                 pass             _t.sleep(interval)         _LIVE_FEED["thread"] = None     _LIVE_FEED["thread"] = _th.Thread(target=_run, daemon=True); _LIVE_FEED["thread"].start()-    return {"success": True, "started": True, "channel": channel, "intervalSec": interval,-            "maxSec": max_sec,-            "_hint": "⚠️ KNOWN LIMIT (2026-08-28): this runs on the Windows bridge, which has no "-                     "adom-shotlog and no container paths, so frames do NOT reach shotlog from here "-                     "yet - drive the capture loop from the container until the ring-buffer redesign "-                     "lands. Intended contract: frames land in shotlog channel %r tagged [main #n] (the 1 fps video) and "-                     "[popup #n.m] (dialogs/panels over it, tied to their tick). Proof frames "-                     "from the import chain are a third kind and carry their own step labels. "-                     "Open with: adom-shotlog open -c %s --skinny. Stop with action:stop." % (channel, channel)}+    return {"success": True, "started": True, "intervalSec": interval, "maxSec": max_sec,+            "_hint": ("Capturing into a box-side ring buffer. Drain it from the container with "+                      "fusion_live_feed {action:'frames', since:<lastTick>}, read_file each "+                      "path, and publish (e.g. adom-shotlog inject -c fusion-live -d "+                      "'[main #n] ...'). tools/live_feed_drain.py does exactly that.")}   def _handle_restart_for_addin(fusion_info: dict, args: dict) -> dict: