grepmax 0.8.2 → 0.9.1

package/dist/commands/add.js

@@ -154,7 +154,7 @@ Examples:
             throw e;
         }
         // Start watcher
-        const launched = (0, watcher_launcher_1.launchWatcher)(projectRoot);
+        const launched = yield (0, watcher_launcher_1.launchWatcher)(projectRoot);
         if (launched.ok) {
             console.log(`Watcher started (PID: ${launched.pid})`);
         }

package/dist/commands/index.js

@@ -105,25 +105,29 @@ Examples:
         // Ensure grammars are present before indexing (silent if already exist)
         yield (0, grammar_loader_1.ensureGrammars)(console.log, { silent: true });
         // Stop any watcher that covers this project — it holds the shared lock
-        const watcher = (0, watcher_store_1.getWatcherCoveringPath)(projectRoot);
-        let restartWatcher = null;
-        if (watcher) {
-            console.log(`Stopping watcher (PID: ${watcher.pid}) for ${path.basename(watcher.projectRoot)}...`);
-            try {
-                process.kill(watcher.pid, "SIGTERM");
-            }
-            catch (_b) { }
-            // Wait for process to exit (up to 5s)
-            for (let i = 0; i < 50; i++) {
-                if (!(0, watcher_store_1.isProcessRunning)(watcher.pid))
-                    break;
-                yield new Promise((r) => setTimeout(r, 100));
+        let restartWatcher = false;
+        const { isDaemonRunning, sendDaemonCommand } = yield Promise.resolve().then(() => __importStar(require("../lib/utils/daemon-client")));
+        if (yield isDaemonRunning()) {
+            console.log("Pausing daemon watcher for reindex...");
+            yield sendDaemonCommand({ cmd: "unwatch", root: projectRoot });
+            restartWatcher = true;
+        }
+        else {
+            const watcher = (0, watcher_store_1.getWatcherCoveringPath)(projectRoot);
+            if (watcher) {
+                console.log(`Stopping watcher (PID: ${watcher.pid}) for ${path.basename(watcher.projectRoot)}...`);
+                try {
+                    process.kill(watcher.pid, "SIGTERM");
+                }
+                catch (_b) { }
+                for (let i = 0; i < 50; i++) {
+                    if (!(0, watcher_store_1.isProcessRunning)(watcher.pid))
+                        break;
+                    yield new Promise((r) => setTimeout(r, 100));
+                }
+                (0, watcher_store_1.unregisterWatcher)(watcher.pid);
+                restartWatcher = true;
             }
-            (0, watcher_store_1.unregisterWatcher)(watcher.pid);
-            restartWatcher = {
-                pid: watcher.pid,
-                projectRoot: watcher.projectRoot,
-            };
         }
         const { spinner, onProgress } = (0, sync_helpers_1.createIndexingSpinner)(projectRoot, "Indexing...", { verbose: options.verbose });
         try {
@@ -168,9 +172,9 @@ Examples:
         finally {
             // Restart the watcher if we stopped one
             if (restartWatcher) {
-                const launched = (0, watcher_launcher_1.launchWatcher)(restartWatcher.projectRoot);
+                const launched = yield (0, watcher_launcher_1.launchWatcher)(projectRoot);
                 if (launched.ok) {
-                    console.log(`Restarted watcher for ${path.basename(restartWatcher.projectRoot)} (PID: ${launched.pid})`);
+                    console.log(`Restarted watcher for ${path.basename(projectRoot)} (PID: ${launched.pid})`);
                 }
                 else if (launched.reason === "spawn-failed") {
                     console.warn(`[index] ${launched.message}`);

package/dist/commands/mcp.js

@@ -353,10 +353,17 @@ exports.mcp = new commander_1.Command("mcp")
     }
     // --- Background watcher ---
     function ensureWatcher() {
-        const result = (0, watcher_launcher_1.launchWatcher)(projectRoot);
-        if (result.ok && !result.reused) {
-            console.log(`[MCP] Started background watcher for ${projectRoot} (PID: ${result.pid})`);
-        }
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const result = yield (0, watcher_launcher_1.launchWatcher)(projectRoot);
+                if (result.ok && !result.reused) {
+                    console.log(`[MCP] Started background watcher for ${projectRoot} (PID: ${result.pid})`);
+                }
+            }
+            catch (err) {
+                console.error("[MCP] Watcher startup failed:", err);
+            }
+        });
     }
     // --- Tool handlers ---
     function handleSemanticSearch(args_1) {

package/dist/commands/remove.js

@@ -99,12 +99,19 @@ Examples:
                 return;
             }
         }
-        // Stop any watcher
-        const watcher = (0, watcher_store_1.getWatcherForProject)(projectRoot);
-        if (watcher) {
-            console.log(`Stopping watcher (PID: ${watcher.pid})...`);
-            yield (0, process_1.killProcess)(watcher.pid);
-            (0, watcher_store_1.unregisterWatcher)(watcher.pid);
+        // Stop any watcher — try daemon IPC first, fall back to direct kill
+        const { isDaemonRunning, sendDaemonCommand } = yield Promise.resolve().then(() => __importStar(require("../lib/utils/daemon-client")));
+        if (yield isDaemonRunning()) {
+            console.log("Unwatching via daemon...");
+            yield sendDaemonCommand({ cmd: "unwatch", root: projectRoot });
+        }
+        else {
+            const watcher = (0, watcher_store_1.getWatcherForProject)(projectRoot);
+            if (watcher) {
+                console.log(`Stopping watcher (PID: ${watcher.pid})...`);
+                yield (0, process_1.killProcess)(watcher.pid);
+                (0, watcher_store_1.unregisterWatcher)(watcher.pid);
+            }
         }
         // Delete vectors from LanceDB
         const paths = (0, project_root_1.ensureProjectPaths)(projectRoot);

package/dist/commands/search.js

@@ -529,7 +529,7 @@ Examples:
         // Ensure a watcher is running for live reindexing
         if (!process.env.VITEST && !((_d = process.env.NODE_ENV) === null || _d === void 0 ? void 0 : _d.includes("test"))) {
             const { launchWatcher } = yield Promise.resolve().then(() => __importStar(require("../lib/utils/watcher-launcher")));
-            const launched = launchWatcher(projectRoot);
+            const launched = yield launchWatcher(projectRoot);
             if (!launched.ok && launched.reason === "spawn-failed") {
                 console.warn(`[search] ${launched.message}`);
             }

package/dist/commands/watch.js

@@ -64,10 +64,53 @@ const IDLE_CHECK_INTERVAL_MS = 60 * 1000; // check every minute
 exports.watch = new commander_1.Command("watch")
     .description("Start background file watcher for live reindexing")
     .option("-b, --background", "Run watcher in background and exit")
+    .option("-d, --daemon", "Run as centralized daemon watching all projects")
     .option("-p, --path <dir>", "Directory to watch (defaults to project root)")
     .option("--no-idle-timeout", "Disable the 30-minute idle shutdown")
     .action((options) => __awaiter(void 0, void 0, void 0, function* () {
     var _a, _b;
+    // --- Daemon mode ---
+    if (options.daemon) {
+        if (options.path) {
+            console.error("Error: --daemon watches all projects globally; --path is not allowed with --daemon");
+            process.exitCode = 1;
+            return;
+        }
+        if (options.background) {
+            const logFile = path.join(config_1.PATHS.logsDir, "daemon.log");
+            const out = (0, log_rotate_1.openRotatedLog)(logFile);
+            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" }),
+            });
+            child.unref();
+            console.log(`Daemon started (PID: ${child.pid}, log: ${logFile})`);
+            process.exit(0);
+        }
+        // Daemon foreground
+        (0, watcher_store_1.migrateFromJson)();
+        const { Daemon } = yield Promise.resolve().then(() => __importStar(require("../lib/daemon/daemon")));
+        const daemon = new Daemon();
+        try {
+            yield daemon.start();
+        }
+        catch (err) {
+            const code = err === null || err === void 0 ? void 0 : err.code;
+            if (code === "EADDRINUSE") {
+                // Another daemon already running — not an error
+                process.exit(0);
+            }
+            console.error("[daemon] Failed to start:", err);
+            process.exitCode = 1;
+            return;
+        }
+        process.on("SIGINT", () => daemon.shutdown().then(() => (0, exit_1.gracefulExit)()));
+        process.on("SIGTERM", () => daemon.shutdown().then(() => (0, exit_1.gracefulExit)()));
+        return;
+    }
+    // --- Per-project mode ---
     const projectRoot = options.path
         ? path.resolve(options.path)
         : (_a = (0, project_root_1.findProjectRoot)(process.cwd())) !== null && _a !== void 0 ? _a : process.cwd();
@@ -96,7 +139,7 @@ exports.watch = new commander_1.Command("watch")
         console.log(`Watcher started for ${projectName} (PID: ${child.pid}, log: ${logFile})`);
         process.exit(0);
     }
-    // --- Foreground mode ---
+    // --- Per-project foreground mode ---
     // Migrate legacy watchers.json to LMDB on first use
     (0, watcher_store_1.migrateFromJson)();
     // Watcher requires project to be registered
@@ -195,16 +238,30 @@ exports.watch
     .command("status")
     .description("Show running watchers")
     .action(() => __awaiter(void 0, void 0, void 0, function* () {
-    const watchers = (0, watcher_store_1.listWatchers)();
-    if (watchers.length === 0) {
-        console.log("No running watchers.");
-        yield (0, exit_1.gracefulExit)();
-        return;
+    const { sendDaemonCommand } = yield Promise.resolve().then(() => __importStar(require("../lib/utils/daemon-client")));
+    const resp = yield sendDaemonCommand({ cmd: "status" });
+    if (resp.ok) {
+        const projects = resp.projects;
+        const uptime = Math.floor(resp.uptime / 60);
+        console.log(`Daemon (PID: ${resp.pid}, uptime: ${uptime}m):`);
+        for (const p of projects) {
+            console.log(`  - ${p.root} [${p.status}]`);
+        }
+        if (projects.length === 0) {
+            console.log("  (no projects)");
+        }
+    }
+    // Also show any per-project watchers not managed by daemon
+    const watchers = (0, watcher_store_1.listWatchers)().filter((w) => !resp.ok || w.pid !== resp.pid);
+    if (watchers.length > 0) {
+        console.log("Per-project watchers:");
+        for (const w of watchers) {
+            const age = Math.floor((Date.now() - w.startTime) / 60000);
+            console.log(`  - PID: ${w.pid} | Root: ${w.projectRoot} | Running: ${age}m`);
+        }
     }
-    console.log("Running watchers:");
-    for (const w of watchers) {
-        const age = Math.floor((Date.now() - w.startTime) / 60000);
-        console.log(`- PID: ${w.pid} | Root: ${w.projectRoot} | Running: ${age}m`);
+    if (!resp.ok && watchers.length === 0) {
+        console.log("No running watchers.");
     }
     yield (0, exit_1.gracefulExit)();
 }));
@@ -214,6 +271,14 @@ exports.watch
     .option("--all", "Stop all running watchers")
     .action((options) => __awaiter(void 0, void 0, void 0, function* () {
     var _a;
+    const { isDaemonRunning, sendDaemonCommand } = yield Promise.resolve().then(() => __importStar(require("../lib/utils/daemon-client")));
+    let stoppedDaemon = false;
+    // Try shutting down daemon first
+    if (yield isDaemonRunning()) {
+        yield sendDaemonCommand({ cmd: "shutdown" });
+        console.log("Daemon stopped.");
+        stoppedDaemon = true;
+    }
     if (options.all) {
         const watchers = (0, watcher_store_1.listWatchers)();
         for (const w of watchers) {
@@ -223,14 +288,22 @@ exports.watch
                 console.warn(`Warning: PID ${w.pid} did not exit after SIGKILL`);
             }
         }
-        console.log(`Stopped ${watchers.length} watcher(s).`);
+        if (watchers.length > 0) {
+            console.log(`Stopped ${watchers.length} per-project watcher(s).`);
+        }
+        else if (!stoppedDaemon) {
+            console.log("No running watchers.");
+        }
         yield (0, exit_1.gracefulExit)();
         return;
     }
+    // Single project stop
     const projectRoot = (_a = (0, project_root_1.findProjectRoot)(process.cwd())) !== null && _a !== void 0 ? _a : process.cwd();
     const watcher = (0, watcher_store_1.getWatcherForProject)(projectRoot);
     if (!watcher) {
-        console.log("No watcher running for this project.");
+        if (!stoppedDaemon) {
+            console.log("No watcher running for this project.");
+        }
         yield (0, exit_1.gracefulExit)();
         return;
     }

package/dist/config.js

@@ -94,6 +94,7 @@ exports.PATHS = {
     models: path.join(GLOBAL_ROOT, "models"),
     grammars: path.join(GLOBAL_ROOT, "grammars"),
     logsDir: path.join(GLOBAL_ROOT, "logs"),
+    daemonSocket: path.join(GLOBAL_ROOT, "daemon.sock"),
     // Centralized index storage — one database for all indexed directories
     lancedbDir: path.join(GLOBAL_ROOT, "lancedb"),
     cacheDir: path.join(GLOBAL_ROOT, "cache"),

package/dist/lib/daemon/daemon.js

@@ -0,0 +1,314 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+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.Daemon = void 0;
+const fs = __importStar(require("node:fs"));
+const net = __importStar(require("node:net"));
+const path = __importStar(require("node:path"));
+const chokidar_1 = require("chokidar");
+const config_1 = require("../../config");
+const batch_processor_1 = require("../index/batch-processor");
+const watcher_1 = require("../index/watcher");
+const meta_cache_1 = require("../store/meta-cache");
+const vector_db_1 = require("../store/vector-db");
+const process_1 = require("../utils/process");
+const project_registry_1 = require("../utils/project-registry");
+const watcher_store_1 = require("../utils/watcher-store");
+const ipc_handler_1 = require("./ipc-handler");
+const IDLE_TIMEOUT_MS = 30 * 60 * 1000; // 30 minutes
+const HEARTBEAT_INTERVAL_MS = 60 * 1000;
+class Daemon {
+    constructor() {
+        this.watcher = null;
+        this.processors = new Map();
+        this.vectorDb = null;
+        this.metaCache = null;
+        this.server = null;
+        this.lastActivity = Date.now();
+        this.startTime = Date.now();
+        this.heartbeatInterval = null;
+        this.idleInterval = null;
+        this.shuttingDown = false;
+        // Sorted longest-first for prefix matching
+        this.sortedRoots = [];
+        // Guard against concurrent watchProject/unwatchProject
+        this.pendingOps = new Set();
+    }
+    start() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // 1. Kill existing per-project watchers
+            const existing = (0, watcher_store_1.listWatchers)();
+            for (const w of existing) {
+                console.log(`[daemon] Taking over from per-project watcher (PID: ${w.pid}, ${path.basename(w.projectRoot)})`);
+                yield (0, process_1.killProcess)(w.pid);
+                (0, watcher_store_1.unregisterWatcher)(w.pid);
+            }
+            // 2. Stale socket cleanup
+            try {
+                fs.unlinkSync(config_1.PATHS.daemonSocket);
+            }
+            catch (_a) { }
+            // 3. Open shared resources
+            try {
+                fs.mkdirSync(config_1.PATHS.cacheDir, { recursive: true });
+                fs.mkdirSync(config_1.PATHS.lancedbDir, { recursive: true });
+                this.vectorDb = new vector_db_1.VectorDB(config_1.PATHS.lancedbDir);
+                this.metaCache = new meta_cache_1.MetaCache(config_1.PATHS.lmdbPath);
+            }
+            catch (err) {
+                console.error("[daemon] Failed to open shared resources:", err);
+                throw err;
+            }
+            // 4. Register daemon (only after resources are open)
+            (0, watcher_store_1.registerDaemon)(process.pid);
+            // 5. Load registered projects and create processors
+            const projects = (0, project_registry_1.listProjects)().filter((p) => p.status === "indexed");
+            const initialRoots = [];
+            for (const p of projects) {
+                this.addProcessor(p.root);
+                initialRoots.push(p.root);
+            }
+            // 6. Create chokidar with all initial roots
+            // Daemon always uses polling — watching multiple large project trees
+            // with native fs.watch can exhaust file descriptors even on macOS.
+            // Polling at 5s intervals is lightweight and reliable for all platforms.
+            this.watcher = (0, chokidar_1.watch)(initialRoots, {
+                ignored: watcher_1.WATCHER_IGNORE_PATTERNS,
+                ignoreInitial: true,
+                persistent: true,
+                usePolling: true,
+                interval: 5000,
+                binaryInterval: 10000,
+            });
+            this.watcher.on("add", (p) => this.routeEvent("change", p));
+            this.watcher.on("change", (p) => this.routeEvent("change", p));
+            this.watcher.on("unlink", (p) => this.routeEvent("unlink", p));
+            this.watcher.on("error", (err) => {
+                console.error("[daemon] Watcher error:", err);
+            });
+            // 7. Heartbeat
+            this.heartbeatInterval = setInterval(() => {
+                (0, watcher_store_1.heartbeat)(process.pid);
+            }, HEARTBEAT_INTERVAL_MS);
+            // 8. Idle timeout
+            this.idleInterval = setInterval(() => {
+                if (Date.now() - this.lastActivity > IDLE_TIMEOUT_MS) {
+                    console.log("[daemon] Idle for 30 minutes, shutting down");
+                    this.shutdown();
+                }
+            }, HEARTBEAT_INTERVAL_MS);
+            // 9. Socket server
+            this.server = net.createServer((conn) => {
+                let buf = "";
+                conn.on("data", (chunk) => {
+                    buf += chunk.toString();
+                    const nl = buf.indexOf("\n");
+                    if (nl === -1)
+                        return;
+                    const line = buf.slice(0, nl);
+                    buf = buf.slice(nl + 1);
+                    let cmd;
+                    try {
+                        cmd = JSON.parse(line);
+                    }
+                    catch (_a) {
+                        conn.write(`${JSON.stringify({ ok: false, error: "invalid JSON" })}\n`);
+                        conn.end();
+                        return;
+                    }
+                    (0, ipc_handler_1.handleCommand)(this, cmd).then((resp) => {
+                        conn.write(`${JSON.stringify(resp)}\n`);
+                        conn.end();
+                    });
+                });
+                conn.on("error", () => { }); // ignore client disconnect
+            });
+            yield new Promise((resolve, reject) => {
+                this.server.on("error", (err) => {
+                    const code = err.code;
+                    if (code === "EADDRINUSE") {
+                        console.error("[daemon] Another daemon is already running");
+                        reject(err);
+                    }
+                    else if (code === "EOPNOTSUPP") {
+                        console.error("[daemon] Filesystem does not support Unix sockets");
+                        process.exitCode = 2;
+                        reject(err);
+                    }
+                    else {
+                        reject(err);
+                    }
+                });
+                this.server.listen(config_1.PATHS.daemonSocket, () => resolve());
+            });
+            console.log(`[daemon] Started (PID: ${process.pid}, ${this.processors.size} projects)`);
+        });
+    }
+    watchProject(root) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.processors.has(root) || this.pendingOps.has(root))
+                return;
+            if (!this.watcher)
+                return;
+            this.addProcessor(root);
+            this.watcher.add(root);
+            console.log(`[daemon] Watching ${root}`);
+        });
+    }
+    addProcessor(root) {
+        if (this.processors.has(root))
+            return;
+        if (!this.vectorDb || !this.metaCache)
+            return;
+        this.pendingOps.add(root);
+        const processor = new batch_processor_1.ProjectBatchProcessor({
+            projectRoot: root,
+            vectorDb: this.vectorDb,
+            metaCache: this.metaCache,
+            dataDir: config_1.PATHS.globalRoot,
+            onReindex: (files, ms) => {
+                console.log(`[daemon:${path.basename(root)}] Reindexed ${files} file${files !== 1 ? "s" : ""} (${(ms / 1000).toFixed(1)}s)`);
+            },
+            onActivity: () => {
+                this.lastActivity = Date.now();
+            },
+        });
+        this.processors.set(root, processor);
+        this.rebuildSortedRoots();
+        (0, watcher_store_1.registerWatcher)({
+            pid: process.pid,
+            projectRoot: root,
+            startTime: Date.now(),
+            status: "watching",
+            lastHeartbeat: Date.now(),
+        });
+        this.pendingOps.delete(root);
+    }
+    unwatchProject(root) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const processor = this.processors.get(root);
+            if (!processor)
+                return;
+            yield processor.close();
+            (_a = this.watcher) === null || _a === void 0 ? void 0 : _a.unwatch(root);
+            this.processors.delete(root);
+            this.rebuildSortedRoots();
+            (0, watcher_store_1.unregisterWatcherByRoot)(root);
+            console.log(`[daemon] Unwatched ${root}`);
+        });
+    }
+    listProjects() {
+        return [...this.processors.keys()].map((root) => ({
+            root,
+            status: "watching",
+        }));
+    }
+    uptime() {
+        return Math.floor((Date.now() - this.startTime) / 1000);
+    }
+    shutdown() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d;
+            if (this.shuttingDown)
+                return;
+            this.shuttingDown = true;
+            console.log("[daemon] Shutting down...");
+            if (this.heartbeatInterval)
+                clearInterval(this.heartbeatInterval);
+            if (this.idleInterval)
+                clearInterval(this.idleInterval);
+            // Close all processors
+            for (const processor of this.processors.values()) {
+                yield processor.close();
+            }
+            // Close chokidar
+            try {
+                yield ((_a = this.watcher) === null || _a === void 0 ? void 0 : _a.close());
+            }
+            catch (_e) { }
+            // Close server + socket
+            (_b = this.server) === null || _b === void 0 ? void 0 : _b.close();
+            try {
+                fs.unlinkSync(config_1.PATHS.daemonSocket);
+            }
+            catch (_f) { }
+            // Unregister all
+            for (const root of this.processors.keys()) {
+                (0, watcher_store_1.unregisterWatcherByRoot)(root);
+            }
+            (0, watcher_store_1.unregisterDaemon)();
+            this.processors.clear();
+            // Close shared resources
+            try {
+                yield ((_c = this.metaCache) === null || _c === void 0 ? void 0 : _c.close());
+            }
+            catch (_g) { }
+            try {
+                yield ((_d = this.vectorDb) === null || _d === void 0 ? void 0 : _d.close());
+            }
+            catch (_h) { }
+            console.log("[daemon] Shutdown complete");
+        });
+    }
+    routeEvent(event, absPath) {
+        const processor = this.findProcessor(absPath);
+        if (processor) {
+            processor.handleFileEvent(event, absPath);
+        }
+    }
+    findProcessor(absPath) {
+        // sortedRoots is longest-first, so first match is the most specific
+        for (const root of this.sortedRoots) {
+            if (absPath.startsWith(root) && (absPath.length === root.length || absPath[root.length] === "/")) {
+                return this.processors.get(root);
+            }
+        }
+        return undefined;
+    }
+    rebuildSortedRoots() {
+        this.sortedRoots = [...this.processors.keys()].sort((a, b) => b.length - a.length);
+    }
+}
+exports.Daemon = Daemon;

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

@@ -0,0 +1,53 @@
+"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.handleCommand = handleCommand;
+function handleCommand(daemon, cmd) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            switch (cmd.cmd) {
+                case "ping":
+                    return { ok: true, pid: process.pid, uptime: daemon.uptime() };
+                case "watch": {
+                    const root = String(cmd.root || "");
+                    if (!root)
+                        return { ok: false, error: "missing root" };
+                    yield daemon.watchProject(root);
+                    return { ok: true, pid: process.pid };
+                }
+                case "unwatch": {
+                    const root = String(cmd.root || "");
+                    if (!root)
+                        return { ok: false, error: "missing root" };
+                    yield daemon.unwatchProject(root);
+                    return { ok: true };
+                }
+                case "status":
+                    return {
+                        ok: true,
+                        pid: process.pid,
+                        uptime: daemon.uptime(),
+                        projects: daemon.listProjects(),
+                    };
+                case "shutdown":
+                    // Respond before shutting down so the client gets the response
+                    setImmediate(() => daemon.shutdown());
+                    return { ok: true };
+                default:
+                    return { ok: false, error: `unknown command: ${cmd.cmd}` };
+            }
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            return { ok: false, error: msg };
+        }
+    });
+}