grepmax 0.17.23 → 0.18.0

package/dist/lib/daemon/mlx-server-manager.js

@@ -0,0 +1,191 @@
+"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;
+    };
+})();
+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.MlxServerManager = void 0;
+const node_child_process_1 = require("node:child_process");
+const fs = __importStar(require("node:fs"));
+const http = __importStar(require("node:http"));
+const path = __importStar(require("node:path"));
+const config_1 = require("../../config");
+const log_rotate_1 = require("../utils/log-rotate");
+const process_1 = require("../utils/process");
+/**
+ * Owns the MLX embed server (port 8100) process lifecycle: spawn, health probe,
+ * zombie recovery, and teardown. Fully isolated — touches only the port and the
+ * child process, no shared daemon state beyond a shutting-down getter.
+ *
+ * Extracted from daemon.ts (Phase 2). `__dirname` resolves the bundled
+ * mlx-embed-server/server.py relative to this file; it sits in the same
+ * dist/lib/daemon directory as daemon.ts did, so resolution is unchanged.
+ */
+class MlxServerManager {
+    constructor(deps) {
+        this.deps = deps;
+        this.mlxChild = null;
+        this.mlxRecoveryInFlight = false;
+    }
+    isMlxServerUp() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const port = parseInt(process.env.MLX_EMBED_PORT || "8100", 10);
+            return new Promise((resolve) => {
+                const req = http.get({ hostname: "127.0.0.1", port, path: "/health", timeout: 2000 }, (res) => { res.resume(); resolve(res.statusCode === 200); });
+                req.on("error", () => resolve(false));
+                req.on("timeout", () => { req.destroy(); resolve(false); });
+            });
+        });
+    }
+    getPortPid(port) {
+        try {
+            const out = (0, node_child_process_1.execSync)(`lsof -ti :${port}`, { timeout: 5000 }).toString().trim();
+            const pid = parseInt(out.split("\n")[0], 10);
+            return Number.isFinite(pid) ? pid : null;
+        }
+        catch (_a) {
+            return null;
+        }
+    }
+    checkMlxHealth() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.deps.getShuttingDown() || this.mlxRecoveryInFlight)
+                return;
+            if (yield this.isMlxServerUp())
+                return;
+            const port = parseInt(process.env.MLX_EMBED_PORT || "8100", 10);
+            const stalePid = this.getPortPid(port);
+            if (!stalePid)
+                return; // No process — let the next user-facing path spawn it.
+            this.mlxRecoveryInFlight = true;
+            try {
+                console.log(`[daemon] MLX zombie detected on port ${port} (PID ${stalePid}) — killing and respawning`);
+                yield (0, process_1.killProcess)(stalePid);
+                yield new Promise((r) => setTimeout(r, 500));
+                yield this.ensureMlxServer();
+            }
+            catch (err) {
+                console.error(`[daemon] MLX recovery failed: ${err instanceof Error ? err.message : String(err)}`);
+            }
+            finally {
+                this.mlxRecoveryInFlight = false;
+            }
+        });
+    }
+    ensureMlxServer(mlxModel) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (yield this.isMlxServerUp()) {
+                console.log("[daemon] MLX embed server already running");
+                return;
+            }
+            // Kill stale process holding the port (orphaned from a previous daemon)
+            const port = parseInt(process.env.MLX_EMBED_PORT || "8100", 10);
+            const stalePid = this.getPortPid(port);
+            if (stalePid) {
+                console.log(`[daemon] Killing stale MLX process on port ${port} (PID: ${stalePid})`);
+                yield (0, process_1.killProcess)(stalePid);
+                // Brief pause for OS to release the port
+                yield new Promise((r) => setTimeout(r, 500));
+            }
+            // Find mlx-embed-server/server.py relative to the grepmax package
+            const candidates = [
+                path.resolve(__dirname, "../../../mlx-embed-server"),
+                path.resolve(__dirname, "../../mlx-embed-server"),
+            ];
+            const serverDir = candidates.find((d) => fs.existsSync(path.join(d, "server.py")));
+            if (!serverDir) {
+                console.warn("[daemon] MLX embed server not found — falling back to CPU embeddings");
+                return;
+            }
+            const logFd = (0, log_rotate_1.openRotatedLog)(path.join(config_1.PATHS.logsDir, "mlx-embed-server.log"));
+            const env = Object.assign({}, process.env);
+            if (mlxModel)
+                env.MLX_EMBED_MODEL = mlxModel;
+            this.mlxChild = (0, node_child_process_1.spawn)("uv", ["run", "python", "server.py"], {
+                cwd: serverDir,
+                detached: true,
+                stdio: ["ignore", logFd, logFd],
+                env,
+            });
+            this.mlxChild.unref();
+            console.log(`[daemon] Starting MLX embed server (PID: ${this.mlxChild.pid})`);
+            // Poll for readiness (up to 30s)
+            for (let i = 0; i < 30; i++) {
+                yield new Promise((r) => setTimeout(r, 1000));
+                if (yield this.isMlxServerUp()) {
+                    console.log("[daemon] MLX embed server ready");
+                    return;
+                }
+            }
+            console.error("[daemon] MLX embed server failed to start within 30s — falling back to CPU embeddings");
+            this.mlxChild = null;
+        });
+    }
+    stopMlxServer() {
+        var _a;
+        // The spawned process is `uv`, which forks `python` then exits. Killing the
+        // recorded PID alone leaves python orphaned (the orphan source for port 8100
+        // collisions across daemon restarts). Always also kill whoever owns the port.
+        if ((_a = this.mlxChild) === null || _a === void 0 ? void 0 : _a.pid) {
+            try {
+                process.kill(-this.mlxChild.pid, "SIGTERM");
+            }
+            catch (_b) {
+                try {
+                    process.kill(this.mlxChild.pid, "SIGTERM");
+                }
+                catch (_c) { }
+            }
+            console.log(`[daemon] Stopped MLX embed server (PID: ${this.mlxChild.pid})`);
+            this.mlxChild = null;
+        }
+        const port = parseInt(process.env.MLX_EMBED_PORT || "8100", 10);
+        const portOwner = this.getPortPid(port);
+        if (portOwner) {
+            try {
+                process.kill(portOwner, "SIGTERM");
+                console.log(`[daemon] Killed orphan MLX on port ${port} (PID: ${portOwner})`);
+            }
+            catch (_d) { }
+        }
+    }
+}
+exports.MlxServerManager = MlxServerManager;

