grepmax 0.26.21 → 0.26.22

package/.claude-plugin/marketplace.json

@@ -10,7 +10,7 @@
       "name": "grepmax",
       "source": "./plugins/grepmax",
       "description": "Semantic code search for Claude Code. Automatically indexes your project and provides intelligent search capabilities.",
-      "version": "0.26.21",
+      "version": "0.26.22",
       "author": {
         "name": "Robert Owens",
         "email": "robowens@me.com"

package/dist/commands/watch.js

@@ -59,6 +59,9 @@ const process_1 = require("../lib/utils/process");
 const project_registry_1 = require("../lib/utils/project-registry");
 const project_root_1 = require("../lib/utils/project-root");
 const watcher_store_1 = require("../lib/utils/watcher-store");
+// Hard ceiling on signal-driven shutdown; comfortably above the daemon's own
+// 30s operation-drain grace so the orderly path normally wins.
+const SIGNAL_EXIT_BACKSTOP_MS = 90000;
 const IDLE_TIMEOUT_MS = 30 * 60 * 1000; // 30 minutes
 const IDLE_CHECK_INTERVAL_MS = 60 * 1000; // check every minute
 exports.watch = new commander_1.Command("watch")
@@ -157,8 +160,24 @@ exports.watch = new commander_1.Command("watch")
         installTimestampedOutput();
         const { Daemon } = yield Promise.resolve().then(() => __importStar(require("../lib/daemon/daemon")));
         const daemon = new Daemon();
-        process.on("SIGINT", () => daemon.shutdown().then(() => (0, exit_1.gracefulExit)()));
-        process.on("SIGTERM", () => daemon.shutdown().then(() => (0, exit_1.gracefulExit)()));
+        // A shutdown that never resolves must still end the process: both
+        // signals arm a hard-exit backstop, the same way the lock-compromised
+        // path does. Without it the daemon sat idle in uv_run for minutes after
+        // SIGTERM (and ignored Activity Monitor's Quit) while a remove waited on
+        // a store lease that could never free.
+        const shutdownOnSignal = (signal) => {
+            const backstop = setTimeout(() => {
+                console.error(`[daemon] shutdown did not complete within ${SIGNAL_EXIT_BACKSTOP_MS / 1000}s of ${signal} — forcing exit`);
+                process.exit(1);
+            }, SIGNAL_EXIT_BACKSTOP_MS);
+            backstop.unref();
+            daemon.shutdown().then(() => {
+                clearTimeout(backstop);
+                return (0, exit_1.gracefulExit)();
+            });
+        };
+        process.on("SIGINT", () => shutdownOnSignal("SIGINT"));
+        process.on("SIGTERM", () => shutdownOnSignal("SIGTERM"));
         process.on("uncaughtException", (err) => {
             console.error("[daemon] uncaughtException:", err);
             daemon.shutdown().then(() => (0, exit_1.gracefulExit)(1));

package/dist/lib/daemon/daemon.js

@@ -44,6 +44,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
+var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Daemon = void 0;
 const fs = __importStar(require("node:fs"));
@@ -81,6 +82,10 @@ const watcher_manager_1 = require("./watcher-manager");
 // drops, and orphan MLX cleanup. 4 hours keeps the daemon resident through a
 // normal workday while still freeing resources overnight. Override with
 // GMAX_DAEMON_IDLE_TIMEOUT_MS=<ms>; set to 0 (or negative) to disable.
+// Grace period for admitted operations to settle during shutdown. See
+// drainOperationsBounded. Env override exists for tests and for a user who
+// would rather wait on a slow-but-progressing operation.
+const SHUTDOWN_DRAIN_TIMEOUT_MS = Number((_a = process.env.GMAX_SHUTDOWN_DRAIN_TIMEOUT_MS) !== null && _a !== void 0 ? _a : 30000);
 const DEFAULT_IDLE_TIMEOUT_MS = 4 * 60 * 60 * 1000;
 const IDLE_TIMEOUT_MS = (() => {
     const raw = process.env.GMAX_DAEMON_IDLE_TIMEOUT_MS;
@@ -1755,6 +1760,40 @@ class Daemon {
         this.recycling = true;
         void this.shutdown().finally(() => process.exit(0));
     }
+    /**
+     * Wait for admitted operations to settle, but never forever. Every operation
+     * has just been aborted; one that still does not return within the grace
+     * period is wedged on something shutdown cannot influence, and holding the
+     * daemon alive for it only leaves the user with a process that ignores
+     * SIGTERM. Resources are released regardless — a wedged op loses its work
+     * either way, and the next start reconciles the store.
+     */
+    drainOperationsBounded(...drains) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let timer;
+            const timeout = new Promise((resolve) => {
+                timer = setTimeout(() => resolve("timeout"), SHUTDOWN_DRAIN_TIMEOUT_MS);
+                timer.unref();
+            });
+            try {
+                const outcome = yield Promise.race([
+                    Promise.all(drains).then(() => "drained"),
+                    timeout,
+                ]);
+                if (outcome === "timeout") {
+                    const ops = this.operations.activeOperationNames();
+                    const locks = this.projectMutex.pendingKeys();
+                    console.error(`[daemon] shutdown drain timed out after ${SHUTDOWN_DRAIN_TIMEOUT_MS / 1000}s — ` +
+                        `abandoning ${ops.length} operation(s) [${ops.join(", ")}] and ` +
+                        `${locks.length} project lock(s) [${locks.join(", ")}] to finish shutdown`);
+                }
+            }
+            finally {
+                if (timer)
+                    clearTimeout(timer);
+            }
+        });
+    }
     shutdown(opts = {}) {
         if (!this.shutdownPromise) {
             this.shutdownPromise = this.performShutdown(opts);
@@ -1763,7 +1802,7 @@ class Daemon {
     }
     performShutdown(opts) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b, _c, _d;
+            var _a, _b, _c, _d, _e;
             this.shuttingDown = true;
             this.ready = false;
             const strictResourceShutdown = this.hasUnfinishedRebuild();
@@ -1795,18 +1834,18 @@ class Daemon {
             try {
                 fs.unlinkSync(config_1.PATHS.daemonSocket);
             }
-            catch (_e) { }
+            catch (_f) { }
             try {
                 fs.unlinkSync(config_1.PATHS.daemonPidFile);
             }
-            catch (_f) { }
+            catch (_g) { }
             if (this.releaseLock) {
                 const release = this.releaseLock;
                 this.releaseLock = null;
                 try {
                     yield release();
                 }
-                catch (_g) { }
+                catch (_h) { }
             }
             if (this.heartbeatInterval)
                 clearInterval(this.heartbeatInterval);
@@ -1823,16 +1862,21 @@ class Daemon {
             for (const ac of this.shutdownAbortControllers) {
                 ac.abort(new operation_coordinator_1.OperationClosedError());
             }
+            // An operation blocked in StoreLease.acquireExclusive (remove, repair)
+            // only listens to the VectorDB's own lease abort, which `vectorDb.close()`
+            // fires — after the drain below. Fire it now, or a lease that never frees
+            // (see known-limitations: recycled-PID reader marker) deadlocks shutdown.
+            (_a = this.vectorDb) === null || _a === void 0 ? void 0 : _a.abortLeaseWaits();
             const operationDrain = this.operations.close();
             const projectDrain = this.projectMutex.close();
             // Abort catchup/recovery and remove each processor before worker teardown.
             yield this.watcherManager.quiesceAll();
-            yield Promise.all([operationDrain, projectDrain]);
+            yield this.drainOperationsBounded(operationDrain, projectDrain);
             // Stop LLM server if running
             try {
-                yield ((_a = this.llmServer) === null || _a === void 0 ? void 0 : _a.stop());
+                yield ((_b = this.llmServer) === null || _b === void 0 ? void 0 : _b.stop());
             }
-            catch (_h) { }
+            catch (_j) { }
             // Destroy worker pool to prevent orphaned child processes
             if (this.workerPool) {
                 if (strictResourceShutdown) {
@@ -1844,7 +1888,7 @@ class Daemon {
                     try {
                         yield this.workerPool.destroy();
                     }
-                    catch (_j) { }
+                    catch (_k) { }
                 }
                 this.workerPool = null;
                 this.resources = null;
@@ -1853,7 +1897,7 @@ class Daemon {
                 try {
                     yield (0, pool_1.destroyWorkerPool)();
                 }
-                catch (_k) { }
+                catch (_l) { }
             }
             // Stop MLX embed server only after worker requests have drained.
             yield this.mlxServerManager.stopMlxServer();
@@ -1865,17 +1909,17 @@ class Daemon {
             this.processors.clear();
             // Close shared resources
             try {
-                yield ((_b = this.metaCache) === null || _b === void 0 ? void 0 : _b.close());
+                yield ((_c = this.metaCache) === null || _c === void 0 ? void 0 : _c.close());
             }
-            catch (_l) { }
+            catch (_m) { }
             if (strictResourceShutdown) {
-                yield ((_c = this.vectorDb) === null || _c === void 0 ? void 0 : _c.close({ requireClosed: true }));
+                yield ((_d = this.vectorDb) === null || _d === void 0 ? void 0 : _d.close({ requireClosed: true }));
             }
             else {
                 try {
-                    yield ((_d = this.vectorDb) === null || _d === void 0 ? void 0 : _d.close());
+                    yield ((_e = this.vectorDb) === null || _e === void 0 ? void 0 : _e.close());
                 }
-                catch (_m) { }
+                catch (_o) { }
             }
             yield serverClosed;
             clearTimeout(forceCloseConnections);

package/dist/lib/store/vector-db.js

@@ -497,6 +497,17 @@ class VectorDB {
      * Run a destructive table mutation while holding the process-wide exclusive
      * store intent. New local writes stop before existing activity is drained.
      */
+    /**
+     * Cancel every in-flight wait on the store lease (exclusive-mutation
+     * acquisition, initial lease attach). Called by the daemon at the start of
+     * shutdown, *before* it drains active operations: a `remove`/`repair` that is
+     * polling for the exclusive lease would otherwise hold its operation slot
+     * until the lease deadline, and shutdown would wait on it — the lease abort
+     * in `close()` never fires because `close()` runs after the drain. Idempotent.
+     */
+    abortLeaseWaits() {
+        this.leaseAbort.abort();
+    }
     withExclusiveTableMutation(mutation) {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.closed)

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

@@ -28,6 +28,12 @@ class KeyedMutex {
         }
         return count;
     }
+    /** Keys currently held or queued — for shutdown diagnostics. */
+    pendingKeys() {
+        return [...this.keys.entries()]
+            .filter(([, state]) => state.locked || state.queue.length > 0)
+            .map(([key]) => key);
+    }
     run(key, signal, fn) {
         const task = (() => __awaiter(this, void 0, void 0, function* () {
             yield this.acquire(key, signal);

package/dist/lib/utils/operation-coordinator.js

@@ -39,6 +39,7 @@ class OperationCoordinator {
         this.controllers = new Set();
         this.activeTasks = new Set();
         this.sharedTasks = new Set();
+        this.taskNames = new Map();
         this.closePromise = null;
     }
     get status() {
@@ -47,7 +48,11 @@ class OperationCoordinator {
     get activeCount() {
         return this.activeTasks.size;
     }
-    runShared(_name, signal, fn) {
+    /** Names of admitted operations that have not settled — for shutdown diagnostics. */
+    activeOperationNames() {
+        return [...this.activeTasks].map((task) => { var _a; return (_a = this.taskNames.get(task)) !== null && _a !== void 0 ? _a : "?"; });
+    }
+    runShared(name, signal, fn) {
         try {
             this.assertSharedAdmission();
         }
@@ -65,11 +70,13 @@ class OperationCoordinator {
         }))();
         this.activeTasks.add(task);
         this.sharedTasks.add(task);
+        this.taskNames.set(task, name);
         const cleanup = () => {
             unlink();
             this.controllers.delete(controller);
             this.activeTasks.delete(task);
             this.sharedTasks.delete(task);
+            this.taskNames.delete(task);
         };
         void task.then(cleanup, cleanup);
         return task;
@@ -107,7 +114,11 @@ class OperationCoordinator {
             }
         }))();
         this.activeTasks.add(task);
-        const cleanup = () => this.activeTasks.delete(task);
+        this.taskNames.set(task, name);
+        const cleanup = () => {
+            this.activeTasks.delete(task);
+            this.taskNames.delete(task);
+        };
         void task.then(cleanup, cleanup);
         return task;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "grepmax",
-  "version": "0.26.21",
+  "version": "0.26.22",
   "author": "Robert Owens <78518764+reowens@users.noreply.github.com>",
   "homepage": "https://github.com/reowens/grepmax",
   "bugs": {

package/plugins/grepmax/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "grepmax",
-  "version": "0.26.21",
+  "version": "0.26.22",
   "description": "Semantic code search for Claude Code. Automatically indexes your project and provides intelligent search capabilities.",
   "author": {
     "name": "Robert Owens",