comfyui-mcp 0.52.38 → 0.52.40

package/dist/orchestrator/panel-tools.js

@@ -3070,6 +3070,137 @@ function isLoraManagerAutocompleteRefusal(res) {
     return (/had no widget after .+ waiting for node extensions to register/i.test(text) &&
         /AUTOCOMPLETE_TEXT_/i.test(text));
 }
+/**
+ * #1944 — the panel's add-node socket proof read "which datatypes does some
+ * installed node output?" off a single-class `/object_info/<class_type>`
+ * payload (or a whole-schema widen that did not land). Custom link types a
+ * SIBLING node produces — SeedVR2LoadDiTModel → SEEDVR2_DIT — then look
+ * unproven, and the refusal claims "no installed node outputs X" while that
+ * very node sits on the canvas. Retrying the add re-runs the same proof;
+ * panel_refresh_nodes re-registers the class, which is what arms the
+ * single-class path. The live graph is the authority the guard did not consult.
+ */
+function isMissingInstalledOutputsRefusal(res) {
+    if (!res.isError)
+        return false;
+    const text = textOfToolResult(res);
+    return (/had no widget after .+ waiting for node extensions to register/i.test(text) &&
+        /no installed node outputs/i.test(text));
+}
+/** Types the panel named as unproven in a #1944-shaped refusal. */
+function parseUnprovenSocketTypes(text) {
+    const types = [];
+    const add = (raw) => {
+        const v = raw.trim();
+        if (v && !types.includes(v))
+            types.push(v);
+    };
+    for (const re of [
+        /no installed node outputs "([^"]+)"/gi,
+        /declared type "([^"]+)": no installed node outputs/gi,
+    ]) {
+        re.lastIndex = 0;
+        let m;
+        while ((m = re.exec(text)))
+            add(m[1]);
+    }
+    return types;
+}
+function nodeOutputDeclaresType(node, socketType) {
+    const outputs = node.outputs;
+    if (Array.isArray(outputs)) {
+        for (const out of outputs) {
+            if (!out || typeof out !== "object" || Array.isArray(out))
+                continue;
+            const t = out.type;
+            if (typeof t !== "string" || !t)
+                continue;
+            if (t === socketType)
+                return true;
+            if (t.split(",").map((part) => part.trim()).includes(socketType))
+                return true;
+        }
+    }
+    const matchedOn = node.matched_on;
+    if (!Array.isArray(matchedOn))
+        return false;
+    const needle = `(${socketType.toLowerCase()})`;
+    return matchedOn.some((entry) => typeof entry === "string" && entry.toLowerCase().includes(needle));
+}
+/**
+ * Ask the live canvas whether each unproven type is actually produced there.
+ * Returns null when a probe fails — an unreadable graph is not evidence the
+ * producers are present, so the original refusal stays the last word.
+ */
+async function findLiveSocketProducers(ctx, types) {
+    const found = new Map();
+    for (const socketType of types) {
+        const probe = await ctx.call({ cmd: "graph_find_nodes", output: socketType, limit: 5 }, 8000);
+        if (probe.isError)
+            return null;
+        const payload = parseToolResultJson(probe);
+        const matches = Array.isArray(payload?.matches) ? payload.matches : [];
+        const producers = [];
+        for (const row of matches) {
+            if (!row || typeof row !== "object" || Array.isArray(row))
+                continue;
+            const rec = row;
+            if (!nodeOutputDeclaresType(rec, socketType))
+                continue;
+            const id = rec.id;
+            const type = rec.type ?? rec.class_type;
+            producers.push({
+                id: id == null ? "?" : String(id),
+                type: typeof type === "string" && type ? type : "unknown",
+            });
+        }
+        found.set(socketType, producers);
+    }
+    return found;
+}
+function liveSocketProducerNote(classType, found) {
+    const target = typeof classType === "string" && classType ? classType : "this node";
+    const lines = [...found.entries()].map(([socket, nodes]) => {
+        const who = nodes
+            .slice(0, 3)
+            .map((n) => `${n.type} #${n.id}`)
+            .join(", ");
+        return `  - ${socket}: ${who}`;
+    });
+    return (`\n\nThis is NOT a missing pack and NOT a widget that is still loading. ` +
+        `The live canvas ALREADY has nodes that output every type the add-node guard ` +
+        `claimed was missing:\n` +
+        `${lines.join("\n")}\n` +
+        `The guard consulted a single-class /object_info payload (or a whole-schema ` +
+        `widen that did not land), not the live frontend graph, so it cannot see ` +
+        `sibling producers added earlier in this session. ` +
+        `Retrying panel_add_node will keep failing; panel_refresh_nodes will not ` +
+        `clear it (it re-registers the class, which is what arms the single-class path). ` +
+        `Workaround: copy an existing "${target}" from another open workflow and ` +
+        `paste it here (panel_copy_nodes / panel_paste_nodes), or reload the ComfyUI ` +
+        `browser tab so the page rebuilds its node registry. Do not retry this class_type ` +
+        `until then.`);
+}
+async function withLiveSocketProducerNote(res, classType, ctx) {
+    if (!isMissingInstalledOutputsRefusal(res))
+        return res;
+    // #1708 is a Vue-widget miss, not a sibling-producer miss. Querying the
+    // canvas for AUTOCOMPLETE_TEXT_* would only delay the named remedy.
+    if (isLoraManagerAutocompleteRefusal(res))
+        return res;
+    const missing = parseUnprovenSocketTypes(textOfToolResult(res));
+    if (!missing.length)
+        return res;
+    const found = await findLiveSocketProducers(ctx, missing);
+    if (!found)
+        return res;
+    if (!missing.every((t) => (found.get(t)?.length ?? 0) > 0))
+        return res;
+    return appendToolResultText(res, liveSocketProducerNote(classType, found));
+}
+async function annotateAddNodeRefusal(res, classType, ctx) {
+    return withFrontendOnlyPanelSkewNote(withLoraManagerAutocompleteNote(await withLiveSocketProducerNote(res, classType, ctx)), classType, ctx);
+}
 const LORA_MANAGER_AUTOCOMPLETE_NOTE = `\n\nThis is NOT a missing pack and NOT a widget that is still loading. ` +
     `ComfyUI-LoRA-Manager registers AUTOCOMPLETE_TEXT_* via getCustomWidgets() into ` +
     `the frontend widget store; the add-node guard only looks at app.widgets (core types), ` +
