ai-or-die 0.1.72 → 0.1.73

package/bin/ai-or-die.js

@@ -142,7 +142,7 @@ async function main() {
     }
 
     const app = new ClaudeCodeWebServer(serverOptions);
-    const httpServer = await app.start();
+    await app.start();
 
     const protocol = options.https ? 'https' : 'http';
     const baseUrl = `${protocol}://localhost:${port}`;
@@ -187,17 +187,15 @@ async function main() {
 
     console.log('\nPress Ctrl+C to stop the server\n');
 
-    const shutdown = async () => {
-      console.log('\nShutting down server...');
-      if (tunnel) await tunnel.stop();
-      httpServer.close(() => {
-        console.log('Server closed');
-        process.exit(0);
-      });
-    };
-
-    process.on('SIGINT', () => { shutdown(); });
-    process.on('SIGTERM', () => { shutdown(); });
+    // Shutdown is owned by the server's single SIGINT/SIGTERM handler
+    // (ClaudeCodeWebServer.handleShutdown), which performs the ordered graceful
+    // teardown: cooperative disposal of the local-LLM (sticky-note) and STT
+    // native worker threads, tunnel stop, session save, then server close.
+    // A second handler here used to race it — its httpServer.close() callback
+    // fires immediately when there are no open connections and called
+    // process.exit(0) before the worker threads could dispose their ggml-based
+    // native models, which aborted the process (SIGABRT / exit 134) on Ctrl+C.
+    // So we deliberately do NOT register a SIGINT/SIGTERM handler here.
 
   } catch (error) {
     console.error('Error starting server:', error.message);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-or-die",
-  "version": "0.1.72",
+  "version": "0.1.73",
   "description": "Universal AI coding terminal — Claude, Copilot, Gemini & more in your browser",
   "main": "src/server.js",
   "bin": {

package/src/server.js

@@ -475,13 +475,31 @@ class ClaudeCodeWebServer {
     forceExitTimer.unref();
 
     console.log(`\nGracefully shutting down (exit code: ${exitCode})...`);
+    // Persist sessions FIRST, before the (bounded but potentially multi-second)
+    // native-engine teardown below. If a pathological native teardown ever blew
+    // the 15s force-exit budget, sessions would already be safe on disk. close()
+    // saves again at the end of a normal shutdown.
+    try { await this.saveSessionsToDisk(true); } catch (_) { /* ignore */ }
     // Tear down the local-LLM summariser + worker so the model/worker thread
     // don't keep the process alive (and don't hold a GGUF file lock on Windows).
     if (this._stickyInitTimer) { clearTimeout(this._stickyInitTimer); this._stickyInitTimer = null; }
     if (this._stickyJsonlPoll) { clearInterval(this._stickyJsonlPoll); this._stickyJsonlPoll = null; }
     this._stickyJsonl.clear();
     try { this.stickyNoteSummarizer.shutdown(); } catch (_) { /* ignore */ }
-    try { await this.stickyNoteEngine.shutdown(); } catch (_) { /* ignore */ }
+    // Tear down both local native worker engines (sticky-note = node-llama-cpp,
+    // STT = sherpa-onnx) concurrently. Each disposes its loaded model/recognizer
+    // on its worker thread before exiting; force-tearing them down via
+    // process.exit() while a model is loaded/loading aborts the process (SIGABRT)
+    // during native cleanup. Running them in parallel keeps total shutdown well
+    // inside the 15s force-exit budget above. STT shutdown was previously missing
+    // entirely. The CLI dev tunnel (only set in --tunnel mode) used to be stopped
+    // by a second SIGINT handler in bin/ai-or-die.js, now removed to avoid a
+    // shutdown race; its stop moves here onto the single graceful path.
+    await Promise.allSettled([
+      Promise.resolve().then(() => this.stickyNoteEngine.shutdown()),
+      Promise.resolve().then(() => this.sttEngine.shutdown()),
+      Promise.resolve().then(() => (this.tunnelManager ? this.tunnelManager.stop() : undefined)),
+    ]);
     await this.close();
     clearTimeout(forceExitTimer);
     process.exit(exitCode);
@@ -5286,6 +5304,20 @@ class ClaudeCodeWebServer {
     // Save sessions before closing
     await this.saveSessionsToDisk(true);
 
+    // Tear down the STT (sherpa-onnx) native worker. close() is the cleanup path
+    // shared by the signal handler (handleShutdown -> close) AND direct close()
+    // callers (e.g. the e2e test servers, which construct a ClaudeCodeWebServer
+    // and call server.close()). Without this, a server that has loaded the STT
+    // model leaks its worker thread past close() and keeps the process alive —
+    // this hung the Windows e2e jobs once the model was cached/present. The
+    // shutdown is cooperative (graceful message, no terminate()) so native
+    // teardown can't abort the process, and idempotent (handleShutdown already
+    // ran it on the signal path, so this is then a no-op). The sticky-note engine
+    // is torn down by handleShutdown only: it is disabled in the e2e test
+    // servers, and its teardown must precede close()'s session-output flush to
+    // avoid re-triggering a summary, so it stays out of this shared path.
+    try { await this.sttEngine.shutdown(); } catch (_) { /* ignore */ }
+
     // Clear all intervals
     if (this.autoSaveInterval) {
       clearInterval(this.autoSaveInterval);

package/src/sticky-note-engine.js

@@ -30,6 +30,7 @@ class StickyNoteEngine {
 
     this._status = 'unavailable';
     this._worker = null;
+    this._spawningWorker = null;
     this._queue = [];
     this._currentRequest = null;
     this._requestIdCounter = 0;
@@ -88,6 +89,11 @@ class StickyNoteEngine {
       });
     }
     this._status = 'loading';
+    // If shutdown began while we were checking/downloading the model, do NOT
+    // spawn a worker we'd immediately have to kill mid-native-load (which aborts
+    // the process). shutdown() awaits this in-flight init, so bailing here lets
+    // it complete cleanly with no worker.
+    if (this._stopping) return;
     await this._spawnWorker();
   }
 
@@ -198,6 +204,11 @@ class StickyNoteEngine {
   _spawnWorker() {
     return new Promise((resolve, reject) => {
       const worker = this._createWorker();
+      // Track the worker from the moment it's created (not just after 'ready')
+      // so shutdown() can stop it cooperatively even while it's still loading the
+      // model. Cleared once it becomes this._worker or fails to boot.
+      this._spawningWorker = worker;
+      const clearPending = () => { if (this._spawningWorker === worker) this._spawningWorker = null; };
 
       const onReady = (msg) => {
         if (!msg) return;
@@ -205,6 +216,16 @@ class StickyNoteEngine {
           worker.off('message', onReady);
           worker.off('error', onError);
           worker.off('exit', onBootExit);
+          clearPending();
+          // If shutdown started while this worker was still loading, do NOT
+          // promote it to the active worker — that would resurrect a torn-down
+          // engine. Ask it to dispose + exit and resolve init as cancelled.
+          if (this._stopping) {
+            this._status = 'unavailable';
+            try { worker.postMessage({ type: 'shutdown' }); } catch { /* ignore */ }
+            resolve();
+            return;
+          }
           this._worker = worker;
           this._status = 'ready';
           this._restartAttempts = 0;
@@ -217,6 +238,7 @@ class StickyNoteEngine {
           worker.off('message', onReady);
           worker.off('error', onError);
           worker.off('exit', onBootExit);
+          clearPending();
           if (msg.code === 'MODULE_NOT_FOUND') this._lastSpawnError = 'MODULE_NOT_FOUND';
           this._status = 'unavailable';
           reject(new Error(msg.message || 'worker error'));
@@ -226,6 +248,7 @@ class StickyNoteEngine {
         worker.off('message', onReady);
         worker.off('error', onError);
         worker.off('exit', onBootExit);
+        clearPending();
         if (err && (err.code === 'MODULE_NOT_FOUND' || (err.message && err.message.includes('node-llama-cpp')))) {
           this._lastSpawnError = 'MODULE_NOT_FOUND';
         }
@@ -238,6 +261,7 @@ class StickyNoteEngine {
         worker.off('message', onReady);
         worker.off('error', onError);
         worker.off('exit', onBootExit);
+        clearPending();
         this._status = 'unavailable';
         reject(new Error(`sticky-note worker exited during init (code ${code})`));
       };
@@ -263,6 +287,32 @@ class StickyNoteEngine {
 
   async shutdown() {
     this._stopping = true;
+
+    // Shared time budget: the init-wait + cooperative-exit waits below together
+    // stay within this window so the whole engine teardown (run concurrently with
+    // the STT engine by handleShutdown) finishes inside handleShutdown's 15s
+    // force-exit budget, leaving room for close(). Realistic teardown is a few
+    // hundred ms; this only caps pathological hangs.
+    const deadline = Date.now() + 10000;
+    const remaining = () => Math.max(0, deadline - Date.now());
+
+    // If a worker is mid model-LOAD (status 'loading' = the native model is being
+    // constructed in the worker thread), wait — bounded — for it to settle so we
+    // can dispose it cooperatively; a worker killed mid-native-load aborts the
+    // process (SIGABRT / exit 134). We do NOT wait during 'downloading' (no native
+    // worker is loaded yet, so process.exit can't abort, and the download can take
+    // minutes — _doInitialize bails before spawning once _stopping is set, so a
+    // Ctrl+C during a first-run download still exits promptly).
+    if (this._initPromise && this._status === 'loading') {
+      await Promise.race([
+        Promise.resolve(this._initPromise).catch(() => {}),
+        new Promise((resolve) => {
+          const t = setTimeout(resolve, remaining());
+          if (t.unref) t.unref();
+        }),
+      ]);
+    }
+
     if (this._restartTimer) {
       clearTimeout(this._restartTimer);
       this._restartTimer = null;
@@ -273,38 +323,31 @@ class StickyNoteEngine {
     }
     this._queue = [];
     this._currentRequest = null;
-    if (this._worker) {
-      const w = this._worker;
-      this._worker = null;
-      try {
-        // Ask the worker to dispose the native model/context cleanly, then
-        // terminate only if it didn't exit on its own. A bare terminate() with
-        // the model loaded can abort the process during native cleanup.
-        let exited = false;
-        await new Promise((resolve) => {
-          let done = false;
-          const finish = () => {
-            if (!done) {
-              done = true;
-              resolve();
-            }
-          };
-          w.once('exit', () => {
-            exited = true;
-            finish();
-          });
-          try {
-            w.postMessage({ type: 'shutdown' });
-          } catch {
-            finish();
-          }
-          const t = setTimeout(finish, 3000);
-          if (t.unref) t.unref();
-        });
-        if (!exited) await w.terminate();
-      } catch {
-        /* ignore */
-      }
+    // Cooperatively stop the worker — the live one, or one still booting (tracked
+    // from creation in _spawnWorker). Ask it to dispose its native model/context
+    // and exit on its own. We deliberately do NOT call worker.terminate():
+    // force-killing a thread that is inside native ggml code (mid model-load or
+    // mid-inference) throws an uncaught Napi error during worker-env teardown and
+    // ggml's set_terminate aborts the whole process (SIGABRT / exit 134) — the
+    // bug this fixes. The wait is bounded (shared deadline) so handleShutdown can
+    // still save sessions + close(); a worker that never exits is reaped by
+    // handleShutdown's 15s force-exit backstop.
+    const w = this._worker || this._spawningWorker;
+    this._worker = null;
+    this._spawningWorker = null;
+    if (w) {
+      await new Promise((resolve) => {
+        let done = false;
+        const finish = () => { if (!done) { done = true; resolve(); } };
+        w.once('exit', finish);
+        try {
+          w.postMessage({ type: 'shutdown' });
+        } catch {
+          finish();
+        }
+        const t = setTimeout(finish, Math.max(1000, remaining()));
+        if (t.unref) t.unref();
+      });
     }
     this._status = 'unavailable';
   }

package/src/sticky-note-jsonl.js

@@ -39,9 +39,16 @@ function cleanProse(s) {
     .trim();
 }
 
-/** Claude's project-dir slug for a cwd: all path separators → '-'. */
+/**
+ * Claude's project-dir slug for a cwd: every non-alphanumeric char → '-'
+ * (drive-letter colon, path separators, spaces, dots, etc.). Matches the folder
+ * claude writes under ~/.claude/projects/. A separator-only replace leaves the
+ * Windows drive-letter colon in place (`C:-Users-...`) and never matches claude's
+ * `C--Users-...`, so the transcript binding — and with it the tab title and the
+ * sticky note — silently fail on Windows.
+ */
 function slugForCwd(cwd) {
-  return String(cwd || '').replace(/[\\/]/g, '-');
+  return String(cwd || '').replace(/[^a-zA-Z0-9]/g, '-');
 }
 
 /** The claude session id is the JSONL basename (the --resume key). */

package/src/sticky-note-worker.js

@@ -90,8 +90,15 @@ parentPort.on('message', (msg) => {
     _inferChain
       .catch(() => {})
       .then(async () => {
+        // Dispose in dependency order: context + model, then the top-level
+        // llama backend. Disposing the backend (await llama.dispose()) is what
+        // actually drains node-llama-cpp's native async work; without it the
+        // worker-thread env teardown that follows process.exit() can hit a
+        // pending Napi completion and ggml's set_terminate aborts the whole
+        // process (SIGABRT / exit 134) on Ctrl+C.
         try { if (context) await context.dispose(); } catch { /* ignore */ }
         try { if (model) await model.dispose(); } catch { /* ignore */ }
+        try { if (llama) await llama.dispose(); } catch { /* ignore */ }
       })
       .finally(() => process.exit(0));
   }

package/src/stt-engine.js

@@ -17,11 +17,13 @@ class SttEngine {
     this._numThreads = options.numThreads || Math.min(4, os.cpus().length);
     this._status = 'unavailable';
     this._worker = null;
+    this._spawningWorker = null;
     this._queue = [];
     this._currentRequest = null;
     this._requestIdCounter = 0;
     this._restartAttempts = 0;
     this._lastSpawnError = null;
+    this._stopping = false;
     this._initPromise = null;
     this._modelManager = new ModelManager({
       modelsDir: options.modelsDir
@@ -62,6 +64,11 @@ class SttEngine {
     }
 
     this._status = 'loading';
+    // If shutdown began while we were checking/downloading the model, do NOT
+    // spawn a worker we'd immediately have to kill mid-native-load (which aborts
+    // the process). shutdown() awaits this in-flight init, so bailing here lets
+    // it complete cleanly with no worker.
+    if (this._stopping) return;
     await this._spawnWorker();
   }
 
@@ -275,6 +282,11 @@ class SttEngine {
 
   _restartWorker(delay) {
     setTimeout(async () => {
+      // Don't respawn if shutdown started after this restart was scheduled.
+      if (this._stopping) {
+        this._status = 'unavailable';
+        return;
+      }
       try {
         await this._spawnWorker();
       } catch (err) {
@@ -294,11 +306,29 @@ class SttEngine {
           nodeModulesDir: path.resolve(__dirname, '..', 'node_modules')
         }
       });
+      // Track the worker from creation (not just after 'ready') so shutdown() can
+      // stop it cooperatively even while it is still loading the recognizer.
+      this._spawningWorker = worker;
+      const clearPending = () => { if (this._spawningWorker === worker) this._spawningWorker = null; };
+      const detach = () => {
+        worker.off('message', onReady);
+        worker.off('error', onError);
+        worker.off('exit', onBootExit);
+      };
 
       const onReady = (msg) => {
         if (msg.type === 'ready') {
-          worker.off('message', onReady);
-          worker.off('error', onError);
+          detach();
+          clearPending();
+          // If shutdown started while this worker was still loading, do NOT
+          // promote it to the active worker — that would resurrect a torn-down
+          // engine. Ask it to exit and resolve init as cancelled.
+          if (this._stopping) {
+            this._status = 'unavailable';
+            try { worker.postMessage({ type: 'shutdown' }); } catch { /* ignore */ }
+            resolve();
+            return;
+          }
           this._worker = worker;
           this._status = 'ready';
           this._restartAttempts = 0;
@@ -311,15 +341,15 @@ class SttEngine {
           this._processQueue();
           resolve();
         } else if (msg.type === 'error') {
-          worker.off('message', onReady);
-          worker.off('error', onError);
+          detach();
+          clearPending();
           reject(new Error(msg.message));
         }
       };
 
       const onError = (err) => {
-        worker.off('message', onReady);
-        worker.off('error', onError);
+        detach();
+        clearPending();
         // Tag dependency errors so _onWorkerExit can skip futile retries
         if (err.code === 'MODULE_NOT_FOUND' || (err.message && err.message.includes('sherpa-onnx-node'))) {
           this._lastSpawnError = 'MODULE_NOT_FOUND';
@@ -327,8 +357,19 @@ class SttEngine {
         reject(err);
       };
 
+      // If the worker dies before emitting ready/error, neither listener above
+      // fires — without this the init Promise would hang forever (and shutdown
+      // would burn its full bounded wait on it).
+      const onBootExit = (code) => {
+        detach();
+        clearPending();
+        this._status = 'unavailable';
+        reject(new Error(`STT worker exited during init (code ${code})`));
+      };
+
       worker.on('message', onReady);
       worker.on('error', onError);
+      worker.on('exit', onBootExit);
     });
   }
 
@@ -421,6 +462,31 @@ class SttEngine {
     // See docs/audits/proc-child-processes.md gap 1.
     this._stopping = true;
 
+    // Shared time budget for the init-wait + cooperative-exit waits below, so the
+    // whole engine teardown (run concurrently with the sticky-note engine by
+    // handleShutdown) finishes inside handleShutdown's 15s force-exit budget,
+    // leaving room for close(). Realistic teardown is sub-second; this only caps
+    // pathological hangs.
+    const deadline = Date.now() + 10000;
+    const remaining = () => Math.max(0, deadline - Date.now());
+
+    // If a worker is mid model-LOAD (status 'loading' = the recognizer is being
+    // constructed in the worker thread), wait — bounded — for it to settle so we
+    // can tear it down cooperatively; a worker killed mid-native-load aborts the
+    // process (SIGABRT / exit 134). We do NOT wait during 'downloading' (no native
+    // worker is loaded yet, and the download can take minutes — _doInitialize
+    // bails before spawning once _stopping is set, so a Ctrl+C during a first-run
+    // download still exits promptly).
+    if (this._initPromise && this._status === 'loading') {
+      await Promise.race([
+        Promise.resolve(this._initPromise).catch(() => {}),
+        new Promise((resolve) => {
+          const t = setTimeout(resolve, remaining());
+          if (t.unref) t.unref();
+        }),
+      ]);
+    }
+
     // Reject all queued requests
     for (const req of this._queue) {
       clearTimeout(req.timer);
@@ -429,9 +495,31 @@ class SttEngine {
     this._queue = [];
     this._currentRequest = null;
 
-    if (this._worker) {
-      await this._worker.terminate();
-      this._worker = null;
+    // Cooperatively stop the worker — the live one, or one still booting (tracked
+    // from creation in _spawnWorker). Ask it to exit on its own. We deliberately
+    // do NOT call worker.terminate(): force-killing a thread inside native
+    // sherpa-onnx code (mid-load or mid-transcribe) throws an uncaught Napi error
+    // during worker-env teardown and ggml's set_terminate aborts the whole
+    // process (SIGABRT / exit 134) — the bug this fixes. The wait is bounded
+    // (shared deadline) so handleShutdown can still save sessions + close(); a
+    // worker that never exits is reaped by handleShutdown's 15s force-exit
+    // backstop.
+    const w = this._worker || this._spawningWorker;
+    this._worker = null;
+    this._spawningWorker = null;
+    if (w) {
+      await new Promise((resolve) => {
+        let done = false;
+        const finish = () => { if (!done) { done = true; resolve(); } };
+        w.once('exit', finish);
+        try {
+          w.postMessage({ type: 'shutdown' });
+        } catch {
+          finish();
+        }
+        const t = setTimeout(finish, Math.max(1000, remaining()));
+        if (t.unref) t.unref();
+      });
     }
 
     this._status = 'unavailable';

package/src/stt-worker.js

@@ -72,8 +72,22 @@ try {
   process.exit(1);
 }
 
+let _shuttingDown = false;
 parentPort.on('message', (msg) => {
+  if (!msg) return;
+  if (msg.type === 'shutdown') {
+    // Graceful teardown. sherpa-onnx-node exposes no dispose API (the recognizer
+    // is GC/finalizer-managed), and transcribe runs synchronously here, so when
+    // this message is processed nothing is in flight. Exit cleanly while idle so
+    // the worker-env teardown doesn't race a pending native op — a bare
+    // terminate() with the recognizer loaded can abort the process during native
+    // cleanup (SIGABRT / exit 134) on Ctrl+C.
+    _shuttingDown = true;
+    process.exit(0);
+    return;
+  }
   if (msg.type === 'transcribe') {
+    if (_shuttingDown) return;
     try {
       // Two input shapes:
       //  - msg.pcm16: raw 16-bit PCM (Int16Array). Conversion to Float32 runs

package/src/usage-reader.js

@@ -321,8 +321,11 @@ class UsageReader {
     try {
       // Get the current working directory to find the right project folder
       const cwd = process.cwd();
-      // Claude uses format: -home-user-Development-project
-      const projectDirName = cwd.replace(/[\\/]/g, '-'); // Handle both Unix / and Windows \ separators
+      // Claude uses format: -home-user-Development-project. It replaces EVERY
+      // non-alphanumeric char with '-', so on Windows the drive-letter colon
+      // becomes a dash too (`C:\Users\me` -> `C--Users-me`). A separator-only
+      // replace leaves the colon and never matches the real folder.
+      const projectDirName = cwd.replace(/[^a-zA-Z0-9]/g, '-');
       let projectPath = path.join(this.claudeProjectsPath, projectDirName);
       
       // Check if the project directory exists