comfyui-mcp 0.52.160 → 0.52.162

package/dist/orchestrator/panel-tools.js

@@ -47,6 +47,7 @@ import { isPreExecutorRefusal } from "../services/panel-refusal.js";
 import { hostLinksAlreadyReindexed, isLandedUnexpose, laterSlotsAfterUnexpose, laterSlotsFromUnexposePayload, unexposeHostLinkShiftNote, } from "../services/unexpose-host-link-shift.js";
 import { retryConnectAgainstLiveGraph } from "../services/connect-live-graph.js";
 import { verifyPrimitiveForceInputAfterConnect } from "../services/primitive-force-input-connect.js";
+import { retryWildcardSlotConnect } from "../services/wildcard-slot-connect.js";
 import { retryExposeSubgraphInput } from "../services/expose-ae-wildcard.js";
 import { applyLiveRootViewing, callAndRememberViewing, callWithRememberedSubgraph, clearStaleSubgraphIdentity, noteConfirmedViewingFromToolResult, parseViewingScope, } from "../services/subgraph-viewing-scope.js";
 import { assertScreenshotPersistAllowed, decodePngBase64, persistScreenshotPng, resolveScreenshotPersistPath, screenshotOverwriteFromArgs, screenshotPersistPathFromArgs, } from "./panel-screenshot-persist.js";
@@ -66,6 +67,7 @@ import { includeRequestedCreateGroupMembers } from "./create-group-membership.js
 import { sizeForUncollapse } from "./edit-node-uncollapse.js";
 import { fastGroupsFilterPropertyNote, isFastGroupsFilterProperty, } from "./rgthree-fast-groups-property.js";
 import { bindImportedTmpWorkflowUuid, bindLoadedWorkflowIdentity, isPlainObject, isStampMismatchSaveRefusal, openLiveMatchesDestAfterReconnect, openLiveMatchesDestContent, patchOpenIdentity, savedPathFromTabId, shouldRebindOpenIdentity, unsavedTmpWorkflowKey, workflowFromSerializeReply, } from "./open-identity-normalization.js";
+import { contentOnlyRootShapeReadNote, isContentOnlyRootShapeMismatch, recoverContentOnlyGraphQuery, } from "./root-shape-mismatch.js";
 import { clearSwitchHold, describeSwitchHold, recordSwitchHold, successProvesSwitchCleared, } from "./switch-hold.js";
 import { NO_ORIGIN_REMEDY } from "./fence-refusal.js";
 import { completeGetErrorsAudit } from "./get-errors-audit.js";
@@ -5109,6 +5111,120 @@ function stripVerifiedLastObservedSchemaNote(res) {
     delete next.schema_source;
     return rewriteToolResultJson(res, next);
 }
