comfyui-mcp 0.52.7 → 0.52.13

package/dist/orchestrator/panel-tools.js

@@ -74,7 +74,7 @@ function journalTabFor(ctx) {
 function journalConversationFor(ctx) {
     return conversationOfScopeAddress(ctx.tabId);
 }
-import { BRIDGE_DEFAULT_TIMEOUT_MS, BRIDGE_READ_DEFAULT_TIMEOUT_MS, dispatchOutcomeOf, isCapabilityRefusal, isPanelCmdUnsupportedError, isReplyTimeoutTagged, isRoutingAmbiguity, requiresWorkflowStampEnforcement, } from "../services/ui-bridge.js";
+import { BRIDGE_DEFAULT_TIMEOUT_MS, BRIDGE_READ_DEFAULT_TIMEOUT_MS, dispatchOutcomeOf, GRAPH_CMD_EFFECT, isCapabilityRefusal, isPanelCmdUnsupportedError, isReplyTimeoutTagged, isRoutingAmbiguity, requiresWorkflowStampEnforcement, } from "../services/ui-bridge.js";
 import { withWorkflowTarget, } from "../services/workflow-target-store.js";
 import { addUserMcpServer, readUserMcpServers, removeUserMcpServer, setUserMcpServerSecret, } from "../services/user-mcp-config.js";
 import { setComfyuiSecret, setAgentSecret, isAllowedAgentSecretKey, receiptDisclosures, shadowedNote, storeDamageNote, } from "../services/panel-secrets.js";
@@ -2545,6 +2545,109 @@ function summarizeSetWidgetEcho(res, full) {
         content: res.content.map((c, i) => i === idx && c.type === "text" ? { ...c, text: JSON.stringify(fitted, null, 2) } : c),
     };
 }
