grepmax 0.23.0 → 0.25.0

package/dist/lib/utils/cross-project.js

@@ -18,7 +18,7 @@ const project_registry_1 = require("./project-registry");
 function resolveCrossProjectScope(opts) {
     const active = !!(opts.allProjects || opts.projects);
     if (!active) {
-        return { active: false, roots: [], warnings: [] };
+        return { active: false, roots: [], projectRoots: [], warnings: [] };
     }
     // Ignore "error"-status projects: the daemon won't search them anyway.
     const all = (0, project_registry_1.listProjects)().filter((p) => p.status !== "error");
@@ -62,9 +62,12 @@ function resolveCrossProjectScope(opts) {
             : undefined;
     }
     else {
-        // --all-projects: search the whole shared table. No project_roots clause
-        // (its absence IS "everything"); only carve out --exclude-projects.
+        // --all-projects still emits an explicit allow-list. The physical table can
+        // contain orphan or failed-project rows that are not eligible here.
         included = all.filter((p) => !excludedRoots.has(p.root));
+        projectRootsCsv = included.length
+            ? included.map((p) => p.root).join(",")
+            : undefined;
         if (excludedRoots.size) {
             excludeProjectRootsCsv = [...excludedRoots].join(",");
         }
@@ -72,6 +75,7 @@ function resolveCrossProjectScope(opts) {
     return {
         active: true,
         roots: included.map((p) => ({ root: p.root, name: p.name })),
+        projectRoots: included.map((p) => p.root),
         projectRootsCsv,
         excludeProjectRootsCsv,
         warnings,

package/dist/lib/utils/daemon-client.js

@@ -71,18 +71,28 @@ function sendDaemonCommand(cmd, opts) {
     var _a;
     const timeout = (_a = opts === null || opts === void 0 ? void 0 : opts.timeoutMs) !== null && _a !== void 0 ? _a : DEFAULT_TIMEOUT_MS;
     return new Promise((resolve) => {
+        var _a, _b;
         let settled = false;
         const finish = (resp) => {
+            var _a;
             if (settled)
                 return;
             settled = true;
+            clearTimeout(timer);
+            (_a = opts === null || opts === void 0 ? void 0 : opts.signal) === null || _a === void 0 ? void 0 : _a.removeEventListener("abort", onAbort);
             socket.destroy();
             resolve(resp);
         };
         const socket = net.createConnection({ path: config_1.PATHS.daemonSocket });
+        const onAbort = () => finish({ ok: false, error: "aborted" });
         const timer = setTimeout(() => {
             finish({ ok: false, error: "timeout" });
         }, timeout);
+        if ((_a = opts === null || opts === void 0 ? void 0 : opts.signal) === null || _a === void 0 ? void 0 : _a.aborted) {
+            finish({ ok: false, error: "aborted" });
+            return;
+        }
+        (_b = opts === null || opts === void 0 ? void 0 : opts.signal) === null || _b === void 0 ? void 0 : _b.addEventListener("abort", onAbort, { once: true });
         socket.on("connect", () => {
             socket.write(`${JSON.stringify(cmd)}\n`);
         });
@@ -266,7 +276,7 @@ function ensureDaemonRunning() {
             return true;
         if (!(yield isDaemonRunning())) {
             const { spawnDaemon } = yield Promise.resolve().then(() => __importStar(require("./daemon-launcher")));
-            const pid = spawnDaemon();
+            const pid = yield spawnDaemon();
             if (!pid)
                 return false;
         }
@@ -289,13 +299,16 @@ function sendStreamingCommand(cmd, onProgress, opts) {
     var _a;
     const timeout = (_a = opts === null || opts === void 0 ? void 0 : opts.timeoutMs) !== null && _a !== void 0 ? _a : DEFAULT_STREAMING_TIMEOUT_MS;
     return new Promise((resolve, reject) => {
+        var _a, _b;
         let settled = false;
         let timer;
         const finish = (result) => {
+            var _a;
             if (settled)
                 return;
             settled = true;
             clearTimeout(timer);
+            (_a = opts === null || opts === void 0 ? void 0 : opts.signal) === null || _a === void 0 ? void 0 : _a.removeEventListener("abort", onAbort);
             socket.destroy();
             if (result instanceof Error)
                 reject(result);
@@ -309,7 +322,17 @@ function sendStreamingCommand(cmd, onProgress, opts) {
             }, timeout);
         };
         const socket = net.createConnection({ path: config_1.PATHS.daemonSocket });
+        const onAbort = () => {
+            const error = new Error("Aborted");
+            error.name = "AbortError";
+            finish(error);
+        };
         resetTimer();
+        if ((_a = opts === null || opts === void 0 ? void 0 : opts.signal) === null || _a === void 0 ? void 0 : _a.aborted) {
+            onAbort();
+            return;
+        }
+        (_b = opts === null || opts === void 0 ? void 0 : opts.signal) === null || _b === void 0 ? void 0 : _b.addEventListener("abort", onAbort, { once: true });
         socket.on("connect", () => {
             socket.write(`${JSON.stringify(cmd)}\n`);
         });

package/dist/lib/utils/daemon-launcher.js

@@ -32,9 +32,19 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.spawnDaemon = spawnDaemon;
 const node_child_process_1 = require("node:child_process");
+const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
 const config_1 = require("../../config");
 const log_rotate_1 = require("./log-rotate");
@@ -43,17 +53,32 @@ const log_rotate_1 = require("./log-rotate");
  * Returns the child PID, or null on failure.
  */
 function spawnDaemon() {
-    var _a;
-    try {
-        const logFile = path.join(config_1.PATHS.logsDir, "daemon.log");
-        const out = (0, log_rotate_1.openRotatedLog)(logFile);
-        const child = (0, node_child_process_1.spawn)(process.argv[0], [process.argv[1], "watch", "--daemon", "-b"], { detached: true, stdio: ["ignore", out, out] });
-        child.unref();
-        return (_a = child.pid) !== null && _a !== void 0 ? _a : null;
-    }
-    catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        console.error(`[daemon-launcher] Failed to spawn daemon: ${msg}`);
-        return null;
-    }
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        let out = null;
+        try {
+            const logFile = path.join(config_1.PATHS.logsDir, "daemon.log");
+            out = (0, log_rotate_1.openRotatedLog)(logFile);
+            const child = (0, node_child_process_1.spawn)(process.argv[0], [process.argv[1], "watch", "--daemon", "-b"], { detached: true, stdio: ["ignore", out, out] });
+            yield new Promise((resolve, reject) => {
+                child.once("spawn", resolve);
+                child.once("error", reject);
+            });
+            child.unref();
+            return (_a = child.pid) !== null && _a !== void 0 ? _a : null;
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            console.error(`[daemon-launcher] Failed to spawn daemon: ${msg}`);
+            return null;
+        }
+        finally {
+            if (out !== null) {
+                try {
+                    fs.closeSync(out);
+                }
+                catch (_b) { }
+            }
+        }
+    });
 }

package/dist/lib/utils/doctor-status.js

@@ -0,0 +1,76 @@
+"use strict";
+/**
+ * Pure presentation helpers for `gmax doctor`. No I/O — callers do the probes
+ * (fs existence, MLX/summarizer health) and pass the results in; these decide
+ * the severity symbol and message. Kept out of doctor.ts so the severity logic
+ * is unit-testable without spinning up the whole command or its dependencies.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.onnxModelStatus = onnxModelStatus;
+exports.gpuEmbedModelStatus = gpuEmbedModelStatus;
+exports.summaryCoverageStatus = summaryCoverageStatus;
+exports.summarizerServerStatus = summarizerServerStatus;
+/**
+ * ONNX model availability from the ~/.gmax/models/<id> dir. Correct for cpu-mode
+ * embed models and for ColBERT (always ONNX in-worker). NOT correct for gpu-mode
+ * embed models — those are served by MLX from the HF cache; use
+ * {@link gpuEmbedModelStatus} for those.
+ */
+function onnxModelStatus(id, exists) {
+    return exists
+        ? { symbol: "ok", message: `${id}: downloaded` }
+        : { symbol: "WARN", message: `${id}: will download on first use` };
+}
+/**
+ * gpu-mode embed model availability, reported from reality rather than the ONNX
+ * models dir (where MLX models never live). A live server is proof enough; a
+ * down server falls back to the pinned HF cache to distinguish "cached, will
+ * load on next start" from "not present, will download" — neither of which is a
+ * warning, since the daemon respawns the server on demand.
+ */
+function gpuEmbedModelStatus(id, health, hfCacheExists) {
+    if (health.up) {
+        return { symbol: "ok", message: `${id}: serving via MLX (port 8100)` };
+    }
+    if (hfCacheExists) {
+        return {
+            symbol: "ok",
+            message: `${id}: cached (will load on next MLX start)`,
+        };
+    }
+    return {
+        symbol: "INFO",
+        message: `${id}: will download on first MLX start`,
+    };
+}
+/**
+ * Summary coverage severity. The summarizer is an opt-in feature that has never
+ * been enabled by default, so zero coverage is INFO (an unexercised opt-in), not
+ * FAIL (which implies breakage and trains users/agents to ignore doctor FAILs).
+ * Any partial coverage below 90% is a genuine WARN (a stalled/incomplete
+ * backfill); >=90% is ok.
+ */
+function summaryCoverageStatus(withSummary, totalChunks) {
+    const pct = totalChunks > 0 ? Math.round((withSummary / totalChunks) * 100) : 0;
+    if (withSummary === 0) {
+        return {
+            symbol: "INFO",
+            message: "Summary coverage: 0% (summarizer never enabled — opt-in)",
+        };
+    }
+    const symbol = pct >= 90 ? "ok" : "WARN";
+    return {
+        symbol,
+        message: `Summary coverage: ${withSummary}/${totalChunks} (${pct}%)`,
+    };
+}
+/**
+ * Summarizer server presence. Being down is INFO, not WARN: the summarizer is
+ * opt-in and, even when enabled, its llama-server idles out after 10min and
+ * respawns on demand — a stopped server is the normal resting state.
+ */
+function summarizerServerStatus(up) {
+    return up
+        ? { symbol: "ok", message: "Summarizer: running (port 8101)" }
+        : { symbol: "INFO", message: "Summarizer: not running (opt-in)" };
+}

package/dist/lib/utils/file-utils.js

@@ -47,6 +47,7 @@ exports.stripMarkdownFrontmatter = stripMarkdownFrontmatter;
 exports.computeContentHash = computeContentHash;
 exports.hasNullByte = hasNullByte;
 exports.readFileSnapshot = readFileSnapshot;
+exports.readContainedTextFileSync = readContainedTextFileSync;
 exports.isIndexableFile = isIndexableFile;
 exports.isIndexablePath = isIndexablePath;
 exports.isGeneratedContent = isGeneratedContent;
@@ -57,6 +58,7 @@ const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
 const node_path_1 = require("node:path");
 const config_1 = require("../../config");
+const path_containment_1 = require("./path-containment");
 function computeBufferHash(buffer) {
     return (0, node_crypto_1.createHash)("sha256").update(buffer).digest("hex");
 }
@@ -99,23 +101,50 @@ function hasNullByte(buffer, sampleLength = 1024) {
     }
     return false;
 }
-function readFileSnapshot(filePath) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const handle = yield fs.promises.open(filePath, "r");
+function readFileSnapshot(filePath_1) {
+    return __awaiter(this, arguments, void 0, function* (filePath, options = {}) {
+        var _a;
+        const resolved = options.projectRoot
+            ? (0, path_containment_1.resolveContainedPath)(options.projectRoot, filePath, {
+                verifyExistingTarget: true,
+            })
+            : filePath;
+        const handle = yield fs.promises.open(resolved, fs.constants.O_RDONLY | ((_a = fs.constants.O_NOFOLLOW) !== null && _a !== void 0 ? _a : 0));
         try {
             const before = yield handle.stat();
+            if (!before.isFile())
+                throw new Error("Path is not a regular file");
             if (before.size > config_1.MAX_FILE_SIZE_BYTES) {
                 throw new Error("File exceeds maximum allowed size");
             }
             const size = before.size;
             const buffer = size > 0 ? Buffer.allocUnsafe(size) : Buffer.alloc(0);
             if (size > 0) {
-                yield handle.read(buffer, 0, size, 0);
+                let offset = 0;
+                while (offset < size) {
+                    const { bytesRead } = yield handle.read(buffer, offset, size - offset, offset);
+                    if (bytesRead <= 0) {
+                        throw new Error("Unexpected end of file during read");
+                    }
+                    offset += bytesRead;
+                }
             }
             const after = yield handle.stat();
             if (before.mtimeMs !== after.mtimeMs || before.size !== after.size) {
                 throw new Error("File changed during read");
             }
+            if (options.projectRoot) {
+                (0, path_containment_1.resolveContainedPath)(options.projectRoot, resolved, {
+                    verifyExistingTarget: true,
+                });
+                const currentLstat = yield fs.promises.lstat(resolved);
+                const current = yield fs.promises.stat(resolved);
+                if (currentLstat.isSymbolicLink() ||
+                    current.dev !== after.dev ||
+                    current.ino !== after.ino) {
+                    throw new Error("File identity changed during read");
+                }
+            }
             return { buffer, mtimeMs: after.mtimeMs, size: after.size };
         }
         finally {
@@ -123,6 +152,47 @@ function readFileSnapshot(filePath) {
         }
     });
 }
+function readContainedTextFileSync(projectRoot, filePath) {
+    var _a;
+    const resolved = (0, path_containment_1.resolveContainedPath)(projectRoot, filePath, {
+        verifyExistingTarget: true,
+    });
+    const fd = fs.openSync(resolved, fs.constants.O_RDONLY | ((_a = fs.constants.O_NOFOLLOW) !== null && _a !== void 0 ? _a : 0));
+    try {
+        const before = fs.fstatSync(fd);
+        if (!before.isFile())
+            throw new Error("Path is not a regular file");
+        if (before.size > config_1.MAX_FILE_SIZE_BYTES) {
+            throw new Error("File exceeds maximum allowed size");
+        }
+        const buffer = Buffer.alloc(before.size);
+        let offset = 0;
+        while (offset < buffer.length) {
+            const bytesRead = fs.readSync(fd, buffer, offset, buffer.length - offset, offset);
+            if (bytesRead <= 0)
+                throw new Error("Unexpected end of file during read");
+            offset += bytesRead;
+        }
+        const after = fs.fstatSync(fd);
+        if (before.mtimeMs !== after.mtimeMs || before.size !== after.size) {
+            throw new Error("File changed during read");
+        }
+        (0, path_containment_1.resolveContainedPath)(projectRoot, resolved, {
+            verifyExistingTarget: true,
+        });
+        const currentLstat = fs.lstatSync(resolved);
+        const current = fs.statSync(resolved);
+        if (currentLstat.isSymbolicLink() ||
+            current.dev !== after.dev ||
+            current.ino !== after.ino) {
+            throw new Error("File identity changed during read");
+        }
+        return buffer.toString("utf8");
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
 // Check if a file should be indexed (extension and size).
 function isIndexableFile(filePath, size) {
     const ext = (0, node_path_1.extname)(filePath).toLowerCase();

package/dist/lib/utils/keyed-mutex.js

@@ -0,0 +1,101 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeyedMutex = void 0;
+function abortError() {
+    const error = new Error("Aborted");
+    error.name = "AbortError";
+    return error;
+}
+class KeyedMutex {
+    constructor() {
+        this.keys = new Map();
+        this.activeTasks = new Set();
+        this.closed = false;
+    }
+    get pending() {
+        let count = 0;
+        for (const state of this.keys.values()) {
+            count += (state.locked ? 1 : 0) + state.queue.length;
+        }
+        return count;
+    }
+    run(key, signal, fn) {
+        const task = (() => __awaiter(this, void 0, void 0, function* () {
+            yield this.acquire(key, signal);
+            try {
+                if (signal === null || signal === void 0 ? void 0 : signal.aborted)
+                    throw abortError();
+                return yield fn();
+            }
+            finally {
+                this.release(key);
+            }
+        }))();
+        this.activeTasks.add(task);
+        const cleanup = () => this.activeTasks.delete(task);
+        void task.then(cleanup, cleanup);
+        return task;
+    }
+    close() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            this.closed = true;
+            for (const [key, state] of this.keys) {
+                for (const waiter of state.queue.splice(0)) {
+                    (_a = waiter.signal) === null || _a === void 0 ? void 0 : _a.removeEventListener("abort", waiter.onAbort);
+                    waiter.reject(abortError());
+                }
+                if (!state.locked)
+                    this.keys.delete(key);
+            }
+            yield Promise.allSettled([...this.activeTasks]);
+        });
+    }
+    acquire(key, signal) {
+        var _a;
+        if (this.closed || (signal === null || signal === void 0 ? void 0 : signal.aborted))
+            return Promise.reject(abortError());
+        const state = (_a = this.keys.get(key)) !== null && _a !== void 0 ? _a : { locked: false, queue: [] };
+        this.keys.set(key, state);
+        if (!state.locked) {
+            state.locked = true;
+            return Promise.resolve();
+        }
+        return new Promise((resolve, reject) => {
+            const waiter = { resolve, reject, signal };
+            const onAbort = () => {
+                const index = state.queue.indexOf(waiter);
+                if (index !== -1)
+                    state.queue.splice(index, 1);
+                reject(abortError());
+            };
+            waiter.onAbort = onAbort;
+            signal === null || signal === void 0 ? void 0 : signal.addEventListener("abort", onAbort, { once: true });
+            state.queue.push(waiter);
+        });
+    }
+    release(key) {
+        var _a;
+        const state = this.keys.get(key);
+        if (!state)
+            return;
+        const next = state.queue.shift();
+        if (next) {
+            (_a = next.signal) === null || _a === void 0 ? void 0 : _a.removeEventListener("abort", next.onAbort);
+            next.resolve();
+            return;
+        }
+        state.locked = false;
+        this.keys.delete(key);
+    }
+}
+exports.KeyedMutex = KeyedMutex;

package/dist/lib/utils/logger.js

@@ -1,12 +1,68 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.VERBOSE = void 0;
+exports.LOG_TIMESTAMPS_ENV = exports.VERBOSE = void 0;
+exports.stampLines = stampLines;
+exports.installTimestampedOutput = installTimestampedOutput;
 exports.log = log;
 exports.debug = debug;
 exports.timer = timer;
 exports.debugTimer = debugTimer;
 exports.debugEvery = debugEvery;
 exports.VERBOSE = process.env.GMAX_DEBUG === "1" || process.env.GMAX_VERBOSE === "1";
+/** Set by the daemon so forked workers (which share its log fd) opt in too. */
+exports.LOG_TIMESTAMPS_ENV = "GMAX_LOG_TIMESTAMPS";
+/** Local time, same shape mlx-embed-server.log uses: 2026-07-06T21:33:26 */
+function timestamp() {
+    const d = new Date();
+    const pad = (n) => String(n).padStart(2, "0");
+    return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}T${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}`;
+}
+/**
+ * Prefix a timestamp to each line in `text` that begins at line start.
+ * `state.atLineStart` carries the position across chunks so a line split
+ * over multiple write() calls is stamped exactly once. Blank lines are
+ * left unstamped. Exported for tests.
+ */
+function stampLines(text, state) {
+    let out = "";
+    let i = 0;
+    while (i < text.length) {
+        const nl = text.indexOf("\n", i);
+        const end = nl === -1 ? text.length : nl + 1;
+        const line = text.slice(i, end);
+        if (state.atLineStart && line !== "\n")
+            out += `${timestamp()} `;
+        out += line;
+        state.atLineStart = nl !== -1;
+        i = end;
+    }
+    return out;
+}
+let timestampsInstalled = false;
+/**
+ * Prefix every stdout/stderr line with a local timestamp. Installed by the
+ * daemon (whose stdio becomes daemon.log) and by workers when the daemon's
+ * env flag is present — never by interactive CLI commands. Without this,
+ * daemon.log lines can't be correlated with the timestamped MLX/LLM server
+ * logs when reconstructing an incident.
+ */
+function installTimestampedOutput() {
+    if (timestampsInstalled)
+        return;
+    timestampsInstalled = true;
+    process.env[exports.LOG_TIMESTAMPS_ENV] = "1"; // forked workers inherit this
+    for (const stream of [process.stdout, process.stderr]) {
+        const orig = stream.write.bind(stream);
+        const state = { atLineStart: true };
+        stream.write = ((chunk, enc, cb) => {
+            const out = typeof chunk === "string" || Buffer.isBuffer(chunk)
+                ? stampLines(chunk.toString(), state)
+                : chunk;
+            // Forward the (chunk, cb) and (chunk, enc, cb) overloads untouched.
+            return orig(out, enc, cb);
+        });
+    }
+}
 function log(tag, msg) {
     process.stderr.write(`[${tag}] ${msg}\n`);
 }

package/dist/lib/utils/mlx-hf-cache.js

@@ -0,0 +1,114 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_MLX_EMBED_MODEL = void 0;
+exports.isMlxModelCached = isMlxModelCached;
+exports.resolveMlxHfHome = resolveMlxHfHome;
+const node_child_process_1 = require("node:child_process");
+const fs = __importStar(require("node:fs"));
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
+const config_1 = require("../../config");
+const logger_1 = require("./logger");
+/** Default model served by mlx-embed-server/server.py (keep in sync). */
+exports.DEFAULT_MLX_EMBED_MODEL = "ibm-granite/granite-embedding-small-english-r2";
+function hasSnapshot(modelDir) {
+    try {
+        return fs.readdirSync(path.join(modelDir, "snapshots")).length > 0;
+    }
+    catch (_a) {
+        return false;
+    }
+}
+/**
+ * Whether an MLX model already has a snapshot in the local pinned HF cache
+ * (~/.gmax/hf). Used by `gmax doctor` to report gpu-mode embed model status
+ * from the HF cache rather than the ONNX models dir (where MLX models never
+ * live). Independent of whether the embed server is currently running.
+ */
+function isMlxModelCached(modelId = exports.DEFAULT_MLX_EMBED_MODEL, localHfHome = config_1.PATHS.hfDir) {
+    const modelDirName = `models--${modelId.replace(/\//g, "--")}`;
+    return hasSnapshot(path.join(localHfHome, "hub", modelDirName));
+}
+/**
+ * Resolve the HF_HOME to spawn the MLX embed server with, pinned to internal
+ * disk (~/.gmax/hf).
+ *
+ * The user's shell HF_HOME — and even ~/.cache/huggingface, which may itself
+ * be a symlink — can live on an external volume. When that volume is
+ * unmounted the embed server dies at model load (PermissionError on the dead
+ * mountpoint) and every worker silently degrades to ONNX CPU. The embed
+ * model is small (~185MB), so keeping a private copy under ~/.gmax/hf makes
+ * the server immune to drive state and shell env.
+ *
+ * Seeds the local cache from the inherited HF cache when the model is
+ * already there (one-time `cp -R`, preserves the hub layout's relative
+ * snapshot→blob symlinks) so the first spawn needs no network. Otherwise the
+ * server downloads into the local cache on startup. Copies land in a temp
+ * dir and are renamed into place so a partial copy never looks complete —
+ * server.py flips to offline mode whenever the model dir is non-empty.
+ */
+function resolveMlxHfHome(modelId = exports.DEFAULT_MLX_EMBED_MODEL, opts = {}) {
+    var _a, _b, _c;
+    const localHfHome = (_a = opts.localHfHome) !== null && _a !== void 0 ? _a : config_1.PATHS.hfDir;
+    const hubDir = path.join(localHfHome, "hub");
+    const modelDirName = `models--${modelId.replace(/\//g, "--")}`;
+    const localModelDir = path.join(hubDir, modelDirName);
+    try {
+        fs.mkdirSync(hubDir, { recursive: true });
+    }
+    catch (_d) { }
+    if (hasSnapshot(localModelDir))
+        return localHfHome;
+    const inherited = (_c = (_b = opts.inheritedHfHome) !== null && _b !== void 0 ? _b : process.env.HF_HOME) !== null && _c !== void 0 ? _c : path.join(os.homedir(), ".cache", "huggingface");
+    const sourceModelDir = path.join(inherited, "hub", modelDirName);
+    const tmpDir = path.join(hubDir, `.seed-${modelDirName}`);
+    try {
+        if (hasSnapshot(sourceModelDir)) {
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+            (0, node_child_process_1.execFileSync)("cp", ["-R", sourceModelDir, tmpDir], { timeout: 300000 });
+            fs.renameSync(tmpDir, localModelDir);
+            (0, logger_1.log)("mlx", `seeded local HF cache for ${modelId} from ${sourceModelDir}`);
+        }
+    }
+    catch (err) {
+        try {
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        }
+        catch (_e) { }
+        (0, logger_1.log)("mlx", `local HF cache seed failed (${err instanceof Error ? err.message : String(err)}) — model will download on first server start`);
+    }
+    return localHfHome;
+}