grepmax 0.26.28 → 0.26.30

package/dist/lib/utils/async-semaphore.js

@@ -0,0 +1,141 @@
+"use strict";
+/**
+ * Counting semaphore with abortable waits, plus a bounded-concurrency map.
+ *
+ * The daemon serves every MCP session over one socket, and some read verbs are
+ * full-table scans whose Arrow buffers live in native memory. Without a cap,
+ * N sessions asking at once means N scans resident at once — the footprint that
+ * froze a 48 GB machine at 9.6 GB. The semaphore bounds how many run; a waiter
+ * whose client disconnects leaves the queue instead of running for nobody.
+ */
+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.AsyncSemaphore = void 0;
+exports.mapWithConcurrency = mapWithConcurrency;
+function abortError(reason) {
+    if (reason instanceof Error)
+        return reason;
+    const error = new Error("Aborted");
+    error.name = "AbortError";
+    return error;
+}
+class AsyncSemaphore {
+    constructor(capacity) {
+        this.capacity = capacity;
+        this.queue = [];
+        if (!Number.isInteger(capacity) || capacity < 1) {
+            throw new RangeError(`semaphore capacity must be >= 1, got ${capacity}`);
+        }
+        this.available = capacity;
+    }
+    /** Slots currently held. */
+    get active() {
+        return this.capacity - this.available;
+    }
+    /** Callers waiting for a slot. */
+    get waiting() {
+        return this.queue.length;
+    }
+    /**
+     * Resolve with a release function once a slot is free. Rejects with an
+     * AbortError if `signal` fires first; the waiter is removed from the queue,
+     * so an abandoned request never takes a slot.
+     */
+    acquire(signal) {
+        if (signal === null || signal === void 0 ? void 0 : signal.aborted)
+            return Promise.reject(abortError(signal.reason));
+        if (this.available > 0) {
+            this.available--;
+            return Promise.resolve(this.releaser());
+        }
+        return new Promise((resolve, reject) => {
+            const waiter = {
+                resolve: () => resolve(this.releaser()),
+                reject,
+                signal,
+            };
+            if (signal) {
+                waiter.onAbort = () => {
+                    const index = this.queue.indexOf(waiter);
+                    if (index !== -1)
+                        this.queue.splice(index, 1);
+                    reject(abortError(signal.reason));
+                };
+                signal.addEventListener("abort", waiter.onAbort, { once: true });
+            }
+            this.queue.push(waiter);
+        });
+    }
+    /** Run `fn` while holding a slot; the slot is released however `fn` ends. */
+    run(signal, fn) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const release = yield this.acquire(signal);
+            try {
+                return yield fn();
+            }
+            finally {
+                release();
+            }
+        });
+    }
+    releaser() {
+        let released = false;
+        return () => {
+            var _a;
+            if (released)
+                return;
+            released = true;
+            const next = this.queue.shift();
+            if (next) {
+                // Hand the slot straight to the next waiter; `available` is unchanged.
+                if (next.onAbort) {
+                    (_a = next.signal) === null || _a === void 0 ? void 0 : _a.removeEventListener("abort", next.onAbort);
+                }
+                next.resolve();
+                return;
+            }
+            this.available++;
+        };
+    }
+}
+exports.AsyncSemaphore = AsyncSemaphore;
+/**
+ * `Promise.all(items.map(fn))` with at most `limit` calls in flight, results in
+ * input order. Once `signal` aborts no new item starts, and the call rejects
+ * with the abort after the in-flight ones settle.
+ */
+function mapWithConcurrency(items, limit, fn, signal) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const results = new Array(items.length);
+        let next = 0;
+        let failure = null;
+        const worker = () => __awaiter(this, void 0, void 0, function* () {
+            while (!failure && next < items.length) {
+                if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
+                    failure = { error: abortError(signal.reason) };
+                    return;
+                }
+                const index = next++;
+                try {
+                    results[index] = yield fn(items[index], index);
+                }
+                catch (error) {
+                    failure !== null && failure !== void 0 ? failure : (failure = { error });
+                }
+            }
+        });
+        const width = Math.max(1, Math.min(Math.floor(limit) || 1, items.length));
+        yield Promise.all(Array.from({ length: width }, worker));
+        if (failure)
+            throw failure.error;
+        return results;
+    });
+}

