comfyui-mcp 0.52.17 → 0.52.20

package/dist/orchestrator/panel-tools.js

@@ -40,8 +40,9 @@ import { isPanelAnsweredError } from "../services/panel-answered.js";
 import { isPreExecutorRefusal } from "../services/panel-refusal.js";
 import { createSdkMcpServer, tool } from "@anthropic-ai/claude-agent-sdk";
 import { parse as parseYaml } from "yaml";
-import { SEMVER_RE } from "../services/ui-bridge.js";
+import { requiredPanelVersion, SEMVER_RE } from "../services/ui-bridge.js";
 import { compareSemver } from "../services/self-update.js";
+import { describeInstallPanelAction } from "../services/panel-recovery.js";
 import { primePanelBase, verifiedPanelDiskVersion, } from "../services/panel-workspace.js";
 import { conversationOfScopeAddress, isScopeAddress, shortTabId } from "../services/session-scope.js";
 import { NODE_ID_MESSAGE, NODE_ID_PATTERN, normalizeNodeId } from "./node-id.js";
@@ -760,6 +761,8 @@ const MUTATING_GRAPH_EDIT_CMDS = new Set([
     "graph_subgraph_group",
     "graph_expose_subgraph_input",
     "graph_expose_subgraph_output",
+    "graph_unexpose_subgraph_input",
+    "graph_unexpose_subgraph_output",
     "graph_promote_widget",
     "graph_move_rail",
     "graph_paste_nodes",
@@ -2549,6 +2552,80 @@ function withLoraManagerAutocompleteNote(res) {
         return res;
     return appendToolResultText(res, LORA_MANAGER_AUTOCOMPLETE_NOTE);
 }
+/**
+ * Types the CURRENT panel's add-node guard allowlists (comfyui-mcp-panel
+ * `web/js/lib/node-resolve.js` `FRONTEND_ONLY_NODE_TYPES`). An older panel
+ * without that allowlist refuses them as "the ComfyUI backend does not provide
+ * it" and points at unrelated failed-import packs (#1828).
+ *
+ * Kept as a copy of the panel's list rather than the orchestrator's
+ * `FRONTEND_ONLY_NODE_TYPES` (workflow-converter): that set is the runtime
+ * classifier's skip list and deliberately omits third-party names. Adding
+ * rgthree types there would change check_runtime, which is not this bug.
+ */
+const PANEL_ADD_NODE_FRONTEND_ONLY_TYPES = new Set([
+    "Note",
+    "MarkdownNote",
+    "Reroute",
+    "PrimitiveNode",
+    "Fast Bypasser (rgthree)",
+    "Fast Muter (rgthree)",
+    "Fast Groups Bypasser (rgthree)",
+    "Fast Groups Muter (rgthree)",
+    "Label (rgthree)",
+    "Reroute (rgthree)",
+    "Node Collector (rgthree)",
+    "SetNode",
+    "GetNode",
+]);
+function isUnknownBackendNodeRefusal(res) {
+    if (!res.isError)
+        return false;
+    return /Unknown node type .+ — the ComfyUI backend does not provide it/i.test(textOfToolResult(res));
+}
+function tabAdvertisedPanelVersion(ctx) {
+    const fn = ctx.bridge.advertisedPanelVersion;
+    if (typeof fn !== "function")
+        return undefined;
+    let reading;
+    try {
+        reading = fn.call(ctx.bridge, ctx.tabId);
+    }
+    catch {
+        return undefined;
+    }
+    const v = reading?.version;
+    return typeof v === "string" && SEMVER_RE.test(v.trim()) ? v.trim() : undefined;
+}
+/**
+ * #1828 — an allowlisted frontend-only type refused as "backend does not
+ * provide it" is version skew when the tab's advertised panel is below this
+ * orchestrator's floor, not a missing pack. Keep the panel's refusal and name
+ * the pack update + hard-refresh; a restart alone leaves cached JS running the
+ * old guard.
+ */
+function withFrontendOnlyPanelSkewNote(res, classType, ctx) {
+    if (typeof classType !== "string")
+        return res;
+    if (!isUnknownBackendNodeRefusal(res))
+        return res;
+    if (!PANEL_ADD_NODE_FRONTEND_ONLY_TYPES.has(classType))
+        return res;
+    const advertised = tabAdvertisedPanelVersion(ctx);
+    if (!advertised)
+        return res;
+    const required = requiredPanelVersion();
+    if (compareSemver(advertised, required) >= 0)
+        return res;
+    const update = describeInstallPanelAction("update", "update the panel pack on the ComfyUI host");
+    return appendToolResultText(res, `\n\nThis is NOT a missing backend pack. "${classType}" is a frontend-only type ` +
+        `that current panels (${required}+) allowlist, so its absence from /object_info is ` +
+        `expected. This tab announced panel ${advertised}, which is below that floor — ` +
+        `the add-node guard in this tab's JavaScript does not have the allowlist. ` +
+        `${update}, restart ComfyUI, then HARD-REFRESH the ComfyUI browser tab ` +
+        `(Ctrl+Shift+R, or Cmd+Shift+R on macOS). A restart alone leaves the tab running ` +
+        `cached old JS, which is why this error can persist after an update.`);
+}
 function appendToolResultText(res, extra) {
     const idx = res?.content?.findIndex((c) => c.type === "text") ?? -1;
     const block = idx >= 0 ? res.content[idx] : undefined;
@@ -8924,6 +9001,8 @@ export const RETRY_TOKEN_CMD_BY_TOOL = {
     panel_promote_widget: "graph_promote_widget",
     panel_expose_subgraph_output: "graph_expose_subgraph_output",
     panel_expose_subgraph_input: "graph_expose_subgraph_input",
+    panel_unexpose_subgraph_output: "graph_unexpose_subgraph_output",
+    panel_unexpose_subgraph_input: "graph_unexpose_subgraph_input",
     panel_unpack_subgraph: "graph_unpack_subgraph",
     panel_update_node: "graph_update_node",
 };
@@ -9342,8 +9421,9 @@ export function buildPanelToolDefs() {
             // install. Give it the bounded refresh ack budget.
             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 withLoraManagerAutocompleteNote(first);
+            if (!isStaleNodeSchemaRefusal(first)) {
+                return withFrontendOnlyPanelSkewNote(withLoraManagerAutocompleteNote(first), args.class_type, ctx);
+            }
             // #1329 — DO THE REFRESH THE REFUSAL ASKS FOR, instead of billing the caller.
             //
             // The reporter uploaded two images, and both LoadImage adds were refused with
@@ -9361,19 +9441,20 @@ export function buildPanelToolDefs() {
                 // The refusal is the better error: it names what is wrong with the SCHEMA and
                 // what clears it. Carry the refresh failure alongside so the caller knows the
                 // automatic attempt happened and why it did not help.
-                return withLoraManagerAutocompleteNote(appendToolResultText(first, `\n\n(Tried to clear this automatically: panel_refresh_nodes was dispatched and FAILED, ` +
+                return withFrontendOnlyPanelSkewNote(withLoraManagerAutocompleteNote(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)})`));
+                    `${textOfToolResult(refreshed)})`)), args.class_type, ctx);
             }
             const second = await add();
-            if (!isStaleNodeSchemaRefusal(second))
-                return withLoraManagerAutocompleteNote(second);
+            if (!isStaleNodeSchemaRefusal(second)) {
+                return withFrontendOnlyPanelSkewNote(withLoraManagerAutocompleteNote(second), args.class_type, ctx);
+            }
             // Still stale after a successful 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 withLoraManagerAutocompleteNote(appendToolResultText(second, `\n\n(This was already retried ONCE automatically: panel_refresh_nodes reported success ` +
+            return withFrontendOnlyPanelSkewNote(withLoraManagerAutocompleteNote(appendToolResultText(second, `\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.)`));
+                `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) => {
@@ -12096,6 +12177,12 @@ CHECKED FOR YOU: the graph read this message prescribes was just run, and it ` +
             to_input: args.to_input,
             name: args.name,
         }, 15000)),
+        def("panel_unexpose_subgraph_output", "REMOVE a subgraph's OUTPUT boundary slot — UN-expose it (the inverse of panel_expose_subgraph_output), so the PARENT graph's subgraph node loses that output slot. You MUST be INSIDE the subgraph first (panel_enter_subgraph). Identify the slot by the string `name` only — the boundary slot name exactly as panel_query_graph lists it under `rails.output.accepts_inputs`. A rail_node_id string such as \"-20\" is forwarded to the panel, which REFUSES it: that is the synthetic id of the whole rail, not of a slot on it. DESTRUCTIVE: the interior wire feeding the slot and any parent-graph wires on host subgraph nodes' matching slot are dropped with it — the reply's `removed.interior_links_dropped` / `removed.host_links_dropped` say how many went. An unknown name refuses and lists the slots that DO exist; nothing is removed on a refusal. Undoable with Ctrl+Z.", {
+            name: z.string().describe("Boundary output slot name (e.g. 'IMAGE') exactly as panel_query_graph lists it under rails.output.accepts_inputs — NOT a rail_node_id."),
+        }, async (args, ctx) => ctx.call({ cmd: "graph_unexpose_subgraph_output", name: args.name }, 15000)),
+        def("panel_unexpose_subgraph_input", "REMOVE a subgraph's INPUT boundary slot — UN-expose it (the inverse of panel_expose_subgraph_input), so the PARENT graph's subgraph node loses that input slot. You MUST be INSIDE the subgraph first (panel_enter_subgraph). Identify the slot by the string `name` only — the boundary slot name exactly as panel_query_graph lists it under `rails.input.provides_outputs`. A rail_node_id string such as \"-10\" is forwarded to the panel, which REFUSES it: that is the synthetic id of the whole rail, not of a slot on it. DESTRUCTIVE: the interior wire the slot fed and any parent-graph wires on host subgraph nodes' matching slot are dropped with it — the reply's `removed.interior_links_dropped` / `removed.host_links_dropped` say how many went. An unknown name refuses and lists the slots that DO exist; nothing is removed on a refusal. Undoable with Ctrl+Z.", {
+            name: z.string().describe("Boundary input slot name (e.g. 'model') exactly as panel_query_graph lists it under rails.input.provides_outputs — NOT a rail_node_id."),
+        }, async (args, ctx) => ctx.call({ cmd: "graph_unexpose_subgraph_input", name: args.name }, 15000)),
         def("panel_unpack_subgraph", "EXPAND / DISSOLVE a subgraph node on the user's open graph — inline its interior nodes back into the PARENT graph, rewire all external links to those now-inlined nodes, and remove the subgraph wrapper. This is the frontend's \"Unpack Subgraph\" (litegraph LGraph.unpackSubgraph) and the exact INVERSE of panel_create_subgraph. Use it to flatten a stage that was over-nested, or to edit interior nodes directly at the parent level. The interior nodes reappear on the parent canvas with their connections preserved. Undoable with Ctrl+Z.", { node_id: nodeId().describe("Subgraph node id to unpack/dissolve (is_subgraph=true, from panel_graph_outline / panel_query_graph).") }, async (args, ctx) => ctx.call({ cmd: "graph_unpack_subgraph", node_id: args.node_id }, 15000)),
         def("panel_search_nodes", "Search installable custom-node packs via the user's BUILT-IN ComfyUI Manager (the same source the Manager UI uses). Returns matching packs {id, title, description}. Use the `id` with panel_install_node. Prefer this over the headless search_custom_nodes tool — it works against the user's actual (Desktop) Manager. If Manager's cache mappings endpoint returns HTTP 5xx, this retries remote/local and still searches; a remaining 5xx is a Manager outage, not proof the pack is missing.", { query: z.string().describe("Search text, e.g. 'kjnodes', 'controlnet', 'ipadapter'."), limit: z.number().int().min(1).max(40).optional().describe("Max results to return, 1-40 (default 15). Requests above 40 are refused; the panel also clamps to 40 and discloses limit_cap.") }, async (args, ctx) => {
             // #1669 — the panel asks getmappings?mode=cache and used to fail the