+// ---- #2545: MiniMaxH3Director duration onValueChange write_warning ----------
+// The panel assigns duration, verifies the value, then invokes the widget
+// callback. ComfyUI's settingStore onValueChange throws
+// `Cannot read properties of undefined (reading 'options')` when editor/options
+// is missing. That throw is a post-write disclosure, not a failed assignment.
+// Relaying it as isError (or leaving write_warning as the salient failure)
+// makes a landed 5→6 write look like a retryable error.
+function isDirectorDurationCallbackWarning(widget, text) {
+    if (widget.toLowerCase() !== "duration")
+        return false;
+    if (!/reading ['"]options['"]/.test(text))
+        return false;
+    return /onValueChange|settingStore|widget_callback/i.test(text);
+}
+function scalarWidgetValuesMatch(requested, observed) {
+    if (Object.is(requested, observed))
+        return true;
+    if ((typeof requested === "number" || typeof requested === "string") &&
+        (typeof observed === "number" || typeof observed === "string")) {
+        return String(requested) === String(observed);
+    }
+    return false;
+}
+function recordFromUnknown(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return null;
+    return value;
+}
+function parseJsonObjectFromToolText(res) {
+    const parsed = parseToolResultJson(res);
+    if (parsed)
+        return parsed;
+    const text = res?.content?.find((c) => c.type === "text")?.text;
+    if (typeof text !== "string")
+        return null;
+    const trimmed = text.replace(/^Error:\s*/i, "").trim();
+    const start = trimmed.indexOf("{");
+    if (start < 0)
+        return null;
+    try {
+        return recordFromUnknown(JSON.parse(trimmed.slice(start)));
+        // unknown-ok: the reply is not JSON; keep the original widget-write result.
+    }
+    catch {
+        return null;
+    }
+}
+function stripWriteWarningFields(record) {
+    const next = { ...record };
+    delete next.write_warning;
+    delete next.write_warning_frame;
+    delete next.write_warning_source;
+    return next;
+}
+function landedDurationWriteResult(payload, set) {
+    const next = payload
+        ? stripWriteWarningFields({ ...payload, set: stripWriteWarningFields(set) })
+        : { set: stripWriteWarningFields(set) };
+    return ok(next);
+}
+async function readNamedWidgetValue(ctx, nodeId, widget) {
+    const probe = await ctx.call({
+        cmd: "graph_query",
+        ids: [nodeId],
+        fields: "detail",
+        limit: 1,
+        max_chars: DYNAMIC_COMBO_PROBE_MAX_CHARS,
+    }, 8000);
+    if (probe.isError)
+        return undefined;
+    const detail = parseVerifiedQueriedNodeDetail(normalizeGraphQueryResult(probe));
+    const requestedId = canonicalQueriedNodeId(nodeId);
+    if (!detail || !requestedId || detail.id !== requestedId || !detail.widgets) {
+        return undefined;
+    }
+    if (!Object.prototype.hasOwnProperty.call(detail.widgets, widget))
+        return undefined;
+    return detail.widgets[widget];
+}
+/**
+ * #2545 — a verified Director duration write whose setting-store callback
+ * threw is still a landed write. Swallow that write_warning when `set.value`
+ * matches the request; if the panel reported it as an error without a set
+ * envelope, one graph_query may prove the value. Anything else stays failed.
+ */
+async function classifyLandedDirectorDurationWriteWarning(ctx, res, nodeId, widget, requested) {
+    const text = textOfToolResult(res);
+    const payload = parseJsonObjectFromToolText(res);
+    const set = recordFromUnknown(payload?.set);
+    const warningText = [
+        typeof set?.write_warning === "string" ? set.write_warning : "",
+        typeof set?.write_warning_frame === "string" ? set.write_warning_frame : "",
+        typeof set?.write_warning_source === "string" ? set.write_warning_source : "",
+        text,
+    ].join("\n");
+    if (!isDirectorDurationCallbackWarning(widget, warningText))
+        return res;
+    if (set && scalarWidgetValuesMatch(requested, set.value)) {
+        return landedDurationWriteResult(payload, set);
+    }
+    if (!res.isError)
+        return res;
+    const observed = await readNamedWidgetValue(ctx, nodeId, widget);
+    if (observed === undefined || !scalarWidgetValuesMatch(requested, observed)) {
+        return res;
+    }
+    return ok({
+        set: {
+            node_id: nodeId,
+            widget,
+            value: observed,
+        },
+    });
+}
 async function exitSubgraphLevels(ctx, count) {
     const failures = [];
     for (let i = 0; i < count; i++) {
@@ -15872,6 +15988,30 @@ export function buildPanelToolDefs() {
                     ? {}
                     : { widget_max_chars: widgetMaxChars.value }),
             }, (cmd, timeoutMs) => ctx.call(cmd, timeoutMs));
+            // #2544 — content-only [root-shape-mismatch] after custom-widget / builder
+            // edits (same node count, unsaved live canvas). Inspect the live graph
+            // read-only. Never open or rebind: that would discard the builder work.
+            if (panelReply.isError && isContentOnlyRootShapeMismatch(toolResultText(panelReply))) {
+                const recovered = await recoverContentOnlyGraphQuery((cmd, timeoutMs) => ctx.call(cmd, timeoutMs), {
+                    types: args.types,
+                    title: args.title,
+                    where: args.where,
+                    ids: args.ids,
+                    upstream_of: args.upstream_of,
+                    downstream_of: args.downstream_of,
+                    depth: args.depth,
+                    fields: args.fields,
+                    group_by: args.group_by,
+                    limit: args.limit,
+                    max_chars: args.max_chars,
+                });
+                if (recovered) {
+                    const recoveredReply = ok(recovered);
+                    rememberLiveRootViewing(ctx, recovered.viewing);
+                    return fitQueryGraphReply(recoveredReply, args.max_chars, widgetMaxChars.note ?? legacyWidgetMaxCharsNote(recoveredReply, widgetMaxChars.value));
+                }
+                return fail(contentOnlyRootShapeReadNote(toolResultText(panelReply)));
+            }
             rememberLiveRootViewing(ctx, parseToolResultJson(panelReply)?.viewing);
             return fitQueryGraphReply(panelReply, args.max_chars, widgetMaxChars.note ?? legacyWidgetMaxCharsNote(panelReply, widgetMaxChars.value));
         }),
