opencode-interrupt-plugin 0.4.11 → 0.4.13

package/README.md

@@ -0,0 +1,66 @@
+# OpenCode Interrupt Plugin
+
+Streaming TTS + voice interruption for OpenCode. Speaks responses as they arrive and detects when you talk over it. **Walkie-talkie mode** lets you hold the spacebar to redirect the model on the fly.
+
+## Installation
+
+Add both the server plugin and the TUI plugin to your `~/.config/opencode/opencode.json`:
+
+```json
+{
+  "plugin": [
+    "opencode-interrupt-plugin",
+    "opencode-interrupt-plugin/tui"
+  ]
+}
+```
+
+The server plugin handles TTS streaming, voice overlap detection, and interrupt injection. The TUI plugin adds the walkie-talkie keybinding (`space`).
+
+## Usage
+
+### Walkie-Talkie Mode
+
+Hold down the **spacebar** while speaking, then release it to redirect the model:
+
+1. The model is generating a response — TTS is playing
+2. **Press and hold** spacebar — generation aborts, TTS stops, mic starts recording
+3. **Speak your correction** while holding spacebar
+4. **Release** spacebar — audio is transcribed via Whisper and sent as your next message
+5. The model responds to your correction
+
+```
+[Model speaking]  →  hold space → speak correction → release space → model redirects
+```
+
+Requires [whisper.cpp](https://github.com/ggerganov/whisper.cpp) with the `base` model installed.
+Run the one-command install script:
+
+```bash
+bash scripts/install-whisper.sh
+```
+
+Or set `OPENAI_API_KEY` in your environment as a fallback.
+
+### Voice Interruption (server plugin)
+
+When TTS is playing, just speak — the plugin detects your voice, stops TTS, and marks the session for correction injection.
+
+## Configuration
+
+| Setting | Type | Default | Description |
+|---------|------|---------|-------------|
+| `licenseKey` | string | none | License key (omit for free mode) |
+| `micThreshold` | number | 0.008 | Voice activation threshold (free mode locked) |
+| `timingWindowMs` | number | 3000 | How long after interrupt to accept corrections |
+
+### Environment Variables
+
+- `OPENAI_API_KEY` — optional fallback for Whisper transcription (used if `whisper` CLI is not found)
+- `WHISPER_MODEL` — path to whisper.cpp model file (default: `~/.local/bin/ggml-base.bin`)
+- `EDGE_TTS_VOICE` — TTS voice (default: `en-US-AriaNeural`)
+
+## How It Works
+
+- **Server plugin**: Monitors mic via sox (continuous PCM pipe), detects voice during TTS playback, injects correction context into the next LLM request
+- **TUI plugin**: Registers a `space` keybinding in OpenCode's TUI keymap; key repeats while held keep the recording active; 300ms of silence after release triggers transcription and redirect

package/dist/index.js

@@ -114,11 +114,12 @@ export const InterruptPlugin = (userConfig = {}) => {
                 if (!msg || !msg.role)
                     return;
                 if (msg.role === 'assistant') {
+                    const state = getSessionState(sessionId);
                     const content = extractText(parts);
                     updateSessionState(sessionId, {
                         lastAssistantContent: content,
                         lastAssistantTimestamp: Date.now(),
-                        wasInterrupted: false,
+                        wasInterrupted: state.awaitingCorrection ? state.wasInterrupted : false,
                     });
                     return;
                 }

package/dist/tui.d.ts

@@ -0,0 +1,6 @@
+import type { TuiPlugin } from "@opencode-ai/plugin/tui";
+declare const _default: {
+    id: string;
+    tui: TuiPlugin;
+};
+export default _default;

package/dist/tui.js

@@ -0,0 +1,165 @@
+import { spawn, execSync } from "node:child_process";
+import { readFileSync, existsSync, unlinkSync } from "node:fs";
+const RECORDING_FILE = "/tmp/interrupt-ptt.wav";
+const WHISPER_MODEL = process.env.WHISPER_MODEL || `${process.env.HOME}/.local/bin/ggml-base.bin`;
+const RELEASE_TIMEOUT_MS = 300;
+let recordingProcess = null;
+let active = false;
+let releaseTimer = null;
+function pttStartRecording() {
+    if (recordingProcess)
+        return;
+    recordingProcess = spawn("sox", [
+        "-d", "--rate", "16000", "--channels", "1",
+        "--encoding", "signed-integer", "--bits", "16",
+        RECORDING_FILE,
+    ], { stdio: ["ignore", "pipe", "pipe"] });
+    recordingProcess.on("exit", () => { recordingProcess = null; });
+    recordingProcess.on("error", () => { recordingProcess = null; });
+}
+function pttStopRecording() {
+    if (!recordingProcess)
+        return;
+    recordingProcess.kill("SIGTERM");
+    recordingProcess = null;
+}
+const TXT_FILE = "/tmp/interrupt-ptt.txt";
+async function transcribeLocal() {
+    try {
+        execSync("whisper --help", { stdio: "ignore", timeout: 3000 });
+    }
+    catch {
+        return null;
+    }
+    try {
+        unlinkSync(TXT_FILE);
+    }
+    catch { /* ignore */ }
+    try {
+        execSync(`whisper -f "${RECORDING_FILE}" -m "${WHISPER_MODEL}" -otxt -of /tmp/interrupt-ptt`, { stdio: "ignore", timeout: 30000 });
+    }
+    catch {
+        return null;
+    }
+    if (existsSync(TXT_FILE)) {
+        const text = readFileSync(TXT_FILE, "utf-8").trim();
+        try {
+            unlinkSync(TXT_FILE);
+        }
+        catch { /* ignore */ }
+        return text || null;
+    }
+    return null;
+}
+async function transcribeAPI() {
+    const apiKey = process.env.OPENAI_API_KEY;
+    if (!apiKey || !existsSync(RECORDING_FILE))
+        return null;
+    const buffer = readFileSync(RECORDING_FILE);
+    const form = new FormData();
+    form.append("file", new Blob([buffer], { type: "audio/wav" }), "recording.wav");
+    form.append("model", "whisper-1");
+    try {
+        const resp = await fetch("https://api.openai.com/v1/audio/transcriptions", {
+            method: "POST",
+            headers: { Authorization: `Bearer ${apiKey}` },
+            body: form,
+        });
+        if (!resp.ok)
+            return null;
+        const data = await resp.json();
+        return data.text;
+    }
+    catch {
+        return null;
+    }
+}
+async function transcribeAndSend(sessionID, directory, api) {
+    pttStopRecording();
+    if (!existsSync(RECORDING_FILE)) {
+        api.ui.toast({ variant: "warning", title: "PTT", message: "No audio captured" });
+        return;
+    }
+    api.ui.toast({ variant: "info", title: "PTT", message: "Transcribing..." });
+    let text = null;
+    text = await transcribeLocal();
+    if (!text)
+        text = await transcribeAPI();
+    if (!text) {
+        api.ui.toast({
+            variant: "error",
+            title: "PTT",
+            message: "Missing whisper — run scripts/install-whisper.sh or set OPENAI_API_KEY",
+        });
+        try {
+            unlinkSync(RECORDING_FILE);
+        }
+        catch { /* ignore */ }
+        return;
+    }
+    try {
+        unlinkSync(RECORDING_FILE);
+    }
+    catch { /* ignore */ }
+    if (!sessionID) {
+        api.ui.toast({ variant: "warning", title: "PTT", message: "No active session" });
+        return;
+    }
+    await api.client.session.prompt({
+        sessionID,
+        directory,
+        parts: [{ type: "text", text }],
+    });
+    api.ui.toast({ variant: "success", title: "PTT", message: `Sent: "${text.slice(0, 60)}"` });
+}
+const tui = async (api, _options, _meta) => {
+    api.keymap.registerLayer({
+        commands: [
+            {
+                name: "interrupt.ptt",
+                title: "Walkie-Talkie (hold space to talk, release to redirect)",
+                category: "Plugin",
+                run: async () => {
+                    const route = api.route.current;
+                    const sessionID = route.name === "session"
+                        ? route.params?.sessionID
+                        : undefined;
+                    const directory = api.state.path.directory;
+                    if (releaseTimer) {
+                        clearTimeout(releaseTimer);
+                        releaseTimer = null;
+                    }
+                    if (!active) {
+                        active = true;
+                        if (sessionID) {
+                            try {
+                                await api.client.session.abort({ sessionID, directory });
+                            }
+                            catch { /* ignore */ }
+                        }
+                        pttStartRecording();
+                        api.ui.toast({ variant: "info", title: "PTT", message: "Recording... (release space to send)" });
+                    }
+                    releaseTimer = setTimeout(() => {
+                        releaseTimer = null;
+                        if (!active)
+                            return;
+                        active = false;
+                        transcribeAndSend(sessionID, directory, api);
+                    }, RELEASE_TIMEOUT_MS);
+                },
+            },
+        ],
+        bindings: [{ key: "space", cmd: "interrupt.ptt" }],
+    });
+    api.lifecycle.onDispose(() => {
+        if (releaseTimer)
+            clearTimeout(releaseTimer);
+        if (recordingProcess) {
+            recordingProcess.kill("SIGTERM");
+            recordingProcess = null;
+        }
+        active = false;
+    });
+};
+export default { id: "interrupt.walkie-talkie", tui };

package/package.json

@@ -1,12 +1,17 @@
 {
   "name": "opencode-interrupt-plugin",
-  "version": "0.4.11",
+  "version": "0.4.13",
   "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",
   "types": "./dist/index.d.ts",
+  "exports": {
+    ".": "./dist/index.js",
+    "./tui": "./dist/tui.js"
+  },
   "files": [
-    "dist/"
+    "dist/",
+    "scripts/"
   ],
   "scripts": {
     "build": "tsc",

package/scripts/install-whisper.sh

@@ -0,0 +1,50 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+WHISPER_DIR="${WHISPER_DIR:-/tmp/whisper-cpp}"
+INSTALL_DIR="${INSTALL_DIR:-${HOME}/.local/bin}"
+MODEL="${MODEL:-base}"
+MODEL_FILE="ggml-${MODEL}.bin"
+
+echo "==> Installing whisper.cpp + ${MODEL} model to ${INSTALL_DIR}"
+
+# --- clone ---
+if [ ! -d "${WHISPER_DIR}" ]; then
+  echo "==> Cloning whisper.cpp..."
+  git clone --depth 1 https://github.com/ggerganov/whisper.cpp "${WHISPER_DIR}"
+else
+  echo "==> whisper.cpp already cloned, updating..."
+  git -C "${WHISPER_DIR}" pull --ff-only
+fi
+
+# --- build ---
+echo "==> Building..."
+cmake -S "${WHISPER_DIR}" -B "${WHISPER_DIR}/build" -DBUILD_SHARED_LIBS=OFF
+cmake --build "${WHISPER_DIR}/build" --config Release -j"$(nproc)"
+
+# --- install binary ---
+mkdir -p "${INSTALL_DIR}"
+cp "${WHISPER_DIR}/build/bin/whisper-cli" "${INSTALL_DIR}/whisper" 2>/dev/null \
+  || cp "${WHISPER_DIR}/build/bin/whisper" "${INSTALL_DIR}/whisper" 2>/dev/null \
+  || { echo "ERROR: couldn't find whisper binary in build output"; exit 1; }
+echo "==> Installed whisper to ${INSTALL_DIR}/whisper"
+
+# --- download model ---
+MODEL_URL="https://huggingface.co/ggerganov/whisper.cpp/resolve/main/${MODEL_FILE}"
+if [ ! -f "${INSTALL_DIR}/${MODEL_FILE}" ]; then
+  echo "==> Downloading ${MODEL} model (~150MB)..."
+  curl -fSL "${MODEL_URL}" -o "${INSTALL_DIR}/${MODEL_FILE}"
+else
+  echo "==> Model already present at ${INSTALL_DIR}/${MODEL_FILE}"
+fi
+echo "==> Model installed to ${INSTALL_DIR}/${MODEL_FILE}"
+
+# --- ensure INSTALL_DIR is on PATH ---
+if [[ ":$PATH:" != *":${INSTALL_DIR}:"* ]]; then
+  echo ""
+  echo "==> NOTE: Add ${INSTALL_DIR} to your PATH:"
+  echo "    echo 'export PATH=\"\$PATH:${INSTALL_DIR}\"' >> ~/.bashrc"
+fi
+
+echo ""
+echo "==> Done! Verify with: whisper --help"