comfyui-mcp 0.50.91 → 0.50.92

package/dist/orchestrator/panel-tools.js

@@ -3436,7 +3436,57 @@ async function waitForOpenReceipt(ctx, path, rid, timing) {
  *  gave up (no tab reconnected within budget / an ambiguous multi-tab session). We
  *  must NOT dispatch — firing into a dead binding is exactly the OUTCOME-UNKNOWN /
  *  double-apply risk the pre-send wait exists to prevent (codex). */
-function noReachableTabFail(cmd) {
+function noReachableTabFail(cmd, ctx) {
+    // #971 — TWO CAUSES, OPPOSITE REMEDIES, and they were folded into one sentence
+    // that sent the reporter in a circle:
+    //
+    //   panel_open_workflow  -> "no reachable tab … or rebind with
+    //                            panel_set_workflow_target({mode:'current'})"
+    //   mode:"current"       -> its only probe is a workflow_list call TO A TAB
+    //
+    // So the advice needed exactly the thing whose absence caused the failure. The
+    // reporter had already run the rebind — it reported `bound` — and was sent back
+    // to it.
+    //
+    // The two causes want different answers, and the bridge can tell them apart:
+    //  • nothing connected  → there is nothing to rebind ONTO. Say so, and name the
+    //    thing that does help (the tab reconnecting, or the user opening/refreshing
+    //    one).
+    //  • tabs connected, none is ours → `mode:"current"` is exactly right: it
+    //    re-points the session at the active tab.
+    let connected = null;
+    try {
+        const tabs = ctx?.bridge?.tabs?.();
+        if (Array.isArray(tabs)) {
+            connected = tabs.filter((t) => !(typeof ctx?.bridge?.isHeadless === "function" && ctx.bridge.isHeadless(t.tab_id))).length;
+        }
+    }
+    catch {
+        connected = null; // an unreadable bridge earns the neutral wording below
+    }
+    if (connected === 0) {
+        // MEASURED, not assumed. An earlier draft of this said "rebinding CANNOT
+        // help while nothing is connected". That is false: with zero tabs
+        // `mode:"current"` returns `deferred: true`, CLEARS the stale binding, and
+        // arms a bind onto the first tab that reconnects. It is worth doing — it
+        // just does not make the command retryable NOW, which is what the caller is
+        // actually asking. Saying which of those it does is the difference between
+        // a useful instruction and the loop the reporter hit.
+        return fail(`${cmd} — this session has no reachable panel tab, and NO panel tab is connected at all ` +
+            `(still reconnecting after a restart/reload, or the ComfyUI browser tab is closed). ` +
+            `Nothing was sent. A rebind will NOT make this retryable yet: with nothing connected, ` +
+            `panel_set_workflow_target({mode:"current"}) clears the stale binding and DEFERS, taking ` +
+            `effect on the first tab that reconnects — useful, but it does not bring a tab back. ` +
+            `Wait for the reconnect and retry, or ask the user to open/refresh the ComfyUI browser tab.`);
+    }
+    if (connected !== null && connected > 0) {
+        return fail(`${cmd} — this session has no reachable panel tab, though ${connected} panel tab(s) are ` +
+            `connected — none of them is bound to this session (its tab was replaced, or several are ` +
+            `open and the session's is gone). Nothing was sent. Rebind onto the live one with ` +
+            `panel_set_workflow_target({mode:"current"}), then retry.`);
+    }
+    // Bridge could not enumerate tabs: keep the old, cause-neutral wording rather
+    // than guessing which of the two it is.
     return fail(`${cmd} — this session has no reachable panel tab yet (still reconnecting after a ` +
         `restart/reload, or multiple tabs are open and none is this session's). Nothing was ` +
         `sent. Retry in a moment, or rebind with panel_set_workflow_target({mode:"current"}).`);
@@ -3449,7 +3499,7 @@ async function openWorkflowWithVerify(path, ctx) {
     // OUTCOME UNKNOWN. A healthy session returns from this instantly; if no tab
     // reconnects within budget we REFUSE rather than dispatch into a dead binding.
     if (ctx.awaitReachable && !(await ctx.awaitReachable())) {
-        return noReachableTabFail("workflow_open");
+        return noReachableTabFail("workflow_open", ctx);
     }
     let dispatchedRid;
     const res = await ctx.call({ cmd: "workflow_open", path }, 15000, (rid) => {
@@ -7802,7 +7852,7 @@ export function buildPanelToolDefs() {
             // if no tab reconnects within budget we REFUSE rather than fire into a dead
             // binding.
             if (ctx.awaitReachable && !(await ctx.awaitReachable())) {
-                return noReachableTabFail(args.name ? "workflow_save_as" : "workflow_save");
+                return noReachableTabFail(args.name ? "workflow_save_as" : "workflow_save", ctx);
             }
             const res = args.name
                 ? await ctx.call({ cmd: "workflow_save_as", name: args.name }, 15000)