comfyui-mcp 0.52.115 → 0.52.116

package/dist/orchestrator/panel-tools.js

@@ -191,7 +191,7 @@ import { RunCompletions } from "./run-completion-journal.js";
 import { AskAnswers, askFingerprint, PANEL_ASK_ID_PREFIX, } from "./ask-answer-journal.js";
 import { getQueueVerified, resetClient, resetObjectInfoCache, } from "../comfyui/client.js";
 import { convertUiToApi, collectNodeTypes } from "../services/workflow-converter.js";
-import { restartComfyUI, preflightLocalRestart, readServingArgv, resolveVerifiedProxyRestartTarget, describeArgvDrift, recordRestartDispatch, clearRestartDispatch, getRestartDispatchRecord, RESTART_DISPATCH_CAUSATION_WINDOW_MS, PROCESS_WIDE_RESTART_DISPATCH_TOKEN, __processControlTestHooks, } from "../services/process-control.js";
+import { captureComfyUITargetFence, restartComfyUI, preflightLocalRestart, readServingArgv, resolveVerifiedProxyRestartTarget, describeArgvDrift, recordRestartDispatch, clearRestartDispatch, getRestartDispatchRecord, RESTART_DISPATCH_CAUSATION_WINDOW_MS, PROCESS_WIDE_RESTART_DISPATCH_TOKEN, __processControlTestHooks, targetFenceMatchesCurrent, targetFencesEqual, } from "../services/process-control.js";
 import { resetManagerApiCache } from "../services/manager-api-cache.js";
 import { desktopSavedLaunchArgs, describeSavedLaunchArgDrift, } from "../services/desktop-launch-args.js";
 import { config, isRemoteMode, isCloudMode, getBootLocalComfyUIBaseUrl, getComfyUIBaseUrl, getComfyuiTargetGeneration, } from "../config.js";
@@ -10013,7 +10013,7 @@ export function makePanelToolCtx(bridge, tabId, workflowTargets, onRunTicketOpen
         const routed = target ? withWorkflowTarget(cmd, target) : cmd;
         return bridge.send(routed, { tabId: ctx.tabId, timeoutMs, onDispatchedRid });
     };
