comfyui-mcp 0.48.26 → 0.48.28

package/dist/orchestrator/panel-tools.js

@@ -222,6 +222,17 @@ function sleep(ms) {
 // settle. Mutating graph edits (add_node/connect/set_widget/…) are deliberately
 // EXCLUDED — re-issuing them could double-apply — so they keep surfacing the
 // bridge's honest OUTCOME-UNKNOWN error.
+// #599: commands whose FRONTEND handler intentionally awaits a fresh /object_info
+// re-register before it can reply — the refresh-before-validate path in
+// graph_set_widget (#338/#458) and graph_add_node (#289/#458), and the explicit
+// forced node-def refresh in refresh_nodes (#608). On a large install with many
+// custom-node packs a legitimate /object_info fetch can take longer than the
+// bridge's 6000 ms DEFAULT ack window, so the panel replies late and the tool
+// returns a FALSE "tab did not reply" timeout even though the write is valid and
+// in progress. Give these a larger BOUNDED ack budget so a slow-but-valid refresh
+// is not mistaken for a dead tab — still capped (never Infinity) so a genuinely
+// frozen/backgrounded tab fails in bounded time instead of hanging forever.
+const OBJECT_INFO_REFRESH_ACK_TIMEOUT_MS = 30_000;
 const RETRY_SAFE_CMDS = new Set([
     // Idempotent reads (mirror UiBridge.READONLY_CMDS + list/status probes).
     "graph_serialize",
@@ -237,6 +248,10 @@ const RETRY_SAFE_CMDS = new Set([
     "node_queue_status",
     // Idempotent full-replace UI state — re-sending the same list is a no-op (#481).
     "set_todo",
+    // #608: a forced /object_info re-register + combo refresh. Non-destructive and
+    // idempotent (re-running just re-fetches the current defs), so a dropped
+    // transport can safely re-issue it once.
+    "refresh_nodes",
 ]);
 /** A command whose result is unchanged by being re-issued after a reconnect —
  *  so it is safe to transparently retry once when the transport dropped. */
@@ -244,6 +259,57 @@ function isRetrySafeCmd(cmd) {
     const name = typeof cmd.cmd === "string" ? cmd.cmd : "";
     return RETRY_SAFE_CMDS.has(name);
 }
+// Graph-EDIT mutations that CHANGE the user's canvas (undoable edits). These are
+// the #436 bug surface: a real side effect the bridge will NOT auto-retry, so —
+// unlike a read — such a command can be neither parked mid-command nor retried
+// once, and firing it into the post-restart "Connected: none" window fails with
+// "no connected tab". It must await a stable binding BEFORE dispatch.
+//
+// This is an EXPLICIT ALLOWLIST, deliberately NOT "everything not read-only":
+// several genuine reads/probes/views that flow through ctx.call are absent from
+// BRIDGE_READONLY_CMDS (e.g. graph_list_subgraphs, training_get_state,
+// graph_canvas, graph_screenshot), so an exclusion rule would wrongly make THOSE
+// wait out the reconnect budget. Under-inclusion here is at worst an unfixed edge
+// (a command keeps today's behavior); over-inclusion would regress a read — so we
+// list only commands that unambiguously mutate the graph. Keep in sync when new
+// graph-edit tools are added (mirrors the RETRY_SAFE_CMDS maintenance model).
+const MUTATING_GRAPH_EDIT_CMDS = new Set([
+    "graph_add_node",
+    "graph_remove_node",
+    "graph_clear",
+    "graph_connect",
+    "graph_disconnect",
+    "graph_set_widget",
+    "graph_move_node",
+    "graph_resize_node",
+    "graph_set_title",
+    "graph_set_node_mode",
+    "graph_set_node_color",
+    "graph_set_node_collapsed",
+    "graph_update_node",
+    "graph_create_group",
+    "graph_edit_group",
+    "graph_remove_group",
+    "graph_move_group",
+    "graph_create_subgraph",
+    "graph_add_subgraph",
+    "graph_save_subgraph",
+    "graph_unpack_subgraph",
+    "graph_subgraph_group",
+    "graph_expose_subgraph_input",
+    "graph_expose_subgraph_output",
+    "graph_promote_widget",
+    "graph_move_rail",
+    "graph_paste_nodes",
+    "graph_auto_layout",
+    "graph_load",
+]);
+/** A MUTATING graph edit that must await a stable tab binding before dispatch so
+ *  it never fires into the post-restart "Connected: none" window (#436). */
+function isMutatingGraphCmd(cmd) {
+    const name = typeof cmd.cmd === "string" ? cmd.cmd : "";
+    return MUTATING_GRAPH_EDIT_CMDS.has(name);
+}
 /** True when an error is a TRANSIENT transport/reconnect drop (the tab went away
  *  or was replaced), NOT a genuine command error or a live-but-frozen reply
  *  timeout. Deliberately EXCLUDES "did not reply within N ms" (a backgrounded/
@@ -1525,6 +1591,21 @@ export function makePanelToolCtx(bridge, tabId, workflowTargets) {
     };
     const call = async (cmd, timeoutMs) => {
         try {
+            // #436: a MUTATING graph edit must not fire into the "Connected: none"
+            // window a ComfyUI restart/reload opens. A read survives that window (it is
+            // parked mid-command and is retry-safe), but a mutating edit is NEITHER — so
+            // panel_graph_outline succeeds while the very next panel_add_node hits
+            // resolveTarget's momentarily-empty registry and fails with
+            // "no connected tab … Connected: none" (the flap). Await a stable binding
+            // BEFORE dispatch — nothing is sent during the wait, so there is no
+            // double-apply risk — exactly as workflow_open/save already do. This returns
+            // INSTANTLY for a healthy session and only waits in the zero-tab window; the
+            // read path (parking + retry-once below) is left exactly as-is. A wait that
+            // times out unreached still falls through to sendRouted, whose authoritative
+            // dispatched:false surfaces the actionable "nothing applied — rebind" message.
+            if (isMutatingGraphCmd(cmd)) {
+                await awaitReachable();
+            }
             ensureReachable();
             return ok(await sendRouted(cmd, timeoutMs));
         }
@@ -1552,6 +1633,33 @@ export function makePanelToolCtx(bridge, tabId, workflowTargets) {
                     return fail(err2);
                 }
             }
+            // #442 defect 4: a MUTATING command (deliberately excluded from RETRY_SAFE_CMDS)
+            // that the bridge refused BEFORE any socket write surfaced the bare routing error
+            // ("no connected tab … Connected: none") with no recovery path — whereas a
+            // retry-safe read like graph_get_errors, via the branch above, names the rebind.
+            // That asymmetry made a brief post-reconnect read/edit-channel disagreement look
+            // like a dead agent (panel_list_workflows kept answering while panel_set_widget
+            // failed, in a multi-tab session the strict-single silent auto-heal won't touch).
+            // We must NOT retry the mutating command (double-apply risk), but the bridge's
+            // AUTHORITATIVE typed flag proves nothing was dispatched (dispatchOutcomeOf ===
+            // false) — so it is safe to state nothing was applied and name the rebind recovery,
+            // preserving the raw cause. Keying on the TYPED flag (not error text) means a
+            // POST-dispatch executor ok:false reply that merely quotes "no connected tab" is
+            // never mis-wrapped as "nothing applied".
+            if (dispatchOutcomeOf(err) === false) {
+                const name = typeof cmd.cmd === "string" ? cmd.cmd : "panel command";
+                // Neutral wording: a dispatched:false flag proves only that the command was NOT
+                // dispatched — it can be a routing refusal (the bound tab is gone / reconnecting),
+                // an ambiguous-or-multiple-tab resolver refusal (other tabs DO exist), or a socket
+                // write failure. All share the same TRUE facts (nothing applied) and the same
+                // recovery (rebind onto the tab that's live now); the raw cause carries the
+                // specifics. Do NOT overstate "disconnected", which is false for the ambiguity case.
+                return fail(`${name} could not be dispatched to this session's panel tab — nothing was applied. ` +
+                    `The tab may be disconnected, still reconnecting after a restart/reload, or the ` +
+                    `session's binding is stale (e.g. another workflow tab is now active). Retry in a ` +
+                    `moment, or rebind with panel_set_workflow_target({mode:"current"}) to follow the ` +
+                    `tab that's live now. (${err instanceof Error ? err.message : String(err)})`);
+            }
             return fail(err);
         }
     };
@@ -2130,7 +2238,12 @@ 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) => ctx.call({ cmd: "graph_add_node", class_type: args.class_type, pos: args.pos, title: args.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)),
         def("panel_remove_node", "Remove a node (and its connections) from the user's open graph by id. Undoable with Ctrl+Z.", { node_id: z.number().int().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");
@@ -2360,7 +2473,12 @@ 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`).");
             }
-            return ctx.call({ cmd: "graph_set_widget", node_id: args.node_id, widget: args.widget, value });
+            // #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
+            // the 6000 ms default ack on a large install and return a FALSE timeout.
+            // Give the guarded write the bounded refresh ack budget.
+            return ctx.call({ cmd: "graph_set_widget", node_id: args.node_id, widget: args.widget, value }, OBJECT_INFO_REFRESH_ACK_TIMEOUT_MS);
         }),
         def("panel_move_node", "Move a node to a new canvas position [x, y] in the user's open graph. Undoable.", {
             node_id: z.number().int().describe("Node id from panel_graph_outline / panel_query_graph."),
@@ -2492,6 +2610,11 @@ export function buildPanelToolDefs() {
             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) => ctx.call({ cmd: "graph_get_errors" })),
+        def("panel_refresh_nodes", "Re-pull the live ComfyUI server's /object_info and rebuild every combo/loader option list in the user's open tab, so an asset that appeared server-side AFTER the tab loaded becomes SELECTABLE without a manual reload (the 'press R' step) or a restart. Use this right after stage_output_as_input (chaining a stage's output into a LoadImage / VHS_LoadVideo / LoadAudio loader — the returned filename won't be in the loader's dropdown until you refresh), after downloading a model / LoRA / VAE (a freshly downloaded file is otherwise 'not a valid option' in its loader), or after installing a node pack. Then panel_set_widget / panel_add_node will accept the new value. Non-destructive: it only re-registers node defs and refreshes combo option lists — it does NOT change your graph and is undo-neutral. Idempotent (safe to call repeatedly). Returns whether the refresh authoritatively fetched fresh defs.", {}, async (_args, ctx) => 
+        // Same bounded ack budget as the refresh-before-validate writes (#599): a
+        // fresh /object_info on a large install routinely exceeds the 6000 ms
+        // default, and this command's WHOLE purpose is to await that fetch.
+        ctx.call({ cmd: "refresh_nodes" }, OBJECT_INFO_REFRESH_ACK_TIMEOUT_MS)),
         def("panel_reload", "Soft-reload yourself to pick up code changes WITHOUT restarting ComfyUI — your chat session resumes automatically and you'll be nudged to continue. Use scope 'orchestrator' (default) after backend/orchestrator code changed (new tools, system prompt, services); use scope 'frontend' after the panel UI (web JS/CSS) changed. This ENDS the current turn — your tools/prompt are reloaded and you continue fresh. For custom-node or model changes that need a full ComfyUI restart, use panel_restart_comfyui instead. Only call this when code has actually changed and needs to take effect now.", {
             scope: z
                 .enum(["orchestrator", "frontend"])
@@ -2514,9 +2637,14 @@ export function buildPanelToolDefs() {
                 // Count only INTERACTIVE (canvas-owning) tabs for the ambiguity guard: one
                 // desktop canvas alongside headless viewers is NOT ambiguous — rebindToActiveTab
                 // binds the sole desktop tab. Only 2+ real canvas tabs are unpickable here.
-                const headless = ctx.bridge.isHeadless;
-                const interactive = Array.isArray(live) && typeof headless === "function"
-                    ? live.filter((t) => !headless(t.tab_id))
+                // Call isHeadless THROUGH the bridge (not an extracted reference): it is a
+                // plain method that reads `this.conns` — invoking a detached `const headless
+                // = ctx.bridge.isHeadless` loses `this`, so `this.conns` throws "Cannot read
+                // properties of undefined (reading 'conns')" and panel_reload fails outright
+                // (panel #478). Mirror the bound `isHeadlessTab` helper used elsewhere here.
+                const isHeadlessTab = (id) => typeof ctx.bridge.isHeadless === "function" && ctx.bridge.isHeadless(id);
+                const interactive = Array.isArray(live)
+                    ? live.filter((t) => !isHeadlessTab(t.tab_id))
                     : live;
                 if (orphaned && Array.isArray(interactive) && interactive.length > 1) {
                     return fail("This session's ComfyUI tab was replaced and multiple tabs are now open — " +
@@ -2984,9 +3112,11 @@ export function buildPanelToolDefs() {
                     if (Array.isArray(live)) {
                         // Count only INTERACTIVE (canvas-owning) tabs: a headless-only reconnect is
                         // NOT a usable graph binding, so it defers (binds once a real canvas tab
-                        // connects) rather than failing as if a tab were pickable.
-                        const headless = ctx.bridge.isHeadless;
-                        const interactive = typeof headless === "function" ? live.filter((t) => !headless(t.tab_id)) : live;
+                        // connects) rather than failing as if a tab were pickable. Call isHeadless
+                        // THROUGH the bridge (it reads `this.conns`) — a detached reference would
+                        // lose `this` and throw "reading 'conns'" (the same #478 unbound-method bug).
+                        const isHeadlessTab = (id) => typeof ctx.bridge.isHeadless === "function" && ctx.bridge.isHeadless(id);
+                        const interactive = live.filter((t) => !isHeadlessTab(t.tab_id));
                         noTabsConnected = interactive.length === 0;
                     }
                     else {