grepmax 0.26.27 → 0.26.30

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

@@ -20,8 +20,9 @@ const autostart_1 = require("./autostart");
 const daemon_client_1 = require("./daemon-client");
 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
@@ -33,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" };
@@ -56,26 +61,48 @@ function launchWatcher(projectRoot) {
         if (notice) {
             return { ok: false, reason: "autostart-disabled", message: notice };
         }
+        // A spawned daemon (or per-project watcher) inherits this process's sandbox
+        // for its whole life. If ~/.gmax is read-only here it will be read-only
+        // there, and the child dies on its own lock mkdir — so probe once and say so
+        // instead of leaving a crash in daemon.log.
+        const sandboxed = (0, store_access_1.storeWriteDeniedNotice)();
+        if (sandboxed) {
+            (0, store_access_1.warnStoreWriteDeniedOnce)(sandboxed);
+            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.27",
+  "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.27",
+  "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();

package/plugins/grepmax/hooks/watch-lease.js

@@ -0,0 +1,163 @@
+// Session watch leases for the hooks.
+//
+// The daemon only watches projects that some session holds a lease on (see
+// src/lib/daemon/watch-leases.ts). The MCP server holds the long-lived one; the
+// hooks take a session lease so a project is watched from the first moment of a
+// session, and drop it at SessionEnd. A hook cannot import from dist, so this
+// speaks the daemon's one-line JSON protocol directly.
+const fs = require("node:fs");
+const net = require("node:net");
+const os = require("node:os");
+const path = require("node:path");
+
+const GMAX_DIR = path.join(os.homedir(), ".gmax");
+const SOCKET = path.join(GMAX_DIR, "daemon.sock");
+
+// Long enough to cover a session without an MCP server; SessionEnd releases it
+// early, and the daemon caps any lease at 12h.
+const SESSION_LEASE_TTL_MS = 4 * 60 * 60 * 1000;
+
+function readHookInput(timeoutMs = 1000) {
+  return new Promise((resolve) => {
+    let data = "";
+    const done = () => {
+      // An open stdin would otherwise keep the hook alive until its timeout.
+      process.stdin.destroy();
+      try {
+        resolve(data ? JSON.parse(data) : {});
+      } catch {
+        resolve({});
+      }
+    };
+    const timer = setTimeout(done, timeoutMs);
+    process.stdin.setEncoding("utf-8");
+    process.stdin.on("data", (chunk) => {
+      data += chunk;
+    });
+    process.stdin.on("end", () => {
+      clearTimeout(timer);
+      done();
+    });
+    process.stdin.on("error", () => {
+      clearTimeout(timer);
+      done();
+    });
+  });
+}
+
+function isWithin(root, dir) {
+  const rel = path.relative(root, dir);
+  return rel === "" || (!rel.startsWith("..") && !path.isAbsolute(rel));
+}
+
+/** The most specific registered project containing `dir`, or null. */
+function registeredRootFor(dir) {
+  try {
+    const projects = JSON.parse(
+      fs.readFileSync(path.join(GMAX_DIR, "projects.json"), "utf-8"),
+    );
+    const resolved = path.resolve(dir);
+    const matches = projects
+      .filter((p) => p && typeof p.root === "string")
+      .filter((p) => isWithin(path.resolve(p.root), resolved))
+      .sort((a, b) => b.root.length - a.root.length);
+    return matches.length > 0 ? matches[0].root : null;
+  } catch {
+    return null;
+  }
+}
+
+function sendOnce(cmd, timeoutMs) {
+  return new Promise((resolve) => {
+    const socket = net.connect(SOCKET);
+    let settled = false;
+    const finish = (result) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      socket.destroy();
+      resolve(result);
+    };
+    const timer = setTimeout(
+      () => finish({ ok: false, retry: false }),
+      timeoutMs,
+    );
+    let buf = "";
+    socket.on("connect", () => socket.write(`${JSON.stringify(cmd)}\n`));
+    socket.on("data", (chunk) => {
+      buf += chunk;
+      const newline = buf.indexOf("\n");
+      if (newline === -1) return;
+      let resp = {};
+      try {
+        resp = JSON.parse(buf.slice(0, newline));
+      } catch {}
+      finish({
+        ok: resp.ok === true,
+        resp,
+        // A daemon the hook just spawned answers before its stores are open.
+        retry: resp.error === "daemon initializing",
+      });
+    });
+    socket.on("error", (err) =>
+      finish({
+        ok: false,
+        retry: err.code === "ENOENT" || err.code === "ECONNREFUSED",
+      }),
+    );
+  });
+}
+
+/**
+ * Send one command, retrying while the daemon is still coming up (the hook may
+ * have just spawned it). Never throws — a hook must not fail the session.
+ */
+async function sendDaemonLine(cmd, deadlineMs = 3000) {
+  const deadline = Date.now() + deadlineMs;
+  for (;;) {
+    const remaining = deadline - Date.now();
+    if (remaining <= 0) return null;
+    const result = await sendOnce(cmd, Math.min(remaining, 2000));
+    if (result.ok) return result.resp;
+    if (!result.retry) return null;
+    await new Promise((r) => setTimeout(r, 200));
+  }
+}
+
+function sessionHolder(input) {
+  const id =
+    input && typeof input.session_id === "string" ? input.session_id : "";
+  return id ? `session:${id}` : null;
+}
+
+async function acquireSessionLease(input, dir) {
+  const holder = sessionHolder(input);
+  const root = registeredRootFor(dir);
+  if (!holder || !root) return false;
+  const resp = await sendDaemonLine({
+    cmd: "watch",
+    root,
+    holder,
+    ttlMs: SESSION_LEASE_TTL_MS,
+  });
+  return resp !== null;
+}
+
+async function releaseSessionLeases(input, dir) {
+  const holder = sessionHolder(input);
+  const root = registeredRootFor(dir);
+  if (!holder || !root) return false;
+  // Only release against a live daemon that understands leases: an older one
+  // reads `unwatch` as "stop watching for everyone".
+  const ping = await sendDaemonLine({ cmd: "ping" }, 1000);
+  if (!ping?.capabilities?.watchLeases) return false;
+  const resp = await sendDaemonLine({ cmd: "unwatch", root, holder }, 1000);
+  return resp !== null;
+}
+
+module.exports = {
+  acquireSessionLease,
+  readHookInput,
+  registeredRootFor,
+  releaseSessionLeases,
+};