comfyui-mcp 0.50.100 → 0.50.102

package/dist/orchestrator/panel-tools.js

@@ -1341,6 +1341,28 @@ function toolResultText(res) {
  *  else about it — including `isError` and any non-text content. Used where the
  *  original message must reach the caller VERBATIM and we are only adding what we
  *  additionally know, never restating (or re-classifying) what it already said. */
+/** All text in a tool result, joined — for quoting one result inside another. */
+function textOfToolResult(res) {
+    return res.content.map((c) => c.text ?? "").join(" ").trim();
+}
+/**
+ * #1329 — the panel's STALE NODE SCHEMA refusal, which is worth acting on rather than
+ * relaying.
+ *
+ * It is the one refusal here whose prescribed remedy has no decision in it: the class
+ * this page registered has drifted from the server's, and `refresh_nodes` re-fetches
+ * /object_info and re-registers it in place. The reporter ran that by hand twice and it
+ * worked twice.
+ *
+ * Matched on the drift sentence rather than on "panel_refresh_nodes", which appears in
+ * several unrelated remedies — keying on the recommendation would make any of them
+ * trigger an add-retry.
+ */
+function isStaleNodeSchemaRefusal(res) {
+    if (!res.isError)
+        return false;
+    return /added or retyped since this page loaded its node schema/i.test(textOfToolResult(res));
+}
 function appendToolResultText(res, extra) {
     const idx = res?.content?.findIndex((c) => c.type === "text") ?? -1;
     const block = idx >= 0 ? res.content[idx] : undefined;
@@ -2487,6 +2509,67 @@ export function readOpenActiveAgainstTarget(active, path, activeConfirmed) {
  * all. Requiring corroboration there is what kept the reporter's own case
  * unexamined.
  */
+/**
+ * #1337 — CLEAR THE FENCE ON THE VERDICT THAT PROVED IDENTITY.
+ *
+ * A reporter's session lost the canvas permanently: every graph call refused with
+ * `workflow instance mismatch`, and the one fence-EXEMPT recovery could not clear it.
+ *
+ * `workflow_open` re-derives the fence only on its success branch. The verdict
+ *
+ *   "workflow_open RAN and the canvas IS bound to X — that much was proven — but the
+ *    graph on it does not match the state that was loaded … You are NOT on the wrong
+ *    workflow: X IS the active one."
+ *
+ * is delivered as an ERROR, so control never reaches the re-derivation. That mismatches
+ * two different levels: the verdict asserts IDENTITY was proven, and what it withholds
+ * is CONTENT (frontend normalisation vs a partial load). Applying content-level
+ * uncertainty to an identity-level fence is what leaves the session with no in-band
+ * recovery — the only remaining move is a browser reload, which destroys unsaved work.
+ *
+ * MEASURED, because the comment that justified the old behaviour asserts otherwise:
+ *   • the panel really does publish NO workflow_uuid on this reply (its own
+ *     FENCE_NOT_REFRESHED text), so there is nothing to adopt FROM THE REPLY — true;
+ *   • but `workflow_list` IS fence-exempt (commandIsCanvasTargetless in the panel's
+ *     workflow-chat-identity.js), and the panel's own recovery text names
+ *     panel_list_workflows as "exempt from the fence" and says it "republishes the
+ *     active identity". So the fence CAN be re-derived here; nothing tried.
+ *
+ * This runs that exempt re-derivation and reports what it achieved. The open still
+ * FAILS — the content warning is preserved verbatim, because "re-read before editing"
+ * is still the right instruction — and nothing is adopted on the UNPROVEN verdict,
+ * where identity itself is in doubt.
+ */
+async function clearFenceOnIdentityProvenOpen(ctx, res) {
+    const text = toolResultText(res);
+    // ONLY the class that states identity was proven. The UNPROVEN verdict ("could not
+    // prove that the active canvas was rebound") must keep failing closed: re-deriving a
+    // fence onto a canvas we cannot identify is how an edit lands on the wrong graph.
+    if (!/the canvas IS bound to/i.test(text))
+        return res;
+    let note;
+    try {
+        const rebind = await rebindWorkflowFence(ctx);
+        note =
+            rebind.status === "refreshed" || rebind.status === "already_current"
+                ? `\n\nFENCE: CLEARED. This reply published no workflow_uuid, so the fence was re-derived ` +
+                    `from the panel's own fence-EXEMPT workflow_list read instead — the active identity is ` +
+                    `${rebind.uuid}, and graph commands from this session are stamped with it again. You do ` +
+                    `NOT need to reload the browser tab, and no unsaved canvas work is at risk. The content ` +
+                    `warning above still stands: re-read the graph before editing.`
+                : `\n\nFENCE: NOT cleared (${rebind.status}). The re-derivation was attempted — the panel ` +
+                    `publishes no workflow_uuid on this verdict, so the fence-exempt workflow_list read is ` +
+                    `the only way to refresh it — and it did not establish an identity. Graph commands stay ` +
+                    `refused. Try panel_list_workflows directly; if that also fails, the panel tab is the ` +
+                    `thing to fix.`;
+    }
+    catch (err) {
+        note =
+            `\n\nFENCE: NOT cleared — the re-derivation threw, so the fence state is UNKNOWN and graph ` +
+                `commands may still be refused. (${err instanceof Error ? err.message : String(err)})`;
+    }
+    return appendToolResultText(res, note);
+}
 async function observeActiveAfterOpen(ctx, requestedPath) {
     let list = null;
     try {
@@ -3621,7 +3704,7 @@ async function openWorkflowWithVerify(path, ctx) {
                 return res;
             const drift = await observeActiveAfterOpen(ctx, path);
             if (!drift)
-                return res;
+                return await clearFenceOnIdentityProvenOpen(ctx, res);
             return fail(`${toolResultText(res)}\n\nAND — checked after that failure — ${drift.activeLabel} is the ` +
                 `ACTIVE workflow now, not ${path}. Whatever that message says about ${path} being active, ` +
                 `it is not: the canvas you would read or write is ${drift.activeLabel}. Do NOT save, ` +
@@ -6675,12 +6758,46 @@ export function buildPanelToolDefs() {
                 .optional()
                 .describe("Canvas [x, y] (two numbers). Auto-placed beside existing nodes when omitted."),
             title: z.string().optional().describe("Optional custom node title."),
-        }, async (args, ctx) => 
-        // #599: the frontend gates the add on a FRESH /object_info (assertAddNode-
-        // ResolvableRefreshing) so an uninstalled class can't be added as a
-        // placeholder — that fetch can outlast the 6000 ms default on a large
-        // install. Give it the bounded refresh ack budget.
-        ctx.call({ cmd: "graph_add_node", class_type: args.class_type, pos: args.pos, title: args.title }, OBJECT_INFO_REFRESH_ACK_TIMEOUT_MS)),
+        }, async (args, ctx) => {
+            // #599: the frontend gates the add on a FRESH /object_info (assertAddNode-
+            // ResolvableRefreshing) so an uninstalled class can't be added as a
+            // placeholder — that fetch can outlast the 6000 ms default on a large
+            // 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 first;
+            // #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
+            // "call panel_refresh_nodes and retry". Doing exactly that worked, both times.
+            // That is a round trip and an agent-visible error for something with one
+            // correct response and no decision in it.
+            //
+            // Safe to automate for a checkable reason, not a hopeful one: the panel's guard
+            // throws BEFORE it creates anything ("Refuse before creating anything"), so the
+            // retry cannot leave two nodes behind. Mutations are otherwise never re-issued
+            // on our own initiative, and that rule is intact — this is not a transport
+            // failure with an unknown outcome, it is a refusal that states its own.
+            const refreshed = await ctx.call({ cmd: "refresh_nodes" }, OBJECT_INFO_REFRESH_ACK_TIMEOUT_MS);
+            if (refreshed.isError) {
+                // 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 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)})`);
+            }
+            const second = await add();
+            if (!isStaleNodeSchemaRefusal(second))
+                return second;
+            // 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 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.)`);
+        }),
         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) => {
             const decision = await ctx.confirm("Clear the canvas? This removes every node from the open workflow. (One Ctrl+Z undoes it.)", "Clear canvas");