@@ -3165,6 +3296,35 @@ function appendToolResultText(res, extra) {
     content[idx] = { type: "text", text: `${block.text}${extra}` };
     return { ...res, content };
 }
+/**
+ * #1873 — Save-As onto an EXISTING name 409s on purpose. ComfyUI's userdata POST
+ * returns 409 when overwrite=false; the frontend's saveWorkflowAs then prompts
+ * and, on confirm, DELETES the occupant. The panel refuses that delete path and
+ * surfaces "choose a different name", which is what forced a third workflow file.
+ *
+ * Matched on the panel's relocating-save collision (`conflictError` in
+ * workflow-save.js), not a generic "409 Conflict" — an in-place save can 409
+ * over its OWN file (#442) and that remedy is not this one.
+ */
+function isSaveAsNameConflict(res) {
+    if (!res.isError)
+        return false;
+    const text = textOfToolResult(res);
+    return /already exists \(409 Conflict\)/i.test(text) && /choose a different name/i.test(text);
+}
+const SAVE_AS_NAME_CONFLICT_NOTE = `\n\nDo NOT pick a third name. Save-As never overwrites an existing file — that 409 is ` +
+    `the copy contract, not a missing overwrite switch. To land the edited copy under the ` +
+    `intended original name while keeping a backup of the pre-edit original:\n` +
+    `1. panel_rename_workflow({path: "<original>", name: "<original>_pre_edit"}) — path can ` +
+    `target a CLOSED listed workflow, so this does not disturb the active tab.\n` +
+    `2. panel_rename_workflow({name: "<original>"}) — no path, so this renames the ACTIVE ` +
+    `copy onto the freed name; the tab follows the file.\n` +
+    `3. panel_save_workflow() — in-place save from then on.`;
+function withSaveAsNameConflictNote(res) {
+    if (!isSaveAsNameConflict(res))
+        return res;
+    return appendToolResultText(res, SAVE_AS_NAME_CONFLICT_NOTE);
+}
 // ---- #1695: bound the panel_set_widget previous/new echo --------------------
 //
 // Code-mode clients (Codex `functions.exec`) batch several panel_set_widget