-    const callOnce = async (cmd, timeoutMs, onDispatchedRid, 
+    const callOnce = async (cmd, timeoutMs, onDispatchedRid, beforeDispatch, 
     // #1560 — reports the error each attempt failed on, so the wrapper below can
     // stamp the bridge's structural marks onto the ToolResult from ONE place. The
     // catch has more than a dozen `fail(...)` exits, each shaping its own message;
@@ -10055,6 +10055,10 @@ export function makePanelToolCtx(bridge, tabId, workflowTargets, onRunTicketOpen
             const blocked = graphCmdBlockedByRunningPrompt(cmd);
             if (blocked)
                 return fail(blocked);
+            // A caller may hold a target/generation fence across the reachability wait.
+            // Run it synchronously in the final gap before sendRouted: an async check here
+            // would reopen the exact retarget window this guard closes.
+            beforeDispatch?.();
             const firstTry = ok(await sendRouted(cmd, timeoutMs, observeRid));
             // panel#1097 — a guard-domain command that SUCCEEDS is the evidence that the
             // switch is over, whichever attempt lands it. Without this an ordinary
@@ -10138,6 +10142,7 @@ export function makePanelToolCtx(bridge, tabId, workflowTargets, onRunTicketOpen
                     await awaitReachable();
                     ensureReachable(); // rebinds a current-mode session onto the reconnected tab
                     holdTab = ctx.tabId;
+                    beforeDispatch?.();
                     const retried = ok(await sendRouted(cmd, timeoutMs, observeRid));
                     // Cleared HERE and nowhere else, and only when the failure this retried
                     // was a SWITCH refusal. Clearing on every routed success let an unguarded
@@ -10921,9 +10926,9 @@ export function makePanelToolCtx(bridge, tabId, workflowTargets, onRunTicketOpen
      * concurrent `ctx.call`s — including the `rebindWorkflowFence` round trip that
      * `callOnce`'s own catch makes — cannot read each other's.
      */
-    const call = async (cmd, timeoutMs, onDispatchedRid) => {
+    const call = async (cmd, timeoutMs, onDispatchedRid, beforeDispatch) => {
         let failure;
-        const res = await callOnce(cmd, timeoutMs, onDispatchedRid, (err) => {
+        const res = await callOnce(cmd, timeoutMs, onDispatchedRid, beforeDispatch, (err) => {
             failure = err;
         });
         return carryWorkflowListReadinessMark(failure, carryMidCommandDisconnectMark(failure, carryPanelAnsweredMark(failure, res)));
@@ -12606,7 +12611,7 @@ function withRetryToken(d) {
             // Double-apply is already the #521 panel ledger's job; this only makes the
             // outcome VISIBLE, which is the half of #694 nothing else does.
             const wrapped = Object.create(ctx);
-            wrapped.call = (cmd, timeoutMs, onDispatchedRid) => ctx.call(
+            wrapped.call = (cmd, timeoutMs, onDispatchedRid, beforeDispatch) => ctx.call(
             // Ask the RETRY MAP's question, not the workflow fence's (codex gate).
             // These were the same answer only while isMutatingGraphCommand
             // over-classified — the #778 defect. Once the fence got its own effect
@@ -12622,7 +12627,7 @@ function withRetryToken(d) {
             // reads, which is asserted in panel-retry-identity.test.ts.
             RETRY_TOKEN_CMDS.has(typeof cmd.cmd === "string" ? cmd.cmd : "")
                 ? { ...cmd, retry_of: retryOf }
-                : cmd, timeoutMs, onDispatchedRid);
+                : cmd, timeoutMs, onDispatchedRid, beforeDispatch);
             const out = await d.handler(args, wrapped);
             // Drained AFTER the handler, deliberately, for two measured reasons.
             //
@@ -12676,6 +12681,44 @@ function withRetryToken(d) {
 export function buildPanelToolDefs() {
     // Local helper so each def reads like the original `tool(...)` call.
     const def = (name, description, schema, handler) => ({ name, description, schema, handler });
+    const capturePanelKitchenTarget = (ctx) => {
+        const base = getComfyUIBaseUrl().replace(/\/+$/, "");
+        const observed = ctx.bridge.tabServerOrigin?.(ctx.tabId);
+        // A hello.comfyui_url/tabOrigin value is page-JS-writable and cannot authorize
+        // a process mutation. The server-observed handshake proves only the origin,
+        // not a path mount; refuse mounted targets rather than guessing which instance
+        // this tab fronts. This is the same fail-closed rule used by panel_reboot.
+        if (ctx.bridge.tabIsLocal?.(ctx.tabId) !== true ||
+            !observed ||
+            !sameHttpOrigin(observed, base) ||
+            (() => {
+                try {
+                    return new URL(base).pathname.replace(/\/+$/, "") !== "";
+                }
+                catch {
+                    return true;
+                }
+            })()) {
+            return undefined;
+        }
+        return { fence: captureComfyUITargetFence(), tabId: ctx.tabId };
+    };
+    const panelKitchenTargetStillCurrent = (ctx, target) => {
+        if (ctx.tabId !== target.tabId || !targetFenceMatchesCurrent(target.fence))
+            return false;
+        const observed = ctx.bridge.tabServerOrigin?.(target.tabId);
+        return (ctx.bridge.tabIsLocal?.(target.tabId) === true &&
+            observed != null &&
+            sameHttpOrigin(observed, target.fence.baseUrl) &&
+            (() => {
+                try {
+                    return new URL(target.fence.baseUrl).pathname.replace(/\/+$/, "") === "";
+                }
+                catch {
+                    return false;
+                }
+            })());
+    };
     const defs = [
         def("panel_query_graph", "FILTER or TRAVERSE a SUBSET of the live canvas, for when you ALREADY KNOW what you're looking for. NOT for 'show me the canvas' or any whole-graph overview — call panel_graph_outline FIRST for that. NOT get_workflow's query action (that queries a saved file or JSON you provide, not the live canvas). Filters, traverses, projects and aggregates over the workflow the user is CURRENTLY VIEWING without dumping the whole graph (replaces the old panel_get_graph full-JSON dump; output is TOKEN-BOUNDED with an explicit truncation marker, so a big graph can never flood your context). Combine: `types` (node type contains any), `title` (contains), `where` widget predicates ANDed ('cfg>7', 'steps<=20', 'sampler_name=euler', 'text~sunset' — ops = != >= <= > < ~contains), `ids` (exact nodes — THE way to read ONE node's exact slot/widget detail: {ids:[42], fields:'detail'}), `upstream_of`/`downstream_of` + `depth` (dependency traversal: upstream = what FEEDS that node, downstream = what CONSUMES it; seed at depth 0), `fields` ('compact' one line per node [default], 'ids', 'detail' = the full node summary with slots + connections + mode), `group_by:'type'` (counts only), `limit` (default 40). detail rows include each node's MODE — a 'bypass' node is skipped and a 'mute' node kills everything downstream, so check modes on the path you care about before running (fix with panel_set_node_mode). Every result also carries `groups` (id, title, member node_ids — groups are geometric, trust this list) and, when viewing a SUBGRAPH (after panel_enter_subgraph), `rails` (boundary rail ids/slots). `max_chars` bounds the WHOLE result, those riders included, and the rows you asked for are spent first: on a big graph the riders lose their member ids, then drop out entirely, rather than starving your query — and each says in-band when it did, with the true counts. `widget_max_chars` raises the per-widget cap only for `fields:'detail'`; use it only with exactly one explicit `ids` entry (for example `{ids:[42], fields:'detail', widget_max_chars:8192}`), with a default of 2048 and a maximum of 32768. If supplied without those preconditions, it is not sent and the result says why; a legacy Panel that still returns the default cap is named in the result. It does not change compact, ids, or broad reads. Typical flow: panel_graph_outline to orient → panel_query_graph to pinpoint/inspect → edit. Read-only.", {
             types: z.array(z.string()).optional().describe("Node type contains ANY of these (case-insensitive)."),
@@ -12749,6 +12792,10 @@ export function buildPanelToolDefs() {
             });
             return fitQueryGraphReply(panelReply, args.max_chars, widgetMaxChars.note ?? legacyWidgetMaxCharsNote(panelReply, widgetMaxChars.value));
         }),
+        // panel_kitchen mixes panel-routed graph evidence with process-global
+        // ComfyUI probes. Bind both halves to the same tab target before allowing
+        // an assessment or mutation; a concurrent hello from another tab must
+        // produce a refusal, never a cross-instance apply.
         def("panel_graph_outline", "READ THE LIVE CANVAS the user is looking at, as text. 'Show me what's on the canvas' / 'what's on the graph right now' / 'read the current workflow' / 'describe the open graph' -> THIS TOOL, with no arguments. NOT visualize_workflow (it DRAWS A DIAGRAM of a workflow you PASS IN — a saved file or JSON — and never sees the live canvas). NOT panel_query_graph (that FILTERS a SUBSET, for when you already know what you're looking for). Returns one `outline` string covering the WHOLE open graph, topologically sorted (sources first, sinks last): each node as `id Type \"title\" [bypass/mute] [OUTPUT] · group:X  widget=value …` with `← inputs` (source_node.output_name) and `→ outputs` (target_node.input_name), after a GROUPS index (title → member node ids). It gives you the WIRING you would otherwise reconstruct by hand — read it FIRST to get oriented, then panel_query_graph to inspect one node ({ids:[42], fields:'detail'}) or panel_find_nodes for free-text search. Over `max_chars` it never cuts the graph short: it sheds per-node detail, or refuses with a reason — never a partial outline. Read-only.", {
             max_chars: z
                 .number()
@@ -18499,7 +18546,7 @@ CHECKED FOR YOU: the graph read this message prescribes was just run, and it ` +
         def("panel_kitchen", "See what comfy-kitchen can do on this GPU against the OPEN canvas, find where the live graph leaves it on the table, and apply the faster path. Same actions as the core `kitchen` tool, fenced like every other panel mutation. Driven by `action`:\n" +
             '- action:"status" — kitchen version, backends (hip/cuda/triton/eager), INT8 attention, GPU fp8/NVFP4/MXFP8, launch flags. Remote sessions report the import probe and model.quant as unknown.\n' +
             '- action:"assess" — walk the live graph\'s UNETLoaders. A recommendation fires only when every fact it needs is known (fp8_e4m3fn_fast widget; --use-ck-attention flag; NVFP4 swap; ROCm --enable-triton-backend).\n' +
-            '- action:"apply" — apply one recommendation_id. Widget edits go through graph_set_widget (Ctrl+Z). Flags need confirm:true; restart_comfyui / panel_restart_comfyui replay argv and do not inject flags. skip_proof:true skips the follow-up panel_run. A black or slower after-run reverts the widget.', {
+            '- action:"apply" — apply one recommendation_id. Widget edits go through graph_set_widget (Ctrl+Z). Flags need confirm:true; directly managed local Python installs get a proven relaunch with the flag appended and retained for later managed starts, while Desktop/remote/external launchers receive an actionable refusal without being stopped or edited. skip_proof:true skips the follow-up panel_run. A black or slower after-run reverts the widget.', {
             action: z
                 .enum(["status", "assess", "apply"])
                 .describe('Which kitchen operation against the live graph.'),
@@ -18516,10 +18563,17 @@ CHECKED FOR YOU: the graph read this message prescribes was just run, and it ` +
                 .optional()
                 .describe("If true, apply the widget/flag plan without queueing a proof panel_run."),
         }, async (args, ctx) => {
+            const target = capturePanelKitchenTarget(ctx);
+            if (!target) {
+                return fail("panel_kitchen refused: the process target could not be tied to this panel tab's exact ComfyUI target and generation. Keep one target selected, then retry.");
+            }
             const status = await gatherKitchenStatus();
+            if (!panelKitchenTargetStillCurrent(ctx, target)) {
+                return fail("panel_kitchen refused: the ComfyUI target changed while status was being assessed. No recommendation was applied; retry after the target settles.");
+            }
             if (args.action === "status") {
                 const hint = kitchenProactiveHint(status, assessKitchen(status, {}));
-                return ok(hint ? { status, hint } : { status });
+                return ok(hint ? { status, hint, target_fence: target.fence } : { status, target_fence: target.fence });
             }
             const query = await ctx.call({
                 cmd: "graph_query",
@@ -18530,6 +18584,9 @@ CHECKED FOR YOU: the graph read this message prescribes was just run, and it ` +
             });
             if (query.isError)
                 return query;
+            if (!panelKitchenTargetStillCurrent(ctx, target)) {
+                return fail("panel_kitchen refused: the ComfyUI target changed while the live graph was being read. No recommendation was applied; retry after the target settles.");
+            }
             const graph = normalizeGraphQueryResult(query);
             if (graph.truncated === true) {
                 const truncationCause = graph.truncated_by === "limit"
@@ -18542,12 +18599,16 @@ CHECKED FOR YOU: the graph read this message prescribes was just run, and it ` +
                     `more specific workflow or retry after reducing the number of UNETLoaders.`);
             }
             const recs = await assessKitchenGraph(status, graph);
+            if (!panelKitchenTargetStillCurrent(ctx, target)) {
+                return fail("panel_kitchen refused: the ComfyUI target changed during assessment. No recommendation was applied; retry after the target settles.");
+            }
             if (args.action === "assess") {
                 const hint = kitchenProactiveHint(status, recs);
                 return ok({
                     status,
                     loaders: extractLoaders(graph),
                     recommendations: recs,
+                    target_fence: target.fence,
                     ...(hint ? { hint } : {}),
                 });
             }
@@ -18561,28 +18622,123 @@ CHECKED FOR YOU: the graph read this message prescribes was just run, and it ` +
             if (!rec) {
                 return fail(`No recommendation "${args.recommendation_id}" on the live graph. Call panel_kitchen action:"assess" first. Known: ${recs.map((r) => r.id).join(", ") || "(none)"}`);
             }
-            const result = await applyKitchenRecommendation({
-                rec,
-                confirm: args.confirm === true,
-                applyWidget: rec.change.type === "widget" || rec.change.type === "model_swap"
-                    ? async (nodeId, widget, value) => {
-                        const write = await ctx.call({ cmd: "graph_set_widget", node_id: nodeId, widget, value }, OBJECT_INFO_REFRESH_ACK_TIMEOUT_MS);
-                        if (write.isError) {
-                            throw new Error(write.content.map((c) => ("text" in c ? c.text : "")).join("\n"));
+            let result;
+            try {
+                result = await applyKitchenRecommendation({
+                    rec,
+                    confirm: args.confirm === true,
+                    applyFlag: rec.change.type === "flag"
+                        ? async (flag) => {
+                            if (!panelKitchenTargetStillCurrent(ctx, target)) {
+                                return {
+                                    applied: false,
+                                    note: `Refusing to apply ${flag}: the ComfyUI target changed after assessment. ` +
+                                        "No launch argument was changed and no restart was attempted.",
+                                };
+                            }
+                            let restart;
+                            try {
+                                restart = await restartComfyUI({
+                                    additionalFlags: [flag],
+                                    targetFence: target.fence,
+                                });
+                            }
+                            catch (err) {
+                                return {
+                                    applied: false,
+                                    note: `Could not apply ${flag}: ${err instanceof Error ? err.message : String(err)} ` +
+                                        "No launch argument was changed; verify the launcher and current ComfyUI argv before retrying.",
+                                };
+                            }
+                            const flagObserved = restart.serving_argv?.includes(flag) === true;
+                            const targetProven = restart.target_stable !== false &&
+                                targetFencesEqual(restart.target_fence, target.fence) &&
+                                panelKitchenTargetStillCurrent(ctx, target);
+                            const applied = restart.started === true &&
+                                restart.startup === "confirmed" &&
+                                restart.listener_ownership === "ours" &&
+                                flagObserved &&
+                                targetProven;
+                            return {
+                                applied,
+                                note: applied
+                                    ? `Applied ${flag} through the proven local relaunch and observed it in the serving ComfyUI argv. The augmented launch recipe is retained for later managed starts.`
+                                    :
+                                        `Did not confirm ${flag} in effect: ${restart.message} ` +
+                                            "panel_kitchen reports applied:false because the relaunch, target fence, and new serving argv were not all proven.",
+                                restart,
+                            };
                         }
-                        return parseToolResultJson(write);
-                    }
-                    : undefined,
-                revertWidget: rec.change.type === "widget" || rec.change.type === "model_swap"
-                    ? async (nodeId, widget, value) => {
-                        await ctx.call({ cmd: "graph_set_widget", node_id: nodeId, widget, value }, OBJECT_INFO_REFRESH_ACK_TIMEOUT_MS);
-                    }
-                    : undefined,
-            });
-            if (result.applied && args.skip_proof !== true && rec.change.type !== "flag") {
-                const run = await ctx.call({ cmd: "graph_run" });
+                        : undefined,
+                    applyWidget: rec.change.type === "widget" || rec.change.type === "model_swap"
+                        ? async (nodeId, widget, value) => {
+                            const write = await ctx.call({ cmd: "graph_set_widget", node_id: nodeId, widget, value }, OBJECT_INFO_REFRESH_ACK_TIMEOUT_MS, undefined, () => {
+                                if (!panelKitchenTargetStillCurrent(ctx, target)) {
+                                    throw new Error("Refusing graph_set_widget: the ComfyUI target changed after the reachability wait. No widget mutation was dispatched.");
+                                }
+                            });
+                            if (write.isError) {
+                                throw new Error(write.content.map((c) => ("text" in c ? c.text : "")).join("\n"));
+                            }
+                            return parseToolResultJson(write);
+                        }
+                        : undefined,
+                    revertWidget: rec.change.type === "widget" || rec.change.type === "model_swap"
+                        ? async (nodeId, widget, value) => {
+                            const revert = await ctx.call({ cmd: "graph_set_widget", node_id: nodeId, widget, value }, OBJECT_INFO_REFRESH_ACK_TIMEOUT_MS, undefined, () => {
+                                if (!panelKitchenTargetStillCurrent(ctx, target)) {
+                                    throw new Error("Refusing graph_set_widget revert: the ComfyUI target changed after the reachability wait. No widget mutation was dispatched.");
+                                }
+                            });
+                            if (revert.isError) {
+                                throw new Error(revert.content.map((c) => ("text" in c ? c.text : "")).join("\n"));
+                            }
+                        }
+                        : undefined,
+                });
+            }
+            catch (err) {
+                result = {
+                    applied: false,
+                    recommendation: rec,
+                    proof: { status: "failed" },
+                    flag_note: `Could not apply the recommendation: ${err instanceof Error ? err.message : String(err)} ` +
+                        "No further widget mutation was dispatched and the launch outcome is not confirmed.",
+                };
+            }
+            if (!panelKitchenTargetStillCurrent(ctx, target)) {
                 return ok({
                     ...result,
+                    applied: false,
+                    stale: true,
+                    target_stable: false,
+                    target_fence: target.fence,
+                    flag_note: (result.flag_note ? `${result.flag_note} ` : "") +
+                        "panel_kitchen reports applied:false because the ComfyUI target changed before the result was returned.",
+                });
+            }
+            const fencedResult = { ...result, target_fence: target.fence };
+            if (fencedResult.applied && args.skip_proof !== true && rec.change.type !== "flag") {
+                const run = await ctx.call({ cmd: "graph_run" });
+                if (!panelKitchenTargetStillCurrent(ctx, target)) {
+                    return ok({
+                        ...fencedResult,
+                        applied: false,
+                        stale: true,
+                        target_stable: false,
+                        proof: {
+                            ...fencedResult.proof,
+                            status: "stale",
+                            summary: (fencedResult.proof.summary ? `${fencedResult.proof.summary}; ` : "") +
+                                "graph_run was dispatched for the previously fenced target, but the target changed before its result was returned; no success is claimed for the current target.",
+                        },
+                        run: parseToolResultJson(run),
+                        flag_note: "panel_kitchen reports applied:false/stale because the ComfyUI target changed while the proof graph_run was in flight.",
+                        target_note: "panel_kitchen reports applied:false/stale because the ComfyUI target changed while the proof graph_run was in flight.",
+                    });
+                }
+                return ok({
+                    ...fencedResult,
                     proof: {
                         ...result.proof,
                         status: "queued",
@@ -18592,7 +18748,7 @@ CHECKED FOR YOU: the graph read this message prescribes was just run, and it ` +
                     run: parseToolResultJson(run),
                 });
             }
-            return ok(result);
+            return ok(fencedResult);
         }),
         def("panel_ui_render", "Render an INTERACTIVE UI CARD in the panel chat from an A2UI-subset JSON spec — choice buttons, forms (TextField/Select/Checkbox + a submit Button), node-wiring diagrams (comfy:graph), and bar/line charts (comfy:chart). Use a card whenever the user must pick between options, confirm a plan, fill in parameters, or would understand a wiring explanation better as a diagram. The card is non-blocking: this returns { card_id } immediately; when the user clicks a button (or submits a form) their choice arrives as a NORMAL chat message (the button's `reply` text; submit buttons append 'name: value' lines) — so after rendering a card that asks a question, END YOUR TURN and wait. Set surface:'wide' for diagram-heavy cards (the panel widens and restores automatically). Spec shape: { surface?, title?, root: '<id>', components: [ {id, type, ...} ] } with children referenced by id. Types: Text{text}, Heading{text,level?}, Button{label,reply?,submit?,style?:'primary'|'secondary'}, Row/Column/Card{children:[ids]}, Divider, Image{src:/view-URL,caption?}, TextField{label,name,value?,placeholder?}, Select{label,name,options:[{label,value?}],value?}, Checkbox{label,name,checked?}, 'comfy:graph'{nodes:[{id,label,color?}],edges:[{from,to,label?}],direction?:'lr'|'tb'}, 'comfy:chart'{kind:'bar'|'line',series:[{label,values:[num]}],x?:[labels]}. Caps: ≤64 components, ≤30 graph nodes, ≤8×256 chart points. On a validation error, FIX the spec and retry.", {
             spec: z