comfyui-mcp 0.51.4 → 0.51.5

package/dist/orchestrator/node-id.js

@@ -0,0 +1,69 @@
+/**
+ * #1425 — the wire contract for a node id, including the SUBGRAPH-QUALIFIED shape.
+ *
+ * #845 made the tools accept back an id they had printed: the graph readers return
+ * ids as strings (`"42"`), so `"42"` and `42` both had to mean node 42. That change
+ * deliberately stopped short of `"5:12"`:
+ *
+ *   > a subgraph-qualified id is a real shape in newer ComfyUI, and silently
+ *   > truncating it to `5` would target the WRONG node rather than fail. If those
+ *   > need supporting, that is a separate, deliberate change to the wire contract.
+ *
+ * This is that change. Unpacking a subgraph leaves genuine ROOT-level nodes carrying
+ * ids like `120:104` and `120:113:78`; the readers list them and render them, and
+ * every write tool refused them — 18 of 21 nodes uneditable in the reporter's
+ * workflow. So the refusal was not protecting anything by then, it was just the
+ * conservative half of a trade whose other half never arrived.
+ *
+ * The two halves have to move TOGETHER. Widening the pattern alone would send
+ * `"263:78"` through `Number.parseInt(…, 10)` and yield `263` — turning a loud
+ * refusal into a silent edit of a DIFFERENT node, which is the exact outcome #845
+ * 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 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
+ * deep case in exactly the way this fixes the shallow one. Only the FIRST segment
+ * may be negative: a leading `-` marks the boundary-rail ids the readers emit, and
+ * a `-` inside a path would be a shape nothing produces.
+ */
+const QUALIFIED = /^-?\d+(?::\d+)+$/;
+/**
+ * Both spellings in ONE pattern, so it can be handed to `z.string().regex()`.
+ *
+ * That matters beyond tidiness: `.regex()` puts a `pattern` on the advertised MCP
+ * input schema, while `.refine()` renders as a bare `{"type":"string"}` (measured
+ * with zod 4's toJSONSchema). Validating through a refine would therefore have told
+ * every client LESS about a node id than the old integer-only rule did.
+ */
+export const NODE_ID_PATTERN = /^-?\d+(?::\d+)*$/;
+/** Does this string name a node at all — either spelling? */
+export function isNodeIdString(v) {
+    return NODE_ID_PATTERN.test(v);
+}
+/** True for the qualified form specifically (`"5:12"`), false for `"5"`. */
+export function isQualifiedNodeId(v) {
+    return QUALIFIED.test(v);
+}
+/**
+ * Normalize an accepted id to what goes on the wire.
+ *
+ * A plain id becomes the NUMBER the panel has always received, so nothing about
+ * the existing surface changes. A qualified id is returned VERBATIM — parsing it
+ * is precisely the bug. Callers must therefore treat a node id as `number | string`
+ * rather than assuming the number.
+ */
+export function normalizeNodeId(v) {
+    if (typeof v === "number")
+        return v;
+    if (QUALIFIED.test(v))
+        return v;
+    return Number.parseInt(v, 10);
+}
+/** The message a rejected id gets. Names the qualified shape explicitly, because a
+ *  caller holding `263:78` needs to know whether it is unsupported or malformed. */
+export const NODE_ID_MESSAGE = "a node id must be an integer (e.g. 42) or a subgraph-qualified id (e.g. 120:104)";
+//# sourceMappingURL=node-id.js.map

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

@@ -0,0 +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"}

package/dist/orchestrator/panel-tools.js

@@ -37,6 +37,7 @@ import { nodesInstallCommandArgs } from "../services/node-management.js";
 import { createSdkMcpServer, tool } from "@anthropic-ai/claude-agent-sdk";
 import { parse as parseYaml } from "yaml";
 import { conversationOfScopeAddress, isScopeAddress, shortTabId } from "../services/session-scope.js";
+import { NODE_ID_MESSAGE, NODE_ID_PATTERN, normalizeNodeId } from "./node-id.js";
 /** #884 — journal TICKETS (run completions #468, ask answers #486) must be
  *  keyed by the REAL tab a run/card was routed to: the panel reports back under
  *  that tab id, and a ticket keyed by the shared scope address a tool ctx is
@@ -6458,14 +6459,22 @@ function validatePanelEditNodeArgs(args) {
  * Nothing about `"42"` is ambiguous. Accept both spellings and normalize to the
  * number the wire has always carried, so the round trip closes.
  *
- * DELIBERATELY STRICT about what counts as a node id: only an integer, or a
- * string that is exactly an integer. `"42px"`, `"4.5"`, `""` and `"5:12"` are
- * still rejected. The last one matters — a subgraph-qualified id is a real
- * shape in newer ComfyUI, and silently truncating it to `5` would target the
- * WRONG node rather than fail. If those need supporting, that is a separate,
- * deliberate change to the wire contract, not something to fall out of a coerce.
+ * STRICT about what counts as a node id: an integer, a string that is exactly an
+ * integer, or a subgraph-qualified id (`"120:104"`). `"42px"`, `"4.5"` and `""`
+ * are still rejected.
+ *
+ * #1425 added the qualified shape — the "separate, deliberate change to the wire
+ * contract" this comment used to defer. Unpacking a subgraph leaves genuine ROOT
+ * nodes carrying those ids, the readers hand them out, and every write tool
+ * refused them. Crucially the qualified form is NOT parsed to a number: see
+ * node-id.ts, where truncating `"263:78"` to `263` would edit the wrong node.
  */
-const nodeId = () => z.union([z.number().int(), z.string().regex(/^-?\d+$/, "a node id must be an integer")]).transform((v) => (typeof v === "number" ? v : Number.parseInt(v, 10)));
+const nodeId = () => z
+    .union([
+    z.number().int(),
+    z.string().regex(NODE_ID_PATTERN, NODE_ID_MESSAGE),
+])
+    .transform(normalizeNodeId);
 /**
  * #845 — which `panel_canvas` arguments the chosen action actually consumes.
  *