@@ -10205,7 +10365,7 @@ export function buildPanelToolDefs() {
                 },
             },
         ])),
-        def("panel_add_node", "Add a node to the user's OPEN ComfyUI graph by class_type (e.g. 'KSampler', 'CheckpointLoaderSimple'). The user sees it appear live; Ctrl+Z undoes it. Returns the created node's id, slots, and default widget values. Frontend-only virtual types are addable too: 'Note' and 'MarkdownNote' — the supported way to ANNOTATE a workflow with on-canvas instructions (add the node, then put the text in its 'text' widget via panel_set_widget) — plus 'Reroute' and 'PrimitiveNode'. These are LiteGraph-native and never appear in the backend node registry, so they legitimately bypass the backend class_type check. ComfyUI-LoRA-Manager's 'Lora Loader (LoraManager)' (and other AUTOCOMPLETE_TEXT_* nodes) cannot be added: the pack is healthy, but the add-node guard cannot see its Vue autocomplete widget. Use 'LoRA Text Loader (LoraManager)' — same outputs, lora_syntax is a STRING — or core LoraLoader; reload/retry will not clear it. ADD NODES ONE AT A TIME, not as a parallel batch: each add carries a fresh /object_info payload and those register SERIALLY, so N concurrent adds become N sequential refresh cycles. On a large install that outruns the 30s per-command deadline and the later adds time out WHILE STILL QUEUED — they then apply when their turn arrives, leaving nodes you were told had failed (panel#767). Sequential adds each get the refresh to themselves and stay well inside the deadline.", {
+        def("panel_add_node", "Add a node to the user's OPEN ComfyUI graph by class_type (e.g. 'KSampler', 'CheckpointLoaderSimple'). The user sees it appear live; Ctrl+Z undoes it. Returns the created node's id, slots, and default widget values. Frontend-only virtual types are addable too: 'Note' and 'MarkdownNote' — the supported way to ANNOTATE a workflow with on-canvas instructions (add the node, then put the text in its 'text' widget via panel_set_widget) — plus 'Reroute' and 'PrimitiveNode'. These are LiteGraph-native and never appear in the backend node registry, so they legitimately bypass the backend class_type check. ComfyUI-LoRA-Manager's 'Lora Loader (LoraManager)' (and other AUTOCOMPLETE_TEXT_* nodes) cannot be added: the pack is healthy, but the add-node guard cannot see its Vue autocomplete widget. Use 'LoRA Text Loader (LoraManager)' — same outputs, lora_syntax is a STRING — or core LoraLoader; reload/retry will not clear it. A 'no installed node outputs' refusal for a custom link type (SEEDVR2_DIT, SEEDVR2_VAE, …) after sibling producer nodes were just added is the guard looking at a single-class /object_info, not the live graph; retry/refresh will not clear it — copy the node from another workflow (panel_copy_nodes / panel_paste_nodes) or reload the tab. ADD NODES ONE AT A TIME, not as a parallel batch: each add carries a fresh /object_info payload and those register SERIALLY, so N concurrent adds become N sequential refresh cycles. On a large install that outruns the 30s per-command deadline and the later adds time out WHILE STILL QUEUED — they then apply when their turn arrives, leaving nodes you were told had failed (panel#767). Sequential adds each get the refresh to themselves and stay well inside the deadline.", {
             class_type: z.string().describe("Exact ComfyUI node class_type to create."),
             pos: xy()
                 .optional()
@@ -10219,7 +10379,7 @@ export function buildPanelToolDefs() {
             const add = () => ctx.call({ cmd: "graph_add_node", class_type: args.class_type, pos: args.pos, title: args.title }, OBJECT_INFO_REFRESH_ACK_TIMEOUT_MS);
             const first = await add();
             if (!isStaleNodeSchemaRefusal(first)) {
-                return withFrontendOnlyPanelSkewNote(withLoraManagerAutocompleteNote(first), args.class_type, ctx);
+                return annotateAddNodeRefusal(first, args.class_type, ctx);
             }
             // #1329 — DO THE REFRESH THE REFUSAL ASKS FOR, instead of billing the caller.
             //
@@ -10254,9 +10414,9 @@ export function buildPanelToolDefs() {
                 // the refresh failure alongside so the caller knows the automatic attempt
                 // happened and why it did not help. No retry here, because the schema really is
                 // unchanged and a second add really would refuse again.
-                return withFrontendOnlyPanelSkewNote(withLoraManagerAutocompleteNote(appendToolResultText(first, `\n\n(Tried to clear this automatically: panel_refresh_nodes was dispatched and FAILED, ` +
+                return annotateAddNodeRefusal(appendToolResultText(first, `\n\n(Tried to clear this automatically: panel_refresh_nodes was dispatched and FAILED, ` +
                     `so the schema is unchanged and retrying the add will refuse again. ` +
-                    `${textOfToolResult(refreshed)})`)), args.class_type, ctx);
+                    `${textOfToolResult(refreshed)})`), args.class_type, ctx);
             }
             // panel#1518 — TAKE THE RETRY, instead of telling the caller to take it.
             //
@@ -10281,7 +10441,7 @@ export function buildPanelToolDefs() {
             // refresh left behind.
             const second = await add();
             if (!isStaleNodeSchemaRefusal(second)) {
-                return withFrontendOnlyPanelSkewNote(withLoraManagerAutocompleteNote(
+                return annotateAddNodeRefusal(
                 // An error from the RETRY, on the path where the caller never asked for a
                 // retry, must say which attempt it came from — otherwise a bare
                 // `graph_add_node` timeout reads as the first add's outcome and leaves the
@@ -10292,12 +10452,12 @@ export function buildPanelToolDefs() {
                         `node schema and created NOTHING, then panel_refresh_nodes was dispatched and did ` +
                         `NOT answer within its window. The error above is from the second attempt, so at ` +
                         `most ONE add is unaccounted for here.)`)
-                    : second), args.class_type, ctx);
+                    : second, args.class_type, ctx);
             }
             // Still stale after the refresh: report THAT, because it means the remedy the
             // refusal prescribes does not fix this instance and a caller following it by hand
             // would loop.
-            return withFrontendOnlyPanelSkewNote(withLoraManagerAutocompleteNote(appendToolResultText(second, refreshOutranItsAck
+            return annotateAddNodeRefusal(appendToolResultText(second, refreshOutranItsAck
                 ? // The refresh was never observed to finish, so "repeating it will not clear
                     // it" and "reload the tab" would both overclaim. What IS known: it was not
                     // cancelled, it is still registering the definitions this add needs, and the
@@ -10313,7 +10473,7 @@ export function buildPanelToolDefs() {
                         `the tab being frozen. ${textOfToolResult(refreshed)})`
                 : `\n\n(This was already retried ONCE automatically: panel_refresh_nodes reported success ` +
                     `and the add still refuses, so repeating panel_refresh_nodes will not clear it. ` +
-                    `Reload the ComfyUI browser tab, which rebuilds the page's node registry from scratch.)`)), args.class_type, ctx);
+                    `Reload the ComfyUI browser tab, which rebuilds the page's node registry from scratch.)`), args.class_type, ctx);
         }),
         def("panel_remove_node", "Remove a node (and its connections) from the user's open graph by id. Undoable with Ctrl+Z.", { node_id: nodeId().describe("Node id from panel_graph_outline / panel_query_graph.") }, async (args, ctx) => ctx.call({ cmd: "graph_remove_node", node_id: args.node_id })),
         def("panel_clear", "Remove EVERY node from the user's open graph — only for an explicit 'clear/reset the canvas'. Just CALL THIS DIRECTLY when they ask to clear: the tool itself pops a confirm card and only wipes on a yes (don't ask separately first). The wipe is a single Ctrl+Z undo. NEVER use this for a 'new workflow' — that's panel_new_workflow (a new tab, leaves this graph intact).", {}, async (_args, ctx) => {
@@ -12210,7 +12370,7 @@ export function buildPanelToolDefs() {
                 multi_select: args.multi_select,
             });
         }),
-        def("panel_save_workflow", "Save the user's open workflow PROGRAMMATICALLY — no Save/Rename dialog ever pops. With no `name`: saves in place (or auto-names + persists a never-saved workflow). With `name`: if the workflow is ALREADY saved under a different name this is a SAVE-AS — it writes a NEW file and leaves the original untouched on disk (it NEVER renames/moves/destroys the original); for a never-saved workflow it is simply the first save. The result reports what happened: `saved_as`+`copied_from`+`original_on_disk` (a disk-verified check that the original file still exists) for a Save-As copy, or `first_save` for a brand-new workflow. Use this freely (e.g. after building a graph) — it won't interrupt the user.", { name: z.string().optional().describe("Name for the workflow (no .json needed). If the workflow is already saved under a different name, this writes a NEW file (Save-As COPY) and leaves the original in place — it never renames/moves/destroys it. Omit to save in place / auto-name an unsaved workflow.") }, async (args, ctx) => {
+        def("panel_save_workflow", "Save the user's open workflow PROGRAMMATICALLY — no Save/Rename dialog ever pops. With no `name`: saves in place (or auto-names + persists a never-saved workflow). With `name`: if the workflow is ALREADY saved under a different name this is a SAVE-AS — it writes a NEW file and leaves the original untouched on disk (it NEVER renames/moves/destroys the original); for a never-saved workflow it is simply the first save. The result reports what happened: `saved_as`+`copied_from`+`original_on_disk` (a disk-verified check that the original file still exists) for a Save-As copy, or `first_save` for a brand-new workflow. A Save-As onto an EXISTING name is a 409 Conflict (the copy never overwrites) — do NOT pick a third name; panel_rename_workflow can target a closed listed original to free the name, then rename the active copy onto it, then panel_save_workflow() in place. Use this freely (e.g. after building a graph) — it won't interrupt the user.", { name: z.string().optional().describe("Name for the workflow (no .json needed). If the workflow is already saved under a different name, this writes a NEW file (Save-As COPY) and leaves the original in place — it never renames/moves/destroys it. An existing target name 409s; do not invent a third name — use panel_rename_workflow to free the original then rename the active copy onto it. Omit to save in place / auto-name an unsaved workflow.") }, async (args, ctx) => {
             // #402: await a stable tab binding before dispatching the (mutating) save, so
             // a save issued in the post-restart "Connected: none" window reaches a live
             // tab instead of failing with a bare "Failed to fetch"/OUTCOME UNKNOWN. Pre-
@@ -12237,8 +12397,11 @@ export function buildPanelToolDefs() {
                     }
                 }
             }
-            if (res.isError)
-                return res;
+            if (res.isError) {
+                // #1873 — named Save-As 409s by contract; the panel's "choose a different
+                // name" is what forced a third file. Keep the 409 and name the rename path.
+                return args.name ? withSaveAsNameConflictNote(res) : res;
+            }
             // #1045 — a SAVE-AS replaces the active workflow instance: the canvas is
             // now the NEW file, with its own identity, while this session's command
             // fence still names the pre-save one. Every graph call afterwards fails
@@ -13000,9 +13163,9 @@ CHECKED FOR YOU: the graph read this message prescribes was just run, and it ` +
         // ack-timeout, confirm via the authoritative workflow_list active identity
         // before reporting failure — see openWorkflowWithVerify.
         async (args, ctx) => openWorkflowWithVerify(args.path, ctx)),
-        def("panel_rename_workflow", "Rename a workflow (the active one, or the one matching `path`).", {
+        def("panel_rename_workflow", "Rename a workflow (the active one, or the one matching `path`). `path` can name a CLOSED listed workflow — renaming it does not disturb the active tab. After a Save-As copy, this is how to land the edited graph under the original name without a third file: rename the closed original aside (`path` + new name), then rename the active copy onto the freed name (no `path`), then panel_save_workflow().", {
             name: z.string().describe("New name (no .json needed)."),
-            path: z.string().optional().describe("Which workflow to rename; omit for the active one."),
+            path: z.string().optional().describe("Which workflow to rename; omit for the active one. Can name a CLOSED listed workflow (does not disturb the active tab)."),
         }, async (args, ctx) => ctx.call({ cmd: "workflow_rename", name: args.name, path: args.path }, 15000)),
         def("panel_close_workflow", "Close a workflow tab (the active one, or the one matching `path`). Refuses if it has unsaved changes unless force:true — save first to avoid losing the user's work.", {
             path: z.string().optional().describe("Which workflow to close; omit for the active one."),