ai-or-die 0.1.70 → 0.1.71

package/bin/ai-or-die.js

@@ -12,6 +12,7 @@ try {
   open = openModule.default || openModule;
 } catch { open = null; }
 const { ClaudeCodeWebServer } = require('../src/server');
+const { isBun } = require('../src/utils/runtime');
 
 const program = new Command();
 
@@ -35,10 +36,14 @@ program
   .option('--terminal-alias <name>', 'display alias for Terminal (default: env TERMINAL_ALIAS or "Terminal")')
   .option('--tunnel', 'enable dev tunnel (requires devtunnel CLI installed)')
   .option('--tunnel-allow-anonymous', 'allow anonymous access to dev tunnel')
-  .option('--stt', 'enable local speech-to-text (downloads ~670MB Parakeet V3 model on first use)')
+  .option('--no-stt', 'disable local speech-to-text (on by default; downloads ~670MB Parakeet V3 model on first use)')
   .option('--stt-endpoint <url>', 'use external STT endpoint (OpenAI-compatible)')
   .option('--stt-model-dir <path>', 'custom directory for STT model files')
-  .option('--stt-threads <number>', 'CPU threads for STT inference (default: auto, max 4)');
+  .option('--stt-threads <number>', 'CPU threads for STT inference (default: auto, max 4)')
+  .option('--no-sticky-notes', 'disable per-tab AI session summaries + auto tab titles (on by default)')
+  .option('--sticky-notes-model-dir <path>', 'custom directory for the sticky-note model file')
+  .option('--sticky-notes-model <url>', 'override the sticky-note model GGUF download URL')
+  .option('--sticky-notes-threads <number>', 'CPU threads for sticky-note inference (default: auto, max 4)');
 
 // Auto-open is OFF by default and opt-in via --open. Legacy callers may still pass
 // --no-open (the old opt-out flag); filter it out so it parses harmlessly as a no-op.
@@ -64,6 +69,22 @@ async function main() {
       process.exit(1);
     }
 
+    // Bun: limited support. The app continues to run, but two native
+    // incompatibilities apply (both externally confirmed, neither fixable here):
+    //   • node-llama-cpp's N-API addon crashes Bun (NAPI FATAL ERROR, exit 133),
+    //     so the sticky-note model is force-disabled (server + engine self-gate).
+    //   • node-pty cannot read the PTY master under Bun (oven-sh/bun#25822) — the
+    //     terminal may "start" but never show a prompt (it hangs).
+    // STT still works under Bun. For a guaranteed-working terminal, use Node.js.
+    if (isBun()) {
+      const bunVer = (process.versions && process.versions.bun) || 'unknown';
+      console.log(`\n\x1b[33m⚠  Running under Bun ${bunVer} — limited support. Continuing with sticky-notes disabled.\x1b[0m`);
+      console.log('   • Sticky-note summaries are disabled under Bun (node-llama-cpp crashes Bun’s N-API).');
+      console.log('   • Heads-up: terminal output can hang under Bun (node-pty/#25822).');
+      console.log('     If the prompt never appears, run with Node.js instead:');
+      console.log(`       \x1b[1mnode ${path.relative(process.cwd(), __filename) || 'bin/ai-or-die.js'} ${process.argv.slice(2).join(' ')}\x1b[0m\n`);
+    }
+
     // Handle authentication logic
     // Tunnel mode disables auth — the tunnel itself controls access
     let authToken = null;
@@ -93,10 +114,15 @@ async function main() {
       geminiAlias: options.geminiAlias || process.env.GEMINI_ALIAS || 'Gemini',
       terminalAlias: options.terminalAlias || process.env.TERMINAL_ALIAS || 'Terminal',
       folderMode: true, // Always use folder mode
-      stt: options.stt || !!process.env.STT_ENABLED,
+      stt: options.stt !== false && process.env.STT_DISABLED !== '1',
       sttEndpoint: options.sttEndpoint || process.env.STT_ENDPOINT,
       sttModelDir: options.sttModelDir || process.env.AI_OR_DIE_MODELS_DIR,
       sttThreads: options.sttThreads || process.env.STT_THREADS,
+      // Per-tab AI session summaries (on by default; --no-sticky-notes disables).
+      stickyNotes: options.stickyNotes !== false && process.env.STICKY_NOTES_DISABLED !== '1',
+      stickyNotesModelDir: options.stickyNotesModelDir || process.env.STICKY_NOTES_MODEL_DIR,
+      stickyNotesModel: options.stickyNotesModel || process.env.STICKY_NOTES_MODEL,
+      stickyNotesThreads: options.stickyNotesThreads || process.env.STICKY_NOTES_THREADS,
     };
 
     console.log('Starting ai-or-die...');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-or-die",