+// ---- #1658: Anima/Krea2 regional canvas prompt textareas --------------------------
+//
+// ComfyUI_LC123_nodes `web/inline_regional_canvas.js` hides the prompt widgets
+// and keeps the authoritative string in `node.properties.animaPrompts[name]`
+// plus a custom <textarea>. `promptValue()` prefers the map; APPLY /
+// `savePrompts()` copies the textarea back over `widget.value`. The widgets
+// do NOT declare `options.property`, so the panel#1363 bound-property verify
+// never fires and `applyWidgetWrite`'s `w.value` read-back is a tautology.
+//
+// `savePrompts` / `setPromptValue` are closures, not methods on the node —
+// there is no route (the LTXDirector / PromptRelay shape). This is the
+// node-keyed refusal (#983 rgthree Fast Groups, #1569 Ideogram4). quality /
+// scene / negative have a real Python-side escape: execute() prefers the
+// `*_prompt_in` sockets. red / green / blue have none.
+const ANIMA_REGIONAL_CANVAS_TYPES = new Set([
+    "AnimaRegionalCanvasInline",
+    "Krea2RegionalCanvasInline",
+    "AnimaRegionalCanvas",
+    "AnimaRegionalInpaintCanvas",
+]);
+const ANIMA_REGIONAL_PROMPT_WIDGETS = new Set([
+    "quality_prompt",
+    "scene_prompt",
+    "red_prompt",
+    "green_prompt",
+    "blue_prompt",
+    "negative_prompt",
+]);
+const ANIMA_REGIONAL_WIRED_PROMPT_INPUT = {
+    quality_prompt: "quality_prompt_in",
+    scene_prompt: "scene_prompt_in",
+    negative_prompt: "negative_prompt_in",
+};
+function isAnimaRegionalPromptWidget(widget) {
+    return ANIMA_REGIONAL_PROMPT_WIDGETS.has(widget);
+}
+/** Type of the single node a compact/detail `graph_query` named, or null when
+ *  the reply does not identify one. Fail-open on an unreadable probe. */
+function parseQueriedNodeType(payload) {
+    if (!payload)
+        return null;
+    const nodes = payload.nodes;
+    if (Array.isArray(nodes)) {
+        for (const n of nodes) {
+            if (!n || typeof n !== "object" || Array.isArray(n))
+                continue;
+            const rec = n;
+            const t = rec.type ?? rec.class_type;
+            if (typeof t === "string" && t)
+                return t;
+        }
+    }
+    const text = typeof payload.text === "string" ? payload.text : "";
+    for (const line of text.split("\n")) {
+        const trimmed = line.trim();
+        // Compact: `#2768 AnimaRegionalCanvasInline "title" · …`
+        const compact = trimmed.match(/^#\S+\s+(\S+)/);
+        if (compact)
+            return compact[1];
+        // Detail JSON line: `{"id":2768,"type":"AnimaRegionalCanvasInline",…}`
+        if (trimmed.startsWith("{")) {
+            try {
+                const row = JSON.parse(trimmed);
+                const t = row.type ?? row.class_type;
+                if (typeof t === "string" && t)
+                    return t;
+            }
+            catch {
+                /* not a detail row */
+            }
+        }
+    }
+    return null;
+}
+function animaRegionalPromptRefusal(type, widget) {
+    const wired = ANIMA_REGIONAL_WIRED_PROMPT_INPUT[widget];
+    const route = wired
+        ? `Wire a PrimitiveStringMultiline into this node's \`${wired}\` socket — execute() prefers that input over the widget.`
+        : `There is no input socket for "${widget}"; the custom textarea is the only durable store.`;
+    return fail(`panel_set_widget cannot set "${widget}" on ${type}. ` +
+        `The node's custom JS stores the prompt in node.properties.animaPrompts["${widget}"] and a hidden textarea; ` +
+        `APPLY / savePrompts() copies the textarea back over widget.value, so a success here would be a lie. ` +
+        `${route} Do not retry panel_set_widget on this widget.`);
+}
+/** Refuse the known LC123 regional-canvas prompt widgets. Identity is read
+ *  from a one-node `graph_query`; anything else (query failed, type unreadable,
+ *  some other node that happens to own `negative_prompt`) is fail-open. */
+async function refuseAnimaRegionalPromptWrite(ctx, nodeId, widget) {
+    if (!isAnimaRegionalPromptWidget(widget))
+        return null;
+    const probe = await ctx.call({
+        cmd: "graph_query",
+        ids: [nodeId],
+        fields: "compact",
+        limit: 1,
+    });
+    if (probe.isError)
+        return null;
+    const type = parseQueriedNodeType(parseToolResultJson(probe));
+    if (!type || !ANIMA_REGIONAL_CANVAS_TYPES.has(type))
+        return null;
+    return animaRegionalPromptRefusal(type, widget);
+}
 // ---- #809: turn the panel's silent `truncated: true` booleans into a remedy --------
 //
 // A bare boolean is the WORST truncation signal there is: it is a field, not prose, so
@@ -7179,21 +7282,22 @@ export function makePanelToolCtx(bridge, tabId, workflowTargets) {
             // downstream of here, so that field is undefined at this point for BOTH states
             // (the trap that silently disabled #1330's transient branch one block up).
             //
-            // NOTHING IS ADOPTED. The probe is the same read-only one (`adopt:false`), so
-            // this reports which state it found and the fence moves only on an explicit
-            // rebind. The refusal itself is preserved verbatim and the call still fails.
+            // AN UNSTAMPED INERT READ IS ADMITTED by minting a first fence from the
+            // live canvas and retrying once. That is not the retarget #1646 removed:
+            // there is no named workflow to abandon, and a pinned session is left
+            // alone. The panel fence is unchanged (#718). A WRONG stamp still fails.
+            // The probe stays read-only until this branch decides to mint.
             if (isWorkflowInstanceMismatch(err) && isFencedGraphRead(cmd)) {
                 const name = typeof cmd.cmd === "string" ? cmd.cmd : "panel command";
                 const raw = err instanceof Error ? err.message : String(err);
-                const stamped = /issued for workflow instance ([0-9a-f-]{36})/i.exec(raw)?.[1] ?? null;
-                const unstamped = /carries no workflow-instance stamp/i.test(raw);
-                // Three-valued on purpose. A panel whose wording matches neither is not
-                // evidence for either state, and this branch must not manufacture one.
-                const shape = unstamped
-                    ? "unstamped"
-                    : stamped
-                        ? "stamped"
-                        : "unstated";
+                // Anchored to the panel's own clause so a message that quotes BOTH
+                // wordings cannot collapse into the missing-stamp state.
+                const stamped = /this command was issued for workflow instance ([0-9a-f-]{36})/i.exec(raw)?.[1] ?? null;
+                const unstamped = /this command carries no workflow-instance stamp/i.test(raw);
+                // Three-valued on purpose. A panel whose wording matches neither — or
+                // both — is not evidence for either state, and this branch must not
+                // manufacture one.
+                const shape = unstamped === Boolean(stamped) ? "unstated" : unstamped ? "unstamped" : "stamped";
                 // Naming `mode:"current"` to a PINNED session is naming something that also
                 // RELEASES the pin. Say so where it applies rather than letting the caller
                 // discover it by losing their target.
@@ -7203,12 +7307,59 @@ export function makePanelToolCtx(bridge, tabId, workflowTargets) {
                         `RELEASES that pin. To keep it, bring that workflow back to the canvas with ` +
                         `panel_open_workflow(${JSON.stringify(pin.path)}) and retry instead.`
                     : "";
-                const RETRY_IS_FREE = `RETRY THIS EXACT CALL ONCE — this is a read, so re-issuing it cannot double-apply ` +
-                    `anything.`;
+                // graph_run is fenced like a read (the panel refuses it before it queues)
+                // but it is not one: GRAPH_CMD_EFFECT lists it as targeted, and calling
+                // it a read would tell the caller a retry cannot double-apply a prompt.
+                const inertRead = GRAPH_CMD_EFFECT[name] === "inert";
+                const RETRY_IS_FREE = inertRead
+                    ? `RETRY THIS EXACT CALL ONCE — this is a read, so re-issuing it cannot double-apply ` +
+                        `anything.`
+                    : `RETRY THIS EXACT CALL ONCE — the panel refused it before it ran, so re-issuing it ` +
+                        `cannot double-apply anything.`;
+                const refusedLead = inertRead
+                    ? `${name} was refused before it ran — no graph data was read.`
+                    : `${name} was refused before it ran — nothing was applied.`;
                 let verdict;
                 try {
                     const probe = await rebindWorkflowFence(ctx, { adopt: false });
                     const live = "uuid" in probe ? probe.uuid : null;
+                    const priorAbsent = "before" in probe && probe.before.known === true && !probe.before.uuid;
+                    const admitUnstampedRead = inertRead && shape === "unstamped" && pin?.mode !== "pinned";
+                    // Mint a first stamp only when this session has none. A fence naming
+                    // some other workflow is the retarget #1646 removed; we do not move it.
+                    if (admitUnstampedRead &&
+                        probe.status === "diverged" &&
+                        priorAbsent &&
+                        typeof live === "string" &&
+                        refreshWorkflowUuid(ctx, { workflow_uuid: live })) {
+                        try {
+                            const retried = ok(await sendRouted(cmd, timeoutMs, observeRid));
+                            if (successProvesSwitchCleared(cmd.cmd))
+                                clearSwitchHold(ctx.tabId);
+                            return retried;
+                        }
+                        catch (retryErr) {
+                            onFailure?.(retryErr);
+                            return fail(retryErr instanceof Error ? retryErr : new Error(String(retryErr)));
+                        }
+                    }
+                    // The fence appeared between dispatch and this probe. Retrying the
+                    // inert read now carries that stamp; nothing is adopted here.
+                    if (admitUnstampedRead &&
+                        (probe.status === "already_current" || probe.status === "healed_by_panel")) {
+                        try {
+                            const retried = ok(await sendRouted(cmd, timeoutMs, observeRid));
+                            if (successProvesSwitchCleared(cmd.cmd))
+                                clearSwitchHold(ctx.tabId);
+                            return retried;
+                        }
+                        catch (retryErr) {
+                            onFailure?.(retryErr);
+                            if (!isWorkflowInstanceMismatch(retryErr)) {
+                                return fail(retryErr instanceof Error ? retryErr : new Error(String(retryErr)));
+                            }
+                        }
+                    }
                     verdict =
                         probe.status === "no_identity"
                             // Worded without reference to the session's own side, because this
@@ -7289,7 +7440,7 @@ export function makePanelToolCtx(bridge, tabId, workflowTargets) {
                             `refusal stands on its own terms and the fence is unchanged. ` +
                             `(${probeErr instanceof Error ? probeErr.message : String(probeErr)})`;
                 }
-                return fail(`${name} was refused before it ran — no graph data was read. ${raw}${verdict}`);
+                return fail(`${refusedLead} ${raw}${verdict}`);
             }
             // #1480 — NAME A REMEDY THE TAB CAN ACTUALLY ACCEPT.
             //
@@ -9534,7 +9685,7 @@ export function buildPanelToolDefs() {
             node_id: nodeId().describe("Node id whose input to disconnect."),
             input: slotRef.optional().describe("Input slot name or index (default 0)."),
         }, async (args, ctx) => ctx.call({ cmd: "graph_disconnect", node_id: args.node_id, input: args.input })),
-        def("panel_set_widget", "Set a widget value on a node in the user's open graph (steps, cfg, seed, ckpt_name, text prompts, …). Returns the previous and new value (a string longer than 1000 chars is echoed as {chars, sha256, preview} so batched calls stay inside the outer tool-result budget — pass `echo: \"full\"` for the verbatim string). Undoable with Ctrl+Z. To CLEAR a text widget to an empty string, pass `clear: true` (some MCP clients drop an empty-string `value` from the serialized payload, so `value: \"\"` may not arrive — `clear: true` always works). For the LTXDirector timeline node (WhatDreamsCost CSGlide), set `timeline_data` with the FULL timeline JSON (segments + global_prompt) to drive its custom timeline UI — this re-syncs the editor and regenerates its derived `local_prompts`/`segment_lengths`/`guide_strength` widgets; setting those derived widgets directly is refused (they are silently reverted).", {
+        def("panel_set_widget", "Set a widget value on a node in the user's open graph (steps, cfg, seed, ckpt_name, text prompts, …). Returns the previous and new value (a string longer than 1000 chars is echoed as {chars, sha256, preview} so batched calls stay inside the outer tool-result budget — pass `echo: \"full\"` for the verbatim string). Undoable with Ctrl+Z. To CLEAR a text widget to an empty string, pass `clear: true` (some MCP clients drop an empty-string `value` from the serialized payload, so `value: \"\"` may not arrive — `clear: true` always works). For the LTXDirector timeline node (WhatDreamsCost CSGlide), set `timeline_data` with the FULL timeline JSON (segments + global_prompt) to drive its custom timeline UI — this re-syncs the editor and regenerates its derived `local_prompts`/`segment_lengths`/`guide_strength` widgets; setting those derived widgets directly is refused (they are silently reverted). For AnimaRegionalCanvasInline / Krea2RegionalCanvasInline (LC123), quality/scene/red/green/blue/negative prompt writes are refused: the custom textarea and node.properties.animaPrompts overwrite widget.value on APPLY. Drive quality/scene/negative via a PrimitiveStringMultiline wired into quality_prompt_in / scene_prompt_in / negative_prompt_in; red/green/blue have no socket.", {
             node_id: nodeId().describe("Node id from panel_graph_outline / panel_query_graph."),
             widget: z.string().describe("Widget name (e.g. 'steps', 'cfg', 'text')."),
             value: z
@@ -9557,6 +9708,14 @@ export function buildPanelToolDefs() {
             if (value === undefined) {
                 return fail("panel_set_widget needs a `value`. To set an empty string, pass `clear: true` (some clients drop an empty-string `value`).");
             }
+            // #1658: LC123 regional-canvas prompt widgets store the text in a
+            // custom textarea + node.properties.animaPrompts; writing widget.value
+            // reports success and is overwritten on APPLY. Refuse before the write
+            // so the reply is not a lie. Identity is a one-node graph_query; an
+            // unreadable probe is fail-open (some other node may own negative_prompt).
+            const blocked = await refuseAnimaRegionalPromptWrite(ctx, args.node_id, args.widget);
+            if (blocked)
+                return blocked;
             // #599: the frontend runs refresh-before-validate here (pulls a fresh
             // /object_info so a just-staged/-downloaded/-installed value is accepted on
             // a single revalidation, #338/#458) — that authoritative fetch can outlast
@@ -10032,8 +10191,49 @@ export function buildPanelToolDefs() {
             // panel forwarded no `prompt_id` — a later completion can only be reported as
             // UNDETERMINED, so telling the agent to idle and wait would park it on a
             // promise we can't keep. Say so and point at the verification path instead.
+            // #1789 — …AND HONEST ABOUT WHAT "AUTOMATICALLY" RESTS ON. The old text
+            // forbade polling outright on the strength of `correlatable`, which
+            // proves only that a completion COULD be recognised — never that one
+            // will arrive. The producer is the panel's `executed` frame, and a
+            // session that lost it sat idle through a clean 28.77s render until a
+            // human intervened, because the one behaviour that would have caught it
+            // in seconds is the one this rider had banned.
+            //
+            // Delivery is now genuinely stronger (the orchestrator fills in from its
+            // own /history observation — run-completion-watchdog.ts), but it is
+            // still not a guarantee this tool can prove at queue time: the watchdog
+            // sees nothing when the monitored ComfyUI is not the one this run went
+            // to, or cannot be polled. So the anti-poll instruction stays PRIMARY —
+            // it is what keeps an agent from burning a turn a second — and it is
+            // paired with a bounded escape hatch: ONE check, long after the render
+            // should have landed, naming the prompt id so it costs a single call.
+            // A weaker promise with a stated fallback beats a strong one that fails
+            // into an infinite idle.
+            // THE REMEDY MUST BE A CALL THAT ACTUALLY RUNS (gate NO-SHIP on the first
+            // cut of this fix). Naming no id for a batch was right — inventing one
+            // would point the agent at a single arbitrary member — but the remedy it
+            // left behind, `queue (action:"status")` with no id, is REFUSED by the
+            // tool: queue-management.ts's requirePromptId throws on an absent
+            // prompt_id, so the agent that obeyed this fallback got an error instead
+            // of a status. That is the reported bug's own shape, one level in: a
+            // rider promising something the code declines to do. Verified live
+            // against the real handler — `status` + id and bare `list` both return
+            // JSON; bare `status` returns isError with "requires `prompt_id`".
+            //
+            // So the two branches get the call that fits what they can name:
+            //   • exactly one id  → status on THAT run, the precise answer;
+            //   • a batch         → list, which takes no id and shows whether any of
+            //                       them are still in flight (get_history settles the
+            //                       outcomes once they are not).
+            const fallbackCheck = queuedIds.length === 1
+                ? `queue (action:"status", prompt_id:"${queuedIds[0]}")`
+                : `queue (action:"list")`;
+            const fallbackTail = queuedIds.length === 1
+                ? ""
+                : ` (this run queued ${queuedIds.length} prompts, so the check is the queue as a whole; get_history settles the outcome of any that are no longer in flight)`;
             const note = correlatable
-                ? "\n\n[IMPORTANT] You will be notified automatically with the output image(s)/video when the render finishes — do NOT poll queue (action:\"list\"), get_history, or get_image (action:\"list_outputs\"). Just end your turn now and wait for the result to be delivered to you."
+                ? "\n\n[IMPORTANT] You will be notified automatically with the output image(s)/video when the render finishes — do NOT poll queue (action:\"list\"), get_history, or get_image (action:\"list_outputs\"). Just end your turn now and wait for the result to be delivered to you." +
+                    `\n[FALLBACK] That notification is journaled and replayed if an agent is not there to take it, and the orchestrator will fill one in from ComfyUI itself — its execution event or its history record — if the panel never reports the finish. But it cannot be GUARANTEED, so do not wait forever on it. If nothing has arrived LONG after this render should have finished (roughly twice the time you expect it to take), make ONE check with ${fallbackCheck} instead of idling indefinitely${fallbackTail}. One check, not a loop — and not before then.`
                 : "\n\n[IMPORTANT] The run was queued, but the panel reported NO prompt id for it, so a completion event CANNOT be correlated back to this run — its outcome will be reported to you as UNDETERMINED. Do NOT simply idle and wait indefinitely: end your turn, and if nothing arrives, confirm the outcome with get_history (action:\"list\") before acting on it.";
             // Backpressure note. A backlog is only alarming when it's a job we did NOT
             // queue (possibly foreign/stuck). Deliberately batching renders — a sweep,