comfyui-mcp 0.52.2 → 0.52.4

package/dist/services/model-resolver.js

@@ -13,7 +13,7 @@ import { logger } from "../utils/logger.js";
 import { downloadWithCache, findResumablePartial, probeRemoteModelPayload } from "./download-cache.js";
 import { reportDownloadProgress } from "./download-progress.js";
 import { modelNotFoundMessage } from "./model-root-scope.js";
-import { resolveModelsDir, resolveModelsDirWithBases, parseModelsDirFromArgv, hasUnresolvableRelativeModelDirFlag, isLiveAuthoritativeModelsDir, modelsDirNamedByServer, } from "./output-dir.js";
+import { resolveModelsDirWithBases, parseModelsDirFromArgv, parseExtraModelPathsConfigsFromArgvRaw, hasUnresolvableRelativeModelDirFlag, isLiveAuthoritativeModelsDir, modelsDirNamedByServer, } from "./output-dir.js";
 import { applyDownloadAuth, redactUrlForLogs, } from "./download-auth.js";
 export const MODEL_SUBDIRS = [
     "checkpoints",
@@ -1143,32 +1143,54 @@ category) {
     // "visible" and gives it the qualified note instead. That is the right trade:
     // the note names the file, the root, and the remedy, whereas the false positive
     // is silent and the user discovers it at queue time.
-    if (!modelsDirNamedByServer(dest.source))
+    //
+    // One exception (#369, the 0.52.1 reports): an extra model root is vouched for by
+    // the server's OWN command line when argv carries an ABSOLUTE
+    // --extra-model-paths-config — that statement is independent of how the PRIMARY
+    // root was derived, and a download redirected onto such a root
+    // (resolveModelSubfolderWithLiveRoot) must be able to confirm here, or the file
+    // lands exactly where the server reads and is STILL reported unconfirmed. With no
+    // argv-named config the extra roots may come from the auto-loaded config beside
+    // an INFERRED main.py — that inherits the inference and vouches for nothing, so
+    // the early UNKNOWN stands. The unvouched primary still cannot support a
+    // NEGATIVE answer below: unknown stays unknown, never "outside the live roots".
+    const primaryNamed = modelsDirNamedByServer(dest.source);
+    if (!primaryNamed &&
+        !parseExtraModelPathsConfigsFromArgvRaw(dest.snapshot.argv).some((p) => isAbsolute(p))) {
         return { inRoots: undefined };
+    }
     const liveRoot = resolve(dest.modelsDir);
-    // A negative answer is only honest when everything it rests on could actually be
-    // canonicalized; otherwise say UNKNOWN rather than accuse a correct placement.
-    let fullyCanonical = target.ok;
-    const primary = await canon(dest.modelsDir);
-    fullyCanonical = fullyCanonical && primary.ok;
-    if (under(primary))
-        return { inRoots: true, liveRoot };
     let extra;
     try {
         extra = await getLiveExtraModelRoots(dest.snapshot);
     }
     catch {
-        return { inRoots: undefined, liveRoot };
+        extra = undefined;
     }
     const wantCat = (category ?? "").trim().toLowerCase();
-    for (const r of extra.roots) {
-        if (wantCat && String(r.category ?? "").trim().toLowerCase() !== wantCat)
-            continue;
-        const rc = await canon(r.dir);
-        fullyCanonical = fullyCanonical && rc.ok;
-        if (under(rc))
+    // A negative answer is only honest when everything it rests on could actually be
+    // canonicalized; otherwise say UNKNOWN rather than accuse a correct placement.
+    let fullyCanonical = target.ok;
+    if (primaryNamed) {
+        const primary = await canon(dest.modelsDir);
+        fullyCanonical = fullyCanonical && primary.ok;
+        if (under(primary))
             return { inRoots: true, liveRoot };
     }
+    if (extra?.authoritative) {
+        for (const r of extra.roots) {
+            if (wantCat && String(r.category ?? "").trim().toLowerCase() !== wantCat)
+                continue;
+            const rc = await canon(r.dir);
+            fullyCanonical = fullyCanonical && rc.ok;
+            if (under(rc))
+                return { inRoots: true, liveRoot };
+        }
+    }
+    if (!primaryNamed)
+        return { inRoots: undefined, liveRoot };
+    if (!extra)
+        return { inRoots: undefined, liveRoot };
     // The live roots are known and this path is in none of them.
     if (!extra.authoritative)
         return { inRoots: undefined, liveRoot };
@@ -1568,18 +1590,40 @@ export async function verifyLandedModel(targetPath, targetSubfolder, opts) {
                 `registers a category serving this file type, this server cannot load it at all.`,
         };
     }
+    // #369 (0.52.1 recurrence) — RESOLVE THE ROOT **WITH** ITS PROVENANCE.
+    //
+    // This used to call `resolveModelsDir()`, which reports the models dir whatever
+    // its `source` — including `configured-base`, the one value a reachable server
+    // never vouched for. The verdict below then compared the landed path against it
+    // and, finding the file inside, told the user the connected ComfyUI READS that
+    // directory. But that root is the very one this download chose, so the file is
+    // inside it BY CONSTRUCTION: the comparison is true for a correct destination and
+    // for a stale second install alike, and cannot tell them apart. On the reporter's
+    // macOS Comfy Desktop pair (two installs under ~/ComfyUI-Installs, the live one
+    // reached through extra_model_paths) that produced "it is in the right place …
+    // Do NOT move the file" for ~25 GB written where the running server never looks.
+    //
+    // So the SOURCE travels with the path, and only a server-NAMED root licenses the
+    // claim. `modelsDirNamedByServer` — not `isLiveAuthoritativeModelsDir` — because
+    // an `observed-root` is INFERRED from where the interpreter lives and is exactly
+    // the inference that lands on the wrong install (#1562).
     let liveModelsDir;
+    let liveModelsDirNamedByServer = false;
     try {
-        liveModelsDir = await resolveModelsDir();
+        const dest = await resolveModelsDirWithBases();
+        liveModelsDir = dest.modelsDir;
+        liveModelsDirNamedByServer = modelsDirNamedByServer(dest.source);
     }
     catch {
         liveModelsDir = undefined;
+        liveModelsDirNamedByServer = false;
     }
     return {
         verifiedPath,
         ...notVisibleVerdict({
             verifiedPath,
             liveModelsDir,
+            liveModelsDirNamedByServer,
             wanted,
             category,
             baseUrl: getComfyUIBaseUrl(),
@@ -1595,14 +1639,33 @@ export async function verifyLandedModel(targetPath, targetSubfolder, opts) {
 /**
  * The verdict for a file that is on disk but absent from the live listing (#1131).
  *
- * "Not listed" has TWO causes and they take OPPOSITE remedies. If the file sits
- * UNDER the very models root the server reads, it is not misplaced: the server
- * simply has not re-read that folder yet. ComfyUI caches its loader option lists
- * and invalidates them on the directory's mtime, so a check this soon after the
- * write routinely races it. Telling that user to "move the file into the running
- * server's models tree" names a directory the file is ALREADY in — a remedy that
- * cannot be followed, which is what the reporter received. Only a file OUTSIDE
- * that root is genuinely in the wrong place.
+ * "Not listed" has THREE causes, and the first two take OPPOSITE remedies:
+ *
+ *   INSIDE a root the SERVER NAMED — not misplaced. The server simply has not
+ *     re-read that folder yet: ComfyUI caches its loader option lists and
+ *     invalidates them on the directory's mtime, so a check this soon after the
+ *     write routinely races it. Telling that user to "move the file into the
+ *     running server's models tree" names a directory the file is ALREADY in — a
+ *     remedy that cannot be followed, which is what #1131's reporter received.
+ *
+ *   OUTSIDE that root — genuinely in the wrong place. Move it.
+ *
+ *   INSIDE a root NOBODY VOUCHED FOR — unknown, and it must be SAID (#369, the
+ *     0.52.1 recurrence). This third state used to be folded into the first,
+ *     because the containment test ran against whatever `resolveModelsDir()`
+ *     returned — including a `configured-base`/`observed-root` value the running
+ *     server never named. That root is the one the download itself resolved to, so
+ *     the landed file is inside it BY CONSTRUCTION and the test answers "inside"
+ *     for a correct destination and a stale second install alike. It is the same
+ *     shape as #1603: two states, one indistinguishable answer, and no way to say
+ *     "unknown". The reporter's macOS Comfy Desktop pair got "so it is in the right
+ *     place … Do NOT move the file" for ~25 GB written into an install the running
+ *     server (reached through extra_model_paths) never reads.
+ *
+ * The unverified branch is deliberately NOT the move remedy either: refusing to
+ * assert readership is not evidence of misplacement, and #1131's harm was exactly
+ * an unfollowable move instruction. It states both candidates, orders them by
+ * likelihood, and names the ONE check that separates them.
  *
  * The DECISION lives here rather than at the call site so it is covered by the
  * same tests as the wording; a branch chosen upstream and passed in as a boolean
@@ -1611,29 +1674,78 @@ export async function verifyLandedModel(targetPath, targetSubfolder, opts) {
 export function notVisibleVerdict(args) {
     const { verifiedPath, liveModelsDir, wanted, category, baseUrl } = args;
     const insideLexically = liveModelsDir !== undefined && isUnderRoot(verifiedPath, liveModelsDir);
-    const insideLiveRoot = insideLexically || args.knownInsideLiveRoots === true;
+    const rootIsServerNamed = args.liveModelsDirNamedByServer === true;
+    // Containment ALONE is not readership. It counts only when the root it is
+    // measured against came from the server (`rootIsServerNamed`), or when the
+    // caller's canonical membership answer — which applies that same narrowing
+    // itself, and additionally covers live extra roots and in-tree junctions —
+    // already said yes.
+    const insideLiveRoot = (insideLexically && rootIsServerNamed) || args.knownInsideLiveRoots === true;
+    // On disk under the root we resolved, with nothing establishing that the server
+    // reads it. Neither remedy is earned; say so, and name the check that decides.
+    const insideUnverifiedRoot = insideLexically && !insideLiveRoot;
+    if (insideUnverifiedRoot) {
+        return {
+            liveVisible: "not-visible",
+            note: `The file IS on disk at ${verifiedPath}, inside ${liveModelsDir} — the models root this ` +
+                `download resolved to. Whether the connected ComfyUI (${baseUrl}) READS that root is ` +
+                `UNCONFIRMED: the running server never named its own models directory, so this root came ` +
+                `from local configuration (COMFYUI_PATH / the saved default workspace) or was inferred ` +
+                `from where the server's interpreter lives — and the file is inside it either way, ` +
+                `because that is the root the download picked. That server does not list "${wanted}" ` +
+                `under "${category}".\n\n` +
+                `TWO very different things produce exactly this, and only one is a problem:\n` +
+                `  1. a STALE LISTING — ComfyUI caches its loader options and invalidates them on the ` +
+                `directory's mtime, so a check this soon after a write routinely races it; or\n` +
+                `  2. a DIFFERENT INSTALL — the bytes are in a models tree the running server never ` +
+                `scans, which is #369 and is how multi-GB downloads get reported as landed and are ` +
+                `never seen again.\n\n` +
+                `Do not move it on the strength of this message alone, and do not treat it as placed ` +
+                `either. SEPARATE THE TWO: refresh the node/model definitions — install_comfyui ` +
+                `(action:"refresh_nodes"), or the panel's refresh — then re-check with list_local_models. ` +
+                `If it STILL does not appear, it is case 2: list_local_models (action:"list_paths") ` +
+                `reports the roots the running server actually reads — move the file into the one for ` +
+                `"${category}". To make future downloads verifiable, point COMFYUI_PATH at the install ` +
+                `that is actually running, or launch it with an absolute --base-directory.`,
+        };
+    }
     return {
         // Still not VISIBLE — we did not observe it in the listing, and #369 exists
         // because an unobserved placement must not render as confirmed. The verdict
         // is unchanged; what changes is the explanation and the remedy.
         liveVisible: "not-visible",
         note: insideLiveRoot
-            ? (insideLexically
-                ? `The file IS on disk at ${verifiedPath}, which is INSIDE the models directory the ` +
-                    `connected ComfyUI reads (${liveModelsDir}) — so it is in the right place. `
-                : `The file IS on disk at ${verifiedPath}, which is inside a models tree the ` +
-                    `connected ComfyUI reads — reached through a link/junction` +
-                    `${liveModelsDir ? ` under ${liveModelsDir}` : ""}, so its real path lying ` +
-                    `outside that directory is the layout working as intended, not a misplacement. `) +
-                `That server does not list "${wanted}" under "${category}" YET, which almost always ` +
-                `means its cached loader options have not been re-read since the write (ComfyUI ` +
-                `invalidates them on the directory's mtime). Do NOT move the file. Refresh the ` +
-                `node/model definitions — install_comfyui (action:"refresh_nodes"), or the panel's ` +
-                `refresh — or restart ComfyUI, then check list_local_models again.`
+            ? // The lexical phrasing NAMES the directory as one the server reads, so it may
+                // only be used when the SERVER named that directory. Otherwise the membership
+                // answer is what vouched for the placement (an extra root / a junction), and
+                // the wording that does not attribute the root is the honest one.
+                (insideLexically && rootIsServerNamed
+                    ? `The file IS on disk at ${verifiedPath}, which is INSIDE the models directory the ` +
+                        `connected ComfyUI reads (${liveModelsDir}) — so it is in the right place. `
+                    : `The file IS on disk at ${verifiedPath}, which is inside a models tree the ` +
+                        `connected ComfyUI reads — reached through a link/junction` +
+                        `${liveModelsDir ? ` under ${liveModelsDir}` : ""}, so its real path lying ` +
+                        `outside that directory is the layout working as intended, not a misplacement. `) +
+                    `That server does not list "${wanted}" under "${category}" YET, which almost always ` +
+                    `means its cached loader options have not been re-read since the write (ComfyUI ` +
+                    `invalidates them on the directory's mtime). Do NOT move the file. Refresh the ` +
+                    `node/model definitions — install_comfyui (action:"refresh_nodes"), or the panel's ` +
+                    `refresh — or restart ComfyUI, then check list_local_models again.`
             : `The file IS on disk at ${verifiedPath}, but the connected ComfyUI ` +
                 `(${baseUrl}) does NOT list "${wanted}" under "${category}" — it will not be ` +
                 `usable in a workflow from there.` +
-                (liveModelsDir ? ` The models directory that server reads is ${liveModelsDir}.` : "") +
+                // Same rule as above: name it as WHAT THE SERVER READS only when the server
+                // named it. An unvouched root is still worth printing — it is where the
+                // bytes are — but as the destination this download resolved to, not as a
+                // fact about the server (#369).
+                (liveModelsDir
+                    ? rootIsServerNamed
+                        ? ` The models directory that server reads is ${liveModelsDir}.`
+                        : ` This download resolved its destination root to ${liveModelsDir} from local ` +
+                            `configuration — the running server never named its own models directory, so that ` +
+                            `is not a confirmed answer for where the file belongs; list_local_models ` +
+                            `(action:"list_paths") reports the roots it actually reads.`
+                    : "") +
                 " Move the file into the running server's models tree (or point COMFYUI_PATH at that install and re-download).",
     };
 }
@@ -1707,28 +1819,84 @@ export async function resolveModelSubfolderWithLiveRoot(targetSubfolder) {
     const { modelsDir, baseDirs, snapshot, source } = await resolveModelsDirWithBases({
         targetCategory: escapes ? "" : categoryOf(normalizedSub),
     });
-    const modelsRoot = resolve(modelsDir);
-    const targetDir = resolve(modelsRoot, raw);
+    let modelsRoot = resolve(modelsDir);
+    let targetDir = resolve(modelsRoot, raw);
     if (targetDir !== modelsRoot && !targetDir.startsWith(modelsRoot + sep)) {
         throw new ModelError(`Refusing to write outside the models directory: ${raw}`);
     }
-    // The root did NOT come from the running server (it could not tell us where it
-    // lives, so we fell back to local config). Before writing, check the one thing
-    // that can still expose a stale-install destination: the server's own listing for
-    // this category. #369 shipped 4.88 GB into a directory the live ComfyUI had never
-    // heard of; refusing here costs nothing and saves the transfer.
-    await assertDestinationVisibleToLiveServer(modelsRoot, raw, source, snapshot);
+    // #369 (the 0.52.1 reports) — a root the SERVER NAMED beats our best inference.
+    //
+    // When the primary root came from local configuration or from an INFERRED live
+    // root, every guard below can do no better than fail OPEN on an empty tree
+    // (#1147's deliberate trade: an empty listing contradicts nothing), so a stale
+    // second install received the write whenever its evidence was silent — the
+    // 0.52.1 reports had gigabytes land in the non-running install while the
+    // connected Desktop server's models lived in the shared root its
+    // --extra-model-paths-config declares (the very root list_paths shows).
+    //
+    // That config flag is the server's OWN command line naming a root it reads this
+    // category from — a statement, not an inference — so it outranks the unvouched
+    // primary and the download goes THERE instead. The gate is deliberately the
+    // exact evidence: an ABSOLUTE --extra-model-paths-config in argv (a relative
+    // one cannot be located from this process and fails closed, per extra-paths),
+    // an AUTHORITATIVE read of it, and a MODEL category (never custom_nodes — a
+    // download must not become a Python import). Anything less keeps the existing
+    // resolution and its corroboration guards untouched.
+    const serverNamedPrimary = modelsDirNamedByServer(source);
+    let redirectedToExtraRoot = false;
+    if (!serverNamedPrimary && snapshot.reachable && !isRemoteMode()) {
+        const category = categoryOf(normalizedSub).toLowerCase();
+        const argvNamesConfig = parseExtraModelPathsConfigsFromArgvRaw(snapshot.argv).some((p) => isAbsolute(p));
+        if (argvNamesConfig && category && !NON_MODEL_EXTRA_CATEGORIES.has(category)) {
+            const extra = await getLiveExtraModelRoots(snapshot);
+            const namedRoot = extra.authoritative
+                ? extra.roots.find((r) => r.category.trim().toLowerCase() === category)
+                : undefined;
+            if (namedRoot) {
+                const extraRoot = resolve(namedRoot.dir);
+                const redirected = resolve(extraRoot, subfolderRemainder(normalizedSub));
+                if (redirected !== extraRoot && !redirected.startsWith(extraRoot + sep)) {
+                    throw new ModelError(`Refusing to write outside the models directory: ${raw}`);
+                }
+                logger.info(`Downloading into the extra model root the connected server named for "${category}" ` +
+                    `(${extraRoot}) instead of the unvouched primary root (${modelsRoot}) — the root the ` +
+                    `server's --extra-model-paths-config declares is where it actually reads (#369).`);
+                modelsRoot = extraRoot;
+                targetDir = redirected;
+                redirectedToExtraRoot = true;
+            }
+        }
+    }
+    if (!redirectedToExtraRoot) {
+        // The root did NOT come from the running server (it could not tell us where it
+        // lives, so we fell back to local config). Before writing, check the one thing
+        // that can still expose a stale-install destination: the server's own listing for
+        // this category. #369 shipped 4.88 GB into a directory the live ComfyUI had never
+        // heard of; refusing here costs nothing and saves the transfer. (A server-named
+        // primary is not skipped here either — the guard itself decides, because a named
+        // root that does not EXIST locally, e.g. a container-side --models-directory,
+        // still gets the cheap check. Only the REDIRECTED destination is exempt: the
+        // server's own config named it, so disagreeing with our inference is moot.)
+        await assertDestinationVisibleToLiveServer(modelsRoot, raw, source, snapshot);
+    }
     // Path-string containment (above) is not enough: an EXISTING symlink somewhere
     // between modelsRoot and targetDir could redirect the real write OUTSIDE the
     // models dir. Because THIS resolver is the single canonical write-target for
     // every local download (startDownloadJob keying AND downloadModel's write), the
     // guard belongs here — co-located with the resolution the write actually uses —
     // so it can never diverge from a caller's separate pre-validation (e.g.
-    // apply_manifest resolving the root a second time; #490 codex review).
+    // apply_manifest resolving the root a second time; #490 codex review). Runs on
+    // the REDIRECTED root too: its code-root veto is what keeps a malicious or
+    // miswritten extra-paths entry from turning this into a write into custom_nodes.
     await assertNoEscapingSymlinkAncestor(modelsRoot, targetDir, raw, baseDirs, snapshot);
     return {
         targetDir,
-        liveRootAtResolve: isLiveAuthoritativeModelsDir(source) ? modelsRoot : undefined,
+        // A redirected destination is bound to the EXTRA root, but the writer's
+        // mid-flight swap check compares PRIMARY roots (currentLiveModelsRoot), so
+        // there is no honest value to bind here — leave it unknown, exactly like any
+        // other non-server-named primary. The post-write check still verifies the
+        // landed file against the connected server.
+        liveRootAtResolve: !redirectedToExtraRoot && isLiveAuthoritativeModelsDir(source) ? modelsRoot : undefined,
     };
 }
 /**