grepmax 0.23.0 → 0.25.0

package/dist/commands/serve.js

@@ -41,77 +41,345 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.serve = void 0;
+exports.serve = exports.MAX_HTTP_SEARCH_LIMIT = void 0;
+exports.waitForChildSpawn = waitForChildSpawn;
+exports.serveRootError = serveRootError;
+exports.createServeHttpServer = createServeHttpServer;
+exports.listenOnLoopback = listenOnLoopback;
 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 commander_1 = require("commander");
 const config_1 = require("../config");
-const grammar_loader_1 = require("../lib/index/grammar-loader");
-const index_config_1 = require("../lib/index/index-config");
-const sync_helpers_1 = require("../lib/index/sync-helpers");
-const syncer_1 = require("../lib/index/syncer");
-const watcher_1 = require("../lib/index/watcher");
-const searcher_1 = require("../lib/search/searcher");
-const setup_helpers_1 = require("../lib/setup/setup-helpers");
-const meta_cache_1 = require("../lib/store/meta-cache");
-const vector_db_1 = require("../lib/store/vector-db");
+const blocked_roots_1 = require("../lib/utils/blocked-roots");
+const daemon_client_1 = require("../lib/utils/daemon-client");
 const exit_1 = require("../lib/utils/exit");
 const log_rotate_1 = require("../lib/utils/log-rotate");
+const path_containment_1 = require("../lib/utils/path-containment");
 const project_root_1 = require("../lib/utils/project-root");
+const scope_filter_1 = require("../lib/utils/scope-filter");
 const server_registry_1 = require("../lib/utils/server-registry");
-function isMlxServerUp() {
-    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);
+const LOOPBACK_HOST = "127.0.0.1";
+const MAX_BODY_BYTES = 1000000;
+exports.MAX_HTTP_SEARCH_LIMIT = 50;
+class HttpRequestError extends Error {
+    constructor(status, code) {
+        super(code);
+        this.status = status;
+        this.code = code;
+    }
+}
+function waitForChildSpawn(child) {
+    return new Promise((resolve, reject) => {
+        const onSpawn = () => {
+            child.off("error", onError);
+            child.on("error", (error) => {
+                console.error(`Background server process error: ${error.message}`);
+            });
+            if (child.pid === undefined) {
+                reject(new Error("Background process started without a PID"));
+                return;
+            }
+            resolve(child.pid);
+        };
+        const onError = (error) => {
+            child.off("spawn", onSpawn);
+            reject(error);
+        };
+        child.once("spawn", onSpawn);
+        child.once("error", onError);
+    });
+}
+function writeJson(res, status, body) {
+    if (res.writableEnded)
+        return;
+    res.statusCode = status;
+    res.setHeader("Content-Type", "application/json");
+    res.end(JSON.stringify(body));
+}
+function readJsonBody(req) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        let size = 0;
+        let settled = false;
+        const fail = (err) => {
+            if (settled)
+                return;
+            settled = true;
+            reject(err);
+        };
+        req.on("data", (chunk) => {
+            if (settled)
+                return;
+            size += chunk.length;
+            if (size > MAX_BODY_BYTES) {
+                fail(new HttpRequestError(413, "payload_too_large"));
+                return;
+            }
+            chunks.push(chunk);
         });
-        req.on("error", () => resolve(false));
-        req.on("timeout", () => {
-            req.destroy();
-            resolve(false);
+        req.on("error", fail);
+        req.on("aborted", () => fail(new HttpRequestError(499, "aborted")));
+        req.on("end", () => {
+            if (settled)
+                return;
+            settled = true;
+            try {
+                const value = chunks.length
+                    ? JSON.parse(Buffer.concat(chunks).toString("utf8"))
+                    : {};
+                if (!value || typeof value !== "object" || Array.isArray(value)) {
+                    reject(new HttpRequestError(400, "invalid_json_object"));
+                    return;
+                }
+                resolve(value);
+            }
+            catch (_a) {
+                reject(new HttpRequestError(400, "invalid_json"));
+            }
         });
     });
 }
