comfyui-mcp 0.52.91 → 0.52.93

package/dist/orchestrator/panel-tools.js

@@ -27,13 +27,13 @@ import { createHash, randomUUID } from "node:crypto";
 // #873 — the operator's tool-surface policy also governs the panel surface.
 import { resolveToolSurfacePolicy, toolActionPolicyError, toolAllowed, } from "../tools/tool-surface-filter.js";
 import { logger as toolPolicyLogger } from "../utils/logger.js";
-import { existsSync, readdirSync, readFileSync, realpathSync, statSync } from "node:fs";
+import { existsSync, lstatSync, readdirSync, readFileSync, realpathSync, statSync } from "node:fs";
 import { forwardedByReferenceNote, oversizedInlineRefusal, resolveServableViewRef, stageFileIntoServedDir, stagedForDisplayNote, readShowMediaAck, unaccountedShowMediaNote, unverifiedViewRefNote, } from "../services/comfy-view-ref.js";
 import { extname, isAbsolute, join, resolve, sep } from "node:path";
 import { fileURLToPath } from "node:url";
 import { comfyuiFetch } from "../comfyui/fetch.js";
 import { assertPanelNotTargetedUnverifiable } from "../services/panel-pin-guard.js";
-import { nodesInstallCommandArgs } from "../services/node-management.js";
+import { findPackOnDisk, nodesInstallCommandArgs, } from "../services/node-management.js";
 import { sanitizePanelUpdateNodeResult } from "../services/manager-update-error.js";
 import { formatQueueStatusPartialNote, getManifestPartialLeftover, } from "../services/manifest-partial.js";
 import { searchPanelNodes } from "../services/manager-node-search.js";
@@ -183,7 +183,7 @@ import { describeUnappliedFilters } from "./civitai-filter-guard.js";
 import { recordTodo, normalizeTodoItems, TODO_STATUS_INPUTS } from "./todo-state.js";
 import { applyCapturedWidgetValues } from "../services/live-widget-overlay.js";
 import { listWorkflowLibraryKeys, userdataFetch } from "../services/userdata-library.js";
-import { resolveEffectiveComfyUIBase } from "../services/workspace-env.js";
+import { resolveCustomNodesScanBaseLive, resolveEffectiveComfyUIBase, } from "../services/workspace-env.js";
 import { getNsfwConsent, setNsfwConsent } from "../services/panel-settings.js";
 import { QueueMonitor } from "../services/queue-monitor.js";
 import { RunCompletions } from "./run-completion-journal.js";
@@ -3215,11 +3215,256 @@ function panelIncarnation(ctx, tabId) {
     const b = ctx.bridge;
     return typeof b?.tabIncarnation === "function" ? b.tabIncarnation(tabId) : undefined;
 }
