comfyui-mcp 0.52.26 → 0.52.27

package/dist/orchestrator/node-id.js

@@ -21,8 +21,18 @@
  * refused to risk. So a qualified id is never converted: it stays the string the
  * reader printed, all the way to the panel.
  */
-/** A plain integer id, the form the wire has always carried. */
-const PLAIN = /^-?\d+$/;
+/**
+ * A plain integer id, the form the wire has always carried.
+ *
+ * Exported because one argument needs this shape ON ITS OWN: panel_run's
+ * `to_node_id` (#1497). Everything else takes NODE_ID_PATTERN, which admits the
+ * qualified form too — but a run-to-node target is resolved by NUMBER all the way
+ * down (the panel's findNodeInScopes does `Number(id)`, and its reply reports
+ * `ran_to_node: Number(to_node_id)`), so admitting `"120:104"` there would trade a
+ * clear schema refusal for a panel-side "node not found" about a node that exists.
+ * The shape lives here so the two patterns cannot drift apart.
+ */
+export const PLAIN_NODE_ID_PATTERN = /^-?\d+$/;
 /**
  * A subgraph-qualified id: integer segments joined by colons (`120:104`,
  * `120:113:78`). No depth limit — nesting is arbitrary, and a limit would fail the

package/dist/orchestrator/node-id.js.map

@@ -1 +1 @@
-{"version":3,"file":"node-id.js","sourceRoot":"","sources":["../../src/orchestrator/node-id.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,gEAAgE;AAChE,MAAM,KAAK,GAAG,SAAS,CAAC;AAExB;;;;;;GAMG;AACH,MAAM,SAAS,GAAG,kBAAkB,CAAC;AAErC;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,kBAAkB,CAAC;AAElD,6DAA6D;AAC7D,MAAM,UAAU,cAAc,CAAC,CAAS;IACtC,OAAO,eAAe,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;AACjC,CAAC;AAED,4EAA4E;AAC5E,MAAM,UAAU,iBAAiB,CAAC,CAAS;IACzC,OAAO,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;AAC3B,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,eAAe,CAAC,CAAkB;IAChD,IAAI,OAAO,CAAC,KAAK,QAAQ;QAAE,OAAO,CAAC,CAAC;IACpC,IAAI,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC;QAAE,OAAO,CAAC,CAAC;IAChC,OAAO,MAAM,CAAC,QAAQ,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;AAChC,CAAC;AAED;oFACoF;AACpF,MAAM,CAAC,MAAM,eAAe,GAC1B,kFAAkF,CAAC"}
+{"version":3,"file":"node-id.js","sourceRoot":"","sources":["../../src/orchestrator/node-id.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH;;;;;;;;;;GAUG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,SAAS,CAAC;AAE/C;;;;;;GAMG;AACH,MAAM,SAAS,GAAG,kBAAkB,CAAC;AAErC;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,kBAAkB,CAAC;AAElD,6DAA6D;AAC7D,MAAM,UAAU,cAAc,CAAC,CAAS;IACtC,OAAO,eAAe,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;AACjC,CAAC;AAED,4EAA4E;AAC5E,MAAM,UAAU,iBAAiB,CAAC,CAAS;IACzC,OAAO,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;AAC3B,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,eAAe,CAAC,CAAkB;IAChD,IAAI,OAAO,CAAC,KAAK,QAAQ;QAAE,OAAO,CAAC,CAAC;IACpC,IAAI,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC;QAAE,OAAO,CAAC,CAAC;IAChC,OAAO,MAAM,CAAC,QAAQ,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;AAChC,CAAC;AAED;oFACoF;AACpF,MAAM,CAAC,MAAM,eAAe,GAC1B,kFAAkF,CAAC"}

package/dist/orchestrator/panel-tools.js

@@ -45,7 +45,7 @@ import { compareSemver } from "../services/self-update.js";
 import { describeInstallPanelAction } from "../services/panel-recovery.js";
 import { peekResolvedPanelBase, 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";
+import { NODE_ID_MESSAGE, NODE_ID_PATTERN, normalizeNodeId, PLAIN_NODE_ID_PATTERN, } from "./node-id.js";
 import { parseContradictoryPromotedWidgetRefusal, resolveInnerPromotedTarget, } from "./promoted-widget.js";
 import { fastGroupsFilterPropertyNote, isFastGroupsFilterProperty, } from "./rgthree-fast-groups-property.js";
 import { isPlainObject, isStampMismatchSaveRefusal, openLiveMatchesDestContent, patchOpenIdentity, shouldRebindOpenIdentity, workflowFromSerializeReply, } from "./open-identity-normalization.js";
@@ -4973,8 +4973,18 @@ panelGapNote = "") {
     // A panel that cannot fence a WRITE gives reads only, however good the stamp is.
     const mutationsRefused = canMutate === false;
     const mutationsUnknown = canMutate === undefined;
+    // #1494 — `reads_only` would be a FALSE consolation for this one cause. The
+    // dispatch-time agreement gate covers `graph_*` READS as well as mutations
+    // (requiresStampTargetAgreement), so a session in that state has neither working
+    // graph reads NOR writes — only the canvas-INDEPENDENT ops that predicate exempts
+    // (graph_update_node, the virtual-type reads) still dispatch, which is not what a
+    // caller reads "reads_only" as. And the whole report is that this call answered
+    // "bound" while everything the gate covers was being refused. It is
+    // `not_recovered`: the caller must not read success out of it.
     const okBinding = mutationsRefused
-        ? "reads_only"
+        ? refusalCause === "target_disagreement"
+            ? "not_recovered"
+            : "reads_only"
         : mutationsUnknown
             ? "unverified"
             : "bound";
@@ -5000,23 +5010,37 @@ panelGapNote = "") {
                 `\n\nWHAT TO DO: call this tool again to bind an identity. If it keeps coming back ` +
                 `without one, have the user click into the workflow tab so the panel reports an active ` +
                 `canvas, then call this again.`
-            : mutationsRefused && refusalCause === "unroutable"
-                ? `\n\nBUT this tab is NOT REACHABLE from the orchestrator right now, so graph mutations ` +
-                    `are refused — and reads are not working either, whatever this note says about them. ` +
-                    `This is NOT a panel-version problem: updating the pack and hard-refreshing cannot help, ` +
-                    `because there is nothing to refresh until the tab is connected again.` +
-                    `\n\nWHAT TO DO: check that the ComfyUI browser tab is still open and its panel is ` +
-                    `connected, then call this again.`
-                : mutationsRefused
-                    ? `\n\nBUT graph MUTATIONS are still refused for this tab: its panel build does not ` +
-                        `advertise the write-boundary workflow fence a graph edit requires, and no rebind — ` +
-                        `including calling this tool again — can add it. Reads work now (this call just read the ` +
-                        `live canvas).\n\nWHAT TO DO FOR EDITS: update the comfyui-mcp-panel pack, then have the ` +
-                        `user HARD-refresh (Ctrl+Shift+R) the ComfyUI browser tab — an open tab keeps running its ` +
-                        `cached bundle, so the capability lags the version on disk until it does. Do NOT use ` +
-                        `panel_reload for this: it has been observed to leave the tab permanently unresponsive ` +
-                        `(#803).`
-                    : "";
+            : mutationsRefused && refusalCause === "target_disagreement"
+                ? `\n\nBUT THIS DID NOT CLEAR THE REFUSAL, and saying otherwise is the bug this ` +
+                    `wording exists to stop (#1494). Graph commands are refused BEFORE they are ` +
+                    `dispatched, by a comparison this call does not perform: the session's stamp against ` +
+                    `the identity the ROUTED TAB last advertised in its handshake. This call compared the ` +
+                    `stamp against the LIVE canvas instead, and those are different facts — the live ` +
+                    `canvas agreeing is exactly why nothing above says "rebound". Graph READS are refused ` +
+                    `by the same gate, so this is not a reads-only session.` +
+                    `\n\nWHAT TO DO: re-open the workflow you mean with panel_open_workflow(<path>) — an ` +
+                    `open proves an identity for the tab under its current id, which is what the gate is ` +
+                    `missing; for a never-saved canvas use its routing_key from panel_list_workflows. The ` +
+                    `panel also re-advertises on its own when it notices the drift, so a command that ` +
+                    `keeps failing here may start working without you doing anything — do NOT read that as ` +
+                    `this call having repaired it.`
+                : mutationsRefused && refusalCause === "unroutable"
+                    ? `\n\nBUT this tab is NOT REACHABLE from the orchestrator right now, so graph mutations ` +
+                        `are refused — and reads are not working either, whatever this note says about them. ` +
+                        `This is NOT a panel-version problem: updating the pack and hard-refreshing cannot help, ` +
+                        `because there is nothing to refresh until the tab is connected again.` +
+                        `\n\nWHAT TO DO: check that the ComfyUI browser tab is still open and its panel is ` +
+                        `connected, then call this again.`
+                    : mutationsRefused
+                        ? `\n\nBUT graph MUTATIONS are still refused for this tab: its panel build does not ` +
+                            `advertise the write-boundary workflow fence a graph edit requires, and no rebind — ` +
+                            `including calling this tool again — can add it. Reads work now (this call just read the ` +
+                            `live canvas).\n\nWHAT TO DO FOR EDITS: update the comfyui-mcp-panel pack, then have the ` +
+                            `user HARD-refresh (Ctrl+Shift+R) the ComfyUI browser tab — an open tab keeps running its ` +
+                            `cached bundle, so the capability lags the version on disk until it does. Do NOT use ` +
+                            `panel_reload for this: it has been observed to leave the tab permanently unresponsive ` +
+                            `(#803).`
+                        : "";
     switch (r.status) {
         case "diverged":
             // #1646 — produced ONLY by a read-only probe (`adopt:false`), which the
@@ -7427,14 +7451,53 @@ export function makePanelToolCtx(bridge, tabId, workflowTargets) {
                 let verdict;
                 try {
                     const probe = await rebindWorkflowFence(ctx, { adopt: false });
+                    // #1494 — WHICH COMPARISON IS REFUSING, asked of the gate itself rather than
+                    // inferred from the probe.
+                    //
+                    // The probe reads the LIVE canvas. The dispatch-time agreement gate refuses on
+                    // the identity the ROUTED TAB last advertised. When the advertisement is the
+                    // stale side, those two disagree — the probe reports `already_current` on the
+                    // very uuid the command carried, which reads as "transient, retry" while every
+                    // retry is compared against the same unchanged advertisement and refused
+                    // identically. That is the reported contradiction: an immediate rebind
+                    // confirming the original instance, next to a refusal naming another one.
+                    //
+                    // Typed, from `tabGraphMutationCapability` (the bridge's own verdict, sharing
+                    // one predicate with `send()`), never a second reading of the refusal's prose.
+                    let gateStillRefuses = false;
+                    try {
+                        const cap = ctx.tabGraphMutationCapability?.();
+                        gateStillRefuses =
+                            cap?.known === true &&
+                                cap.canMutate === false &&
+                                cap.because === "target_disagreement";
+                    }
+                    catch {
+                        gateStillRefuses = false; // a diagnostic must never replace the outcome
+                    }
                     verdict =
                         probe.status === "already_current" && stamped && probe.uuid === stamped
-                            ? `\n\nCHECKED: the live canvas now reports the SAME workflow instance this ` +
-                                `command carried (${stamped}), so the mismatch was TRANSIENT: the identity ` +
-                                `flipped and settled back, which happens while a new unsaved workflow is still ` +
-                                `materialising. RETRY THIS EXACT CALL ONCE. Nothing was applied, so a retry ` +
-                                `cannot double-apply, and re-issuing the whole build would duplicate the work ` +
-                                `that already succeeded.`
+                            ? gateStillRefuses
+                                ? `\n\nCHECKED, and the two claims are BOTH true of different things: the live ` +
+                                    `canvas does report the SAME workflow instance this command carried ` +
+                                    `(${stamped}), and the refusal above is not about the live canvas — it is ` +
+                                    `the pre-dispatch check on the identity the ROUTED TAB last advertised, ` +
+                                    `which is the stale side here. So a bare retry is compared against that ` +
+                                    `same unchanged value and is refused the same way; ` +
+                                    `panel_set_workflow_target({mode:"current"}) reports "already current" for ` +
+                                    `the same reason and does not clear it either. Nothing was applied. WHAT TO ` +
+                                    `DO: re-open the workflow you mean with panel_open_workflow(<path>) — that ` +
+                                    `proves an identity for the tab under its CURRENT id, which is what is ` +
+                                    `missing; for a never-saved canvas use its routing_key from ` +
+                                    `panel_list_workflows. The panel also re-advertises on its own once it ` +
+                                    `notices the drift, so a retry may start working shortly — that is the ` +
+                                    `panel repairing it, not this call.`
+                                : `\n\nCHECKED: the live canvas now reports the SAME workflow instance this ` +
+                                    `command carried (${stamped}), so the mismatch was TRANSIENT: the identity ` +
+                                    `flipped and settled back, which happens while a new unsaved workflow is still ` +
+                                    `materialising. RETRY THIS EXACT CALL ONCE. Nothing was applied, so a retry ` +
+                                    `cannot double-apply, and re-issuing the whole build would duplicate the work ` +
+                                    `that already succeeded.`
                             : probe.status === "already_current"
                                 ? `\n\nCHECKED: the session's fence already names the live canvas ` +
                                     `(${probe.uuid}), so it was not the stale side. Retry once — if it refuses ` +
@@ -8966,6 +9029,38 @@ const nodeId = () => z
     z.string().regex(NODE_ID_PATTERN, NODE_ID_MESSAGE),
 ])
     .transform(normalizeNodeId);
+/**
+ * #1497 — the ONE node-id argument #845 never reached: panel_run's `to_node_id`.
+ *
+ * #845 made every panel tool accept back an id it had PRINTED, because the graph
+ * readers hand out ids as strings (`summarizeNode` returns `id: node.id`, and on
+ * the modern ComfyUI frontend that is `"11"`, not `11`). Twenty-seven node-id
+ * arguments adopted `nodeId()`; this one kept `z.number().int()` and was missed,
+ * so the documented round trip — take the id `panel_add_node` just returned, hand
+ * it to panel_run — failed with a raw `expected number, received string`, exactly
+ * as #845 described and #427 hit for panel_create_group. A canonical validator is
+ * adopted per CALL SITE, and this call site never adopted it.
+ *
+ * NOT `nodeId()`, deliberately. That helper also admits the subgraph-QUALIFIED
+ * shape (`"120:104"`, #1425) and passes it through as a string, which is right for
+ * a write that addresses a node by key. A run-to-node target is not addressed by
+ * key — it is an EXECUTION ROOT, resolved numerically the whole way down:
+ * the panel's `findNodeInScopes` matches on `Number(id)`, its reply reports
+ * `ran_to_node: Number(to_node_id)`, and two branches here (#772's stamp-race
+ * re-issue and #468's run ticket) gate on `typeof args.to_node_id === "number"`.
+ * Widening this argument to the qualified form would therefore turn a clear schema
+ * refusal into a panel-side "node 120:104 was not found" about a node that plainly
+ * exists, and silently drop the run ticket that correlates the completion. So the
+ * spelling widens and the SHAPE does not: `11` and `"11"` both mean node 11, and
+ * a qualified id is still refused — now by name, with a reason.
+ */
+const RUN_TO_NODE_ID_MESSAGE = 'a run-to-node target must be a plain integer node id — 42 or "42" both work. A subgraph-qualified id (e.g. "120:104") is not an execution root: pass the output node\'s own plain id, which is what panel_query_graph prints for it even when it is nested inside a subgraph';
+const runToNodeId = () => z
+    .union([
+    z.number().int(),
+    z.string().regex(PLAIN_NODE_ID_PATTERN, RUN_TO_NODE_ID_MESSAGE),
+])
+    .transform((v) => (typeof v === "number" ? v : Number.parseInt(v, 10)));
 /**
  * #845 — which `panel_canvas` arguments the chosen action actually consumes.
  *
@@ -10238,11 +10333,9 @@ export function buildPanelToolDefs() {
                 .max(100)
                 .optional()
                 .describe("Times to queue (default 1)."),
-            to_node_id: z
-                .number()
-                .int()
+            to_node_id: runToNodeId()
                 .optional()
-                .describe("Output node id to render UP TO (partial execution). Omit to run the whole graph. Must be an OUTPUT node — one with is_output:true in panel_query_graph's detail rows. May be nested inside a subgraph (pass the node's own id)."),
+                .describe("Output node id to render UP TO (partial execution). Omit to run the whole graph. Must be an OUTPUT node — one with is_output:true in panel_query_graph's detail rows. May be nested inside a subgraph (pass the node's own id). Takes the id EXACTLY as the readers print it: 11 and \"11\" both mean node 11 (#1497). A subgraph-qualified id (\"120:104\") is not an execution root and is refused."),
             allow_duplicate: z
                 .boolean()
                 .optional()
@@ -10623,7 +10716,32 @@ export function buildPanelToolDefs() {
                 return appendToolResultText(res, lateAckNote);
             return res;
         }),
-        def("panel_get_errors", "WHY IS THAT NODE RED / WHY DID THE RUN FAIL? The single error surface for the user's open tab: every errored node JOINED TO ITS CAUSE, which ComfyUI itself does not show — LiteGraph only paints a red outline and stores no reason, which is why users report \"red node, no error message\". Call this whenever the user mentions a red/highlighted/erroring node, a failed run, or \"required models are missing\" — instead of guessing from widget values. Each entry in `nodes[]` is the node's full detail summary plus `red_outline` and `reasons[]`, drawn from every source: `missing_model` (exact file, its models directory, the widget holding it, and a download URL when known), `missing_media` (a referenced input image/video that isn't on disk — the usual cause of a red LoadImage), `validation` (per-input errors from the last queue attempt: message, details, offending input), and `execution` (runtime failure with `exception_type`, e.g. PIL.UnidentifiedImageError). TWO THINGS THAT MAKE THIS ESSENTIAL: (1) missing model/media assets paint nodes red AS SOON AS THE WORKFLOW LOADS, long before any queue attempt — so the raw validation map is still EMPTY while the user is staring at red nodes; (2) a node that throws AT RUNTIME is never painted red at all, so it can't be spotted on the canvas — it appears here with red_outline:false. Also returns graph-level `missing_models`, `missing_media`, `missing_node_types` (or `missing_node_count`), plus the raw `node_errors` map and `last_execution_error` for reference. A ⚠️ GRAPH VALIDATION block is auto-injected at your turn start when this state changes; call this to re-check on demand (e.g. after you edit widgets/links). Read-only.", {}, async (_args, ctx) => withTruncationHints(await ctx.call({ cmd: "graph_get_errors" }), [
+        def("panel_get_errors", "WHY IS THAT NODE RED / WHY DID THE RUN FAIL? The single error surface for the user's open tab: every errored node JOINED TO ITS CAUSE, which ComfyUI itself does not show — LiteGraph only paints a red outline and stores no reason, which is why users report \"red node, no error message\". Call this whenever the user mentions a red/highlighted/erroring node, a failed run, or \"required models are missing\" — instead of guessing from widget values. Each entry in `nodes[]` is the node's full detail summary plus `red_outline` and `reasons[]`, drawn from every source: `missing_model` (exact file, its models directory, the widget holding it, and a download URL when known), `missing_media` (a referenced input image/video that isn't on disk — the usual cause of a red LoadImage), `validation` (per-input errors from the last queue attempt: message, details, offending input), and `execution` (runtime failure with `exception_type`, e.g. PIL.UnidentifiedImageError). TWO THINGS THAT MAKE THIS ESSENTIAL: (1) missing model/media assets paint nodes red AS SOON AS THE WORKFLOW LOADS, long before any queue attempt — so the raw validation map is still EMPTY while the user is staring at red nodes; (2) a node that throws AT RUNTIME is never painted red at all, so it can't be spotted on the canvas — it appears here with red_outline:false. Also returns graph-level `missing_models`, `missing_media`, `missing_node_types` (or `missing_node_count`), plus the raw `node_errors` map and `last_execution_error` for reference. A ⚠️ GRAPH VALIDATION block is auto-injected at your turn start when this state changes; call this to re-check on demand (e.g. after you edit widgets/links). Read-only.", {}, 
+        // #1493 — graph_get_errors belongs to the #599 refresh-ack cohort above, and was the
+        // one member of it left on the generic read default.
+        //
+        // Its frontend handler deliberately awaits a FORCED /object_info re-register before it
+        // will trust a combo to clear a resolved missing-model candidate (#610), and it spends a
+        // shared 18 000 ms elective budget across that refresh race, the /system_stats probe and the
+        // /view media probes (GET_ERRORS_TOTAL_BUDGET_MS, panel web/js/lib/get-errors-budget.js).
+        // That budget was sized to sit under BRIDGE_READ_DEFAULT_TIMEOUT_MS — which leaves 2 000 ms
+        // for everything the call still has to do AFTER the waits: collectMissingAssets over the
+        // whole graph, the per-node live combo scan, the subgraph walk, and serializing a reply big
+        // enough that this tool ships two truncation riders for it.
+        //
+        // The reported sequence spends that budget exactly as designed — panel_refresh_nodes, three
+        // promoted-widget writes on a model-loader subgraph, a save — and panel_get_errors was then
+        // declared "backgrounded or frozen" at 20 000 ms by a tab that had just answered four
+        // commands and did reply, late. That is the precise failure the shared budget exists to
+        // prevent (#589): an agent left with NO error surface for a workflow whose nodes are red.
+        //
+        // The margin has to come from THIS side. The panel's 18 s bound must stay where it is — it
+        // is what keeps a current panel safe in front of an OLDER orchestrator still using the 20 s
+        // default — so the orchestrator widens its own wait to the same bounded budget its
+        // refresh-before-validate siblings already use. This read is idempotent, so waiting longer
+        // costs a slow reply and never a double-applied write; it stays BOUNDED (never Infinity), so
+        // a genuinely frozen tab still fails, just at 30 s instead of 20 s.
+        async (_args, ctx) => withTruncationHints(await ctx.call({ cmd: "graph_get_errors" }, OBJECT_INFO_REFRESH_ACK_TIMEOUT_MS), [
             {
                 flag: "truncated",
                 key: "truncation_hint",