grepmax 0.7.31 → 0.7.33

package/dist/commands/serve.js

@@ -380,6 +380,7 @@ exports.serve = new commander_1.Command("serve")
             // Ensure we exit if server fails to start
             process.exit(1);
         });
+        server.setTimeout(60000); // 60s request timeout
         server.listen(port, () => {
             const address = server.address();
             const actualPort = typeof address === "object" && address ? address.port : port;

package/dist/lib/index/watcher.js

@@ -77,6 +77,8 @@ 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;
@@ -96,14 +98,19 @@ function startWatcher(opts) {
         binaryInterval: 10000,
     });
     watcher.on("error", (err) => {
-        console.error("[watch] Watcher error:", err);
+        console.error(`[${wtag}] Watcher error:`, err);
     });
     const scheduleBatch = () => {
         if (debounceTimer)
             clearTimeout(debounceTimer);
         debounceTimer = setTimeout(() => processBatch(), DEBOUNCE_MS);
     };
-    const BATCH_TIMEOUT_MS = 120000;
+    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* () {
         var _a;
         if (closed || processing || pending.size === 0)
@@ -111,13 +118,13 @@ function startWatcher(opts) {
         processing = true;
         const batchTimeout = setTimeout(() => {
             if (processing) {
-                console.error("[watch] Batch processing timed out after 120s, resetting");
+                console.error(`[${wtag}] Batch processing timed out after 120s, resetting`);
                 processing = false;
             }
         }, BATCH_TIMEOUT_MS);
         const batch = new Map(pending);
         pending.clear();
-        (0, logger_1.log)("watch", `Processing ${batch.size} changed files`);
+        (0, logger_1.log)(wtag, `Processing ${batch.size} changed files`);
         const start = Date.now();
         let reindexed = 0;
         const changedIds = [];
@@ -188,7 +195,11 @@ function startWatcher(opts) {
                             reindexed++;
                         }
                         else {
-                            console.error(`[watch] Failed to process ${absPath}:`, err);
+                            console.error(`[${wtag}] Failed to process ${absPath}:`, err);
+                            if (!pool.isHealthy()) {
+                                console.error(`[${wtag}] Worker pool unhealthy, aborting batch`);
+                                break;
+                            }
                         }
                     }
                 }
@@ -216,10 +227,11 @@ function startWatcher(opts) {
             finally {
                 yield lock.release();
             }
+            const duration = Date.now() - start;
             if (reindexed > 0) {
-                const duration = Date.now() - start;
                 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);
@@ -230,7 +242,7 @@ function startWatcher(opts) {
             if (isLockError) {
                 consecutiveLockFailures++;
             }
-            console.error("[watch] Batch processing failed:", err);
+            console.error(`[${wtag}] Batch processing failed:`, err);
             let dropped = 0;
             for (const [absPath, event] of batch) {
                 const count = ((_a = retryCount.get(absPath)) !== null && _a !== void 0 ? _a : 0) + 1;
@@ -244,7 +256,7 @@ function startWatcher(opts) {
                 }
             }
             if (dropped > 0) {
-                console.warn(`[watch] Dropped ${dropped} file(s) after ${MAX_RETRIES} failed retries`);
+                console.warn(`[${wtag}] Dropped ${dropped} file(s) after ${MAX_RETRIES} failed retries`);
             }
             if (pending.size > 0) {
                 const backoffMs = Math.min(DEBOUNCE_MS * Math.pow(2, consecutiveLockFailures), 30000);
@@ -320,7 +332,7 @@ function startWatcher(opts) {
             yield vectorDb.createFTSIndex();
         }
         catch (err) {
-            console.error("[watch] FTS rebuild failed:", err);
+            console.error(`[${wtag}] FTS rebuild failed:`, err);
         }
     }), FTS_REBUILD_INTERVAL_MS);
     ftsInterval.unref();

package/dist/lib/workers/embeddings/mlx-client.js

@@ -95,13 +95,9 @@ function postJSON(path, body) {
 /**
  * Check if MLX server is reachable. Caches result for CHECK_INTERVAL_MS.
  */
-function isMlxUp() {
+function checkHealth() {
     return __awaiter(this, void 0, void 0, function* () {
-        const now = Date.now();
-        if (mlxAvailable !== null && now - lastCheck < CHECK_INTERVAL_MS) {
-            return mlxAvailable;
-        }
-        const result = yield new Promise((resolve) => {
+        return new Promise((resolve) => {
             const req = http.get({ hostname: MLX_HOST, port: MLX_PORT, path: "/health", timeout: 2000 }, (res) => {
                 res.resume();
                 resolve(res.statusCode === 200);
@@ -112,6 +108,20 @@ function isMlxUp() {
                 resolve(false);
             });
         });
+    });
+}
+function isMlxUp() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const now = Date.now();
+        if (mlxAvailable !== null && now - lastCheck < CHECK_INTERVAL_MS) {
+            return mlxAvailable;
+        }
+        let result = yield checkHealth();
+        // On first check (cold start), retry once after 3s — server may still be loading
+        if (!result && mlxAvailable === null) {
+            yield new Promise((r) => setTimeout(r, 3000));
+            result = yield checkHealth();
+        }
         mlxAvailable = result;
         lastCheck = now;
         return result;

package/dist/lib/workers/pool.js

@@ -123,6 +123,9 @@ class WorkerPool {
             this.spawnWorker();
         }
     }
+    isHealthy() {
+        return !this.destroyed && this.workers.length > 0;
+    }
     clearTaskTimeout(task) {
         if (task.timeout) {
             clearTimeout(task.timeout);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "grepmax",
-  "version": "0.7.31",
+  "version": "0.7.33",
   "author": "Robert Owens <robowens@me.com>",
   "homepage": "https://github.com/reowens/grepmax",
   "bugs": {

package/plugins/grepmax/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "grepmax",
-  "version": "0.7.31",
+  "version": "0.7.33",
   "description": "Semantic code search for Claude Code. Automatically indexes your project and provides intelligent search capabilities.",
   "author": {
     "name": "Robert Owens",