grepmax 0.24.0 → 0.25.0

package/dist/lib/daemon/ipc-handler.js

@@ -42,6 +42,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.EXCLUSIVE_GENERATION_REBUILD_PROTOCOL = void 0;
 exports.writeProgress = writeProgress;
 exports.writeDone = writeDone;
 exports.startHeartbeat = startHeartbeat;
@@ -49,6 +50,9 @@ exports.handleCommand = handleCommand;
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
 const logger_1 = require("../utils/logger");
+const operation_coordinator_1 = require("../utils/operation-coordinator");
+const path_containment_1 = require("../utils/path-containment");
+const project_registry_1 = require("../utils/project-registry");
 const DAEMON_VERSION = (() => {
     try {
         return JSON.parse(fs.readFileSync(path.join(__dirname, "../../../package.json"), "utf-8")).version;
@@ -57,6 +61,7 @@ const DAEMON_VERSION = (() => {
         return "unknown";
     }
 })();
+exports.EXCLUSIVE_GENERATION_REBUILD_PROTOCOL = 1;
 /**
  * Write a streaming progress line to the IPC connection.
  */
@@ -74,6 +79,19 @@ function writeDone(conn, data) {
     conn.write(`${JSON.stringify(Object.assign({ type: "done" }, data))}\n`);
     conn.end();
 }
+function errorResponse(err) {
+    if (err instanceof operation_coordinator_1.OperationBusyError ||
+        err instanceof operation_coordinator_1.OperationClosedError) {
+        return { ok: false, error: err.message, code: err.code };
+    }
+    return {
+        ok: false,
+        error: err instanceof Error ? err.message : String(err),
+    };
+}
+function startStreaming(conn, operation) {
+    void operation().catch((err) => writeDone(conn, errorResponse(err)));
+}
 const HEARTBEAT_INTERVAL_MS = 5000;
 /**
  * Emit periodic heartbeat lines so the client's watchdog timer resets even
@@ -102,9 +120,15 @@ function startHeartbeat(conn, intervalMs = HEARTBEAT_INTERVAL_MS) {
  */
 function handleCommand(daemon, cmd, conn) {
     return __awaiter(this, void 0, void 0, function* () {
-        var _a, _b, _c, _d, _e;
+        var _a, _b, _c, _d, _e, _f, _g;
         try {
             (0, logger_1.debug)("daemon", `ipc cmd=${cmd.cmd}${cmd.root ? ` root=${cmd.root}` : ""}`);
+            if (cmd.cmd !== "ping" &&
+                cmd.cmd !== "shutdown" &&
+                (daemon.operationStatus() === "closing" ||
+                    daemon.operationStatus() === "closed")) {
+                return errorResponse(new operation_coordinator_1.OperationClosedError());
+            }
             // The socket listens before LanceDB/MetaCache are open so liveness probes
             // succeed during slow startup. Gate resource-dependent commands until those
             // stores exist; ping/shutdown must always work (probes + restart).
@@ -119,6 +143,12 @@ function handleCommand(daemon, cmd, conn) {
                         pid: process.pid,
                         uptime: daemon.uptime(),
                         version: DAEMON_VERSION,
+                        operationStatus: daemon.operationStatus(),
+                        resourceGeneration: daemon.resourceGenerationId(),
+                        rebuildPending: daemon.hasUnfinishedRebuild(),
+                        capabilities: {
+                            exclusiveGenerationRebuild: exports.EXCLUSIVE_GENERATION_REBUILD_PROTOCOL,
+                        },
                     };
                 case "watch": {
                     const root = String(cmd.root || "");
@@ -141,7 +171,17 @@ function handleCommand(daemon, cmd, conn) {
                         uptime: daemon.uptime(),
                         projects: daemon.listProjects(),
                         diskPressure: daemon.getDiskPressure(),
+                        mlx: daemon.getMlxStatus(),
                     };
+                case "project-stats": {
+                    const root = String(cmd.root || "");
+                    if (!root)
+                        return { ok: false, error: "missing root" };
+                    const project = (0, project_registry_1.listProjects)().find((entry) => entry.root === root);
+                    if (!project)
+                        return { ok: false, error: "project not registered" };
+                    return Object.assign({ ok: true }, (yield daemon.projectStats(root)));
+                }
                 case "shutdown": {
                     const reason = String((_a = cmd.reason) !== null && _a !== void 0 ? _a : "unknown");
                     const fromPid = (_b = cmd.from_pid) !== null && _b !== void 0 ? _b : "?";
@@ -155,7 +195,9 @@ function handleCommand(daemon, cmd, conn) {
                     setImmediate(() => daemon.shutdown());
                     return { ok: true };
                 }
-                case "search": {
+                case "search":
+                case "search-v2": {
+                    const isV2 = cmd.cmd === "search-v2";
                     const projectRoot = String(cmd.projectRoot || "");
                     if (!projectRoot)
                         return { ok: false, error: "missing projectRoot" };
@@ -169,6 +211,9 @@ function handleCommand(daemon, cmd, conn) {
                     conn.on("close", onClose);
                     try {
                         const limitRaw = typeof cmd.limit === "number" ? cmd.limit : 10;
+                        if (!Number.isInteger(limitRaw) || limitRaw < 1 || limitRaw > 1000) {
+                            return { ok: false, error: "invalid limit" };
+                        }
                         const skeletonLimitRaw = typeof cmd.skeletonLimit === "number"
                             ? cmd.skeletonLimit
                             : undefined;
@@ -181,12 +226,57 @@ function handleCommand(daemon, cmd, conn) {
                             !Array.isArray(cmd.filters)
                             ? cmd.filters
                             : undefined;
+                        const projectRoots = filters === null || filters === void 0 ? void 0 : filters.projectRoots;
+                        const eligibleProjects = new Set((0, project_registry_1.listProjects)()
+                            .filter((project) => project.status !== "error")
+                            .map((project) => project.root));
+                        if (isV2) {
+                            if (!Array.isArray(projectRoots) || projectRoots.length === 0) {
+                                return { ok: false, error: "missing projectRoots" };
+                            }
+                            if (projectRoots.some((root) => typeof root !== "string" || !eligibleProjects.has(root))) {
+                                return { ok: false, error: "invalid projectRoots" };
+                            }
+                            if ((filters === null || filters === void 0 ? void 0 : filters.inPrefixes) !== undefined ||
+                                (filters === null || filters === void 0 ? void 0 : filters.excludePrefixes) !== undefined) {
+                                return {
+                                    ok: false,
+                                    error: "project path filters are not valid for cross-project search",
+                                };
+                            }
+                        }
+                        else if (projectRoots !== undefined) {
+                            return { ok: false, error: "projectRoots requires search-v2" };
+                        }
+                        else {
+                            const legacyRoots = filters === null || filters === void 0 ? void 0 : filters.project_roots;
+                            if (typeof legacyRoots === "string" &&
+                                legacyRoots.split(",").some((root) => !eligibleProjects.has(root))) {
+                                return { ok: false, error: "invalid project_roots" };
+                            }
+                            for (const prefix of [
+                                ...((_f = filters === null || filters === void 0 ? void 0 : filters.inPrefixes) !== null && _f !== void 0 ? _f : []),
+                                ...((_g = filters === null || filters === void 0 ? void 0 : filters.excludePrefixes) !== null && _g !== void 0 ? _g : []),
+                            ]) {
+                                (0, path_containment_1.resolveContainedPath)(projectRoot, prefix);
+                            }
+                        }
+                        let pathPrefix;
+                        if (typeof cmd.pathPrefix === "string") {
+                            if (isV2) {
+                                return {
+                                    ok: false,
+                                    error: "pathPrefix is not valid for cross-project search",
+                                };
+                            }
+                            pathPrefix = `${(0, path_containment_1.resolveContainedPath)(projectRoot, cmd.pathPrefix).replace(/\/$/, "")}/`;
+                        }
                         const resp = yield daemon.search({
                             projectRoot,
                             query,
                             limit: limitRaw,
                             filters,
-                            pathPrefix: typeof cmd.pathPrefix === "string" ? cmd.pathPrefix : undefined,
+                            pathPrefix,
                             rerank: cmd.rerank === true,
                             explain: cmd.explain === true,
                             seeds: cmd.seeds &&
@@ -209,40 +299,60 @@ function handleCommand(daemon, cmd, conn) {
                     const root = String(cmd.root || "");
                     if (!root)
                         return { ok: false, error: "missing root" };
-                    daemon.addProject(root, conn);
+                    startStreaming(conn, () => daemon.addProject(root, conn));
+                    return null;
+                }
+                case "ensure-project": {
+                    const root = String(cmd.root || "");
+                    if (!root)
+                        return { ok: false, error: "missing root" };
+                    startStreaming(conn, () => daemon.ensureProject(root, conn));
                     return null;
                 }
                 case "index": {
                     const root = String(cmd.root || "");
                     if (!root)
                         return { ok: false, error: "missing root" };
-                    daemon.indexProject(root, conn, {
+                    startStreaming(conn, () => daemon.indexProject(root, conn, {
                         reset: !!cmd.reset,
                         dryRun: !!cmd.dryRun,
-                    });
+                    }));
                     return null;
                 }
                 case "remove": {
                     const root = String(cmd.root || "");
                     if (!root)
                         return { ok: false, error: "missing root" };
-                    daemon.removeProject(root, conn);
+                    startStreaming(conn, () => daemon.removeProject(root, conn));
                     return null;
                 }
-                case "repair": {
+                case "repair":
+                    return {
+                        ok: false,
+                        error: "legacy repair protocol is disabled; restart gmax and use repair-v2",
+                        code: "REBUILD_PROTOCOL_REQUIRED",
+                    };
+                case "repair-v2": {
+                    if (cmd.protocol !== exports.EXCLUSIVE_GENERATION_REBUILD_PROTOCOL) {
+                        return {
+                            ok: false,
+                            error: "unsupported exclusive rebuild protocol",
+                            code: "REBUILD_PROTOCOL_REQUIRED",
+                        };
+                    }
                     // Global drop-and-rebuild recovery for a physical table-width mismatch.
                     // Streams per-project progress; daemon manages the connection.
-                    daemon.repairRebuild(conn);
+                    startStreaming(conn, () => daemon.repairRebuild(conn));
                     return null;
                 }
                 case "summarize": {
                     const root = String(cmd.root || "");
                     if (!root)
                         return { ok: false, error: "missing root" };
-                    daemon.summarizeProject(root, conn, {
+                    startStreaming(conn, () => daemon.summarizeProject(root, conn, {
                         limit: typeof cmd.limit === "number" ? cmd.limit : undefined,
                         pathPrefix: typeof cmd.pathPrefix === "string" ? cmd.pathPrefix : undefined,
-                    });
+                    }));
                     return null;
                 }
                 // --- LLM server management ---
@@ -265,8 +375,7 @@ function handleCommand(daemon, cmd, conn) {
             }
         }
         catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            return { ok: false, error: msg };
+            return errorResponse(err);
         }
     });
 }