package/dist/lib/utils/process-footprint.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readFootprintMb = readFootprintMb;
+exports.parseFootprintMb = parseFootprintMb;
+const node_child_process_1 = require("node:child_process");
+/**
+ * Physical footprint of a process, in MB — the number Activity Monitor and jetsam
+ * use, and the one the daemon's recycle watermark has to read.
+ *
+ * `process.memoryUsage().rss` is not that number on macOS. RSS only counts pages
+ * currently resident, so once the compressor or swap takes a page it drops out:
+ * the daemon read 469 MB of RSS while `footprint` reported 4 GB (9.6 GB peak), and
+ * the RSS watermark never fired. `footprint -p` counts compressed and swapped dirty
+ * memory too, and costs ~50 ms.
+ *
+ * Off macOS, or when the sample cannot be parsed, falls back to RSS — an
+ * underestimate, which only ever delays a recycle, never causes a spurious one.
+ */
+function readFootprintMb(pid = process.pid) {
+    if (process.platform === "darwin") {
+        try {
+            const output = (0, node_child_process_1.execFileSync)("footprint", ["-p", String(pid)], {
+                encoding: "utf-8",
+                timeout: 5000,
+                stdio: ["ignore", "pipe", "ignore"],
+            });
+            const parsed = parseFootprintMb(output);
+            if (parsed != null)
+                return parsed;
+        }
+        catch (_a) { }
+    }
+    return pid === process.pid ? process.memoryUsage().rss / (1024 * 1024) : 0;
+}
+const UNIT_TO_MB = {
+    B: 1 / (1024 * 1024),
+    KB: 1 / 1024,
+    MB: 1,
+    GB: 1024,
+};
+/** Parse the `Footprint: 4232 MB` header line of `footprint -p` output. */
+function parseFootprintMb(output) {
+    const match = /Footprint:\s*([\d.]+)\s*(B|KB|MB|GB)\b/.exec(output);
+    if (!match)
+        return null;
+    const value = Number(match[1]);
+    const scale = UNIT_TO_MB[match[2]];
+    if (!Number.isFinite(value) || scale == null)
+        return null;
+    return value * scale;
+}

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

@@ -22,7 +22,7 @@ const daemon_launcher_1 = require("./daemon-launcher");
 const project_registry_1 = require("./project-registry");
 const store_access_1 = require("./store-access");
 const watcher_store_1 = require("./watcher-store");
