grepmax 0.8.2 → 0.9.1

package/dist/lib/index/batch-processor.js

@@ -0,0 +1,286 @@
+"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.ProjectBatchProcessor = void 0;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const config_1 = require("../../config");
+const cache_check_1 = require("../utils/cache-check");
+const file_utils_1 = require("../utils/file-utils");
+const logger_1 = require("../utils/logger");
+const lock_1 = require("../utils/lock");
+const pool_1 = require("../workers/pool");
+const watcher_batch_1 = require("./watcher-batch");
+const DEBOUNCE_MS = 2000;
+const FTS_REBUILD_INTERVAL_MS = 5 * 60 * 1000;
+const MAX_RETRIES = 5;
+class ProjectBatchProcessor {
+    constructor(opts) {
+        this.pending = new Map();
+        this.retryCount = new Map();
+        this.debounceTimer = null;
+        this.processing = false;
+        this.closed = false;
+        this.consecutiveLockFailures = 0;
+        this.currentBatchAc = null;
+        this.projectRoot = opts.projectRoot;
+        this.vectorDb = opts.vectorDb;
+        this.metaCache = opts.metaCache;
+        this.dataDir = opts.dataDir;
+        this.onReindex = opts.onReindex;
+        this.onActivity = opts.onActivity;
+        this.wtag = `watch:${path.basename(opts.projectRoot)}`;
+        const taskTimeoutMs = (() => {
+            var _a;
+            const fromEnv = Number.parseInt((_a = process.env.GMAX_WORKER_TASK_TIMEOUT_MS) !== null && _a !== void 0 ? _a : "", 10);
+            return Number.isFinite(fromEnv) && fromEnv > 0 ? fromEnv : 120000;
+        })();
+        this.batchTimeoutMs = Math.max(Math.ceil(taskTimeoutMs * 1.5), 120000);
+        this.ftsInterval = setInterval(() => __awaiter(this, void 0, void 0, function* () {
+            if (this.closed || this.processing)
+                return;
+            try {
+                yield this.vectorDb.createFTSIndex();
+            }
+            catch (err) {
+                console.error(`[${this.wtag}] FTS rebuild failed:`, err);
+            }
+        }), FTS_REBUILD_INTERVAL_MS);
+        this.ftsInterval.unref();
+    }
+    handleFileEvent(event, absPath) {
+        var _a;
+        if (this.closed)
+            return;
+        if (event !== "unlink") {
+            const ext = path.extname(absPath).toLowerCase();
+            const bn = path.basename(absPath).toLowerCase();
+            if (!config_1.INDEXABLE_EXTENSIONS.has(ext) && !config_1.INDEXABLE_EXTENSIONS.has(bn))
+                return;
+        }
+        this.pending.set(absPath, event);
+        (_a = this.onActivity) === null || _a === void 0 ? void 0 : _a.call(this);
+        this.scheduleBatch();
+    }
+    close() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            this.closed = true;
+            (_a = this.currentBatchAc) === null || _a === void 0 ? void 0 : _a.abort();
+            if (this.debounceTimer)
+                clearTimeout(this.debounceTimer);
+            clearInterval(this.ftsInterval);
+        });
+    }
+    scheduleBatch() {
+        if (this.debounceTimer)
+            clearTimeout(this.debounceTimer);
+        this.debounceTimer = setTimeout(() => this.processBatch(), DEBOUNCE_MS);
+    }
+    processBatch() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            if (this.closed || this.processing || this.pending.size === 0)
+                return;
+            this.processing = true;
+            const batchAc = new AbortController();
+            this.currentBatchAc = batchAc;
+            const batchTimeout = setTimeout(() => {
+                (0, logger_1.log)(this.wtag, `Batch timed out after ${this.batchTimeoutMs}ms, aborting`);
+                batchAc.abort();
+            }, this.batchTimeoutMs);
+            const batch = new Map(this.pending);
+            this.pending.clear();
+            const filenames = [...batch.keys()].map((p) => path.basename(p));
+            (0, logger_1.log)(this.wtag, `Processing ${batch.size} changed files: ${filenames.join(", ")}`);
+            const start = Date.now();
+            let reindexed = 0;
+            try {
+                const lock = yield (0, lock_1.acquireWriterLockWithRetry)(this.dataDir, {
+                    maxRetries: 3,
+                    retryDelayMs: 500,
+                });
+                try {
+                    const pool = (0, pool_1.getWorkerPool)();
+                    const deletes = [];
+                    const vectors = [];
+                    const metaUpdates = new Map();
+                    const metaDeletes = [];
+                    const attempted = new Set();
+                    for (const [absPath, event] of batch) {
+                        if (batchAc.signal.aborted)
+                            break;
+                        attempted.add(absPath);
+                        if (event === "unlink") {
+                            deletes.push(absPath);
+                            metaDeletes.push(absPath);
+                            reindexed++;
+                            continue;
+                        }
+                        // change or add
+                        try {
+                            const stats = yield fs.promises.stat(absPath);
+                            if (!(0, file_utils_1.isIndexableFile)(absPath, stats.size))
+                                continue;
+                            const cached = this.metaCache.get(absPath);
+                            if ((0, cache_check_1.isFileCached)(cached, stats)) {
+                                continue;
+                            }
+                            const result = yield pool.processFile({
+                                path: absPath,
+                                absolutePath: absPath,
+                            }, batchAc.signal);
+                            const metaEntry = {
+                                hash: result.hash,
+                                mtimeMs: result.mtimeMs,
+                                size: result.size,
+                            };
+                            if (cached && cached.hash === result.hash) {
+                                metaUpdates.set(absPath, metaEntry);
+                                continue;
+                            }
+                            if (result.shouldDelete) {
+                                deletes.push(absPath);
+                                metaUpdates.set(absPath, metaEntry);
+                                reindexed++;
+                                continue;
+                            }
+                            deletes.push(absPath);
+                            if (result.vectors.length > 0) {
+                                vectors.push(...result.vectors);
+                            }
+                            metaUpdates.set(absPath, metaEntry);
+                            reindexed++;
+                        }
+                        catch (err) {
+                            if (batchAc.signal.aborted)
+                                break;
+                            const code = err === null || err === void 0 ? void 0 : err.code;
+                            if (code === "ENOENT") {
+                                deletes.push(absPath);
+                                metaDeletes.push(absPath);
+                                reindexed++;
+                            }
+                            else {
+                                console.error(`[${this.wtag}] Failed to process ${absPath}:`, err);
+                                if (!pool.isHealthy()) {
+                                    console.error(`[${this.wtag}] Worker pool unhealthy, aborting batch`);
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                    // Requeue files that weren't attempted (aborted or pool unhealthy)
+                    for (const [absPath, event] of batch) {
+                        if (!attempted.has(absPath) && !this.pending.has(absPath)) {
+                            this.pending.set(absPath, event);
+                        }
+                    }
+                    // Flush to VectorDB: insert first, then delete old (preserving new)
+                    const newIds = vectors.map((v) => v.id);
+                    if (vectors.length > 0) {
+                        yield this.vectorDb.insertBatch(vectors);
+                    }
+                    if (deletes.length > 0) {
+                        if (newIds.length > 0) {
+                            yield this.vectorDb.deletePathsExcludingIds(deletes, newIds);
+                        }
+                        else {
+                            yield this.vectorDb.deletePaths(deletes);
+                        }
+                    }
+                    // Update MetaCache
+                    for (const [p, entry] of metaUpdates) {
+                        this.metaCache.put(p, entry);
+                    }
+                    for (const p of metaDeletes) {
+                        this.metaCache.delete(p);
+                    }
+                }
+                finally {
+                    yield lock.release();
+                }
+                const duration = Date.now() - start;
+                if (reindexed > 0) {
+                    (_a = this.onReindex) === null || _a === void 0 ? void 0 : _a.call(this, reindexed, duration);
+                }
+                (0, logger_1.log)(this.wtag, `Batch complete: ${batch.size} files, ${reindexed} reindexed (${(duration / 1000).toFixed(1)}s)`);
+                this.consecutiveLockFailures = 0;
+                for (const absPath of batch.keys()) {
+                    this.retryCount.delete(absPath);
+                }
+            }
+            catch (err) {
+                const isLockError = err instanceof Error && err.message.includes("lock already held");
+                if (isLockError) {
+                    this.consecutiveLockFailures++;
+                }
+                console.error(`[${this.wtag}] Batch processing failed:`, err);
+                const { requeued, dropped, backoffMs } = (0, watcher_batch_1.computeRetryAction)(batch, this.retryCount, MAX_RETRIES, isLockError, this.consecutiveLockFailures, DEBOUNCE_MS);
+                for (const [absPath, event] of requeued) {
+                    if (!this.pending.has(absPath)) {
+                        this.pending.set(absPath, event);
+                    }
+                }
+                if (dropped > 0) {
+                    console.warn(`[${this.wtag}] Dropped ${dropped} file(s) after ${MAX_RETRIES} failed retries`);
+                }
+                if (this.pending.size > 0) {
+                    if (this.debounceTimer)
+                        clearTimeout(this.debounceTimer);
+                    this.debounceTimer = setTimeout(() => this.processBatch(), backoffMs);
+                }
+            }
+            finally {
+                clearTimeout(batchTimeout);
+                this.currentBatchAc = null;
+                this.processing = false;
+                if (this.pending.size > 0) {
+                    this.scheduleBatch();
+                }
+            }
+        });
+    }
+}
+exports.ProjectBatchProcessor = ProjectBatchProcessor;

