ai-or-die 0.1.71 → 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.71",
+  "version": "0.1.73",
   "description": "Universal AI coding terminal — Claude, Copilot, Gemini & more in your browser",
   "main": "src/server.js",
   "bin": {

package/src/public/app.js

@@ -1386,8 +1386,19 @@ class ClaudeCodeWebInterface {
 
         this.voiceController = new window.VoiceHandler.VoiceInputController({
             mode: this.voiceMode,
+            // Refuse a new recording while a previous transcription is still
+            // pending (single timeout slot + no correlation id — overlapping
+            // uploads would clobber each other's spinner/timeout).
+            canStart: function () {
+                return !self._voiceTranscriptionTimeout;
+            },
             onRecordingStart: function () {
                 self._playMicChime('on');
+                // Suspend the heartbeat pong-timeout while capturing: the main
+                // thread can be busy enough (esp. the ScriptProcessor fallback)
+                // to miss a pong, which would otherwise force a spurious reconnect.
+                self._voiceRecordingActive = true;
+                if (self._heartbeat) self._heartbeat.pause();
                 btn.classList.add('recording');
                 btn.classList.remove('processing');
                 btn.setAttribute('aria-pressed', 'true');
@@ -1415,6 +1426,8 @@ class ClaudeCodeWebInterface {
             },
             onRecordingStop: function (result) {
                 self._playMicChime('off');
+                self._voiceRecordingActive = false;
+                if (self._heartbeat) self._heartbeat.resume();
                 btn.classList.remove('recording');
                 btn.setAttribute('aria-pressed', 'false');
                 btn.title = 'Voice Input (Ctrl+Shift+M)';
@@ -1425,21 +1438,33 @@ class ClaudeCodeWebInterface {
                 }
 
                 if (self.voiceMode === 'local' && result && result.samples) {
+                    // Guard against a zero-sample recording (would send a
+                    // header-only frame the server rejects as "too short").
+                    if (!result.samples.byteLength || result.samples.byteLength < 2) {
+                        btn.classList.remove('processing');
+                        if (window.feedback) window.feedback.error('No audio captured');
+                        return;
+                    }
+
                     btn.classList.add('processing');
-                    // Convert Int16 PCM to base64 efficiently (chunked to avoid call stack overflow)
-                    var pcmBytes = new Uint8Array(result.samples.buffer);
-                    var CHUNK_SIZE = 8192;
-                    var parts = [];
-                    for (var i = 0; i < pcmBytes.length; i += CHUNK_SIZE) {
-                        var chunk = pcmBytes.subarray(i, Math.min(i + CHUNK_SIZE, pcmBytes.length));
-                        parts.push(String.fromCharCode.apply(null, chunk));
+
+                    // Send raw Int16 PCM as a tagged binary WS frame (no base64 —
+                    // base64's 33% inflation is what pushed long clips past the
+                    // 1 MiB frame guard and crashed the page).
+                    var frame = window.VoiceFrame.buildVoiceFrame(result.samples);
+                    var sent = self.sendBinary(frame);
+
+                    if (!sent) {
+                        // Socket not OPEN (e.g. mid-reconnect): fail fast instead of
+                        // silently dropping the frame and hanging the spinner 90 s.
+                        btn.classList.remove('processing');
+                        var notSentMsg = 'Connection not ready — recording not sent';
+                        if (window.feedback) window.feedback.error(notSentMsg);
+                        if (self.terminal) {
+                            self.terminal.write('\r\n\x1b[31m[Voice error] ' + notSentMsg + '\x1b[0m\r\n');
+                        }
+                        return;
                     }
-                    var base64Audio = btoa(parts.join(''));
-                    self.send({
-                        type: 'voice_upload',
-                        audio: base64Audio,
-                        durationMs: result.durationMs
-                    });
 
                     // Client-side timeout for transcription processing (90 seconds)
                     self._voiceTranscriptionTimeout = setTimeout(function () {
@@ -1467,6 +1492,8 @@ class ClaudeCodeWebInterface {
                 self._deliverVoiceTranscription(text);
             },
             onError: function (err) {
+                self._voiceRecordingActive = false;
+                if (self._heartbeat) self._heartbeat.resume();
                 btn.classList.remove('recording', 'processing');
                 btn.setAttribute('aria-pressed', 'false');
                 btn.title = 'Voice Input (Ctrl+Shift+M)';
@@ -1497,6 +1524,8 @@ class ClaudeCodeWebInterface {
                 }
             },
             onCancel: function () {
+                self._voiceRecordingActive = false;
+                if (self._heartbeat) self._heartbeat.resume();
                 btn.classList.remove('recording', 'processing');
                 btn.setAttribute('aria-pressed', 'false');
                 btn.title = 'Voice Input (Ctrl+Shift+M)';
@@ -2043,6 +2072,32 @@ class ClaudeCodeWebInterface {
                 if (this._heartbeat) { this._heartbeat.stop(); this._heartbeat = null; }
                 if (this._heartbeatTimer) { clearInterval(this._heartbeatTimer); this._heartbeatTimer = null; }
                 if (this._pongTimer) { clearTimeout(this._pongTimer); this._pongTimer = null; }
+
+                // A close mid-transcription must not leave the mic spinner + its
+                // 90 s timeout hanging.
+                if (this._voiceTranscriptionTimeout) {
+                    clearTimeout(this._voiceTranscriptionTimeout);
+                    this._voiceTranscriptionTimeout = null;
+                }
+                this._voiceRecordingActive = false;
+                const voiceBtn = document.getElementById('voiceInputBtn');
+                if (voiceBtn) voiceBtn.classList.remove('processing');
+
+                // Log the close code so field reports can tell a server frame
+                // rejection (1009/1003, at stop) from a heartbeat pong-timeout
+                // (4000, mid-recording).
+                console.warn('[ws] closed', event.code, event.reason || '');
+
+                // 1009/1003 are server-initiated CLEAN closes (wasClean=true): the
+                // server rejected our frame. Surface a specific message and still
+                // reconnect below, instead of dead-ending on "refresh the page".
+                const voiceClose = (window.VoiceFrame && window.VoiceFrame.classifyVoiceClose)
+                    ? window.VoiceFrame.classifyVoiceClose(event.code)
+                    : { rejected: false, message: null };
+                if (voiceClose.rejected && window.feedback) {
+                    window.feedback.error(voiceClose.message);
+                }
+
                 // During server restart, don't count failures against reconnect budget
                 // but still use backoff to avoid thundering herd
                 if (this._serverRestarting) {
@@ -2056,7 +2111,7 @@ class ClaudeCodeWebInterface {
                         if (restartGen !== this._socketGeneration) return;
                         this.reconnect();
                     }, restartBackoff);
-                } else if (!event.wasClean && this.reconnectAttempts < this.maxReconnectAttempts) {
+                } else if ((!event.wasClean || voiceClose.rejected) && this.reconnectAttempts < this.maxReconnectAttempts) {
                     this.updateStatus('Reconnecting (' + (this.reconnectAttempts + 1) + '/' + this.maxReconnectAttempts + ')...');
                     // First attempt is fast (250ms covers a server-process restart window);
                     // subsequent attempts use exponential backoff with jitter.
@@ -2174,6 +2229,17 @@ class ClaudeCodeWebInterface {
         }
     }
 
+    // Send a binary WS frame (e.g. a voice PCM frame). Returns true if it was
+    // handed to an OPEN socket, false otherwise so the caller can react to a
+    // closed/closing socket instead of silently dropping the frame.
+    sendBinary(view) {
+        if (this.socket && this.socket.readyState === WebSocket.OPEN) {
+            this.socket.send(view);
+            return true;
+        }
+        return false;
+    }
+
     _handleStickyNoteUpdate(message) {
         if (!message || !message.sessionId) return;
         const sm = this.sessionTabManager;
@@ -4368,6 +4434,9 @@ class ClaudeCodeWebInterface {
             log: (m) => console.warn('[heartbeat]', m),
         });
         this._heartbeat.start();
+        // If a recording is in progress (e.g. this heartbeat was re-created after
+        // a reconnect mid-recording), keep pong-timeout enforcement suspended.
+        if (this._voiceRecordingActive) this._heartbeat.pause();
         // Keep _heartbeatTimer/_pongTimer references in sync for legacy code
         // (disconnect() still nulls them defensively); the watchdog owns the
         // real timer lifecycle via stop().

package/src/public/heartbeat-watchdog.js

@@ -59,6 +59,10 @@
             this._clearTimeout = t.clearTimeout || ((id) => clearTimeout(id));
             this._heartbeatTimer = null;
             this._pongTimer = null;
+            // When paused (e.g. during mic recording), pings still go out but a
+            // missed pong does NOT force a reconnect — the client main thread can
+            // be busy capturing audio and briefly stop servicing the pong.
+            this._paused = false;
         }
 
         _isStale() {
@@ -75,6 +79,9 @@
             } catch (_) {
                 return;
             }
+            // Paused: keep liveness pings flowing but do NOT arm the pong-timeout
+            // (a missed pong while recording must not force-close the socket).
+            if (this._paused) return;
             if (this._pongTimer) this._clearTimeout(this._pongTimer);
             this._pongTimer = this._setTimeout(() => {
                 if (this._isStale()) return;
@@ -118,6 +125,24 @@
                 this._pongTimer = null;
             }
         }
+
+        /**
+         * Suspend pong-timeout enforcement (pings continue). Use while the client
+         * main thread may be busy enough to miss a pong — e.g. mic recording —
+         * so a transient stall doesn't trigger a spurious reconnect.
+         */
+        pause() {
+            this._paused = true;
+            if (this._pongTimer) {
+                this._clearTimeout(this._pongTimer);
+                this._pongTimer = null;
+            }
+        }
+
+        /** Resume normal pong-timeout enforcement (next ping re-arms it). */
+        resume() {
+            this._paused = false;
+        }
     }
 
     return HeartbeatWatchdog;

package/src/public/index.html

@@ -801,6 +801,7 @@
     <script src="vscode-tunnel.js"></script>
     <script src="app-tunnel.js"></script>
     <script src="voice-handler.js"></script>
+    <script src="voice-frame.js"></script>
     <script src="command-palette.js"></script>
     <script src="extra-keys.js"></script>
     <script src="input-overlay.js"></script>

package/src/public/voice-frame.js

@@ -0,0 +1,73 @@
+/**
+ * VoiceFrame
+ *
+ * Pure helpers for the client->server binary voice path, factored out of app.js
+ * so they can be unit-tested in Node. Mirrors the UMD shape of
+ * heartbeat-watchdog.js (CommonJS in tests, `window.VoiceFrame` in the browser).
+ */
+(function (global, factory) {
+    if (typeof module === 'object' && module.exports) {
+        module.exports = factory();
+    } else {
+        global.VoiceFrame = factory();
+    }
+}(typeof self !== 'undefined' ? self : this, function () {
+
+    // Wire header: [ "VUP1" (4) ][ version (1) ][ type (1) ] then raw 16-bit PCM.
+    var MAGIC_V = 0x56; // 'V'
+    var MAGIC_U = 0x55; // 'U'
+    var MAGIC_P = 0x50; // 'P'
+    var MAGIC_1 = 0x31; // '1'
+    var PROTO_VERSION = 0x01;
+    var FRAME_TYPE_PCM = 0x01;
+    var HEADER_BYTES = 6;
+
+    /**
+     * Build a binary voice frame: the 6-byte header followed by the PCM bytes of
+     * `samples`. Uses byteOffset/byteLength so a subarray-backed Int16Array is
+     * copied correctly (not the whole underlying buffer).
+     *
+     * @param {Int16Array} samples
+     * @returns {Uint8Array}
+     */
+    function buildVoiceFrame(samples) {
+        var pcm = new Uint8Array(samples.buffer, samples.byteOffset, samples.byteLength);
+        var frame = new Uint8Array(HEADER_BYTES + pcm.length);
+        frame[0] = MAGIC_V;
+        frame[1] = MAGIC_U;
+        frame[2] = MAGIC_P;
+        frame[3] = MAGIC_1;
+        frame[4] = PROTO_VERSION;
+        frame[5] = FRAME_TYPE_PCM;
+        frame.set(pcm, HEADER_BYTES);
+        return frame;
+    }
+
+    /**
+     * Classify a WebSocket close code for the voice path.
+     *
+     * 1009 (server rejected an oversized frame) and 1003 (unsupported/garbage
+     * binary) are server-initiated CLEAN closes, so `event.wasClean` is true and
+     * the default onclose path would SKIP reconnect and dead-end on
+     * "refresh the page". Treat them as recoverable: show a specific message and
+     * still reconnect (bounded by the normal attempt budget).
+     *
+     * @param {number} code
+     * @returns {{rejected: boolean, message: (string|null)}}
+     */
+    function classifyVoiceClose(code) {
+        if (code === 1009 || code === 1003) {
+            return {
+                rejected: true,
+                message: 'A voice message was rejected by the server. Reconnecting…'
+            };
+        }
+        return { rejected: false, message: null };
+    }
+
+    return {
+        HEADER_BYTES: HEADER_BYTES,
+        buildVoiceFrame: buildVoiceFrame,
+        classifyVoiceClose: classifyVoiceClose
+    };
+}));

package/src/public/voice-handler.js

@@ -625,6 +625,9 @@ function VoiceInputController(options) {
   this._onTranscription = options.onTranscription || null;
   this._onError = options.onError || null;
   this._onCancel = options.onCancel || null;
+  // Optional predicate: if it returns false, a start request is ignored (e.g.
+  // a previous transcription is still pending). Gates both button + keyboard.
+  this._canStart = options.canStart || null;
 
   this._recorder = null;
   this._starting = false;
@@ -670,6 +673,7 @@ VoiceInputController.prototype.startRecording = function () {
   var self = this;
   if (self._starting) return;
   if (self._recorder && self._recorder.isRecording) return;
+  if (self._canStart && !self._canStart()) return;
 
   self._starting = true;
   self._recorder = self._createRecorder();