grepmax 0.26.36 → 0.26.37

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.36",
+      "version": "0.26.37",
       "author": {
         "name": "Robert Owens",
         "email": "robowens@me.com"

package/README.md

@@ -216,6 +216,7 @@ The daemon watches only projects that are in use: each Claude Code session (its
 ```bash
 gmax watch --daemon -b        # Start daemon manually
 gmax watch stop               # Stop daemon
+gmax watch restart            # Stop it, wait for it to exit, start a fresh one (--json)
 gmax status                   # See all projects + watcher status
 ```
 
@@ -440,7 +441,7 @@ gmax doctor --fix             # Auto-repair (compact, prune, fix locks)
 gmax doctor --agent           # Machine-readable health output
 gmax index                    # Reindex (auto-detects and repairs cache/vector mismatches)
 gmax index --reset            # Full reindex from scratch
-gmax watch stop && gmax watch --daemon -b  # Restart daemon
+gmax watch restart            # Restart daemon
 ```
 
 `gmax doctor` reports ANN index state. `ANN: vector index not built` is normal with the default exact-search configuration.

package/dist/commands/watch.js

@@ -52,6 +52,7 @@ const syncer_1 = require("../lib/index/syncer");
 const watcher_1 = require("../lib/index/watcher");
 const meta_cache_1 = require("../lib/store/meta-cache");
 const vector_db_1 = require("../lib/store/vector-db");
+const daemon_restart_1 = require("../lib/utils/daemon-restart");
 const exit_1 = require("../lib/utils/exit");
 const filter_builder_1 = require("../lib/utils/filter-builder");
 const log_rotate_1 = require("../lib/utils/log-rotate");
@@ -131,20 +132,10 @@ exports.watch = new commander_1.Command("watch")
                 // competitor; the startup code would only kill the busy peer.
                 process.exit(0);
             }
-            const logFile = path.join(config_1.PATHS.logsDir, "daemon.log");
-            const out = (0, log_rotate_1.openRotatedLog)(logFile);
-            let child;
+            const { spawnDaemonProcess } = yield Promise.resolve().then(() => __importStar(require("../lib/utils/daemon-launcher")));
+            let started;
             try {
-                child = (0, node_child_process_1.spawn)(process.argv[0], [process.argv[1], "watch", "--daemon"], {
-                    detached: true,
-                    stdio: ["ignore", out, out],
-                    cwd: process.cwd(),
-                    env: Object.assign(Object.assign({}, process.env), { GMAX_BACKGROUND: "true" }),
-                });
-                yield new Promise((resolve, reject) => {
-                    child.once("spawn", resolve);
-                    child.once("error", reject);
-                });
+                started = yield spawnDaemonProcess();
             }
             catch (error) {
                 const message = error instanceof Error ? error.message : String(error);
@@ -152,14 +143,7 @@ exports.watch = new commander_1.Command("watch")
                 process.exitCode = 1;
                 return;
             }
-            finally {
-                try {
-                    fs.closeSync(out);
-                }
-                catch (_c) { }
-            }
-            child.unref();
-            console.log(`Daemon started (PID: ${child.pid}, log: ${logFile})`);
+            console.log(`Daemon started (PID: ${started.pid}, log: ${started.logFile})`);
             process.exit(0);
         }
         // Daemon foreground
@@ -210,7 +194,7 @@ exports.watch = new commander_1.Command("watch")
             try {
                 yield daemon.shutdown();
             }
-            catch (_d) { }
+            catch (_c) { }
             process.exitCode = 1;
             return;
         }
@@ -258,7 +242,7 @@ exports.watch = new commander_1.Command("watch")
             try {
                 fs.closeSync(out);
             }
-            catch (_e) { }
+            catch (_d) { }
         }
         child.unref();
         console.log(`Watcher started for ${projectName} (PID: ${child.pid}, log: ${logFile})`);
@@ -413,6 +397,85 @@ exports.watch
     }
     yield (0, exit_1.gracefulExit)();
 }));
+exports.watch
+    .command("restart")
+    .description("Stop the daemon and start a fresh one; waits for the old one to exit")
+    .option("--json", "Machine-readable result", false)
+    .action((options) => __awaiter(void 0, void 0, void 0, function* () {
+    const emit = (result) => {
+        if (options.json)
+            console.log(JSON.stringify(result));
+        else if (result.ok)
+            console.log((0, daemon_restart_1.formatRestartResult)(result));
+        else
+            console.error((0, daemon_restart_1.formatRestartResult)(result));
+    };
+    const refuse = (error) => {
+        emit({
+            ok: false,
+            previousPid: null,
+            stoppedVia: null,
+            pid: null,
+            version: null,
+            workers: null,
+            workerThreads: null,
+            adopted: false,
+            readyMs: null,
+            error,
+        });
+    };
+    // Refused before anything is stopped: a daemon that cannot be started
+    // again from here must not be taken down.
+    if (process.env.GMAX_SECONDARY_STORE === "1") {
+        refuse("this project's index lives on an external drive and never runs a daemon");
+        yield (0, exit_1.gracefulExit)(2);
+        return;
+    }
+    const { storeWriteDeniedNotice } = yield Promise.resolve().then(() => __importStar(require("../lib/utils/store-access")));
+    const denied = storeWriteDeniedNotice();
+    if (denied) {
+        refuse(denied);
+        yield (0, exit_1.gracefulExit)(2);
+        return;
+    }
+    const client = yield Promise.resolve().then(() => __importStar(require("../lib/utils/daemon-client")));
+    const { spawnDaemonProcess } = yield Promise.resolve().then(() => __importStar(require("../lib/utils/daemon-launcher")));
+    let parentCmd = "?";
+    try {
+        const { execSync } = yield Promise.resolve().then(() => __importStar(require("node:child_process")));
+        parentCmd = execSync(`ps -o command= -p ${process.ppid}`, {
+            encoding: "utf8",
+        }).trim();
+    }
+    catch (_a) { }
+    const result = yield (0, daemon_restart_1.restartDaemon)({
+        ping: (timeoutMs) => client.sendDaemonCommand({ cmd: "ping" }, { timeoutMs }),
+        status: () => client.sendDaemonCommand({ cmd: "status" }),
+        requestShutdown: () => client.sendDaemonCommand({
+            cmd: "shutdown",
+            reason: "gmax-watch-restart",
+            from_pid: process.pid,
+            from_ppid: process.ppid,
+            from_argv: process.argv.slice(0, 4),
+            from_parent_cmd: parentCmd,
+        }, { timeoutMs: 10000 }),
+        liveDaemonPidFromFiles: () => client.isDaemonHeartbeatFresh() ? client.readDaemonPid() : null,
+        isAlive: watcher_store_1.isProcessRunning,
+        terminate: (pid) => process.kill(pid, "SIGTERM"),
+        spawn: () => __awaiter(void 0, void 0, void 0, function* () {
+            try {
+                return (yield spawnDaemonProcess()).pid;
+            }
+            catch (_a) {
+                return null;
+            }
+        }),
+        sleep: (ms) => new Promise((r) => setTimeout(r, ms)),
+        now: () => Date.now(),
+    });
+    emit(result);
+    yield (0, exit_1.gracefulExit)(result.ok ? 0 : 1);
+}));
 exports.watch
     .command("stop")
     .description("Stop watcher for current project")

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

@@ -43,6 +43,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.spawnDaemon = spawnDaemon;
+exports.spawnDaemonProcess = spawnDaemonProcess;
 const node_child_process_1 = require("node:child_process");
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
@@ -82,3 +83,36 @@ function spawnDaemon() {
         }
     });
 }
+/**
+ * Spawn the daemon itself (`watch --daemon`, not the `-b` launcher), detached,
+ * logging to daemon.log. Resolves to the daemon's own PID; throws when the
+ * spawn fails.
+ */
+function spawnDaemonProcess() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const logFile = path.join(config_1.PATHS.logsDir, "daemon.log");
+        const out = (0, log_rotate_1.openRotatedLog)(logFile);
+        try {
+            const child = (0, node_child_process_1.spawn)(process.argv[0], [process.argv[1], "watch", "--daemon"], {
+                detached: true,
+                stdio: ["ignore", out, out],
+                cwd: process.cwd(),
+                env: Object.assign(Object.assign({}, process.env), { GMAX_BACKGROUND: "true" }),
+            });
+            yield new Promise((resolve, reject) => {
+                child.once("spawn", resolve);
+                child.once("error", reject);
+            });
+            child.unref();
+            if (child.pid === undefined)
+                throw new Error("spawned without a PID");
+            return { pid: child.pid, logFile };
+        }
+        finally {
+            try {
+                fs.closeSync(out);
+            }
+            catch (_a) { }
+        }
+    });
+}

package/dist/lib/utils/daemon-restart.js

@@ -0,0 +1,151 @@
+"use strict";
+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.restartDaemon = restartDaemon;
+exports.formatRestartResult = formatRestartResult;
+// Matches the daemon's own drain grace (DRAIN_GRACE_MS in daemon-client): a
+// graceful shutdown can legitimately run this long on a large index.
+const DEFAULT_EXIT_TIMEOUT_MS = 90000;
+const DEFAULT_READY_TIMEOUT_MS = 60000;
+const DEFAULT_POLL_MS = 200;
+function pidOf(resp) {
+    return typeof resp.pid === "number" && resp.pid > 0 ? resp.pid : null;
+}
+function restartDaemon(deps_1) {
+    return __awaiter(this, arguments, void 0, function* (deps, opts = {}) {
+        var _a, _b, _c, _d;
+        const exitTimeoutMs = (_a = opts.exitTimeoutMs) !== null && _a !== void 0 ? _a : DEFAULT_EXIT_TIMEOUT_MS;
+        const readyTimeoutMs = (_b = opts.readyTimeoutMs) !== null && _b !== void 0 ? _b : DEFAULT_READY_TIMEOUT_MS;
+        const pollMs = (_c = opts.pollMs) !== null && _c !== void 0 ? _c : DEFAULT_POLL_MS;
+        const result = {
+            ok: false,
+            previousPid: null,
+            stoppedVia: null,
+            pid: null,
+            version: null,
+            workers: null,
+            workerThreads: null,
+            adopted: false,
+            readyMs: null,
+        };
+        // A busy daemon can miss a short ping while its heartbeat is still fresh;
+        // the files catch that case so it is stopped rather than raced.
+        const first = yield deps.ping(5000);
+        const previousPid = first.ok
+            ? ((_d = pidOf(first)) !== null && _d !== void 0 ? _d : deps.liveDaemonPidFromFiles())
+            : deps.liveDaemonPidFromFiles();
+        result.previousPid = previousPid;
+        if (first.ok && previousPid === null) {
+            result.error =
+                "a daemon answered but did not name its PID; stop it with `gmax watch stop` first";
+            return result;
+        }
+        if (previousPid !== null) {
+            const shutdown = yield deps.requestShutdown();
+            if (shutdown.ok) {
+                result.stoppedVia = "ipc";
+            }
+            else if (deps.isAlive(previousPid)) {
+                // SIGTERM runs the same graceful shutdown as the IPC verb.
+                try {
+                    deps.terminate(previousPid);
+                    result.stoppedVia = "sigterm";
+                }
+                catch (_e) { }
+            }
+            const deadline = deps.now() + exitTimeoutMs;
+            while (deps.isAlive(previousPid)) {
+                if (deps.now() >= deadline) {
+                    result.error = `the daemon (PID ${previousPid}) did not exit within ${Math.round(exitTimeoutMs / 1000)}s; it is still running and no second daemon was started`;
+                    return result;
+                }
+                yield deps.sleep(pollMs);
+            }
+        }
+        const startedAt = deps.now();
+        // Something else (a session hook, an MCP server) may have started a daemon
+        // in the gap. Spawning beside it would only lose the lock race, so use it.
+        const gap = yield deps.ping(2000);
+        let spawnedPid = null;
+        if (gap.ok && pidOf(gap) !== previousPid) {
+            result.adopted = true;
+        }
+        else {
+            spawnedPid = yield deps.spawn();
+            if (spawnedPid === null) {
+                result.error = "the new daemon could not be spawned";
+                return result;
+            }
+        }
+        const readyBy = startedAt + readyTimeoutMs;
+        for (;;) {
+            const resp = yield deps.ping(2000);
+            const pid = pidOf(resp);
+            if (resp.ok && pid !== null && pid !== previousPid) {
+                if (resp.ready !== false) {
+                    result.pid = pid;
+                    result.version = typeof resp.version === "string" ? resp.version : null;
+                    if (spawnedPid !== null && pid !== spawnedPid)
+                        result.adopted = true;
+                    break;
+                }
+            }
+            else if (spawnedPid !== null && !resp.ok && !deps.isAlive(spawnedPid)) {
+                result.error = `the new daemon (PID ${spawnedPid}) exited during startup; see ~/.gmax/logs/daemon.log`;
+                return result;
+            }
+            if (deps.now() >= readyBy) {
+                result.error = `the new daemon did not become ready within ${Math.round(readyTimeoutMs / 1000)}s${spawnedPid !== null ? ` (PID ${spawnedPid})` : ""}`;
+                result.pid = spawnedPid;
+                return result;
+            }
+            yield deps.sleep(pollMs);
+        }
+        result.readyMs = deps.now() - startedAt;
+        const status = yield deps.status();
+        if (status.ok) {
+            if (typeof status.workers === "number")
+                result.workers = status.workers;
+            const threads = status.workerThreads;
+            if (threads && typeof threads.value === "number") {
+                result.workerThreads = threads.value;
+            }
+        }
+        result.ok = true;
+        return result;
+    });
+}
+function formatRestartResult(r) {
+    var _a;
+    const lines = [];
+    if (r.previousPid !== null) {
+        lines.push(`Stopped daemon (PID ${r.previousPid}).`);
+    }
+    else if (r.ok || r.pid !== null) {
+        lines.push("No daemon was running.");
+    }
+    if (!r.ok) {
+        lines.push(`Restart failed: ${(_a = r.error) !== null && _a !== void 0 ? _a : "unknown error"}.`);
+        return lines.join("\n");
+    }
+    const parts = [`PID ${r.pid}`];
+    if (r.version)
+        parts.push(`v${r.version}`);
+    if (r.workerThreads !== null)
+        parts.push(`${r.workerThreads} worker threads`);
+    if (r.workers !== null) {
+        parts.push(`${r.workers} worker${r.workers === 1 ? "" : "s"} running`);
+    }
+    if (r.readyMs !== null)
+        parts.push(`ready in ${(r.readyMs / 1000).toFixed(1)}s`);
+    lines.push(`${r.adopted ? "Daemon already started by another caller" : "Daemon started"} (${parts.join(", ")}).`);
+    return lines.join("\n");
+}

package/package.json

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