Fusion - the Fusion 360 Bridge

@@ -1410,6 +1410,104 @@ def _post_open_screenshot(result: dict, settle_time: float = 2.0) -> dict:     return _apply_failure_dialogs(result)  +# ── Fusion's OWN error toasts, read programmatically (John, 2026-09-01) ──────+# Fusion draws many errors as CEF overlays INSIDE the canvas: no top-level window, so+# neither Win32 enumeration nor UIA can see them, and check_dialogs reported "no dialogs"+# while an Error box sat on the user's screen ("Cannot create a managed library from a+# document not saved in a Fusion Hub"). Fusion DOES log every one of them to its own+# AppLogFile as a `New Alert message` line, so the bridge reads that instead of guessing+# from pixels. Bridge-side on purpose: it works with the add-in wedged and needs no+# Fusion restart to deploy.+_ALERT_RE = re.compile(r"New Alert message\.\s*(?:Tooltip:\s*(?P<tip>.*?))?"+                       r"(?:,\s*Short Message:\s*(?P<short>.*?))?"+                       r"(?:,\s*Long Message:\s*(?P<long>.*?))?\s*$")+++def _fusion_log_path():+    """Newest Fusion AppLogFile for the signed-in user, or None."""+    try:+        base = os.path.join(os.path.expanduser("~"), "AppData", "Local", "Autodesk",+                            "Autodesk Fusion 360")+        best = None+        for entry in os.listdir(base):+            d = os.path.join(base, entry, "logs")+            if not os.path.isdir(d):+                continue+            for f in os.listdir(d):+                if f.startswith("AppLogFile") and f.endswith(".log"):+                    fp = os.path.join(d, f)+                    m = os.path.getmtime(fp)+                    if best is None or m > best[0]:+                        best = (m, fp)+        return best[1] if best else None+    except Exception:+        return None+++def _fusion_alerts(since_sec: float = 300.0, tail_bytes: int = 400000) -> list:+    """Fusion's own alert toasts from the last `since_sec` seconds.++    Returns [{at, text}] newest last. Never raises."""+    import time as _t, datetime as _dt+    path = _fusion_log_path()+    if not path:+        return []+    try:+        size = os.path.getsize(path)+        with open(path, "r", encoding="utf-8", errors="replace") as fh:+            if size > tail_bytes:+                fh.seek(size - tail_bytes)+                fh.readline()+            lines = fh.readlines()+    except Exception:+        return []+    cutoff = _t.time() - max(1.0, since_sec)+    out = []+    for line in lines:+        if "New Alert message" not in line:+            continue+        stamp = None+        m0 = re.match(r"\s*(\d{8}T\d{6})", line)+        if m0:+            try:+                stamp = _dt.datetime.strptime(m0.group(1), "%Y%m%dT%H%M%S").timestamp()+            except Exception:+                stamp = None+        if stamp is not None and stamp < cutoff:+            continue+        m = _ALERT_RE.search(line)+        text = ""+        if m:+            text = (m.group("short") or m.group("tip") or "").strip()+        if not text:+            text = line.split("New Alert message.", 1)[-1].strip()[:400]+        out.append({"at": m0.group(1) if m0 else None, "text": text[:400]})+    return out+++def _with_fusion_alerts(resp: dict, since_sec: float = 300.0) -> dict:+    """Attach Fusion's own alert toasts to a dialog report, so an in-canvas CEF error is+    never invisible just because it has no window (John, 2026-09-01)."""+    try:+        alerts = _fusion_alerts(since_sec)+        if alerts:+            resp = dict(resp or {})+            resp["fusionAlerts"] = alerts+            resp["_hint"] = ("Fusion raised %d alert(s) in the last %ds - the newest is %r. "+                             "These are in-canvas CEF overlays with no top-level window, so "+                             "they do NOT appear in dialogs[]; read fusionAlerts and treat the "+                             "driving command as FAILED unless you know otherwise."+                             % (len(alerts), int(since_sec), alerts[-1].get("text", "")[:160]))+        elif not (resp or {}).get("dialogs"):+            resp = dict(resp or {})+            resp["fusionAlerts"] = []+            resp["_hint"] = ("No Fusion dialogs, owned popups, or alert toasts in the last "+                             "%ds." % int(since_sec))+    except Exception:+        pass+    return resp++ def _capture_dialog_array(settle: float = 0.6) -> dict | None:     """After a mutating op, enumerate + screenshot any owned popups / modal dialogs so     the AI can SEE and ANALYZE them. Titles alone are not enough: a dialog's body text@@ -2698,11 +2796,20 @@ COMMAND_HANDLERS = {     # can ANALYZE before acting. Use while polling a long op (e.g. a Hub upload) or any     # time you suspect a dialog is up. Mutating verbs attach this automatically; this is     # the manual entry point. See the fusion-driving skill.-    "check_dialogs": lambda fi, args: (+    "check_dialogs": lambda fi, args: _with_fusion_alerts(         _capture_dialog_array(settle=float(args.get("settle", 0.3)))-        or {"success": True, "dialogsDetected": 0, "dialogs": [],-            "_hint": "No Fusion dialogs/owned popups are currently up."}-    ),+        or {"success": True, "dialogsDetected": 0, "dialogs": []},+        float(args.get("alertsSinceSec", 300))),+    # Fusion's own error/warning toasts (the CEF overlays no window enumeration can see).+    "fusion_alerts": lambda fi, args: {+        "success": True,+        "alerts": _fusion_alerts(float(args.get("sinceSec", 300))),+        "logFile": _fusion_log_path(),+        "_hint": ("Fusion draws many errors as in-canvas CEF overlays with NO top-level "+                  "window, so check_dialogs alone cannot see them; these come from Fusion's "+                  "own AppLogFile 'New Alert message' entries. An empty list means Fusion "+                  "raised no toast in the window - not that a command succeeded."),+    },     "addin_status": lambda fi, args: _handle_addin_status(),     # LAST-RESORT human escalation (John 2026-07-07): when the bridge is truly blocked     # on the user (password/2FA, UAC), send an ab toast that reaches their MAIN machine