package/dist/lib/index/watcher.js

@@ -44,16 +44,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WATCHER_IGNORE_PATTERNS = void 0;
 exports.startWatcher = startWatcher;
-const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
 const chokidar_1 = require("chokidar");
-const config_1 = require("../../config");
-const cache_check_1 = require("../utils/cache-check");
-const file_utils_1 = require("../utils/file-utils");
-const logger_1 = require("../utils/logger");
-const lock_1 = require("../utils/lock");
-const pool_1 = require("../workers/pool");
-const watcher_batch_1 = require("./watcher-batch");
+const batch_processor_1 = require("./batch-processor");
 // Chokidar ignored — must exclude heavy directories to keep FD count low.
 // On macOS, chokidar uses FSEvents (single FD) but falls back to fs.watch()
 // (one FD per directory) if FSEvents isn't available or for some subdirs.
@@ -72,20 +65,10 @@ exports.WATCHER_IGNORE_PATTERNS = [
     "**/lancedb/**",
     /(^|[/\\])\../, // dotfiles
 ];
-const DEBOUNCE_MS = 2000;
-const FTS_REBUILD_INTERVAL_MS = 5 * 60 * 1000;
 function startWatcher(opts) {
-    const { projectRoot, vectorDb, metaCache, dataDir, onReindex } = opts;
-    const projectName = path.basename(projectRoot);
-    const wtag = `watch:${projectName}`;
-    const pending = new Map();
-    const retryCount = new Map();
-    let debounceTimer = null;
-    let processing = false;
-    let closed = false;
-    let consecutiveLockFailures = 0;
-    let currentBatchAc = null;
-    const MAX_RETRIES = 5;
+    const { projectRoot } = opts;
+    const wtag = `watch:${path.basename(projectRoot)}`;
+    const processor = new batch_processor_1.ProjectBatchProcessor(opts);
     // macOS: FSEvents is a single-FD kernel API — no EMFILE risk and no polling.
     // Linux: inotify is event-driven but uses one FD per watch; fall back to
     //        polling for monorepos to avoid hitting ulimit.
@@ -98,215 +81,12 @@ function startWatcher(opts) {
     watcher.on("error", (err) => {
         console.error(`[${wtag}] Watcher error:`, err);
     });
-    const scheduleBatch = () => {
-        if (debounceTimer)
-            clearTimeout(debounceTimer);
-        debounceTimer = setTimeout(() => processBatch(), DEBOUNCE_MS);
-    };
-    const taskTimeoutMs = (() => {
-        var _a;
-        const fromEnv = Number.parseInt((_a = process.env.GMAX_WORKER_TASK_TIMEOUT_MS) !== null && _a !== void 0 ? _a : "", 10);
-        return Number.isFinite(fromEnv) && fromEnv > 0 ? fromEnv : 120000;
-    })();
-    const BATCH_TIMEOUT_MS = Math.max(Math.ceil(taskTimeoutMs * 1.5), 120000);
-    const processBatch = () => __awaiter(this, void 0, void 0, function* () {
-        if (closed || processing || pending.size === 0)
-            return;
-        processing = true;
-        const batchAc = new AbortController();
-        currentBatchAc = batchAc;
-        const batchTimeout = setTimeout(() => {
-            (0, logger_1.log)(wtag, `Batch timed out after ${BATCH_TIMEOUT_MS}ms, aborting`);
-            batchAc.abort();
-        }, BATCH_TIMEOUT_MS);
-        const batch = new Map(pending);
-        pending.clear();
-        const filenames = [...batch.keys()].map((p) => path.basename(p));
-        (0, logger_1.log)(wtag, `Processing ${batch.size} changed files: ${filenames.join(", ")}`);
-        const start = Date.now();
-        let reindexed = 0;
-        try {
-            const lock = yield (0, lock_1.acquireWriterLockWithRetry)(dataDir, {
-                maxRetries: 3,
-                retryDelayMs: 500,
-            });
-            try {
-                const pool = (0, pool_1.getWorkerPool)();
-                const deletes = [];
-                const vectors = [];
-                const metaUpdates = new Map();
-                const metaDeletes = [];
-                const attempted = new Set();
-                for (const [absPath, event] of batch) {
-                    if (batchAc.signal.aborted)
-                        break;
-                    attempted.add(absPath);
-                    if (event === "unlink") {
-                        deletes.push(absPath);
-                        metaDeletes.push(absPath);
-                        reindexed++;
-                        continue;
-                    }
-                    // change or add
-                    try {
-                        const stats = yield fs.promises.stat(absPath);
-                        if (!(0, file_utils_1.isIndexableFile)(absPath, stats.size))
-                            continue;
-                        // Quick mtime/size check — skip worker pool if unchanged
-                        const cached = metaCache.get(absPath);
-                        if ((0, cache_check_1.isFileCached)(cached, stats)) {
-                            continue;
-                        }
-                        const result = yield pool.processFile({
-                            path: absPath,
-                            absolutePath: absPath,
-                        }, batchAc.signal);
-                        const metaEntry = {
-                            hash: result.hash,
-                            mtimeMs: result.mtimeMs,
-                            size: result.size,
-                        };
-                        if (cached && cached.hash === result.hash) {
-                            metaUpdates.set(absPath, metaEntry);
-                            continue;
-                        }
-                        if (result.shouldDelete) {
-                            deletes.push(absPath);
-                            metaUpdates.set(absPath, metaEntry);
-                            reindexed++;
-                            continue;
-                        }
-                        // Delete old vectors, insert new
-                        deletes.push(absPath);
-                        if (result.vectors.length > 0) {
-                            vectors.push(...result.vectors);
-                        }
-                        metaUpdates.set(absPath, metaEntry);
-                        reindexed++;
-                    }
-                    catch (err) {
-                        if (batchAc.signal.aborted)
-                            break;
-                        const code = err === null || err === void 0 ? void 0 : err.code;
-                        if (code === "ENOENT") {
-                            deletes.push(absPath);
-                            metaDeletes.push(absPath);
-                            reindexed++;
-                        }
-                        else {
-                            console.error(`[${wtag}] Failed to process ${absPath}:`, err);
-                            if (!pool.isHealthy()) {
-                                console.error(`[${wtag}] Worker pool unhealthy, aborting batch`);
-                                break;
-                            }
-                        }
-                    }
-                }
-                // Requeue files that weren't attempted (aborted or pool unhealthy)
-                for (const [absPath, event] of batch) {
-                    if (!attempted.has(absPath) && !pending.has(absPath)) {
-                        pending.set(absPath, event);
-                    }
-                }
-                // Flush to VectorDB: insert first, then delete old (preserving new)
-                const newIds = vectors.map((v) => v.id);
-                if (vectors.length > 0) {
-                    yield vectorDb.insertBatch(vectors);
-                }
-                if (deletes.length > 0) {
-                    if (newIds.length > 0) {
-                        yield vectorDb.deletePathsExcludingIds(deletes, newIds);
-                    }
-                    else {
-                        yield vectorDb.deletePaths(deletes);
-                    }
-                }
-                // Update MetaCache
-                for (const [p, entry] of metaUpdates) {
-                    metaCache.put(p, entry);
-                }
-                for (const p of metaDeletes) {
-                    metaCache.delete(p);
-                }
-            }
-            finally {
-                yield lock.release();
-            }
-            const duration = Date.now() - start;
-            if (reindexed > 0) {
-                onReindex === null || onReindex === void 0 ? void 0 : onReindex(reindexed, duration);
-            }
-            (0, logger_1.log)(wtag, `Batch complete: ${batch.size} files, ${reindexed} reindexed (${(duration / 1000).toFixed(1)}s)`);
-            consecutiveLockFailures = 0;
-            for (const absPath of batch.keys()) {
-                retryCount.delete(absPath);
-            }
-        }
-        catch (err) {
-            const isLockError = err instanceof Error && err.message.includes("lock already held");
-            if (isLockError) {
-                consecutiveLockFailures++;
-            }
-            console.error(`[${wtag}] Batch processing failed:`, err);
-            const { requeued, dropped, backoffMs } = (0, watcher_batch_1.computeRetryAction)(batch, retryCount, MAX_RETRIES, isLockError, consecutiveLockFailures, DEBOUNCE_MS);
-            for (const [absPath, event] of requeued) {
-                if (!pending.has(absPath)) {
-                    pending.set(absPath, event);
-                }
-            }
-            if (dropped > 0) {
-                console.warn(`[${wtag}] Dropped ${dropped} file(s) after ${MAX_RETRIES} failed retries`);
-            }
-            if (pending.size > 0) {
-                if (debounceTimer)
-                    clearTimeout(debounceTimer);
-                debounceTimer = setTimeout(() => processBatch(), backoffMs);
-            }
-        }
-        finally {
-            clearTimeout(batchTimeout);
-            currentBatchAc = null;
-            processing = false;
-            // Process any events that came in while we were processing
-            if (pending.size > 0) {
-                scheduleBatch();
-            }
-        }
-    });
-    const onFileEvent = (event, absPath) => {
-        if (closed)
-            return;
-        if (event !== "unlink") {
-            const ext = path.extname(absPath).toLowerCase();
-            const bn = path.basename(absPath).toLowerCase();
-            if (!config_1.INDEXABLE_EXTENSIONS.has(ext) && !config_1.INDEXABLE_EXTENSIONS.has(bn))
-                return;
-        }
-        pending.set(absPath, event);
-        scheduleBatch();
-    };
-    watcher.on("add", (p) => onFileEvent("change", p));
-    watcher.on("change", (p) => onFileEvent("change", p));
-    watcher.on("unlink", (p) => onFileEvent("unlink", p));
-    // Periodic FTS rebuild
-    const ftsInterval = setInterval(() => __awaiter(this, void 0, void 0, function* () {
-        if (closed || processing)
-            return;
-        try {
-            yield vectorDb.createFTSIndex();
-        }
-        catch (err) {
-            console.error(`[${wtag}] FTS rebuild failed:`, err);
-        }
-    }), FTS_REBUILD_INTERVAL_MS);
-    ftsInterval.unref();
+    watcher.on("add", (p) => processor.handleFileEvent("change", p));
+    watcher.on("change", (p) => processor.handleFileEvent("change", p));
+    watcher.on("unlink", (p) => processor.handleFileEvent("unlink", p));
     return {
         close: () => __awaiter(this, void 0, void 0, function* () {
-            closed = true;
-            currentBatchAc === null || currentBatchAc === void 0 ? void 0 : currentBatchAc.abort();
-            if (debounceTimer)
-                clearTimeout(debounceTimer);
-            clearInterval(ftsInterval);
+            yield processor.close();
             yield watcher.close();
         }),
     };

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

@@ -0,0 +1,108 @@
+"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.sendDaemonCommand = sendDaemonCommand;
+exports.isDaemonRunning = isDaemonRunning;
+const net = __importStar(require("node:net"));
+const config_1 = require("../../config");
+const DEFAULT_TIMEOUT_MS = 5000;
+/**
+ * Send a JSON command to the daemon over the Unix domain socket.
+ * Returns the parsed response, or {ok: false, error} on failure.
+ */
+function sendDaemonCommand(cmd, opts) {
+    var _a;
+    const timeout = (_a = opts === null || opts === void 0 ? void 0 : opts.timeoutMs) !== null && _a !== void 0 ? _a : DEFAULT_TIMEOUT_MS;
+    return new Promise((resolve) => {
+        let settled = false;
+        const finish = (resp) => {
+            if (settled)
+                return;
+            settled = true;
+            socket.destroy();
+            resolve(resp);
+        };
+        const socket = net.createConnection({ path: config_1.PATHS.daemonSocket });
+        const timer = setTimeout(() => {
+            finish({ ok: false, error: "timeout" });
+        }, timeout);
+        socket.on("connect", () => {
+            socket.write(`${JSON.stringify(cmd)}\n`);
+        });
+        let buf = "";
+        socket.on("data", (chunk) => {
+            buf += chunk.toString();
+            const nl = buf.indexOf("\n");
+            if (nl !== -1) {
+                clearTimeout(timer);
+                try {
+                    finish(JSON.parse(buf.slice(0, nl)));
+                }
+                catch (_a) {
+                    finish({ ok: false, error: "invalid response" });
+                }
+            }
+        });
+        socket.on("error", (err) => {
+            var _a;
+            clearTimeout(timer);
+            finish({ ok: false, error: (_a = err.code) !== null && _a !== void 0 ? _a : err.message });
+        });
+        socket.on("close", () => {
+            clearTimeout(timer);
+            if (!settled) {
+                finish({ ok: false, error: "connection closed" });
+            }
+        });
+    });
+}
+/**
+ * Check if the daemon is running by sending a ping.
+ */
+function isDaemonRunning() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const resp = yield sendDaemonCommand({ cmd: "ping" }, { timeoutMs: 2000 });
+        return resp.ok === true;
+    });
+}