-function startMlxServer(mlxModel) {
-    // Look for mlx-embed-server 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)
-        return null;
-    const out = (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;
+function daemonErrorStatus(error) {
+    if (error === "busy" || error === "rebuilding")
+        return 503;
+    if (error === "project not registered" || error === "project not watched") {
+        return 404;
+    }
+    if (error === "invalid limit" || error === "invalid path")
+        return 400;
+    return 500;
+}
+function serveRootError(root) {
+    if (!(0, blocked_roots_1.isBlockedProjectRoot)(root))
+        return undefined;
+    return (`Refusing to serve ${root}: this path is blocked from indexing.\n` +
+        `(Blocked: ${blocked_roots_1.BLOCKED_ROOTS_DESCRIPTION}.)\n` +
+        "Pick a specific project subdirectory instead.");
+}
+function optionalString(body, key) {
+    const value = body[key];
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== "string")
+        throw new HttpRequestError(400, `invalid_${key}`);
+    return value;
+}
+function optionalStringArray(body, key) {
+    const value = body[key];
+    if (value === undefined)
+        return undefined;
+    if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) {
+        throw new HttpRequestError(400, `invalid_${key}`);
     }
-    const child = (0, node_child_process_1.spawn)("uv", ["run", "python", "server.py"], {
-        cwd: serverDir,
-        detached: true,
-        stdio: ["ignore", out, out],
-        env,
+    return value;
+}
+function createServeHttpServer(projectRoot, deps) {
+    const active = new Set();
+    const server = http.createServer((req, res) => __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c, _d;
+        (_a = deps.onActivity) === null || _a === void 0 ? void 0 : _a.call(deps);
+        if (req.method === "GET" && req.url === "/health") {
+            writeJson(res, 200, { status: "ok" });
+            return;
+        }
+        const ac = new AbortController();
+        active.add(ac);
+        const abort = () => ac.abort();
+        req.once("aborted", abort);
+        res.once("close", () => {
+            if (!res.writableFinished)
+                abort();
+        });
+        try {
+            if (req.method === "GET" && req.url === "/stats") {
+                const response = yield deps.stats(ac.signal);
+                if (!response.ok) {
+                    writeJson(res, daemonErrorStatus(response.error), {
+                        error: (_b = response.error) !== null && _b !== void 0 ? _b : "stats_failed",
+                    });
+                    return;
+                }
+                const { ok: _ok } = response, stats = __rest(response, ["ok"]);
+                writeJson(res, 200, stats);
+                return;
+            }
+            if (req.method === "POST" && req.url === "/search") {
+                const body = yield readJsonBody(req);
+                const query = typeof body.query === "string" ? body.query.trim() : "";
+                if (!query)
+                    throw new HttpRequestError(400, "invalid_query");
+                const limit = body.limit === undefined ? 10 : body.limit;
+                if (typeof limit !== "number" ||
+                    !Number.isInteger(limit) ||
+                    limit < 1 ||
+                    limit > exports.MAX_HTTP_SEARCH_LIMIT) {
+                    throw new HttpRequestError(400, "invalid_limit");
+                }
+                const requestedPath = optionalString(body, "path");
+                const inValues = optionalStringArray(body, "in");
+                const excludeValues = optionalStringArray(body, "exclude");
+                const scope = (0, scope_filter_1.resolveScope)({
+                    projectRoot,
+                    in: (inValues === null || inValues === void 0 ? void 0 : inValues.length)
+                        ? inValues
+                        : requestedPath
+                            ? [requestedPath]
+                            : undefined,
+                    exclude: excludeValues,
+                });
+                if (requestedPath) {
+                    (0, path_containment_1.resolveContainedPath)(projectRoot, requestedPath, {
+                        verifyExistingTarget: true,
+                    });
+                }
+                const filters = {};
+                const file = optionalString(body, "file");
+                const language = optionalString(body, "lang");
+                const role = optionalString(body, "role");
+                if (file)
+                    filters.file = file;
+                if (language)
+                    filters.language = language;
+                if (role)
+                    filters.role = role;
+                if (scope.inPrefixes.length > 0)
+                    filters.inPrefixes = scope.inPrefixes;
+                if (scope.excludePrefixes.length > 0) {
+                    filters.excludePrefixes = scope.excludePrefixes;
+                }
+                const response = yield deps.search({
+                    query,
+                    limit,
+                    pathPrefix: scope.pathPrefix,
+                    filters: Object.keys(filters).length ? filters : undefined,
+                }, ac.signal);
+                if (!response.ok) {
+                    writeJson(res, daemonErrorStatus(response.error), {
+                        error: (_c = response.error) !== null && _c !== void 0 ? _c : "search_failed",
+                    });
+                    return;
+                }
+                writeJson(res, 200, { results: (_d = response.data) !== null && _d !== void 0 ? _d : [] });
+                return;
+            }
+            writeJson(res, 404, { error: "not_found" });
+        }
+        catch (err) {
+            if (ac.signal.aborted)
+                return;
+            if (err instanceof path_containment_1.PathContainmentError) {
+                writeJson(res, 400, { error: "path_outside_project" });
+            }
+            else if (err instanceof HttpRequestError) {
+                writeJson(res, err.status, { error: err.code });
+            }
+            else {
+                writeJson(res, 500, {
+                    error: err instanceof Error ? err.message : "internal_error",
+                });
+            }
+        }
+        finally {
+            active.delete(ac);
+        }
+    }));
+    server.setTimeout(60000);
+    return {
+        server,
+        abortActive: () => {
+            for (const ac of active)
+                ac.abort();
+            active.clear();
+        },
+    };
+}
+function listenOnLoopback(server_1, startPort_1) {
+    return __awaiter(this, arguments, void 0, function* (server, startPort, attempts = 10) {
+        let port = startPort;
+        for (let attempt = 0; attempt < attempts; attempt++, port++) {
+            try {
+                yield new Promise((resolve, reject) => {
+                    const onError = (err) => {
+                        server.off("listening", onListening);
+                        reject(err);
+                    };
+                    const onListening = () => {
+                        server.off("error", onError);
+                        resolve();
+                    };
+                    server.once("error", onError);
+                    server.once("listening", onListening);
+                    server.listen(port, LOOPBACK_HOST);
+                });
+                const address = server.address();
+                return typeof address === "object" && address ? address.port : port;
+            }
+            catch (err) {
+                if (err.code !== "EADDRINUSE")
+                    throw err;
+            }
+        }
+        throw new Error(`Could not find an open port between ${startPort} and ${startPort + attempts - 1}`);
+    });
+}
+function closeServer(server) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!server.listening)
+            return;
+        yield new Promise((resolve) => {
+            const timeout = setTimeout(() => {
+                var _a;
+                (_a = server.closeAllConnections) === null || _a === void 0 ? void 0 : _a.call(server);
+                resolve();
+            }, 5000);
+            server.close(() => {
+                clearTimeout(timeout);
+                resolve();
+            });
+        });
     });
