comfyui-mcp 0.50.104 → 0.50.106

package/dist/orchestrator/panel-tools.js

@@ -1099,6 +1099,60 @@ export function restartTimeoutFallbackAdvice({ headlessBase, panelBase, observed
         "card — check that this is the same ComfyUI you have been working on, since I " +
         "could not confirm which one this panel is running inside.");
 }
+/**
+ * #1359 — an /object_info failure that names WHICH host it asked, and why that host.
+ *
+ * `panel_strip_workflow` reads the graph from the connected panel and then fetches node
+ * definitions through the global headless client, which resolves COMFYUI_URL. For a
+ * local session those are one machine. For a connected REMOTE panel they are two, and
+ * the tool fails with a bare
+ *
+ *   fetch failed: connect ECONNREFUSED 127.0.0.1:8188 — while requesting
+ *   http://127.0.0.1:8188/object_info
+ *
+ * which says nothing about the canvas being on a different host. The reporter of #1359
+ * had to read the compiled orchestrator to find that out.
+ *
+ * This does NOT fix the split authority — that needs the panel to serve its own
+ * /object_info, a protocol change tracked separately. It makes the existing failure
+ * diagnosable, and names the workaround that works today.
+ *
+ * The panel's origin is the SERVER-OBSERVED handshake Origin where available: the
+ * browser sets it on the WS upgrade and page JS cannot forge it. It is only being
+ * PRINTED here, never fetched from, so an unreadable one costs a detail rather than a
+ * wrong conclusion.
+ */
+function objectInfoHostMismatchMessage(ctx, err, liveCanvasSource) {
+    const raw = err instanceof Error ? err.message : String(err);
+    let panelOrigin = null;
+    try {
+        panelOrigin = ctx.bridge?.tabServerOrigin?.(ctx.tabId) ?? null;
+    }
+    catch {
+        /* best effort — the message stands without it */
+    }
+    const configured = getComfyUIBaseUrl();
+    if (!liveCanvasSource) {
+        // pack / path / inline: COMFYUI_URL is the right authority, so the bare failure is
+        // already about the host the caller asked for. Say only what is true.
+        return `${raw}\n\nNode definitions are read from COMFYUI_URL (${configured}) for a pack/path/inline source. That host did not answer /object_info.`;
+    }
+    const differs = panelOrigin != null && configured != null && !sameHttpBase(panelOrigin, configured);
+    return (`${raw}\n\nTHE GRAPH AND ITS NODE DEFINITIONS CAME FROM DIFFERENT PLACES. The workflow was ` +
+        `captured from the connected panel` +
+        (panelOrigin ? ` (ComfyUI at ${panelOrigin})` : "") +
+        `, but node definitions are fetched over COMFYUI_URL (${configured}) — and that is the ` +
+        `request that failed` +
+        (differs
+            ? `. Those are two different hosts, which is why this could not work: the orchestrator ` +
+                `has no route to the panel's ComfyUI for /object_info.`
+            : `.`) +
+        `\n\nWORKAROUND: point COMFYUI_URL at the same ComfyUI the panel is connected to` +
+        (panelOrigin ? ` (${panelOrigin})` : "") +
+        ` and retry, or pass an explicit \`graph\`/\`pack\`/\`path\` source instead of the live ` +
+        `canvas. This is a known split of authority (#1359): stripping the LIVE canvas needs ` +
+        `the definitions to come from the panel's own ComfyUI, which needs a panel-side change.`);
+}
 function captureRebootHealthBase(ctx) {
     if (isCloudMode() || isRemoteMode())
         return null;
@@ -6848,7 +6902,26 @@ export function buildPanelToolDefs() {
             const captureNotes = [];
             const raw = await resolveWorkflowInput(args, ctx, true, captureNotes);
             const ui = raw;
-            const bulk = await getObjectInfo();
+            // #1359 — the graph came from the PANEL; the node definitions come from
+            // COMFYUI_URL. Those are the same machine for a local session and different
+            // ones for a connected REMOTE panel, and when they differ this fails with a
+            // bare `ECONNREFUSED 127.0.0.1:8188` that never mentions the canvas host. The
+            // reporter had to read dist/ to discover that the two halves have different
+            // authorities.
+            //
+            // Only the live-canvas source is affected: a pack/path/inline graph is
+            // deliberately tied to COMFYUI_URL, so its definitions belong there.
+            const liveCanvasSource = args.pack == null && args.path == null && args.graph == null;
+            let bulk;
+            try {
+                bulk = await getObjectInfo();
+            }
+            catch (err) {
+                // Returned as a tool ERROR rather than thrown: a throw here escapes the
+                // handler and reaches the caller as a transport-shaped failure, which is how
+                // the bare ECONNREFUSED got to the reporter in the first place.
+                return fail(objectInfoHostMismatchMessage(ctx, err, liveCanvasSource));
+            }
             const objectInfo = await backfillObjectInfo(bulk, collectNodeTypes(ui));
             const converted = convertUiToApi(ui, objectInfo);
             const workflow = converted.workflow;
@@ -7763,6 +7836,34 @@ export function buildPanelToolDefs() {
                 return ok(`🔒 Token saved to MCP server "${server}" (${args.target_kind} "${args.key}"). Call panel_reload to load it.`);
             }
             catch (err) {
+                // #1352 — A TIMED-OUT SECRET CARD IS NOT A FROZEN TAB.
+                //
+                // The bridge's generic no-reply message ("the ComfyUI tab may be backgrounded
+                // or frozen") is right for every other command and wrong here. This card
+                // blocks up to 300s on a MASKED INPUT, and the overwhelmingly likely reason it
+                // went unanswered is that a human is still typing — off finding the key in a
+                // password manager or a billing console. Nothing is wrong with the tab, and
+                // sending someone to fix one is the #1332 defect in a new place.
+                //
+                // It also has to say what happens to a value entered LATE, because that is the
+                // question the caller will actually have. MEASURED: this card is sent as a raw
+                // `request_secret` command with NO ask_id, and the late-reply buffer
+                // (takeLateAskReply) is keyed BY ask id — so a value typed after the timeout
+                // has no path back to this call. It is discarded, and the tool must be called
+                // again. "It may still arrive" would be a guess, and an expensive one: the
+                // user would wait for a save that cannot happen.
+                if (isReplyTimeoutError(err)) {
+                    return fail(`The secret card was not answered within 300s, so NOTHING was saved and no ` +
+                        `credential was read. That is very likely just time — the card asks for a ` +
+                        `token, and finding one in a password manager or a billing console can take ` +
+                        `longer than that. It does NOT mean the tab is frozen, and it does NOT mean ` +
+                        `the user declined.\n\n` +
+                        `A value typed into that card NOW cannot reach this call: it carries no id ` +
+                        `this reply could be matched to, so a late answer is discarded rather than ` +
+                        `saved. Ask whether they still want to set it and call panel_request_secret ` +
+                        `again when they are ready to paste — the value goes straight from the masked ` +
+                        `field into storage, and must never be typed into the conversation.`);
+                }
                 return fail(err);
             }
         }),