-async function settleDroppedEnqueue(ctx, res, dispatch) {
-    if (res.isError)
+function registryInstallId(args) {
+    // The normalized command is the authority here. In particular, a repository
+    // URL that arrived in `id` has already been rerouted to `repository` and must
+    // not enter this local registry-only fallback.
+    if (args.repository !== undefined || typeof args.id !== "string")
+        return null;
+    const id = args.id.trim();
+    if (!id || /[/\\\x00-\x1F\x7F]/.test(id) || /^[a-z][a-z0-9+.-]*:\/\//i.test(id)) {
+        return null;
+    }
+    return id;
+}
+/** A path comparison that does not let case or slash spelling retarget evidence on Windows. */
+function sameFilesystemPath(a, b) {
+    try {
+        const normalize = (value) => resolve(value).replace(/[\\/]+$/, "");
+        const left = normalize(a);
+        const right = normalize(b);
+        return process.platform === "win32"
+            ? left.toLowerCase() === right.toLowerCase()
+            : left === right;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Strict post-install evidence for the registry-only fallback.
+ *
+ * `findPackOnDisk` is intentionally broader because other node-management
+ * operations must recognize renamed and disabled packs. This fallback needs a
+ * narrower answer: the exact, newly-created, enabled directory, with Manager's
+ * tracking marker and readable Python/package metadata. A symlink, marker-only
+ * husk, arbitrary same-name folder, or any read error is inconclusive.
+ */
+function inspectNewRegistryPack(id, scanBase) {
+    const customNodes = join(scanBase, "custom_nodes");
+    try {
+        const entries = readdirSync(customNodes, { withFileTypes: true });
+        const wanted = id.toLowerCase();
+        const entry = entries.find((candidate) => candidate.name.toLowerCase() === wanted);
+        if (!entry || entry.isSymbolicLink() || !entry.isDirectory()) {
+            return { state: "not-found", scanned: customNodes };
+        }
+        const dir = join(customNodes, entry.name);
+        const lstat = lstatSync(dir);
+        if (!lstat.isDirectory() || lstat.isSymbolicLink()) {
+            return { state: "not-found", scanned: customNodes };
+        }
+        // Reject junctions and other directory indirections too. The panel's local
+        // proof must describe the directory Manager just populated, not another tree.
+        if (!sameFilesystemPath(realpathSync(dir), dir)) {
+            return { state: "not-found", scanned: customNodes };
+        }
+        const files = readdirSync(dir, { withFileTypes: true });
+        const tracking = files.find((file) => file.name === ".tracking" && file.isFile());
+        const code = files.find((file) => file.isFile() &&
+            (file.name.toLowerCase() === "__init__.py" ||
+                file.name.toLowerCase() === "pyproject.toml" ||
+                file.name.toLowerCase().endsWith(".py")));
+        if (!tracking || !code)
+            return { state: "not-found", scanned: customNodes };
+        // Reading both the Manager marker and the loadable file makes an access
+        // failure a refusal, never a truthy `looksLikeAPack` fallback.
+        readFileSync(join(dir, tracking.name));
+        readFileSync(join(dir, code.name));
+        return { state: "found", dir };
+    }
+    catch (err) {
+        return {
+            state: "unreadable",
+            reason: err instanceof Error ? err.message : String(err),
+        };
+    }
+}
+async function captureRegistryInstallSnapshot(args, panelBaseBeforeDispatch) {
+    const id = registryInstallId(args);
+    if (!id || !panelBaseBeforeDispatch)
+        return null;
+    try {
+        const scanBase = await resolveCustomNodesScanBaseLive({ requireLive: true });
+        if (!scanBase)
+            return null;
+        return { id, scanBase, before: findPackOnDisk(id, scanBase) };
+    }
+    catch {
+        return null;
+    }
+}
+function queueStatusRecord(reply) {
+    if (!reply)
+        return null;
+    const nested = reply.status;
+    if (nested && typeof nested === "object" && !Array.isArray(nested)) {
+        // Manager responses can put queue counters under `status` while leaving
+        // failure metadata (for example recent_failures) on the outer envelope.
+        // Flatten both records so the settlement gate cannot discard that evidence.
+        return { ...reply, ...nested };
+    }
+    return reply;
+}
+function explicitQueueFailure(value) {
+    if (value === true)
+        return true;
+    if (typeof value === "number")
+        return Number.isFinite(value) && value > 0;
+    if (typeof value === "string")
+        return value.trim() !== "";
+    if (Array.isArray(value))
+        return value.length > 0;
+    return value !== null && typeof value === "object";
+}
+function queueReportsFailure(status) {
+    // These are the protocol's explicit failure payloads. Empty lists/strings and
+    // false flags are not failures; every non-empty/error-shaped value is.
+    for (const key of [
+        "failed",
+        "error",
+        "failure",
+        "failures",
+        "recent_failures",
+        "errors",
+    ]) {
+        if (explicitQueueFailure(status[key]))
+            return true;
+    }
+    for (const key of [
+        "failed_count",
+        "failure_count",
+        "error_count",
+        "fail_count",
+    ]) {
+        if (typeof status[key] === "number" && status[key] > 0)
+            return true;
+    }
+    if (typeof status.failure_reporting === "string") {
+        const reporting = status.failure_reporting.trim().toLowerCase();
+        if (reporting === "failed" || reporting === "failure" || reporting === "error") {
+            return true;
+        }
+    }
+    const state = typeof status.status === "string" ? status.status.toLowerCase() : "";
+    return state === "failed" || state === "failure" || state === "error";
+}
+function queueSettledForDiskCorroboration(status, outerReply) {
+    if (!status || queueReportsFailure(status) || (outerReply && queueReportsFailure(outerReply))) {
+        return false;
+    }
+    if (status.is_processing !== false)
+        return false;
+    for (const key of ["pending_count", "in_progress_count"]) {
+        if (typeof status[key] === "number" && status[key] !== 0)
+            return false;
+    }
+    // A legacy zero-total idle snapshot is the known dropped-enqueue signature;
+    // settleDroppedEnqueue turns that into a warning and blocks this path. A v4
+    // idle snapshot has no total_count, so the strict disk delta remains the
+    // available post-install evidence.
+    if (status.total_count === 0)
+        return false;
+    if (typeof status.total_count === "number" &&
+        (typeof status.done_count !== "number" || status.done_count <= 0)) {
+        return false;
+    }
+    return typeof status.pending_count === "number" ||
+        (typeof status.total_count === "number" && status.total_count > 0) ||
+        (typeof status.done_count === "number" && status.done_count > 0);
+}
+/**
+ * #2180 — Panel 0.15.71 can report a registry install as unverified when a
+ * registry zip lands in custom_nodes without entering the installed list.
+ *
+ * The fallback is deliberately narrower than the normal node-management disk
+ * scan: it can only corroborate a registry id whose target was absent in a
+ * pre-dispatch snapshot, after the queued response has passed queue settlement,
+ * and only when a strict new-pack read succeeds on the same live target.
+ */
+async function corroborateUntrackedRegistryInstall(ctx, res, snapshot, dispatch, panelBaseBeforeDispatch, mayCorroborateDisk) {
+    if (!mayCorroborateDisk || res.isError || !snapshot || snapshot.before.state !== "not-found") {
         return res;
-    if (!claimsQueued(parseToolResultJson(res)))
+    }
+    const parsed = parseToolResultJson(res);
+    if (!parsed ||
+        parsed.installed !== false ||
+        parsed.verified !== false ||
+        !claimsQueued(parsed) ||
+        parsed.failed === true ||
+        parsed.error === true) {
+        return res;
+    }
+    // Require the panel response to echo the same registry identity. A fresh
+    // directory with only a caller-supplied same-name id is not proof that the
+    // Manager installed that id.
+    if (typeof parsed.id !== "string" ||
+        parsed.id.trim().toLowerCase() !== snapshot.id.toLowerCase()) {
+        return res;
+    }
+    // The follow-up must still be attributable to the panel and server that were
+    // captured before dispatch. This mirrors settleDroppedEnqueue's takeover guard
+    // and keeps local disk evidence inside the requireLive/security scope.
+    if (ctx.tabId !== dispatch.tab || dispatch.incarnation === undefined)
+        return res;
+    if (panelIncarnation(ctx, ctx.tabId) !== dispatch.incarnation)
+        return res;
+    if (!panelBaseBeforeDispatch || !sameHttpBase(getComfyUIBaseUrl(), panelBaseBeforeDispatch)) {
+        return res;
+    }
+    let liveScanBase;
+    try {
+        liveScanBase = await resolveCustomNodesScanBaseLive({ requireLive: true });
+    }
+    catch {
         return res;
+    }
+    if (!liveScanBase || !sameFilesystemPath(liveScanBase, snapshot.scanBase))
+        return res;
+    const disk = inspectNewRegistryPack(snapshot.id, snapshot.scanBase);
+    if (disk.state !== "found")
+        return res;
+    const upgraded = {
+        ...parsed,
+        installed: true,
+        verified: true,
+        restart_required: true,
+        verification_evidence: "new-on-disk-registry-pack",
+        note: [
+            typeof parsed.note === "string" ? parsed.note : undefined,
+            `The pre-install snapshot found no matching pack, and after queue settlement a readable enabled registry pack with Manager tracking metadata appeared at ${disk.dir}.`,
+            "The disk evidence does not establish the requested version or channel; those response fields were preserved unchanged. Restart ComfyUI before relying on the new nodes.",
+        ]
+            .filter(Boolean)
+            .join(" "),
+    };
+    return {
+        ...res,
+        content: [
+            { type: "text", text: JSON.stringify(upgraded, null, 2) },
+            ...res.content.slice(1),
+        ],
+        ...(res.structuredContent
+            ? { structuredContent: { ...res.structuredContent, ...upgraded } }
+            : {}),
+    };
+}
+async function settleDroppedEnqueue(ctx, res, dispatch) {
+    if (res.isError)
+        return { result: res, mayCorroborateDisk: false };
+    if (!claimsQueued(parseToolResultJson(res))) {
+        return { result: res, mayCorroborateDisk: false };
+    }
     // The queue is only evidence about the panel the install was DISPATCHED to
     // (codex P1 — and the same guard #1468 needed, which I did not carry across).
     // `ctx.call` runs ensureReachable first, which silently rebinds an unpinned
@@ -3233,7 +3478,7 @@ async function settleDroppedEnqueue(ctx, res, dispatch) {
     // both are captured: the key AND the incarnation currently holding it.
     const queue = await ctx.call({ cmd: "nodes_queue_status" }, 15000);
     if (ctx.tabId !== dispatch.tab)
-        return res;
+        return { result: res, mayCorroborateDisk: false };
     // Both captured BEFORE the install was dispatched, not here — a takeover that
     // happens DURING the install is already baked in by the time this function
     // runs, so comparing two post-install readings would always agree and the guard
@@ -3242,11 +3487,20 @@ async function settleDroppedEnqueue(ctx, res, dispatch) {
     // rule out a same-key takeover, so it does not get to make a claim about which
     // panel answered.
     if (dispatch.incarnation === undefined)
-        return res;
-    if (panelIncarnation(ctx, ctx.tabId) !== dispatch.incarnation)
-        return res;
-    if (queue.isError || !queueNeverSawATask(parseToolResultJson(queue)))
-        return res;
+        return { result: res, mayCorroborateDisk: false };
+    if (panelIncarnation(ctx, ctx.tabId) !== dispatch.incarnation) {
+        return { result: res, mayCorroborateDisk: false };
+    }
+    if (queue.isError)
+        return { result: res, mayCorroborateDisk: false };
+    const queueReply = parseToolResultJson(queue);
+    const status = queueStatusRecord(queueReply);
+    if (!queueNeverSawATask(queueReply)) {
+        return {
+            result: res,
+            mayCorroborateDisk: queueSettledForDiskCorroboration(status, queueReply),
+        };
+    }
     // NO PROVENANCE CLAIM AT ALL — deliberately, after five review rounds.
     //
     // Earlier drafts explained WHY the task was probably dropped ("the Manager
@@ -3260,19 +3514,22 @@ async function settleDroppedEnqueue(ctx, res, dispatch) {
     // saying, needs no provenance, and cannot be wrong. The cause belongs to
     // whoever can see the install — so the message asks for the ONE check that
     // settles it and stops there. Less useful in the common case; never false.
-    return appendNote(res, `WARNING — THE QUEUE DOES NOT HAVE THIS TASK. The Manager accepted the install above, but a ` +
-        `read taken immediately afterwards, on that same panel, reports an IDLE queue holding no ` +
-        `tasks at all (total_count, done, in_progress all 0). "queued" is its acknowledgement, not ` +
-        `a receipt.\n\n` +
-        `THIS IS NOT PROOF EITHER WAY. Those counters are also cleared by a queue RESET, which ` +
-        `other operations in this server issue, so an install that really ran can read exactly ` +
-        `like this if a reset landed in between.\n\n` +
-        `SO CHECK: call panel_list_nodes and see whether the pack is actually there. Do not restart ` +
-        `on the assumption it installed, and do not reinstall on the assumption it did not.\n\n` +
-        `IF IT IS ABSENT: install it through the headless install_custom_node, which verifies the ` +
-        `pack really landed instead of trusting the queue, and can clone a repository URL directly ` +
-        `when the Manager will not take it. This tool cannot clone for you — it drives whatever ` +
-        `ComfyUI the panel is bound to, which need not be this machine.`);
+    return {
+        result: appendNote(res, `WARNING — THE QUEUE DOES NOT HAVE THIS TASK. The Manager accepted the install above, but a ` +
+            `read taken immediately afterwards, on that same panel, reports an IDLE queue holding no ` +
+            `tasks at all (total_count, done, in_progress all 0). "queued" is its acknowledgement, not ` +
+            `a receipt.\n\n` +
+            `THIS IS NOT PROOF EITHER WAY. Those counters are also cleared by a queue RESET, which ` +
+            `other operations in this server issue, so an install that really ran can read exactly ` +
+            `like this if a reset landed in between.\n\n` +
+            `SO CHECK: call panel_list_nodes and see whether the pack is actually there. Do not restart ` +
+            `on the assumption it installed, and do not reinstall on the assumption it did not.\n\n` +
+            `IF IT IS ABSENT: install it through the headless install_custom_node, which verifies the ` +
+            `pack really landed instead of trusting the queue, and can clone a repository URL directly ` +
+            `when the Manager will not take it. This tool cannot clone for you — it drives whatever ` +
+            `ComfyUI the panel is bound to, which need not be this machine.`),
+        mayCorroborateDisk: false,
+    };
 }
 /**
  * #1699 — a drained Manager queue is not apply_manifest completion when
@@ -15660,18 +15917,24 @@ CHECKED FOR YOU: the graph read this message prescribes was just run, and it ` +
             // #1129 — the panel identity is captured BEFORE dispatch, because a
             // takeover during the install is exactly what the follow-up read must not
             // be attributed to.
+            // #2180 — the local disk corroboration below uses the same server-authorized
+            // binding, captured before dispatch, so a reconnect cannot retarget it.
+            const panelBaseBeforeDispatch = captureRebootHealthBase(ctx);
             const dispatch = {
                 tab: ctx.tabId,
                 incarnation: panelIncarnation(ctx, ctx.tabId),
             };
+            // #2180 — this snapshot must happen BEFORE Manager dispatch. A post-only
+            // scan cannot distinguish a newly landed registry zip from an old pack,
+            // a concurrent writer, or a directory that merely shares the id.
+            const registrySnapshot = await captureRegistryInstallSnapshot(cmdArgs, panelBaseBeforeDispatch);
             const res = await ctx.call({ cmd: "nodes_install", ...cmdArgs }, 30000);
-            // #1129 — settle BEFORE any supplemental note is appended. The note is glued on
-            // after the JSON body, which makes the payload unparseable as JSON, so a probe
-            // running afterwards reads `null`, concludes the panel never claimed a queue,
-            // and silently does nothing. Git notes describe v4 bare-name resolution, but
-            // v4 Git requests now fail before this point and legacy 3.x receives files:[url]
-            // directly; appending that v4 note to a legacy success would be false.
-            const settled = await settleDroppedEnqueue(ctx, res, dispatch);
+            // #1129 / #2180 — settle EVERY queued/pending response before any disk
+            // corroboration. An early rewrite would bypass the queue read and could
+            // turn a still-running or failed request into installed:true.
+            const settlement = await settleDroppedEnqueue(ctx, res, dispatch);
+            const corroborated = await corroborateUntrackedRegistryInstall(ctx, settlement.result, registrySnapshot, dispatch, panelBaseBeforeDispatch, settlement.mayCorroborateDisk);
+            const settled = corroborated;
             if (note && !cmdArgs.repository) {
                 const text = settled.content.find((c) => c.type === "text");
                 if (text && text.type === "text") {