opencode-interrupt-plugin 0.4.6 → 0.4.8

package/dist/audio/monitor.d.ts

@@ -1,14 +1,15 @@
 import { EventEmitter } from 'events';
 export declare class AudioMonitor extends EventEmitter {
-    private pollTimer;
+    private proc;
     private isRunning;
     private threshold;
-    private pollMs;
-    constructor(threshold?: number, pollMs?: number);
+    private windowSamples;
+    private sumSquares;
+    private totalSamples;
+    constructor(threshold?: number, windowMs?: number);
     start(): void;
-    private poll;
+    private startCapture;
     stop(): void;
-    private handleRMS;
     setThreshold(threshold: number): void;
     isActive(): boolean;
 }

package/dist/audio/monitor.js

@@ -1,72 +1,84 @@
 import { spawn } from 'child_process';
 import { EventEmitter } from 'events';
 import { debug } from '../log.js';
+const SAMPLE_RATE = 44100;
+const CHANNELS = 1;
+const BITS = 16;
 export class AudioMonitor extends EventEmitter {
-    pollTimer = null;
+    proc = null;
     isRunning = false;
     threshold;
-    pollMs;
-    constructor(threshold = 0.02, pollMs = 100) {
+    windowSamples;
+    sumSquares = 0;
+    totalSamples = 0;
+    constructor(threshold = 0.02, windowMs = 100) {
         super();
         this.threshold = threshold;
-        this.pollMs = pollMs;
+        this.windowSamples = Math.floor(SAMPLE_RATE * windowMs / 1000);
     }
     start() {
         if (this.isRunning)
             return;
-        debug('[interrupt-monitor] Starting audio monitor');
+        debug('[interrupt-monitor] Starting audio monitor (continuous mode)');
         this.isRunning = true;
         this.emit('started');
-        this.poll();
+        this.startCapture();
     }
-    poll() {
-        if (!this.isRunning)
-            return;
-        const proc = spawn('sox', [
+    startCapture() {
+        this.sumSquares = 0;
+        this.totalSamples = 0;
+        this.proc = spawn('sox', [
             '-q', '-d',
-            '-t', 'sox', '-',
-            'trim', '0', '0.1',
-            'stat',
-        ], { stdio: ['ignore', 'ignore', 'pipe'] });
-        let out = '';
-        proc.stderr?.on('data', (d) => { out += d.toString(); });
-        proc.on('exit', (code) => {
+            '-t', 'raw',
+            '-b', String(BITS),
+            '-e', 'signed',
+            '-r', String(SAMPLE_RATE),
+            '-c', String(CHANNELS),
+            '-',
+        ]);
+        this.proc.stdout?.on('data', (buf) => {
             if (!this.isRunning)
                 return;
-            if (code !== 0) {
-                debug(`[interrupt-monitor] sox exited with code ${code}`);
+            const BYTES_PER_SAMPLE = BITS / 8;
+            for (let i = 0; i + BYTES_PER_SAMPLE <= buf.length; i += BYTES_PER_SAMPLE) {
+                const sample = buf.readInt16LE(i);
+                this.sumSquares += sample * sample;
+                this.totalSamples++;
             }
-            const rms = parseRMSFromStat(out);
-            if (rms !== null) {
+            if (this.totalSamples >= this.windowSamples) {
+                const rms = Math.sqrt(this.sumSquares / this.totalSamples) / 32768;
                 debug(`[interrupt-monitor] RMS: ${rms.toFixed(6)} (threshold: ${this.threshold})`);
-                this.handleRMS(rms);
-            }
-            else {
-                debug(`[interrupt-monitor] Failed to parse RMS from stderr (${out.length} chars)`);
+                if (rms > this.threshold) {
+                    this.emit('voice-detected', rms);
+                }
+                this.sumSquares = 0;
+                this.totalSamples = 0;
             }
-            this.pollTimer = setTimeout(() => this.poll(), this.pollMs);
         });
-        proc.on('error', (err) => {
+        this.proc.on('error', (err) => {
             if (!this.isRunning)
                 return;
-            debug(`[interrupt-monitor] sox spawn error: ${err.message}`);
+            debug(`[interrupt-monitor] sox error: ${err.message}`);
             this.emit('error', new Error('sox not found. Install it: brew install sox (macOS) or apt install sox (Linux)'));
             this.isRunning = false;
         });
+        this.proc.on('close', (code) => {
+            if (!this.isRunning)
+                return;
+            debug(`[interrupt-monitor] sox exited (code ${code}), restarting...`);
+            if (this.isRunning) {
+                this.startCapture();
+            }
+        });
     }
     stop() {
         this.isRunning = false;
-        if (this.pollTimer) {
-            clearTimeout(this.pollTimer);
-            this.pollTimer = null;
+        if (this.proc) {
+            this.proc.kill();
+            this.proc = null;
         }
         this.emit('stopped');
     }
-    handleRMS(rms) {
-        if (rms > this.threshold) {
-            this.emit('voice-detected', rms);
-        }
-    }
     setThreshold(threshold) {
         this.threshold = threshold;
     }
@@ -74,17 +86,3 @@ export class AudioMonitor extends EventEmitter {
         return this.isRunning;
     }
 }
-function parseRMSLine(line) {
-    const match = line.match(/RMS\s+amplitude:\s+([\d.]+)/);
-    if (match)
-        return parseFloat(match[1]);
-    return null;
-}
-function parseRMSFromStat(output) {
-    for (const line of output.split('\n')) {
-        const rms = parseRMSLine(line);
-        if (rms !== null)
-            return rms;
-    }
-    return null;
-}

package/dist/tts/index.js

@@ -129,6 +129,8 @@ export class TTSStreamer extends EventEmitter {
         return this.engine.isPlaying || this.queue.length > 0 || this.processing || (Date.now() - this.lastActivity < 3000);
     }
     resetSession() {
+        this.stopped = false;
+        this.processing = false;
         this.buffer.clear();
         this.queue = [];
         this.spokenText = "";
@@ -136,9 +138,15 @@ export class TTSStreamer extends EventEmitter {
     }
     async processQueue() {
         this.processing = true;
+        debug(`[interrupt-tts] processQueue start, queue=${this.queue.length}, stopped=${this.stopped}`);
         while (this.queue.length > 0 && !this.stopped) {
             const sentence = this.queue.shift();
-            await this.engine.speak(sentence);
+            try {
+                await this.engine.speak(sentence);
+            }
+            catch (err) {
+                debug(`[interrupt-tts] TTS error in processQueue: ${err}`);
+            }
             if (!this.stopped) {
                 this.spokenText += sentence + " ";
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-interrupt-plugin",
-  "version": "0.4.6",
+  "version": "0.4.8",
   "description": "Streaming TTS + voice interruption for OpenCode. Speaks responses as they arrive and detects when you talk over it.",
   "type": "module",
   "main": "./dist/index.js",