Fusion - the Fusion 360 Bridge

@@ -535,6 +535,26 @@ def _handle_new_electronics_from_eagle(args: dict) -> dict:     }  ++def _addin_round_trip_ready(tries: int = 2, gap: float = 1.5) -> bool:+    """Can the add-in actually EXECUTE a command, twice in a row?++    The distinction that issue #36 turned on: a listening socket proves the add-in's HTTP+    thread is up, not that Fusion's main thread will run our command. get_app_state is the+    cheapest real round-trip, so it is the honest readiness test.+    """+    import time as _t+    for i in range(tries):+        try:+            if not _proxy_to_addin("get_app_state", {}, timeout=6).get("success"):+                return False+        except Exception:+            return False+        if i + 1 < tries:+            _t.sleep(gap)+    return True++ def _handle_launch(fusion_info: dict, args: dict) -> dict:     """Launch Fusion 360 and optionally wait for the AdomBridge add-in."""     # LIVE detect (not the stale bridge-start fusion_info snapshot) so a launch right@@ -648,7 +668,17 @@ def _handle_launch(fusion_info: dict, args: dict) -> dict:             _t.sleep(1.0)             continue         # No seat dialog -> is the add-in actually serving? (ground truth for drivable)-        if _probe_addin(timeout=1.5):+        #+        # ⚠️ A PORT THAT ANSWERS IS NOT AN ADD-IN THAT CAN WORK (page issue #36, found by+        # ralph-testing the web-control page): `_probe_addin` proves a socket replied, and+        # this verb's own hint promises it "blocks until the add-in is ready". A caller+        # reasonably took that at face value, fired the next verb, and got "add-in not+        # responding" - three surface buttons failed in that window, and minutes later the+        # identical calls worked. So require a REAL command round-trip (get_app_state, the+        # cheapest thing the add-in actually executes on its main thread), and require it+        # TWICE: the first success can land while the add-in is still finishing startup,+        # and one more tick is far cheaper than handing the caller a false ready.+        if _probe_addin(timeout=1.5) and _addin_round_trip_ready():             addin_ok = True             # Give the human a window worth looking at (background, no activation).             try:@@ -1570,6 +1600,26 @@ def _handle_fusion_readiness(fusion_info: dict, args: dict) -> dict:                 "fusion_install_fusion (no shell approval needed) - it streams the free trial and "                 "this verb reports installing:true until done.") +    # READY MUST MEAN DRIVABLE (page issue #36). `addin_ok` above comes from an HTTP GET to+    # the add-in's own web server, which is served by its HTTP thread - it is up well before+    # Fusion's MAIN thread will execute a command. Callers poll this verb precisely to learn+    # "can I fire my next verb now", so confirm with one real round-trip before saying yes.+    # Cheap when the main thread is free (~50ms); when it is not, failing here is exactly the+    # answer the caller needed.+    if ready:+        try:+            if not _proxy_to_addin("get_app_state", {}, timeout=4).get("success"):+                ready = False+                result_note = ("the add-in's HTTP server is up but its main thread did not "+                               "execute a test command yet - not drivable this second")+            else:+                result_note = None+        except Exception:+            ready = False+            result_note = "the add-in did not complete a test command round-trip"+    else:+        result_note = None+     result = {         "success": True,         "hostApp": "Fusion 360",@@ -1579,7 +1629,7 @@ def _handle_fusion_readiness(fusion_info: dict, args: dict) -> dict:         "ready": ready,         "bridgeVersion": BRIDGE_VERSION,         **stale_info,-        "_hint": hint,+        "_hint": (hint + " NOTE: " + result_note) if result_note else hint,     }     # MEASURED PROGRESS WHILE LAUNCHING (issue #32): the poll verb must render the same     # bar the launch verb started, or the caller is back to a spinner with no end.