@@ -16618,7 +16758,7 @@ export function buildPanelToolDefs() {
                 return fail(err);
             }
         }),
-        def("panel_connect", "Connect an output slot of one node to an input slot of another in the user's open graph. Slots accept a name ('MODEL', 'samples') or numeric index. If both slot args are omitted the panel picks the first type-compatible pairing. On failure the error lists every slot with its type and [connected] flag — re-check with panel_query_graph ({ids:[node_id], fields:'detail'}). A frontend PrimitiveNode only serializes through a target widget; connecting one to a forceInput-only / non-widget STRING is refused (panel_run would omit the required input) — use a backend STRING producer such as PrimitiveStringMultiline instead. Undoable.", {
+        def("panel_connect", "Connect an output slot of one node to an input slot of another in the user's open graph. Slots accept a name ('MODEL', 'samples') or numeric index. If both slot args are omitted the panel picks the first type-compatible pairing. On failure the error lists every slot with its type and [connected] flag — re-check with panel_query_graph ({ids:[node_id], fields:'detail'}). LiteGraph wildcard-to-wildcard (`*` → `*`) pairings are compatible (a PrimitiveNode 'connect to widget input' output can land on LogicIF.when_true / when_false so the primitive becomes typed from the destination). A frontend PrimitiveNode only serializes through a target widget; connecting one to a forceInput-only / non-widget STRING is refused (panel_run would omit the required input) — use a backend STRING producer such as PrimitiveStringMultiline instead. Undoable.", {
             from_node_id: nodeId().describe("Source node id."),
             from_output: slotRef
                 .optional()
@@ -16651,7 +16791,8 @@ export function buildPanelToolDefs() {
             };
             const call = (cmd, timeoutMs) => ctx.call(cmd, timeoutMs);
             const connected = await retryConnectAgainstLiveGraph(connectArgs, call);
-            return verifyPrimitiveForceInputAfterConnect(connectArgs, connected, call);
+            const afterWildcard = await retryWildcardSlotConnect(connectArgs, connected, call);
+            return verifyPrimitiveForceInputAfterConnect(connectArgs, afterWildcard, call);
         }),
         def("panel_disconnect", "Disconnect an input slot of a node in the user's open graph. Undoable with Ctrl+Z.", {
             node_id: nodeId().describe("Node id whose input to disconnect."),
@@ -16785,14 +16926,15 @@ export function buildPanelToolDefs() {
                     mutationId = rid;
                 }, beforeDispatch);
                 const echoed = stripVerifiedLastObservedSchemaNote(summarizeSetWidgetEcho(written, echoFull));
+                const classified = await classifyLandedDirectorDurationWriteWarning(ctx, echoed, nodeId, widget, value);
                 // #2495 — ONLY a tagged no-reply on a named Power Lora row is settled
                 // by a read. An acked executor error is a definite outcome.
-                if (isReplyTimeoutResult(echoed) &&
+                if (isReplyTimeoutResult(classified) &&
                     isPowerLoraDynamicRowWidget(widget) &&
                     args.defer_until_idle !== true) {
-                    return settlePowerLoraWidgetAfterAckTimeout(ctx, echoed, nodeId, widget, value, mutationId, dispatchTab);
+                    return settlePowerLoraWidgetAfterAckTimeout(ctx, classified, nodeId, widget, value, mutationId, dispatchTab);
                 }
-                return echoed;
+                return classified;
             };
             let writePromotedInner;
             const guardedWrite = async (nodeId, widget, targetExpectedNodeType = expectedNodeType) => {