Fusion - the Fusion 360 Bridge

@@ -27,6 +27,7 @@ import hashlib import json import os import secrets+import subprocess import threading import time import urllib.parse@@ -77,6 +78,64 @@ APS_DIR = Path(os.path.expanduser("~")) / ".adom" / "fusion-aps" CONFIG_FILE = APS_DIR / "config.json" TOKENS_FILE = APS_DIR / "tokens.json" USAGE_FILE = APS_DIR / "usage.json"+# Which browser+profile the user's Autodesk sign-in ACTUALLY succeeded in. Power users+# run many browsers and many profiles; the OS default is usually NOT the one holding the+# warm Autodesk/SSO session. So we REMEMBER the browser+profile that worked and reuse it,+# instead of blindly firing webbrowser.open (which hits the OS default and forces a fresh+# login in the wrong place). Set on a successful driven sign-in; reused on every later one.+SIGNIN_BROWSER_FILE = APS_DIR / "signin-browser.json"+++def load_signin_browser() -> dict | None:+    """The remembered {name, exe, profileDir, newWindow} that last authed to Autodesk, or None."""+    try:+        return json.loads(SIGNIN_BROWSER_FILE.read_text(encoding="utf-8"))+    except Exception:+        return None+++def save_signin_browser(pref: dict) -> bool:+    """Remember the browser+profile that just worked, so the next sign-in reuses it."""+    try:+        APS_DIR.mkdir(parents=True, exist_ok=True)+        keep = {k: pref.get(k) for k in ("name", "exe", "profileDir", "newWindow", "how")+                if pref.get(k) is not None}+        keep["updatedAt"] = time.strftime("%Y-%m-%dT%H:%M:%S")+        SIGNIN_BROWSER_FILE.write_text(json.dumps(keep, indent=2), encoding="utf-8")+        return True+    except Exception:+        return False+++def forget_signin_browser() -> bool:+    try:+        SIGNIN_BROWSER_FILE.unlink()+        return True+    except FileNotFoundError:+        return True+    except Exception:+        return False+++def _launch_url_in_browser(pref: dict, url: str) -> bool:+    """Launch a SPECIFIC browser+profile (not the OS default) at url. Chromium browsers+    take --profile-directory + --new-window; a bare exe still opens its default profile.+    Returns True if the process spawned."""+    exe = pref.get("exe")+    if not exe or not os.path.exists(exe):+        return False+    cmd = [exe]+    prof = pref.get("profileDir")+    if prof:+        cmd.append(f"--profile-directory={prof}")+    if pref.get("newWindow", True):+        cmd.append("--new-window")+    cmd.append(url)+    try:+        subprocess.Popen(cmd, close_fds=True)+        return True+    except Exception:+        return False  # ── NEVER-CHARGE GUARANTEE (hard rule) ─────────────────────────────────────── # A user must NEVER be charged money — a card on file is only ever for Autodesk's@@ -304,8 +363,9 @@ class _CallbackHandler(BaseHTTPRequestHandler):         pass  -def start_signin() -> dict:+def start_signin(args: dict | None = None) -> dict:     global _signin_state, _active_redirect_uri+    args = args or {}     client_id = get_client_id()     if not client_id:         return {"success": False, "error": "No APS Client ID configured.",@@ -367,23 +427,72 @@ def start_signin() -> dict:         # re-login every time.     }     auth_url = AUTH_URL + "?" + urllib.parse.urlencode(params)-    try:-        webbrowser.open(auth_url)-    except Exception:++    # ── SMART BROWSER CHOICE (John, 2026-07-08: "power users have tons of browsers with tons+    #    of profiles ... cache what browser you used when you successfully logged in ... don't+    #    be lazy") ─────────────────────────────────────────────────────────────────────────+    # Priority: (1) a browser+profile passed in THIS call, (2) the one we REMEMBERED from the+    # last successful sign-in, (3) if neither AND the caller can drive the extension, open+    # NOTHING and tell it to open in the user's REAL browser (new window) via nbrowser_* — that+    # window holds the warm Autodesk/SSO session. Only fall back to the OS default browser when+    # explicitly allowed, because on a multi-browser machine the default is usually the WRONG+    # one (no session / wrong profile) and forces a needless fresh login.+    passed = None+    if args.get("exe"):+        passed = {"name": args.get("browser") or args.get("name"), "exe": args.get("exe"),+                  "profileDir": args.get("profileDir"), "newWindow": args.get("newWindow", True)}+    pref = passed or load_signin_browser()+    opened_via = None+    opened_pref = None+    if pref and _launch_url_in_browser(pref, auth_url):+        opened_via = "remembered_browser" if not passed else "specified_browser"+        opened_pref = {k: pref.get(k) for k in ("name", "exe", "profileDir")}+        # A browser passed explicitly is now the remembered one (it's what the caller chose to+        # drive). A previously-remembered one is refreshed to keep its timestamp warm.+        save_signin_browser(pref)+    elif args.get("allowDefaultBrowser"):+        # Legacy fallback — only when the caller opts in (e.g. no extension available).         try:-            os.startfile(auth_url)  # noqa: Windows+            webbrowser.open(auth_url)+            opened_via = "os_default_browser"         except Exception:-            pass+            try:+                os.startfile(auth_url)  # noqa: Windows+                opened_via = "os_default_browser"+            except Exception:+                opened_via = None+    else:+        opened_via = "none_use_extension"++    if opened_via in ("remembered_browser", "specified_browser"):+        _hint = (f"Opened the Autodesk consent in the REMEMBERED browser ({opened_pref.get('name') or 'cached'}"+                 f"{'/' + opened_pref['profileDir'] if opened_pref.get('profileDir') else ''}) — the one that "+                 "authed last time. A background listener on port "+                 f"{bound_port} captures the token once you approve. Poll fusion_aps_status until signedIn:true.")+    elif opened_via == "os_default_browser":+        _hint = ("Opened in the OS DEFAULT browser (fallback). On a multi-browser machine this may be the "+                 "wrong profile; prefer driving authUrl in the user's real browser via nbrowser_open_window "+                 "(new window), then call fusion_aps_set_browser to remember it. Poll fusion_aps_status.")+    else:+        _hint = ("NO browser opened on purpose. This machine has no REMEMBERED Autodesk browser yet, and a "+                 "multi-browser box's OS default is usually the wrong one. OPEN authUrl in the user's REAL "+                 "browser via a NEW window (adom-desktop nbrowser_open_window {url:authUrl}) so its warm "+                 "Autodesk/SSO session is used, then call fusion_aps_set_browser {name,exe,profileDir} to "+                 "REMEMBER it for next time. A listener on port "+                 f"{bound_port} captures the token once you approve. Poll fusion_aps_status until signedIn:true.")      return {         "success": True,-        "output": "Opened the Autodesk sign-in page in your browser. Approve access, "-                  "then call fusion_aps_status to confirm.",+        "output": ("Autodesk sign-in started. " + (+            "Approve access in the opened browser, then call fusion_aps_status."+            if opened_via and opened_via != "none_use_extension"+            else "Open authUrl in the user's real browser (new window) to approve.")),         "authUrl": auth_url,         "redirectUri": _active_redirect_uri,-        "_hint": "A background listener on port "-                 f"{bound_port} will capture the token automatically once you approve. "-                 "Poll fusion_aps_status until signedIn:true (up to ~3 min).",+        "openedVia": opened_via,+        "openedBrowser": opened_pref,+        "needsExtensionOpen": opened_via == "none_use_extension",+        "_hint": _hint,     }  @@ -443,14 +552,49 @@ def handle_set_client_id(args: dict) -> dict:   def handle_signin(args: dict) -> dict:-    res = start_signin()+    res = start_signin(args or {})     # Move custom fields under data so the relay forwards them.     if res.get("success"):         res["data"] = {"authUrl": res.pop("authUrl", None),-                       "redirectUri": res.pop("redirectUri", None)}+                       "redirectUri": res.pop("redirectUri", None),+                       "openedVia": res.pop("openedVia", None),+                       "openedBrowser": res.pop("openedBrowser", None),+                       "needsExtensionOpen": res.pop("needsExtensionOpen", False)}     return res  +def handle_set_browser(args: dict) -> dict:+    """Remember the browser+profile that successfully authed to Autodesk, so every later+    fusion_aps_signin reuses it instead of the OS default. Call this right after a driven+    sign-in succeeds (with the browser you opened authUrl in). Fields: name, exe, profileDir,+    newWindow. `exe` is the browser binary on the host; profileDir is e.g. 'Default'/'Profile 2'."""+    exe = (args.get("exe") or "").strip()+    pref = {"name": args.get("name") or args.get("browser"), "exe": exe or None,+            "profileDir": args.get("profileDir"), "newWindow": args.get("newWindow", True),+            "how": args.get("how") or ("extension" if not exe else "launch")}+    if not exe and pref["how"] != "extension":+        return {"success": False, "error": "Provide exe (browser binary path) or how:'extension'.",+                "_hint": "e.g. {name:'Edge', exe:'C:/Program Files (x86)/Microsoft/Edge/Application/msedge.exe', profileDir:'Default'}"}+    ok = save_signin_browser(pref)+    return {"success": ok, "output": f"Remembered Autodesk sign-in browser: {pref.get('name') or exe or pref['how']}.",+            "data": {"saved": ok, "browser": load_signin_browser()}}+++def handle_get_browser(args: dict) -> dict:+    """Show the remembered Autodesk sign-in browser (None if not set yet)."""+    pref = load_signin_browser()+    return {"success": True, "output": ("Remembered: " + (pref.get("name") or pref.get("exe") or pref.get("how"))+            if pref else "No Autodesk sign-in browser remembered yet."),+            "data": {"browser": pref}}+++def handle_forget_browser(args: dict) -> dict:+    """Forget the remembered browser (next sign-in re-detects / uses the extension)."""+    ok = forget_signin_browser()+    return {"success": ok, "output": "Forgot the remembered Autodesk sign-in browser." if ok else "Could not clear it.",+            "data": {"cleared": ok}}++ def handle_get(args: dict) -> dict:     """Raw authenticated GET — dev/verify helper for nailing the APS grammar."""     path = args.get("path")