-  "version": "0.1.70",
+  "version": "0.1.71",
   "description": "Universal AI coding terminal — Claude, Copilot, Gemini & more in your browser",
   "main": "src/server.js",
   "bin": {
@@ -41,6 +41,7 @@
   "dependencies": {
     "@lydell/node-pty": "1.2.0-beta.10",
     "@vscode/ripgrep": "^1.18.0",
+    "@xterm/headless": "^6.0.0",
     "chokidar": "^5.0.0",
     "commander": "^12.1.0",
     "cors": "^2.8.5",
@@ -66,5 +67,8 @@
     "jsdom": "^24.1.3",
     "mocha": "^11.7.1",
     "postject": "^1.0.0-alpha.6"
+  },
+  "optionalDependencies": {
+    "node-llama-cpp": "^3.18.1"
   }
 }

package/src/base-bridge.js

@@ -8,6 +8,22 @@ const os = require('os');
 const PTY_WRITE_CHUNK_SIZE = 4096;
 /** Inter-chunk delay in ms — allows ConPTY buffer to drain */
 const PTY_WRITE_CHUNK_DELAY_MS = 10;
+/**
+ * Grace window (ms) during which a read EAGAIN with no life-sign yet is treated
+ * as a benign transient startup blip and swallowed. After this, a *sustained*
+ * EAGAIN flood with no output is treated as a real failure and surfaced (rather
+ * than hanging silently until the 30s spawn watchdog). Node delivers its first
+ * PTY output well within this window; Bun's permanent read EAGAIN does not.
+ */
+const PTY_EAGAIN_GRACE_MS = 3000;
+/**
+ * Minimum number of pre-life-sign EAGAIN errors before a session is treated as a
+ * sustained-failure (the Bun + node-pty read loop fires EAGAIN continuously,
+ * forever). Set well above any plausible Node startup count (node-pty emits
+ * "EAGAIN twice at first"), so a stray late EAGAIN on a slow Node session can
+ * never trip a false teardown — worst case it falls through to the 30s watchdog.
+ */
+const PTY_EAGAIN_FAIL_THRESHOLD = 50;
 
 class BaseBridge {
   constructor(toolName, options = {}) {
@@ -28,6 +44,40 @@ class BaseBridge {
     this._commandReady = this.initCommand();
   }
 
+  /**
+   * True when a PTY 'error' is a read EAGAIN ("resource temporarily unavailable").
+   * @param {Error & {code?: string}} error
+   * @returns {boolean}
+   */
+  static isEagainError(error) {
+    return !!(error && (error.code === 'EAGAIN' || (error.message && error.message.includes('EAGAIN'))));
+  }
+
+  /**
+   * Decide whether a PTY 'error' is a benign, swallowable transient read EAGAIN.
+   *
+   * Swallow when the error is EAGAIN AND any of: a life-sign already arrived
+   * (post-startup blip); we are still inside the startup grace window; or the
+   * EAGAIN count has not yet reached the sustained-failure threshold. Only a
+   * *sustained* EAGAIN flood with no life-sign past the grace window (the Bun +
+   * node-pty read failure, oven-sh/bun#25822, where the master never delivers
+   * data) is surfaced — so the session tears down + the client gets feedback
+   * instead of an infinite hang, while a stray late EAGAIN on a slow Node
+   * session is never enough to false-fail it.
+   *
+   * @param {Error & {code?: string}} error
+   * @param {boolean} receivedLifeSign - true once any onData/onExit fired
+   * @param {number} elapsedMs - ms since the PTY was spawned
+   * @param {number} eagainCount - count of EAGAIN errors seen so far (incl. this one)
+   * @returns {boolean} true → swallow (return early); false → handle the error
+   */
+  static shouldSwallowTransientEagain(error, receivedLifeSign, elapsedMs, eagainCount) {
+    if (!BaseBridge.isEagainError(error)) return false;
+    if (receivedLifeSign) return true;
+    if (elapsedMs < PTY_EAGAIN_GRACE_MS) return true;
+    return eagainCount < PTY_EAGAIN_FAIL_THRESHOLD;
+  }
+
   /**
    * Async command discovery — runs where/which without blocking the event loop.
    * Called automatically from the constructor; await bridge._commandReady to ensure it's done.
@@ -264,9 +314,16 @@ class BaseBridge {
 
       // Spawn watchdog: if no data, exit, or error arrives within 30s, treat as failure
       let receivedLifeSign = false;
+      const ptyStartedAt = Date.now();
+      let eagainCount = 0;
+      // One-shot guard so the watchdog + error paths can each tear the session
+      // down + call onError at most once (a sustained EAGAIN flood fires the
+      // error handler repeatedly).
+      let terminalFailureHandled = false;
       const SPAWN_TIMEOUT_MS = 30000;
       const spawnWatchdog = setTimeout(() => {
-        if (!receivedLifeSign && session.active) {
+        if (!receivedLifeSign && session.active && !terminalFailureHandled) {
+          terminalFailureHandled = true;
           console.error(`${this.toolName} session ${sessionId}: no response within ${SPAWN_TIMEOUT_MS}ms, treating as spawn failure`);
           session.active = false;
           this.sessions.delete(sessionId);
@@ -340,6 +397,26 @@ class BaseBridge {
       this._addPtyDisposable(session, onExitDisposable);
 
       const errorHandler = (error) => {
+        // read EAGAIN ("resource temporarily unavailable") is a known transient
+        // PTY-startup condition under Node — node-pty's own socket 'error'
+        // handler ignores it ("fs.ReadStream gets EAGAIN twice at first") and
+        // keeps the master fd alive. We attach a *second* 'error' listener on the
+        // same socket, so we swallow the same transient blips: any EAGAIN after a
+        // life-sign (output/exit already arrived), within a short startup grace
+        // window, or below the sustained-failure threshold. That stops a benign
+        // EAGAIN from tearing the session down and surfacing a fatal "Connection
+        // Error" that makes the client retry + double-spawn.
+        //
+        // But a *sustained* EAGAIN flood with no life-sign is NOT transient — it
+        // is the Bun + node-pty read failure (oven-sh/bun#25822), where the PTY
+        // master never delivers data. Swallowing it forever turns a dead session
+        // into a silent hang until the 30s watchdog. Once the grace window passes
+        // AND the EAGAIN count crosses the threshold (with no life-sign), fall
+        // through so the error surfaces (client gets feedback / can reconnect).
+        if (BaseBridge.isEagainError(error)) eagainCount++;
+        if (BaseBridge.shouldSwallowTransientEagain(error, receivedLifeSign, Date.now() - ptyStartedAt, eagainCount)) {
+          return;
+        }
         if (!receivedLifeSign) {
           receivedLifeSign = true;
           clearTimeout(spawnWatchdog);
@@ -349,12 +426,22 @@ class BaseBridge {
         if (error.message && error.message.includes('read EIO')) {
           return;
         }
+        // One-shot: a sustained EAGAIN flood (or the watchdog) must not tear the
+        // session down or call onError more than once.
+        if (terminalFailureHandled) {
+          return;
+        }
+        terminalFailureHandled = true;
         console.error(`${this.toolName} session ${sessionId} error:`, error);
         if (session.killTimeout) {
           clearTimeout(session.killTimeout);
           session.killTimeout = null;
         }
         this._disposePtyDisposables(session, sessionId);
+        // Kill the PTY child so a failed session (e.g. a Bun EAGAIN flood, where
+        // the shell is alive but unreadable) doesn't leak as a zombie process /
+        // FD — mirrors the spawn-watchdog teardown. Harmless if already dead.
+        try { ptyProcess.kill(); } catch (e) { /* ignore — may already be dead */ }
         if (this.sessions.has(sessionId)) {
           session.active = false;
           this.sessions.delete(sessionId);