comfyui-mcp 0.52.111 → 0.52.113

package/dist/services/process-control.js

@@ -40,14 +40,16 @@ const IS_WIN = platform() === "win32";
 // live-interpreter resolver can use them without importing this module (which would
 // cycle through workspace-env). Re-exported here: this is still their public home.
 export { parseListenerPidFromNetstat, findPidByPort };
-/**
- * Find PIDs of the Desktop app's Electron shell — current branding
- * ("Comfy Desktop.exe" / "Comfy Desktop.app") and legacy ("ComfyUI.exe" /
- * "ComfyUI.app"). The Python backend is a child of the Electron app, so we
- * need to kill the parent to fully stop the Desktop app.
- */
-function findDesktopAppPids() {
+function isExpectedPgrepNoMatch(error) {
+    return (!IS_WIN &&
+        typeof error === "object" &&
+        error !== null &&
+        "status" in error &&
+        error.status === 1);
+}
+function findDesktopAppPidsWithStatus() {
     const pids = [];
+    let complete = true;
     if (IS_WIN) {
         for (const exe of ["ComfyUI.exe", "Comfy Desktop.exe"]) {
             try {
@@ -61,7 +63,7 @@ function findDesktopAppPids() {
                 }
             }
             catch {
-                // No processes with this image name
+                complete = false;
             }
         }
     }
@@ -77,11 +79,50 @@ function findDesktopAppPids() {
                     pids.push(pid);
             }
         }
-        catch {
-            // No Desktop app processes found
+        catch (error) {
+            if (!isExpectedPgrepNoMatch(error))
+                complete = false;
+        }
+    }
+    return { pids, complete };
+}
+function findDesktopAppPids() {
+    return findDesktopAppPidsWithStatus().pids;
+}
+/**
+ * Find Python processes that may be the Desktop server when the port-owner
+ * lookup is unavailable. This is only a candidate list: every candidate is
+ * re-read through the process identity reader and must still pass the exact
+ * command and authenticated-ancestry checks below.
+ */
+function findPythonProcessPids() {
+    const pids = new Set();
+    let complete = true;
+    const names = IS_WIN ? ["python.exe", "pythonw.exe"] : ["python", "python3", "pythonw"];
+    for (const name of names) {
+        try {
+            const out = IS_WIN
+                ? execSync(`tasklist /FI "IMAGENAME eq ${name}" /FO CSV /NH`, {
+                    encoding: "utf-8",
+                    timeout: 5000,
+                })
+                : execSync(`pgrep -x "${name}"`, {
+                    encoding: "utf-8",
+                    timeout: 5000,
+                });
+            for (const line of String(out).split(/\r?\n/)) {
+                const match = IS_WIN ? line.match(/^"[^"]+","(\d+)"/) : line.match(/^\s*(\d+)\s*$/);
+                const pid = match ? Number.parseInt(match[1], 10) : NaN;
+                if (Number.isInteger(pid) && pid > 0)
+                    pids.add(pid);
+            }
+        }
+        catch (error) {
+            if (!isExpectedPgrepNoMatch(error))
+                complete = false;
         }
     }
-    return pids;
+    return { pids: [...pids], complete };
 }
 function killProcessTree(pid) {
     try {
@@ -236,6 +277,235 @@ function isDesktopApp(argv) {
         joined.includes("comfy desktop") ||
         joined.includes("@comfyorgcomfyui-electron"));
 }
+/**
+ * Return a path without command-line quoting and with the host's path rules
+ * applied. POSIX paths are intentionally not case-folded: unlike Windows,
+ * `/ComfyUI/main.py` and `/comfyui/main.py` are different paths.
+ */
+function normalizeRecoveryPath(path) {
+    const unquoted = path.trim().replace(/^['"]+|['"]+$/g, "");
+    if (!IS_WIN)
+        return unquoted;
+    return unquoted.replace(/\\/g, "/").toLowerCase();
+}
+function isAbsoluteRecoveryPath(path) {
+    return IS_WIN
+        ? /^[a-z]:[\\/]/i.test(path) || /^\\\\/.test(path)
+        : path.startsWith("/");
+}
+function isComfyUIServerScript(path) {
+    const normalized = normalizeRecoveryPath(path);
+    const segments = normalized.split("/").filter(Boolean);
+    if (segments.pop() !== "main.py")
+        return false;
+    // Desktop's H3 launch names the ComfyUI install explicitly. A broad
+    // "Desktop" marker elsewhere in argv must not make an arbitrary helper.py
+    // authoritative.
+    return segments.some((segment) => segment === (IS_WIN ? "comfyui" : "ComfyUI"));
+}
+function isDesktopConfigPath(path) {
+    const normalized = normalizeRecoveryPath(path);
+    if (!isAbsoluteRecoveryPath(path))
+        return false;
+    const segments = normalized.split("/").filter(Boolean);
+    return segments.some((segment) => segment === (IS_WIN ? "comfy desktop" : "Comfy Desktop"));
+}
+/**
+ * Is this the exact H3 server command Desktop uses for its backend?
+ *
+ * The old check only looked for `main.py` plus any Desktop-looking token. That
+ * allowed an unrelated helper launched from the Desktop install to become a
+ * restart target. Keep the accepted shape deliberately narrow: script, Manager
+ * flag, one absolute Desktop model-paths config, and the requested port, in that
+ * order and with no extra arguments.
+ */
+function isDesktopServerArgv(argv, port) {
+    if (argv.length !== 6)
+        return false;
+    const [script, managerFlag, configFlag, configPath, portFlag, reportedPort] = argv;
+    return Boolean(script &&
+        managerFlag === "--enable-manager" &&
+        configFlag === "--extra-model-paths-config" &&
+        configPath &&
+        isComfyUIServerScript(script) &&
+        isDesktopConfigPath(configPath) &&
+        portFlag === "--port" &&
+        reportedPort === String(port));
+}
+function normalizeRecoveryToken(token) {
+    const unquoted = token.trim().replace(/^['"]+|['"]+$/g, "");
+    return IS_WIN ? unquoted.replace(/\\/g, "/").toLowerCase() : unquoted;
+}
+/**
+ * Match the server's argv to an OS process command without the permissive
+ * substring semantics used for ordinary corroboration. Requiring equal lengths
+ * rejects an injected extra command or flag. Windows permits the process table to
+ * report an absolute spelling for Desktop's relative `ComfyUI\\main.py`; POSIX
+ * does not get that suffix fallback because its path and case rules are exact.
+ */
+function exactDesktopServerCommand(identity, serverArgv) {
+    if (identity.argvFidelity !== "exact" ||
+        !identity.commandLine ||
+        !identity.argv ||
+        identity.argv.length < 2) {
+        return false;
+    }
+    const observed = identity.argv.slice(1);
+    if (observed.length !== serverArgv.length)
+        return false;
+    return observed.every((token, index) => {
+        const actual = normalizeRecoveryToken(token);
+        const expected = normalizeRecoveryToken(serverArgv[index] ?? "");
+        if (actual === expected)
+            return true;
+        // Only Windows may reconcile Desktop's relative sys.argv[0] with the
+        // absolute script path exposed by the process table.
+        const expectedRaw = (serverArgv[index] ?? "").trim().replace(/^['"]+|['"]+$/g, "");
+        if (!IS_WIN ||
+            index !== 0 ||
+            /^[a-z]:[\\/]/i.test(expectedRaw) ||
+            /^\\\\/.test(expectedRaw)) {
+            return false;
+        }
+        return actual.endsWith(`/${expected}`);
+    });
+}
+function isVerifiedExecutablePath(path) {
+    return Boolean(path && isAbsoluteRecoveryPath(path));
+}
+function sameRecoveryPath(a, b) {
+    return normalizeRecoveryPath(a) === normalizeRecoveryPath(b);
+}
+function hasExactProcessIdentity(identity) {
+    return Boolean(identity?.startedAt &&
+        identity.executablePath &&
+        identity.commandLine &&
+        identity.argvFidelity === "exact" &&
+        identity.argv?.length);
+}
+/**
+ * The process reader exposes two different Python paths on Windows/Linux for a
+ * venv: `executablePath` is the base interpreter image, while argv[0] is the venv
+ * interpreter that owns the server's site-packages. Either path alone is not
+ * enough; the pair must have the shape the reader documents, and the server's
+ * exact H3 command must tie the venv path to the ComfyUI install.
+ */
+function isPythonInterpreterPath(path) {
+    if (!isVerifiedExecutablePath(path))
+        return false;
+    const basename = path.replace(/\\/g, "/").split("/").pop()?.toLowerCase() ?? "";
+    return /^python(?:w)?(?:\d+(?:\.\d+)*)?(?:\.exe)?$/.test(basename);
+}
+function isAuthenticatedPython(identity, serverArgv) {
+    const executable = identity.executablePath;
+    const argv0 = identity.argv?.[0];
+    if (!hasExactProcessIdentity(identity) ||
+        !isPythonInterpreterPath(executable) ||
+        !isPythonInterpreterPath(argv0)) {
+        return false;
+    }
+    // A normal process has the same path in both fields. A venv process is the
+    // documented exception: the kernel image resolves to base Python, while
+    // argv[0] remains the venv trampoline. Do not accept arbitrary two-Python
+    // paths; only that one-way base -> venv relationship is reader-proven.
+    const samePath = sameRecoveryPath(executable, argv0);
+    if (!samePath && !(isVenvInterpreterPath(argv0) && !isVenvInterpreterPath(executable))) {
+        return false;
+    }
+    if (!serverArgv)
+        return true;
+    // A recovered Desktop server must use a venv interpreter under the same
+    // ComfyUI install named by its H3 script. This rejects an arbitrary absolute
+    // `C:\\attacker\\venv\\Scripts\\python.exe` even when its basename is valid.
+    if (!isVenvInterpreterPath(argv0))
+        return false;
+    const script = normalizeRecoveryPath(serverArgv[0] ?? "");
+    const pythonPath = normalizeRecoveryPath(argv0);
+    const comfySegment = IS_WIN ? "comfyui" : "ComfyUI";
+    const scriptSegments = script.split("/").filter(Boolean);
+    const pythonSegments = pythonPath.split("/").filter(Boolean);
+    const scriptRootIndex = scriptSegments.lastIndexOf(comfySegment);
+    const pythonRootIndex = pythonSegments.lastIndexOf(comfySegment);
+    if (scriptRootIndex < 0 || pythonRootIndex < 0)
+        return false;
+    if (isAbsoluteRecoveryPath(serverArgv[0] ?? "")) {
+        const expectedRoot = scriptSegments.slice(0, scriptRootIndex + 1);
+        if (!expectedRoot.every((segment, index) => pythonSegments[index] === segment)) {
+            return false;
+        }
+    }
+    return true;
+}
+function expectedDesktopExecutablePaths() {
+    if (IS_WIN) {
+        const localAppData = process.env.LOCALAPPDATA;
+        const userProfile = process.env.USERPROFILE;
+        return [
+            "C:/Program Files/Comfy Desktop/Comfy Desktop.exe",
+            "C:/Program Files/ComfyUI/ComfyUI.exe",
+            ...(localAppData
+                ? [
+                    `${localAppData}/Programs/Comfy Desktop/Comfy Desktop.exe`,
+                    `${localAppData}/Programs/@comfyorgcomfyui-electron/ComfyUI.exe`,
+                    `${localAppData}/Programs/ComfyUI/ComfyUI.exe`,
+                ]
+                : []),
+            ...(userProfile ? [`${userProfile}/Programs/ComfyUI/ComfyUI.exe`] : []),
+        ];
+    }
+    const home = homedir();
+    return [
+        "/Applications/Comfy Desktop.app/Contents/MacOS/Comfy Desktop",
+        "/Applications/Comfy Desktop.app/Contents/MacOS/ComfyUI",
+        "/Applications/ComfyUI.app/Contents/MacOS/Comfy Desktop",
+        "/Applications/ComfyUI.app/Contents/MacOS/ComfyUI",
+        `${home}/Applications/Comfy Desktop.app/Contents/MacOS/Comfy Desktop`,
+        `${home}/Applications/Comfy Desktop.app/Contents/MacOS/ComfyUI`,
+        `${home}/Applications/ComfyUI.app/Contents/MacOS/Comfy Desktop`,
+        `${home}/Applications/ComfyUI.app/Contents/MacOS/ComfyUI`,
+    ];
+}
+function isExpectedDesktopExecutablePath(path) {
+    const normalized = normalizeRecoveryPath(path);
+    return expectedDesktopExecutablePaths().some((candidate) => sameRecoveryPath(normalized, candidate));
+}
+function isAuthenticatedDesktopSupervisor(identity) {
+    return Boolean(hasExactProcessIdentity(identity) &&
+        identity.executablePath &&
+        identity.argv?.[0] &&
+        isExpectedDesktopExecutablePath(identity.executablePath) &&
+        sameRecoveryPath(identity.executablePath, identity.argv[0]) &&
+        isDesktopSupervisorProcess(identity));
+}
+function directDesktopPythonAncestry(pid, knownPids, readParent, readIdentity) {
+    // The issue's accepted shape is specifically Desktop.exe -> python.exe ->
+    // server python.exe. Do not walk through an arbitrary wrapper and turn a
+    // merely shared Desktop ancestor into restart authority.
+    const pythonPid = readParent(pid);
+    if (pythonPid == null)
+        return "unavailable";
+    if (pythonPid <= 1 || pythonPid === pid)
+        return undefined;
+    const python = readIdentity(pythonPid);
+    if (!python || !isAuthenticatedPython(python))
+        return "unavailable";
+    const desktopPid = readParent(pythonPid);
+    if (desktopPid == null)
+        return "unavailable";
+    if (desktopPid <= 1 || desktopPid === pythonPid)
+        return undefined;
+    if (!knownPids.has(desktopPid))
+        return undefined;
+    const desktop = readIdentity(desktopPid);
+    if (!desktop ||
+        !hasExactProcessIdentity(desktop) ||
+        !isVerifiedExecutablePath(desktop.executablePath)) {
+        return "unavailable";
+    }
+    if (!isAuthenticatedDesktopSupervisor(desktop))
+        return undefined;
+    return { desktopPid, desktopIdentity: desktop };
+}
 /**
  * Try to find the ComfyUI Desktop exe from common install locations.
  * Used as a fallback when no process info was previously captured.
@@ -2334,6 +2604,101 @@ async function reconfirmAnsweringServer(argv, pid, port) {
         return "unknown";
     return ownerNow === pid ? "confirmed" : "changed";
 }
+/**
+ * Recover a Desktop backend when the listener cannot be mapped to a PID.
+ *
+ * This is deliberately narrower than the old "find a Desktop process by name"
+ * fallback. The server has to have supplied a Desktop-shaped `sys.argv`; the OS
+ * process table has to expose one exact, spawn-faithful Python command with the
+ * same arguments; its direct parent has to be Python and that process's direct
+ * parent has to be a name-discovered Desktop PID; and the normal supervision
+ * classifier must authenticate every causality link. Missing or ambiguous evidence
+ * returns undefined so the caller keeps its existing refusal.
+ */
+function recoverDesktopProcessFromAncestry(port, serverArgv) {
+    if (!isDesktopServerArgv(serverArgv, port))
+        return undefined;
+    const desktopProbe = findDesktopAppPidsWithStatus();
+    if (!desktopProbe.complete)
+        return undefined;
+    const desktopPids = new Set(desktopProbe.pids);
+    if (desktopPids.size === 0)
+        return undefined;
+    const pythonProbe = findPythonProcessPids();
+    if (!pythonProbe.complete)
+        return undefined;
+    const identities = new Map();
+    const readIdentity = (pid) => {
+        if (!identities.has(pid))
+            identities.set(pid, resolveProcessIdentity(pid));
+        return identities.get(pid);
+    };
+    const readParent = (pid) => {
+        // The normal reader and the test seam both represent the same OS fact. Use
+        // the seam when installed, otherwise retain the identity snapshot in the
+        // cache so one recovery decision does not mix process generations.
+        if (parentPidResolverOverride)
+            return readParentPid(pid);
+        return readIdentity(pid)?.parentPid;
+    };
+    const matches = [];
+    let evidenceUnavailable = false;
+    for (const pid of pythonProbe.pids) {
+        const identity = readIdentity(pid);
+        if (!hasExactProcessIdentity(identity)) {
+            evidenceUnavailable = true;
+            continue;
+        }
+        // Fully observed non-matching Python processes are ordinary background
+        // processes and can be ignored. Once the exact H3 command matches, however,
+        // an untrusted executable path is an ambiguous target and must fail closed.
+        if (!exactDesktopServerCommand(identity, serverArgv))
+            continue;
+        if (!isAuthenticatedPython(identity, serverArgv)) {
+            evidenceUnavailable = true;
+            continue;
+        }
+        const ancestry = directDesktopPythonAncestry(pid, desktopPids, readParent, readIdentity);
+        if (ancestry === "unavailable") {
+            evidenceUnavailable = true;
+            continue;
+        }
+        if (!ancestry)
+            continue;
+        const { verdict } = classifyDesktopSupervision({
+            pid,
+            readParentPid: readParent,
+            readIdentity,
+            processExists,
+            isSupervisorProcess: isDesktopSupervisorProcess,
+        });
+        if (verdict === "supervised") {
+            matches.push({ pid, identity, ...ancestry });
+        }
+        else if (verdict === "unconfirmed") {
+            evidenceUnavailable = true;
+        }
+    }
+    // Two identical H3 launches under Desktop are not distinguishable once the
+    // port table is unavailable. Choosing one would turn ambiguity into authority.
+    if (evidenceUnavailable || matches.length !== 1)
+        return undefined;
+    const match = matches[0];
+    if (!match)
+        return undefined;
+    return {
+        pid: match.pid,
+        port,
+        argv: [...serverArgv],
+        osArgv: match.identity.argv,
+        osArgvExact: match.identity.argvFidelity === "exact",
+        osCommandLine: match.identity.commandLine,
+        observedInterpreter: observedInterpreterFromIdentity(match.identity),
+        isDesktopApp: true,
+        desktopExePath: match.desktopIdentity.executablePath,
+        startedAt: match.identity.startedAt,
+    };
+}
 async function gatherProcessInfo() {
     const port = config.resolvedPort;
     // 1. Get argv from /system_stats, BRACKETED by port-owner lookups.
@@ -2490,6 +2855,17 @@ async function gatherProcessInfo() {
         throw err;
     }
     if (!pid) {
+        // A broken Windows listener can leave the server alive and still answering
+        // through an already-established panel connection, while every port-owner
+        // lookup returns unknown. Bind that server through the authenticated
+        // Desktop→Python ancestry instead of treating a Desktop name scan as proof.
+        // The recovery helper returns nothing unless the command and ancestry are
+        // independently verified, so the ordinary fail-closed error remains intact.
+        if (argv.length > 0) {
+            const recovered = recoverDesktopProcessFromAncestry(port, argv);
+            if (recovered)
+                return recovered;
+        }
         // Liveness is the reachable SERVER, not only a local PID scan. If
         // /system_stats just answered (argv populated) yet we still can't map the
         // listening socket to a PID, say so precisely instead of claiming the