-    child.unref();
-    return child;
 }
 exports.serve = new commander_1.Command("serve")
-    .description("HTTP search server with live file watching")
+    .description("Loopback HTTP search adapter backed by the gmax daemon")
     .option("-p, --port <port>", "Port to listen on", process.env.GMAX_PORT || "4444")
     .option("-b, --background", "Run in background", false)
-    .option("--cpu", "Use CPU-only embeddings (skip MLX GPU server)", false)
+    .option("--cpu", "Deprecated: configure daemon CPU mode with gmax config", false)
     .option("--no-idle-timeout", "Disable the 30-minute idle shutdown", false)
     .action((_args, cmd) => __awaiter(void 0, void 0, void 0, function* () {
     var _a, _b;
     const options = cmd.optsWithGlobals();
-    let port = parseInt(options.port, 10);
-    const startPort = port;
+    const port = Number.parseInt(options.port, 10);
     const projectRoot = (_a = (0, project_root_1.findProjectRoot)(process.cwd())) !== null && _a !== void 0 ? _a : process.cwd();
-    // Check if already running
+    if (!Number.isInteger(port) || port < 1 || port > 65535) {
+        console.error(`Invalid port: ${options.port}`);
+        process.exitCode = 1;
+        return;
+    }
+    const blockedRootError = serveRootError(projectRoot);
+    if (blockedRootError) {
+        console.error(blockedRootError);
+        process.exitCode = 1;
+        return;
+    }
+    if (options.cpu) {
+        console.error("--cpu is now configured on the daemon. Run `gmax config --embed-mode cpu`, then start serve again.");
+        process.exitCode = 1;
+        return;
+    }
     const existing = (0, server_registry_1.getServerForProject)(projectRoot);
     if (existing && (0, server_registry_1.isProcessRunning)(existing.pid)) {
         console.log(`Server already running for ${projectRoot} (PID: ${existing.pid}, Port: ${existing.port})`);
@@ -127,325 +395,101 @@ exports.serve = new commander_1.Command("serve")
         const logFile = path.join(config_1.PATHS.logsDir, `server-${safeName}.log`);
         const out = (0, log_rotate_1.openRotatedLog)(logFile);
         const err = (0, log_rotate_1.openRotatedLog)(logFile);
-        const child = (0, node_child_process_1.spawn)(process.argv[0], [process.argv[1], ...args], {
-            detached: true,
-            stdio: ["ignore", out, err],
-            cwd: process.cwd(),
-            env: Object.assign(Object.assign({}, process.env), { GMAX_BACKGROUND: "true" }),
-        });
-        child.unref();
-        console.log(`Started background server (PID: ${child.pid})`);
-        return;
-    }
-    const paths = (0, project_root_1.ensureProjectPaths)(projectRoot);
-    const projectName = path.basename(projectRoot);
-    // Propagate project root to worker processes
-    process.env.GMAX_PROJECT_ROOT = projectRoot;
-    // Determine embed mode: --cpu flag overrides, then config, then default
-    // Default to GPU on Apple Silicon, CPU everywhere else
-    const isAppleSilicon = process.arch === "arm64" && process.platform === "darwin";
-    const indexConfig = (0, index_config_1.readIndexConfig)(paths.configPath);
-    const useGpu = options.cpu
-        ? false
-        : ((_b = indexConfig === null || indexConfig === void 0 ? void 0 : indexConfig.embedMode) !== null && _b !== void 0 ? _b : (isAppleSilicon ? "gpu" : "cpu")) === "gpu";
-    const mlxModel = indexConfig === null || indexConfig === void 0 ? void 0 : indexConfig.mlxModel;
-    // MLX GPU embed server — started when GPU mode is active.
-    let mlxChild = null;
-    if (!useGpu) {
-        console.log(`[serve:${projectName}] CPU-only mode`);
-    }
-    else {
-        const mlxUp = yield isMlxServerUp();
-        if (mlxUp) {
-            console.log(`[serve:${projectName}] MLX GPU server already running`);
+        try {
+            const child = (0, node_child_process_1.spawn)(process.argv[0], [process.argv[1], ...args], {
+                detached: true,
+                stdio: ["ignore", out, err],
+                cwd: process.cwd(),
+                env: Object.assign(Object.assign({}, process.env), { GMAX_BACKGROUND: "true" }),
+            });
+            const childPid = yield waitForChildSpawn(child);
+            child.unref();
+            console.log(`Started background server (PID: ${childPid})`);
         }
-        else {
-            mlxChild = startMlxServer(mlxModel);
-            if (mlxChild) {
-                console.log(`[serve] Starting MLX GPU embed server (PID: ${mlxChild.pid})${mlxModel ? ` [${mlxModel}]` : ""}`);
-                let ready = false;
-                for (let i = 0; i < 30; i++) {
-                    yield new Promise((r) => setTimeout(r, 1000));
-                    if (yield isMlxServerUp()) {
-                        console.log(`[serve:${projectName}] MLX GPU server ready`);
-                        ready = true;
-                        break;
-                    }
-                }
-                if (!ready) {
-                    console.error(`[serve:${projectName}] MLX GPU server failed to start. Run with --cpu to use CPU embeddings.`);
-                    process.exitCode = 1;
-                    return;
-                }
-            }
-            else {
-                console.error(`[serve:${projectName}] MLX server not found. Run with --cpu to use CPU embeddings.`);
-                process.exitCode = 1;
-                return;
-            }
+        catch (err) {
+            console.error(`Failed to start background server: ${err instanceof Error ? err.message : String(err)}`);
+            process.exitCode = 1;
         }
+        finally {
+            fs.closeSync(out);
+            fs.closeSync(err);
+        }
+        return;
     }
+    const startupAc = new AbortController();
+    let runtime = null;
+    let idleTimer = null;
+    let registered = false;
+    let shutdownPromise = null;
+    const shutdown = (code = 0) => {
+        if (shutdownPromise)
+            return shutdownPromise;
+        shutdownPromise = (() => __awaiter(void 0, void 0, void 0, function* () {
+            startupAc.abort();
+            if (idleTimer)
+                clearInterval(idleTimer);
+            runtime === null || runtime === void 0 ? void 0 : runtime.abortActive();
+            if (runtime)
+                yield closeServer(runtime.server);
+            if (registered)
+                (0, server_registry_1.unregisterServer)(process.pid);
+            yield (0, exit_1.gracefulExit)(code);
+        }))();
+        return shutdownPromise;
+    };
+    process.once("SIGINT", () => void shutdown());
+    process.once("SIGTERM", () => void shutdown());
     try {
-        yield (0, setup_helpers_1.ensureSetup)();
-        yield (0, grammar_loader_1.ensureGrammars)(console.log, { silent: true });
-        // Initial sync is self-contained (creates+closes its own VectorDB+MetaCache).
-        if (!process.env.GMAX_BACKGROUND) {
-            const { spinner, onProgress } = (0, sync_helpers_1.createIndexingSpinner)(projectRoot, "Indexing before starting server...");
-            try {
-                yield (0, syncer_1.initialSync)({ projectRoot, onProgress });
-                spinner.succeed("Initial index ready. Starting server...");
-            }
-            catch (e) {
-                spinner.fail("Indexing failed");
-                throw e;
-            }
+        if (!(yield (0, daemon_client_1.ensureDaemonRunning)())) {
+            throw new Error("Could not start the gmax daemon");
         }
-        else {
-            yield (0, syncer_1.initialSync)({ projectRoot });
+        const ensured = yield (0, daemon_client_1.sendStreamingCommand)({ cmd: "ensure-project", root: projectRoot }, () => { }, { signal: startupAc.signal });
+        if (!ensured.ok) {
+            throw new Error(String((_b = ensured.error) !== null && _b !== void 0 ? _b : "project setup failed"));
         }
-        // Open long-lived resources for serving + watching.
-        const vectorDb = new vector_db_1.VectorDB(paths.lancedbDir);
-        const metaCache = new meta_cache_1.MetaCache(paths.lmdbPath);
-        const searcher = new searcher_1.Searcher(vectorDb);
-        // Start live file watcher
-        let fileWatcher = yield (0, watcher_1.startWatcher)({
-            projectRoot,
-            vectorDb,
-            metaCache,
-            dataDir: paths.dataDir,
-            onReindex: (files, durationMs) => {
-                console.log(`[watch:${projectName}] Reindexed ${files} file${files !== 1 ? "s" : ""} (${(durationMs / 1000).toFixed(1)}s)`);
+        let lastActivity = Date.now();
+        runtime = createServeHttpServer(projectRoot, {
+            onActivity: () => {
+                lastActivity = Date.now();
             },
+            search: (input, signal) => (0, daemon_client_1.sendDaemonCommand)({
+                cmd: "search",
+                projectRoot,
+                query: input.query,
+                limit: input.limit,
+                pathPrefix: input.pathPrefix,
+                filters: input.filters,
+                rerank: true,
+            }, { timeoutMs: 65000, signal }),
+            stats: (signal) => (0, daemon_client_1.sendDaemonCommand)({ cmd: "project-stats", root: projectRoot }, { timeoutMs: 10000, signal }),
         });
-        console.log(`[serve:${projectName}] File watcher active`);
-        // Idle timeout: shut down if no searches for 30 minutes
-        // Disabled when started by MCP server (--no-idle-timeout)
-        let lastActivity = Date.now();
+        const actualPort = yield listenOnLoopback(runtime.server, port);
+        (0, server_registry_1.registerServer)({
+            pid: process.pid,
+            port: actualPort,
+            projectRoot,
+            startTime: Date.now(),
+        });
+        registered = true;
         if (options.idleTimeout) {
-            const IDLE_TIMEOUT_MS = 30 * 60 * 1000;
-            const idleCheck = setInterval(() => {
-                if (Date.now() - lastActivity > IDLE_TIMEOUT_MS) {
-                    console.log(`[serve:${projectName}] Idle timeout reached, shutting down.`);
-                    clearInterval(idleCheck);
-                    process.kill(process.pid, "SIGTERM");
+            idleTimer = setInterval(() => {
+                if (Date.now() - lastActivity > 30 * 60 * 1000) {
+                    void shutdown();
                 }
             }, 60000);
-            idleCheck.unref();
+            idleTimer.unref();
         }
-        const server = http.createServer((req, res) => __awaiter(void 0, void 0, void 0, function* () {
-            var _a, _b, _c, _d, _e;
-            try {
-                if (req.method === "GET" && req.url === "/health") {
-                    lastActivity = Date.now();
-                    res.statusCode = 200;
-                    res.setHeader("Content-Type", "application/json");
-                    res.end(JSON.stringify({ status: "ok" }));
-                    return;
-                }
-                if (req.method === "GET" && req.url === "/stats") {
-                    try {
-                        const dbStats = yield vectorDb.getStats();
-                        const cfg = (0, index_config_1.readIndexConfig)(paths.configPath);
-                        const stats = {
-                            files: dbStats.chunks > 0
-                                ? yield vectorDb.getDistinctFileCount()
-                                : 0,
-                            chunks: dbStats.chunks,
-                            totalBytes: dbStats.totalBytes,
-                            vectorDim: (_a = cfg === null || cfg === void 0 ? void 0 : cfg.vectorDim) !== null && _a !== void 0 ? _a : null,
-                            embedMode: (_b = cfg === null || cfg === void 0 ? void 0 : cfg.embedMode) !== null && _b !== void 0 ? _b : (isAppleSilicon ? "gpu" : "cpu"),
-                            model: (_c = cfg === null || cfg === void 0 ? void 0 : cfg.embedModel) !== null && _c !== void 0 ? _c : null,
-                            mlxModel: (_d = cfg === null || cfg === void 0 ? void 0 : cfg.mlxModel) !== null && _d !== void 0 ? _d : null,
-                            indexedAt: (_e = cfg === null || cfg === void 0 ? void 0 : cfg.indexedAt) !== null && _e !== void 0 ? _e : null,
-                            watching: fileWatcher !== null,
-                        };
-                        res.statusCode = 200;
-                        res.setHeader("Content-Type", "application/json");
-                        res.end(JSON.stringify(stats));
-                    }
-                    catch (err) {
-                        res.statusCode = 500;
-                        res.setHeader("Content-Type", "application/json");
-                        res.end(JSON.stringify({
-                            error: (err === null || err === void 0 ? void 0 : err.message) || "stats_failed",
-                        }));
-                    }
-                    return;
-                }
-                if (req.method === "POST" && req.url === "/search") {
-                    lastActivity = Date.now();
-                    const chunks = [];
-                    let totalSize = 0;
-                    let aborted = false;
-                    req.on("data", (chunk) => {
-                        if (aborted)
-                            return;
-                        totalSize += chunk.length;
-                        if (totalSize > 1000000) {
-                            aborted = true;
-                            res.statusCode = 413;
-                            res.setHeader("Content-Type", "application/json");
-                            res.end(JSON.stringify({ error: "payload_too_large" }));
-                            req.destroy();
-                            return;
-                        }
-                        chunks.push(chunk);
-                    });
-                    req.on("end", () => __awaiter(void 0, void 0, void 0, function* () {
-                        if (aborted)
-                            return;
-                        try {
-                            const body = chunks.length
-                                ? JSON.parse(Buffer.concat(chunks).toString("utf-8"))
-                                : {};
-                            const query = typeof body.query === "string" ? body.query : "";
-                            const limit = typeof body.limit === "number" ? body.limit : 10;
-                            // Use absolute path prefix for search filtering
-                            let searchPath = `${projectRoot}/`;
-                            if (typeof body.path === "string") {
-                                const resolvedPath = path.resolve(projectRoot, body.path);
-                                searchPath = resolvedPath.endsWith("/")
-                                    ? resolvedPath
-                                    : `${resolvedPath}/`;
-                            }
-                            // Add AbortController for cancellation
-                            const ac = new AbortController();
-                            req.on("close", () => {
-                                if (req.complete)
-                                    return;
-                                ac.abort();
-                            });
-                            res.on("close", () => {
-                                if (res.writableFinished)
-                                    return;
-                                ac.abort();
-                            });
-                            const result = yield searcher.search(query, limit, { rerank: true }, undefined, searchPath, undefined, // intent
-                            ac.signal);
-                            if (ac.signal.aborted) {
-                                // Request was cancelled, don't write response if possible
-                                // (Though usually 'close' means the socket is gone anyway)
-                                return;
-                            }
-                            res.statusCode = 200;
-                            res.setHeader("Content-Type", "application/json");
-                            res.end(JSON.stringify({ results: result.data }));
-                        }
-                        catch (err) {
-                            if (err instanceof Error && err.name === "AbortError") {
-                                // Request cancelled
-                                return;
-                            }
-                            res.statusCode = 500;
-                            res.setHeader("Content-Type", "application/json");
-                            res.end(JSON.stringify({
-                                error: (err === null || err === void 0 ? void 0 : err.message) || "search_failed",
-                            }));
-                        }
-                    }));
-                    req.on("error", (err) => {
-                        console.error(`[serve:${projectName}] request error:`, err);
-                        aborted = true;
-                    });
-                    return;
-                }
-                res.statusCode = 404;
-                res.end();
-            }
-            catch (err) {
-                console.error(`[serve:${projectName}] request handler error:`, err);
-                if (!res.headersSent) {
-                    res.statusCode = 500;
-                    res.setHeader("Content-Type", "application/json");
-                    res.end(JSON.stringify({ error: "internal_error" }));
-                }
-            }
-        }));
-        server.on("error", (e) => {
-            if (e.code === "EADDRINUSE") {
-                const nextPort = port + 1;
-                if (nextPort < startPort + 10) {
-                    console.log(`Port ${port} in use, retrying with ${nextPort}...`);
-                    port = nextPort;
-                    server.close(() => {
-                        server.listen(port);
-                    });
-                    return;
-                }
-                console.error(`Could not find an open port between ${startPort} and ${startPort + 9}`);
-            }
-            console.error(`[serve:${projectName}] server error:`, e);
-            // Ensure we exit if server fails to start
-            process.exit(1);
+        runtime.server.on("error", (err) => {
+            console.error(`[serve:${path.basename(projectRoot)}] server error:`, err);
+            void shutdown(1);
         });
-        server.setTimeout(60000); // 60s request timeout
-        server.listen(port, () => {
-            const address = server.address();
-            const actualPort = typeof address === "object" && address ? address.port : port;
-            if (!process.env.GMAX_BACKGROUND) {
-                console.log(`gmax server listening on http://localhost:${actualPort} (${projectRoot})`);
-            }
-            (0, server_registry_1.registerServer)({
-                pid: process.pid,
-                port: actualPort,
-                projectRoot,
-                startTime: Date.now(),
-            });
-        });
-        const shutdown = () => __awaiter(void 0, void 0, void 0, function* () {
-            (0, server_registry_1.unregisterServer)(process.pid);
-            // Stop file watcher first
-            if (fileWatcher) {
-                try {
-                    yield fileWatcher.close();
-                }
-                catch (_a) { }
-                fileWatcher = null;
-            }
-            // Stop MLX server if we started it
-            if (mlxChild === null || mlxChild === void 0 ? void 0 : mlxChild.pid) {
-                try {
-                    process.kill(mlxChild.pid, "SIGTERM");
-                }
-                catch (_b) { }
-            }
-            // Properly await server close
-            yield new Promise((resolve, reject) => {
-                server.close((err) => {
-                    if (err) {
-                        console.error("Error closing server:", err);
-                        reject(err);
-                    }
-                    else {
-                        resolve();
-                    }
-                });
-                // Timeout fallback in case close hangs
-                setTimeout(resolve, 5000);
-            });
-            // Clean close of owned resources
-            try {
-                yield metaCache.close();
-            }
-            catch (e) {
-                console.error("Error closing meta cache:", e);
-            }
-            try {
-                yield vectorDb.close();
-            }
-            catch (e) {
-                console.error("Error closing vector DB:", e);
-            }
-            yield (0, exit_1.gracefulExit)();
-        });
-        process.on("SIGINT", shutdown);
-        process.on("SIGTERM", shutdown);
+        if (!process.env.GMAX_BACKGROUND) {
+            console.log(`gmax server listening on http://${LOOPBACK_HOST}:${actualPort} (${projectRoot})`);
+        }
     }
-    catch (error) {
-        const message = error instanceof Error ? error.message : "Unknown error";
-        console.error("Serve failed:", message);
-        process.exitCode = 1;
-        yield (0, exit_1.gracefulExit)(1);
+    catch (err) {
+        console.error(`Serve failed: ${err instanceof Error ? err.message : String(err)}`);
+        yield shutdown(1);
     }
 }));
 exports.serve
@@ -458,9 +502,9 @@ exports.serve
         return;
     }
     console.log("Running servers:");
-    servers.forEach((s) => {
-        console.log(`- PID: ${s.pid} | Port: ${s.port} | Root: ${s.projectRoot}`);
-    });
+    for (const server of servers) {
+        console.log(`- PID: ${server.pid} | Port: ${server.port} | Root: ${server.projectRoot}`);
+    }
 });
 exports.serve
     .command("stop")
@@ -471,31 +515,29 @@ exports.serve
     if (options.all) {
         const servers = (0, server_registry_1.listServers)();
         let count = 0;
-        servers.forEach((s) => {
+        for (const server of servers) {
             try {
-                process.kill(s.pid, "SIGTERM");
+                process.kill(server.pid, "SIGTERM");
                 count++;
             }
-            catch (e) {
-                console.error(`Failed to stop PID ${s.pid}:`, e);
+            catch (err) {
+                console.error(`Failed to stop PID ${server.pid}:`, err);
             }
-        });
+        }
         console.log(`Stopped ${count} servers.`);
+        return;
     }
-    else {
-        const projectRoot = (_a = (0, project_root_1.findProjectRoot)(process.cwd())) !== null && _a !== void 0 ? _a : process.cwd();
-        const server = (0, server_registry_1.getServerForProject)(projectRoot);
-        if (server) {
-            try {
-                process.kill(server.pid, "SIGTERM");
-                console.log(`Stopped server for ${projectRoot} (PID: ${server.pid})`);
-            }
-            catch (e) {
-                console.error(`Failed to stop PID ${server.pid}:`, e);
-            }
-        }
-        else {
-            console.log(`No server found for ${projectRoot}`);
-        }
+    const projectRoot = (_a = (0, project_root_1.findProjectRoot)(process.cwd())) !== null && _a !== void 0 ? _a : process.cwd();
+    const server = (0, server_registry_1.getServerForProject)(projectRoot);
+    if (!server) {
+        console.log(`No server found for ${projectRoot}`);
+        return;
+    }
+    try {
+        process.kill(server.pid, "SIGTERM");
+        console.log(`Stopped server for ${projectRoot} (PID: ${server.pid})`);
+    }
+    catch (err) {
+        console.error(`Failed to stop PID ${server.pid}:`, err);
     }
 });