opencode-interrupt-plugin 0.4.35 → 0.4.36

package/dist/index.js

@@ -2,6 +2,7 @@ import { resolveConfig } from './config.js';
 import { checkLicense } from './license/guard.js';
 import { debug } from './log.js';
 import { processTranscription } from './clean-text.js';
+import { detectLanguage, getVoiceForLanguage } from './language.js';
 import { getSessionState, updateSessionState, clearSessionState, } from './store.js';
 import { prepareInjection } from './injector.js';
 import { onTTSStart, onTTSEnd, isTTSTool } from './audio/tts-tracker.js';
@@ -9,9 +10,71 @@ import { VoiceOverlapDetector } from './audio/overlap.js';
 import { detectTextInterruption } from './detector.js';
 import { TTSStreamer } from './tts/index.js';
 import { spawn, execSync } from "node:child_process";
-import { readFileSync, existsSync, unlinkSync } from "node:fs";
+import { readFileSync, existsSync, unlinkSync, writeFileSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
 let activeSessionId = null;
 let pendingInterrupt = null;
+let isLicensed = false;
+const MAX_FREE_INTERRUPTS_PER_DAY = 20;
+const INTERRUPT_COUNT_DIR = join(process.env.HOME || '/tmp', '.cache', 'opencode');
+const INTERRUPT_COUNT_FILE = join(INTERRUPT_COUNT_DIR, 'interrupt-count.json');
+// simple checksum to detect casual tampering — not cryptographic
+const COUNT_CK_KEY = 'interrupt-cap-v1';
+function checksumCount(data) {
+    let hash = 0;
+    for (let i = 0; i < data.length; i++) {
+        hash = ((hash << 5) - hash) + data.charCodeAt(i);
+        hash |= 0;
+    }
+    const keyHash = COUNT_CK_KEY.split('').reduce((h, c) => ((h << 5) - h) + c.charCodeAt(0), 0);
+    return String((hash ^ keyHash) >>> 0);
+}
+function getInterruptCount() {
+    try {
+        const raw = readFileSync(INTERRUPT_COUNT_FILE, 'utf-8');
+        const parsed = JSON.parse(raw);
+        if (!parsed.date || typeof parsed.count !== 'number' || !parsed.ck)
+            return { date: '', count: 0 };
+        const expected = checksumCount(`${parsed.date}:${parsed.count}`);
+        if (parsed.ck !== expected)
+            return { date: '', count: 0 };
+        return { date: parsed.date, count: parsed.count };
+    }
+    catch {
+        return { date: '', count: 0 };
+    }
+}
+function writeInterruptCount(date, count) {
+    try {
+        mkdirSync(INTERRUPT_COUNT_DIR, { recursive: true });
+    }
+    catch { /* ignore */ }
+    const ck = checksumCount(`${date}:${count}`);
+    writeFileSync(INTERRUPT_COUNT_FILE, JSON.stringify({ date, count, ck }));
+}
+function checkInterruptCap() {
+    if (isLicensed)
+        return true;
+    const today = new Date().toISOString().slice(0, 10);
+    const record = getInterruptCount();
+    if (record.date !== today) {
+        writeInterruptCount(today, 0);
+        return true;
+    }
+    return record.count < MAX_FREE_INTERRUPTS_PER_DAY;
+}
+function incrementInterruptCount() {
+    if (isLicensed)
+        return;
+    const today = new Date().toISOString().slice(0, 10);
+    const record = getInterruptCount();
+    if (record.date !== today) {
+        writeInterruptCount(today, 1);
+    }
+    else {
+        writeInterruptCount(today, record.count + 1);
+    }
+}
 const RECORDING_FILE = "/tmp/interrupt-ptt.wav";
 let recordingProcess = null;
 let pttActive = false;
@@ -127,6 +190,19 @@ async function transcribeAndSend(sessionID, directory, api, modelPath) {
         api.ui.toast({ variant: "warning", title: "PTT", message: "⚠️ Open a session first, then type /ptt" });
         return;
     }
+    if (!checkInterruptCap()) {
+        api.ui.toast({ variant: "warning", title: "PTT", message: "⚠️ Free limit (20/day) reached — purchase Pro for unlimited interrupts" });
+        try {
+            unlinkSync(RECORDING_FILE);
+        }
+        catch { /* ignore */ }
+        return;
+    }
+    const state = getSessionState(sessionID);
+    if (!state.interruptCounted)
+        incrementInterruptCount();
+    else
+        updateSessionState(sessionID, { interruptCounted: false });
     api.ui.toast({ variant: "info", title: "PTT", message: polished ? "✨ Sending polished transcript..." : "✉️ Sending transcript..." });
     await api.client.session.prompt({ sessionID, directory, parts: [{ type: "text", text: clean }] });
     const preview = clean.length > 80 ? clean.slice(0, 77) + "..." : clean;
@@ -176,6 +252,19 @@ async function transcribeAndSendV1(sessionID, client, modelPath) {
         await client.tui.showToast({ body: { title: "PTT", message: "⚠️ Open a session first, then type /ptt", variant: "warning", duration: 5000 } });
         return;
     }
+    if (!checkInterruptCap()) {
+        await client.tui.showToast({ body: { title: "PTT", message: "⚠️ Free limit (20/day) reached — purchase Pro for unlimited interrupts", variant: "warning", duration: 6000 } });
+        try {
+            unlinkSync(RECORDING_FILE);
+        }
+        catch { /* ignore */ }
+        return;
+    }
+    const state = getSessionState(sessionID);
+    if (!state.interruptCounted)
+        incrementInterruptCount();
+    else
+        updateSessionState(sessionID, { interruptCounted: false });
     await client.tui.showToast({ body: { title: "PTT", message: polished ? "✨ Sending polished transcript..." : "✉️ Sending transcript...", variant: "info" } });
     await client.session.prompt({ path: { id: sessionID }, body: { parts: [{ type: "text", text: clean }] } });
     const preview = clean.length > 80 ? clean.slice(0, 77) + "..." : clean;
@@ -190,13 +279,14 @@ const TTS_COMMANDS = [
 export const InterruptPlugin = (userConfig = {}) => {
     return async ({ client }) => {
         const licenseResult = await checkLicense(userConfig.licenseKey);
+        isLicensed = licenseResult.allowed;
         const config = resolveConfig(userConfig, licenseResult.allowed);
         if (config.debug) {
-            console.log(`[interrupt] Plugin loaded (${config.isLicensed ? 'licensed' : 'free'} mode)`);
+            console.log(`[interrupt] Plugin loaded (${isLicensed ? 'licensed' : 'free'} mode)`);
         }
-        if (!config.isLicensed) {
-            console.log('\n[interrupt] Free mode — voice interruption enabled with default settings.\n' +
-                '  Purchase a license at camaramagic.com to customize sensitivity, mic threshold, and more.\n');
+        if (!isLicensed) {
+            console.log('\n[interrupt] Free mode — 20 interrupts/day, base whisper model only.\n' +
+                '  Purchase a license at camaramagic.com for unlimited interrupts, model selection, TTS voices, and auto-language detection.\n');
         }
         if (config.tts) {
             if (config.debug) {
@@ -229,13 +319,19 @@ export const InterruptPlugin = (userConfig = {}) => {
                 debug(`[interrupt] Voice overlap event buffered (no active session)`);
                 return;
             }
+            if (!checkInterruptCap()) {
+                debug(`[interrupt] Voice overlap blocked — free limit reached`);
+                return;
+            }
             debug(`[interrupt] Voice overlap detected (RMS: ${event.rmsLevel.toFixed(4)})`);
+            incrementInterruptCount();
             updateSessionState(activeSessionId, {
                 wasInterrupted: true,
                 partialContentAtInterrupt: event.partialTTSContent,
                 interruptTimestamp: event.overlapTimestamp,
                 awaitingCorrection: true,
                 interruptSource: 'voice',
+                interruptCounted: true,
             });
         });
         overlapDetector.on('monitor-error', (err) => {
@@ -299,6 +395,14 @@ export const InterruptPlugin = (userConfig = {}) => {
                 if (msg.role === 'user' && !overlapDetector.isActive()) {
                     const state = getSessionState(sessionId);
                     const userText = extractText(parts);
+                    if (isLicensed && userText) {
+                        const detectedLang = detectLanguage(userText);
+                        const newVoice = getVoiceForLanguage(detectedLang);
+                        if (newVoice !== config.ttsVoice) {
+                            ttsStreamer.updateVoice(newVoice);
+                            debug(`[interrupt] Auto-language: ${detectedLang} → ${newVoice}`);
+                        }
+                    }
                     const signal = detectTextInterruption(userText, state);
                     if (signal.detected) {
                         const partialContent = state.lastAssistantContent;
@@ -367,6 +471,10 @@ export const InterruptPlugin = (userConfig = {}) => {
                         await transcribeAndSendV1(sessionID, client, config.whisperModel);
                     }
                     else {
+                        if (!checkInterruptCap()) {
+                            await client.tui.showToast({ body: { title: "PTT", message: "⚠️ Free limit (20/day) reached — purchase Pro for unlimited interrupts", variant: "warning", duration: 6000 } });
+                            throw new Error('Command handled by interrupt plugin');
+                        }
                         pttActive = true;
                         if (sessionID) {
                             try {

package/dist/language.d.ts

@@ -0,0 +1,2 @@
+export declare function detectLanguage(text: string): string;
+export declare function getVoiceForLanguage(lang: string): string;

package/dist/language.js

@@ -0,0 +1,46 @@
+/* ------------------------------------------------------------------ */
+/*  Auto-language detection + edge-tts voice mapping (Pro-only)       */
+/* ------------------------------------------------------------------ */
+const CJK_RANGE = /[\u4e00-\u9fff\u3400-\u4dbf\uf900-\ufaff]/;
+const HIRAGANA_KATAKANA = /[\u3040-\u309f\u30a0-\u30ff]/;
+const CYRILLIC = /[\u0400-\u04ff]/;
+const ARABIC = /[\u0600-\u06ff]/;
+const DEVANAGARI = /[\u0900-\u097f]/;
+const KOREAN = /[\uac00-\ud7af]/;
+const LANG_MAP = [
+    { name: 'ja', voice: 'ja-JP-NanamiNeural', test: (t) => HIRAGANA_KATAKANA.test(t) || (CJK_RANGE.test(t) && !KOREAN.test(t) && /[のをにがはがでと]$/.test(t)) },
+    { name: 'zh', voice: 'zh-CN-XiaoxiaoNeural', test: (t) => CJK_RANGE.test(t) && !HIRAGANA_KATAKANA.test(t) && !KOREAN.test(t) },
+    { name: 'ko', voice: 'ko-KR-SunHiNeural', test: (t) => KOREAN.test(t) },
+    { name: 'ru', voice: 'ru-RU-SvetlanaNeural', test: (t) => CYRILLIC.test(t) },
+    { name: 'ar', voice: 'ar-SA-ZariyahNeural', test: (t) => ARABIC.test(t) },
+    { name: 'hi', voice: 'hi-IN-SwaraNeural', test: (t) => DEVANAGARI.test(t) },
+    { name: 'fr', voice: 'fr-FR-DeniseNeural', test: (t) => /[àâçéèêëîïôûùüÿœæ]/i.test(t) || /\b(je|tu|nous|vous|ils|elles|est|sont|avec|pour|dans|sur|pas|les|des|ces|mes|tes|ses|leur|lequel|laquelle|comment|pourquoi|donc|mais|ou|et|car|rien|toujours|jamais|bonjour|merci|oui|non|salut|au|aux|du|de|la|le|ce|cet|cette)\b/i.test(t) },
+    { name: 'de', voice: 'de-DE-KatjaNeural', test: (t) => /[äöüß]/i.test(t) || /\b(der|die|das|den|dem|des|ein|eine|einen|einer|einem|ist|sind|war|wird|haben|sein|kein|aber|und|oder|weil|dass|nicht|sehr|auch|noch|schon|immer|nie|bitte|danke|hallo|tschüss|ja|nein|gut|schlecht|groß|klein)\b/i.test(t) },
+    { name: 'es', voice: 'es-ES-ElviraNeural', test: (t) => /[áéíóúüñ¿¡]/i.test(t) || /\b(el|la|los|las|un|una|unos|unas|es|son|está|están|tiene|tienen|hay|con|sin|para|por|muy|más|menos|como|qué|quién|dónde|cuándo|cuál|este|esta|ese|esa|aquel|aquella|pero|porque|y|o|no|sí|gracias|hola|adiós|bueno|malo|grande|pequeño)\b/i.test(t) },
+    { name: 'pt', voice: 'pt-BR-FranciscaNeural', test: (t) => /[àãáâéêíóôõúç]/i.test(t) },
+    { name: 'it', voice: 'it-IT-ElsaNeural', test: (t) => /[àèéìòù]/i.test(t) },
+    { name: 'nl', voice: 'nl-NL-MaartenNeural', test: (t) => /\b(de|het|een|van|voor|met|niet|ook|maar)\b/i.test(t) && !/[äöüß]/i.test(t) },
+    { name: 'pl', voice: 'pl-PL-AgnieszkaNeural', test: (t) => /[ąćęłńóśźż]/i.test(t) },
+    { name: 'da', voice: 'da-DK-ChristelNeural', test: (t) => /[æøå]/i.test(t) },
+    { name: 'sv', voice: 'sv-SE-SofieNeural', test: (t) => /[åäö]/i.test(t) && !/[øæ]/i.test(t) && !/\b(og|er|det|til|at|en|den|de|han|hun|jeg|vi|ikke|der|med|sig|men|som|for|på|af|eller|et|det|kan|skal|har|være|været|blevet|have|gør|gøre)\b/i.test(t) },
+    { name: 'fi', voice: 'fi-FI-SelmaNeural', test: (t) => /[äö]/i.test(t) && !CYRILLIC.test(t) && !CJK_RANGE.test(t) && /\b(ja|on|se|ei|mutta|että|myös|tai|voidaan|tämä|ovat|hän|kanssa|voi|miten|mikä)\b/i.test(t) },
+    { name: 'tr', voice: 'tr-TR-EmelNeural', test: (t) => /[çğıöşü]/i.test(t) && !/[äåæø]/i.test(t) },
+    { name: 'ro', voice: 'ro-RO-AlinaNeural', test: (t) => /[ăâîșț]/i.test(t) },
+    { name: 'hu', voice: 'hu-HU-NoemiNeural', test: (t) => /[áéíóöúű]/i.test(t) && !/[ăâîșț]/i.test(t) },
+];
+const DEFAULT_VOICE = 'en-US-AvaNeural';
+export function detectLanguage(text) {
+    if (!text)
+        return 'en';
+    for (const entry of LANG_MAP) {
+        if (entry.test(text))
+            return entry.name;
+    }
+    return 'en';
+}
+export function getVoiceForLanguage(lang) {
+    if (lang === 'en')
+        return DEFAULT_VOICE;
+    const entry = LANG_MAP.find(e => e.name === lang);
+    return entry?.voice ?? DEFAULT_VOICE;
+}

package/dist/store.d.ts

@@ -6,6 +6,7 @@ export interface SessionState {
     interruptTimestamp: number;
     awaitingCorrection: boolean;
     interruptSource?: 'voice' | 'text';
+    interruptCounted: boolean;
 }
 export declare function getSessionState(sessionId: string): SessionState;
 export declare function updateSessionState(sessionId: string, updates: Partial<SessionState>): SessionState;

package/dist/store.js

@@ -8,6 +8,7 @@ export function getSessionState(sessionId) {
             partialContentAtInterrupt: '',
             interruptTimestamp: 0,
             awaitingCorrection: false,
+            interruptCounted: false,
         });
     }
     return sessions.get(sessionId);

package/dist/tts/engine.d.ts

@@ -9,10 +9,12 @@ export declare class TTSEngine extends EventEmitter {
     private generator;
     private playing;
     private voice;
+    get currentVoice(): string;
     private rate;
     private volume;
     constructor(options?: TTSEngineOptions);
     speak(text: string): Promise<void>;
     stop(): void;
+    updateVoice(voice: string): void;
     get isPlaying(): boolean;
 }

package/dist/tts/engine.js

@@ -11,6 +11,7 @@ export class TTSEngine extends EventEmitter {
     generator = null;
     playing = false;
     voice;
+    get currentVoice() { return this.voice; }
     rate;
     volume;
     constructor(options = {}) {
@@ -90,6 +91,10 @@ export class TTSEngine extends EventEmitter {
         }
         this.playing = false;
     }
+    updateVoice(voice) {
+        this.voice = voice;
+        debug(`[interrupt-tts] voice updated to ${voice}`);
+    }
     get isPlaying() {
         return this.playing;
     }

package/dist/tts/index.d.ts

@@ -29,6 +29,8 @@ export declare class TTSStreamer extends EventEmitter {
     stop(): void;
     disable(): void;
     enable(): void;
+    /** Pro-only feature — free tier always uses default voice */
+    updateVoice(voice: string): void;
     getPartialContent(): string;
     isPlaying(): boolean;
     resetSession(): void;

package/dist/tts/index.js

@@ -119,6 +119,12 @@ export class TTSStreamer extends EventEmitter {
     enable() {
         this.enabled = true;
     }
+    /** Pro-only feature — free tier always uses default voice */
+    updateVoice(voice) {
+        if (voice && voice !== this.engine.currentVoice) {
+            this.engine.updateVoice(voice);
+        }
+    }
     getPartialContent() {
         if (this.spokenText.trim()) {
             return this.spokenText.trim() + "...[interrupted]";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-interrupt-plugin",
-  "version": "0.4.35",
+  "version": "0.4.36",
   "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",