package/dist/lib/daemon/process-manager.js

@@ -0,0 +1,139 @@
+"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.ProcessManager = void 0;
+const node_child_process_1 = require("node:child_process");
+const daemon_client_1 = require("../utils/daemon-client");
+const logger_1 = require("../utils/logger");
+const process_1 = require("../utils/process");
+const pool_1 = require("../workers/pool");
+/**
+ * OS-level process hygiene for the daemon: discovering processes by title,
+ * sweeping orphaned workers, and killing stale daemons/workers at startup.
+ *
+ * Extracted from daemon.ts (Phase 2). Holds no daemon state beyond its own
+ * orphan-suspicion set and a shutting-down getter — the lowest-coupling of the
+ * three managers.
+ */
+class ProcessManager {
+    constructor(deps) {
+        this.deps = deps;
+        // PIDs flagged as orphan workers on the previous sweep. A worker must look
+        // orphaned twice in a row before we kill it, so a worker the pool forked
+        // between our process snapshot and its array update is never killed by a race.
+        this.suspectedOrphanWorkers = new Set();
+    }
+    /**
+     * Kill gmax-worker processes that are children of THIS daemon but the worker
+     * pool no longer tracks — strays left behind if a kill ever failed silently.
+     * Filters by parent PID so a per-project `gmax watch`'s own workers are never
+     * touched. Requires a worker to look orphaned on two consecutive sweeps so a
+     * just-forked worker can't be killed by a snapshot race.
+     */
+    sweepOrphanWorkers() {
+        if (this.deps.getShuttingDown() || !(0, pool_1.isWorkerPoolInitialized)())
+            return;
+        const tracked = new Set((0, pool_1.getWorkerPool)().getWorkerPids());
+        const workerPids = new Set(this.findProcessesByTitle("gmax-worker"));
+        const ourChildren = this.findChildPids();
+        const orphans = ourChildren.filter((pid) => workerPids.has(pid) && !tracked.has(pid));
+        const confirmed = orphans.filter((pid) => this.suspectedOrphanWorkers.has(pid));
+        this.suspectedOrphanWorkers = new Set(orphans);
+        for (const pid of confirmed) {
+            console.log(`[daemon] Killing orphan worker PID:${pid} (untracked by pool)`);
+            try {
+                process.kill(pid, "SIGKILL");
+            }
+            catch (_a) { }
+            this.suspectedOrphanWorkers.delete(pid);
+        }
+    }
+    /** Child PIDs of this process (workers, MLX, llama-server). */
+    findChildPids() {
+        try {
+            const out = (0, node_child_process_1.execSync)(`pgrep -P ${process.pid}`, {
+                timeout: 5000,
+                encoding: "utf-8",
+            }).trim();
+            if (!out)
+                return [];
+            return out
+                .split("\n")
+                .map((s) => parseInt(s.trim(), 10))
+                .filter((n) => Number.isFinite(n) && n > 0);
+        }
+        catch (_a) {
+            return [];
+        }
+    }
+    /**
+     * Find and kill all stale gmax-daemon and gmax-worker processes.
+     * Uses pgrep to scan by process title rather than relying solely on
+     * the PID file, which becomes stale when a daemon is orphaned through
+     * the lock-compromise path.
+     */
+    killStaleProcesses() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // 1. Check for other daemon processes
+            const daemonPids = this.findProcessesByTitle("gmax-daemon")
+                .filter((pid) => pid !== process.pid);
+            const workerPids = this.findProcessesByTitle("gmax-worker");
+            if (daemonPids.length === 0 && workerPids.length === 0) {
+                (0, logger_1.log)("daemon", "No stale processes found");
+                return;
+            }
+            for (const pid of daemonPids) {
+                (0, logger_1.log)("daemon", `found daemon PID:${pid}, checking liveness...`);
+                // A busy daemon (mid-index, compaction, big LMDB write) can block the
+                // event loop long enough to miss a ping. Two independent liveness
+                // probes — if either says "alive", defer to the running peer instead
+                // of killing its workers mid-flight.
+                //   1. daemon.lock mtime (refreshed by heartbeat every 60s)
+                //   2. socket ping with a generous 10s timeout
+                const heartbeatFresh = (0, daemon_client_1.isDaemonHeartbeatFresh)();
+                const responsive = yield (0, daemon_client_1.isDaemonRunning)({ timeoutMs: 10000 });
+                if (heartbeatFresh || responsive) {
+                    (0, logger_1.log)("daemon", `existing daemon PID:${pid} is alive (heartbeat=${heartbeatFresh} ping=${responsive}) — exiting`);
+                    process.exit(0);
+                }
+                (0, logger_1.log)("daemon", `stale daemon PID:${pid} unresponsive and heartbeat stale — killing`);
+                yield (0, process_1.killProcess)(pid);
+                (0, logger_1.log)("daemon", `killed stale daemon PID:${pid}`);
+            }
+            // 2. Kill orphaned workers from previous daemon instances.
+            // Safe because this runs before the new daemon's worker pool is initialized.
+            for (const pid of workerPids) {
+                (0, logger_1.log)("daemon", `killing orphaned worker PID:${pid}`);
+                yield (0, process_1.killProcess)(pid);
+            }
+            (0, logger_1.log)("daemon", `Cleaned up ${daemonPids.length} stale daemon(s), ${workerPids.length} orphaned worker(s)`);
+        });
+    }
+    findProcessesByTitle(title) {
+        try {
+            const out = (0, node_child_process_1.execSync)(`pgrep -x "${title}"`, {
+                timeout: 5000,
+                encoding: "utf-8",
+            }).trim();
+            if (!out)
+                return [];
+            return out
+                .split("\n")
+                .map((s) => parseInt(s.trim(), 10))
+                .filter((n) => Number.isFinite(n) && n > 0);
+        }
+        catch (_a) {
+            // pgrep exits 1 when no processes match — not an error
+            return [];
+        }
+    }
+}
+exports.ProcessManager = ProcessManager;