-function launchWatcher(projectRoot) {
+function launchWatcher(projectRoot, lease) {
     return __awaiter(this, void 0, void 0, function* () {
         var _a;
         // 1. Project must be registered
@@ -34,15 +34,19 @@ function launchWatcher(projectRoot) {
                 message: `Project not registered. Run: gmax add ${projectRoot}`,
             };
         }
-        // 2. Check if watcher already running (daemon registers per-project entries)
-        const existing = (_a = (0, watcher_store_1.getWatcherForProject)(projectRoot)) !== null && _a !== void 0 ? _a : (0, watcher_store_1.getWatcherCoveringPath)(projectRoot);
+        // 2. Check if watcher already running (daemon registers per-project entries).
+        // A lease holder must reach the daemon every time: the renewal is the point.
+        const existing = lease
+            ? undefined
+            : ((_a = (0, watcher_store_1.getWatcherForProject)(projectRoot)) !== null && _a !== void 0 ? _a : (0, watcher_store_1.getWatcherCoveringPath)(projectRoot));
         if (existing && (0, watcher_store_1.isProcessRunning)(existing.pid)) {
             return { ok: true, pid: existing.pid, reused: true };
         }
+        const watchCmd = Object.assign({ cmd: "watch", root: projectRoot }, lease);
         // 3. Try daemon IPC
         let resp;
         try {
-            resp = yield (0, daemon_client_1.sendDaemonCommand)({ cmd: "watch", root: projectRoot });
+            resp = yield (0, daemon_client_1.sendDaemonCommand)(watchCmd);
         }
         catch (_b) {
             resp = { ok: false, error: "request-failed" };
@@ -67,25 +71,38 @@ function launchWatcher(projectRoot) {
             return { ok: false, reason: "sandboxed", message: sandboxed };
         }
         const error = resp.error;
-        if (error === "ENOENT" || error === "ECONNREFUSED") {
-            const daemonPid = yield (0, daemon_launcher_1.spawnDaemon)();
-            if (daemonPid) {
-                for (let i = 0; i < 25; i++) {
-                    yield new Promise((r) => setTimeout(r, 200));
-                    try {
-                        const retry = yield (0, daemon_client_1.sendDaemonCommand)({
-                            cmd: "watch",
-                            root: projectRoot,
-                        });
-                        if (retry.ok && typeof retry.pid === "number") {
-                            return { ok: true, pid: retry.pid, reused: false };
-                        }
+        // Anything but "nothing is listening" is a live daemon that said no or was
+        // slow (initializing, busy, timeout). A per-project watcher next to it would
+        // be a second writer on the store, and the MCP lease renewal would spawn one
+        // every few minutes — so report instead of falling through.
+        if (error !== "ENOENT" && error !== "ECONNREFUSED") {
+            return {
+                ok: false,
+                reason: "daemon-refused",
+                message: `Daemon did not accept the watch: ${error !== null && error !== void 0 ? error : "unknown error"}`,
+            };
+        }
+        const daemonPid = yield (0, daemon_launcher_1.spawnDaemon)();
+        if (daemonPid) {
+            for (let i = 0; i < 25; i++) {
+                yield new Promise((r) => setTimeout(r, 200));
+                try {
+                    const retry = yield (0, daemon_client_1.sendDaemonCommand)(watchCmd);
+                    if (retry.ok && typeof retry.pid === "number") {
+                        return { ok: true, pid: retry.pid, reused: false };
                     }
-                    catch (_c) { }
                 }
+                catch (_c) { }
             }
+            // Still opening its stores. The daemon only kills per-project watchers at
+            // startup, so one spawned now would outlive that sweep and run beside it.
+            return {
+                ok: false,
+                reason: "daemon-refused",
+                message: `Daemon (PID ${daemonPid}) is still starting; the watch will be retried`,
+            };
         }
-        // 5. Fall back to per-project spawn
+        // 5. Fall back to per-project spawn (the daemon could not be started)
         try {
             const child = (0, node_child_process_1.spawn)(process.argv[0], [process.argv[1], "watch", "--path", projectRoot, "-b"], { detached: true, stdio: "ignore" });
             yield new Promise((resolve, reject) => {

package/dist/lib/workers/pool.js

@@ -182,6 +182,24 @@ const WORKER_RSS_RECYCLE_MB = (() => {
 // a transient high-water mark that the next task's GC releases; the second
 // reading confirms the memory is actually sticky.
 const BLOAT_STREAK_TO_RECYCLE = 2;
+// Scale-up policy. A new worker costs a cold start (~10-15s to boot and load
+// models, ~1 GB peak) and is reaped after 60s idle, so spawning one whenever a
+// task finds no idle worker turned every small watcher batch into 3-4 spawns
+// (~300 cold spawns/day measured on a live host). An extra worker is spawned
+// only when one of these holds:
+//   - the pool has no workers at all;
+//   - a priority task (search) is waiting — search never queues behind indexing;
+//   - unassigned tasks exceed SCALE_UP_BACKLOG_PER_WORKER per live worker;
+//   - the oldest unassigned task has waited SCALE_UP_WAIT_MS. A timer
+//     re-checks this, so a queued task is never starved by a quiet pool.
+const SCALE_UP_BACKLOG_PER_WORKER = 4;
+const SCALE_UP_WAIT_MS = (() => {
+    var _a;
+    const fromEnv = Number.parseInt((_a = process.env.GMAX_WORKER_SCALE_UP_WAIT_MS) !== null && _a !== void 0 ? _a : "", 10);
+    if (Number.isFinite(fromEnv) && fromEnv >= 0)
+        return fromEnv;
+    return 2000;
+})();
 // Methods that must skip the indexing backlog. encodeQuery is the search hot
 // path: a single query is ~17ms but waits behind every queued processFile.
 // rerank is similarly small and latency-sensitive.
@@ -204,6 +222,8 @@ class WorkerPool {
         this.consecutiveRespawns = 0;
         this.respawnLimitReached = false;
         this.idleReapInterval = null;
+        // Re-runs dispatch once the oldest unassigned task reaches SCALE_UP_WAIT_MS.
+        this.scaleUpTimer = null;
         const resolved = resolveProcessWorker();
         this.modulePath = resolved.filename;
         this.execArgv = resolved.execArgv;
@@ -418,6 +438,7 @@ class WorkerPool {
                 payload,
                 resolve: safeResolve,
                 reject: safeReject,
+                queuedAt: Date.now(),
                 signal,
             };
             if (signal) {
@@ -485,9 +506,12 @@ class WorkerPool {
             return t && !t.worker;
         });
         const nextTaskId = (_a = findUnassigned(this.priorityQueue)) !== null && _a !== void 0 ? _a : findUnassigned(this.taskQueue);
-        if (nextTaskId === undefined)
+        if (nextTaskId === undefined) {
+            this.clearScaleUpTimer();
             return;
-        // Lazy spawn: if no idle worker and below max, spawn one
+        }
+        // Lazy spawn: if no idle worker and below max, spawn one when the backlog
+        // warrants it (see SCALE_UP_WAIT_MS); otherwise wait for a busy worker.
         if (!idle && this.workers.length < this.maxWorkers) {
             if (this.respawnLimitReached) {
                 if (this.workers.length === 0) {
@@ -495,6 +519,11 @@ class WorkerPool {
                 }
                 return;
             }
+            const waitMs = this.scaleUpDelayMs();
+            if (waitMs > 0) {
+                this.armScaleUpTimer(waitMs);
+                return;
+            }
             this.spawnWorker();
             idle = this.workers[this.workers.length - 1];
         }
@@ -534,6 +563,46 @@ class WorkerPool {
         }
         this.dispatch();
     }
+    /**
+     * How long to hold off spawning another worker for the queued work: 0 means
+     * spawn now. Called only when no worker is idle and the pool is below max.
+     */
+    scaleUpDelayMs() {
+        if (this.workers.length === 0)
+            return 0;
+        const unassigned = (queue) => queue.flatMap((id) => {
+            const t = this.tasks.get(id);
+            return t && !t.worker ? [t] : [];
+        });
+        if (unassigned(this.priorityQueue).length > 0)
+            return 0;
+        const waiting = unassigned(this.taskQueue);
+        if (waiting.length === 0)
+            return 0;
+        if (waiting.length > this.workers.length * SCALE_UP_BACKLOG_PER_WORKER) {
+            return 0;
+        }
+        const oldest = Math.min(...waiting.map((t) => t.queuedAt));
+        return Math.max(0, oldest + SCALE_UP_WAIT_MS - Date.now());
+    }
+    armScaleUpTimer(delayMs) {
+        var _a, _b;
+        // An armed timer belongs to a task at least as old as this one, so it
+        // fires no later than this one would. Firing early only re-evaluates.
+        if (this.scaleUpTimer)
+            return;
+        this.scaleUpTimer = setTimeout(() => {
+            this.scaleUpTimer = null;
+            this.dispatch();
+        }, delayMs);
+        (_b = (_a = this.scaleUpTimer).unref) === null || _b === void 0 ? void 0 : _b.call(_a);
+    }
+    clearScaleUpTimer() {
+        if (this.scaleUpTimer) {
+            clearTimeout(this.scaleUpTimer);
+            this.scaleUpTimer = null;
+        }
+    }
     processFile(input, signal) {
         return this.enqueue("processFile", input, signal);
     }
@@ -715,6 +784,7 @@ class WorkerPool {
                 clearInterval(this.idleReapInterval);
                 this.idleReapInterval = null;
             }
+            this.clearScaleUpTimer();
             for (const task of this.tasks.values()) {
                 task.reject(new Error("Worker pool destroyed"));
                 this.completeTask(task, null);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "grepmax",
-  "version": "0.26.28",
+  "version": "0.26.30",
   "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.28",
+  "version": "0.26.30",
   "description": "Semantic code search for Claude Code. Automatically indexes your project and provides intelligent search capabilities.",
   "author": {
     "name": "Robert Owens",

package/plugins/grepmax/hooks/cwd-changed.js

@@ -1,44 +1,26 @@
-const fs = require("node:fs");
-const _path = require("node:path");
 const { execFileSync } = require("node:child_process");
+const {
+  acquireSessionLease,
+  readHookInput,
+  registeredRootFor,
+  releaseSessionLeases,
+} = require("./watch-lease");
 
-function readStdin() {
-  return new Promise((resolve) => {
-    let data = "";
-    process.stdin.setEncoding("utf-8");
-    process.stdin.on("data", (chunk) => (data += chunk));
-    process.stdin.on("end", () => {
-      try {
-        resolve(JSON.parse(data));
-      } catch {
-        resolve({});
-      }
-    });
-    // If no stdin arrives within 1s, proceed with empty input
-    setTimeout(() => resolve({}), 1000);
-  });
-}
+// Keep the daemon watching the project this session is in now, and let go of
+// the one it left. See watch-lease.js.
+async function main() {
+  const input = await readHookInput();
+  const newCwd = input.new_cwd || input.cwd || process.cwd();
+  const oldCwd = input.old_cwd;
 
-function isProjectRegistered(dir) {
-  try {
-    const projectsPath = _path.join(
-      require("node:os").homedir(),
-      ".gmax",
-      "projects.json",
-    );
-    if (!fs.existsSync(projectsPath)) return false;
-    const projects = JSON.parse(fs.readFileSync(projectsPath, "utf-8"));
-    return projects.some((p) => dir.startsWith(p.root));
-  } catch {
-    return false;
+  if (oldCwd) {
+    const oldRoot = registeredRootFor(oldCwd);
+    if (oldRoot && oldRoot !== registeredRootFor(newCwd)) {
+      await releaseSessionLeases(input, oldCwd);
+    }
   }
-}
-
-async function main() {
-  const input = await readStdin();
-  const newCwd = input.new_cwd || process.cwd();
 
-  if (!isProjectRegistered(newCwd)) return;
+  if (!registeredRootFor(newCwd)) return;
 
   try {
     execFileSync("gmax", ["watch", "--daemon", "-b"], {
@@ -50,6 +32,7 @@ async function main() {
       execFileSync("gmax", ["watch", "-b"], { timeout: 5000, stdio: "ignore" });
     } catch {}
   }
+  await acquireSessionLease(input, newCwd);
 }
 
 main();

package/plugins/grepmax/hooks/start.js

@@ -1,6 +1,11 @@
 const fs = require("node:fs");
 const _path = require("node:path");
 const { execFileSync } = require("node:child_process");
+const {
+  acquireSessionLease,
+  readHookInput,
+  registeredRootFor,
+} = require("./watch-lease");
 
 // Inline fallback so SessionStart context is never empty if the installed
 // gmax package can't be resolved (e.g. gmax not yet on PATH). The canonical
@@ -61,21 +66,8 @@ function getSessionStartHint() {
   return FALLBACK_SESSION_START_HINT;
 }
 
-function isProjectRegistered() {
-  try {
-    const projectsPath = _path.join(
-      require("node:os").homedir(),
-      ".gmax",
-      "projects.json",
-    );
-    const projects = JSON.parse(
-      require("node:fs").readFileSync(projectsPath, "utf-8"),
-    );
-    const cwd = process.cwd();
-    return projects.some((p) => cwd.startsWith(p.root));
-  } catch {
-    return false;
-  }
+function isProjectRegistered(dir) {
+  return registeredRootFor(dir) !== null;
 }
 
 // A kill switch for the auto-start. Create ~/.gmax/autostart-disabled (or export
@@ -96,9 +88,10 @@ function isAutostartDisabled() {
   }
 }
 
-function startWatcher() {
+async function startWatcher(input) {
   if (isAutostartDisabled()) return;
-  if (!isProjectRegistered()) return;
+  const dir = input.cwd || process.cwd();
+  if (!isProjectRegistered(dir)) return;
   try {
     execFileSync("gmax", ["watch", "--daemon", "-b"], {
       timeout: 5000,
@@ -112,11 +105,14 @@ function startWatcher() {
       // Watcher may already be running or gmax not in PATH — ignore
     }
   }
+  // The daemon only watches projects a session holds a lease on.
+  await acquireSessionLease(input, dir);
 }
 
-function main() {
+async function main() {
+  const input = await readHookInput();
   // The daemon owns embed-server configuration and lifecycle.
-  startWatcher();
+  await startWatcher(input);
 
   const response = {
     hookSpecificOutput: {

package/plugins/grepmax/hooks/stop.js

@@ -1,9 +1,18 @@
-// Intentionally a no-op.
+// Releases this session's watch lease. It never stops the daemon.
 //
-// Previously this ran `gmax watch stop` on every Claude SessionEnd. With
+// This hook used to run `gmax watch stop` on every Claude SessionEnd. With
 // multiple concurrent Claude sessions sharing one daemon, that meant *any*
 // session ending killed the daemon for every *other* session — silently
 // breaking their search/index and forcing repeated daemon restarts.
 //
-// The daemon's own 30-minute idle timeout handles cleanup when nothing is
-// using it, so SessionEnd has no work to do here.
+// Now it only drops the lease this session took at SessionStart. The daemon
+// unwatches the project once no other session (or MCP server) holds it, and its
+// own idle timeout handles shutdown when nothing is using it.
+const { readHookInput, releaseSessionLeases } = require("./watch-lease");
+
+async function main() {
+  const input = await readHookInput();
+  await releaseSessionLeases(input, input.cwd || process.cwd());
+}
+
+main();