opencode-interrupt-plugin 0.3.1

package/LICENSE

@@ -0,0 +1,20 @@
+License Terms
+=============
+
+This software is not free software. Use is conditioned on either:
+
+1. A valid paid license obtained via Polar.sh, granting full configuration access
+   and supporting ongoing development; OR
+
+2. Free (unlicensed) usage with the following restrictions:
+   - Voice interruption detection is enabled with fixed default settings only
+   - No customization of microphone threshold, sensitivity, timing, or debug output
+   - The config interface (PluginConfig) may not be exercised beyond defaults
+   - No warranty or support is provided
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+
+Paid license keys are validated at runtime against the Polar.sh API.
+License activation is limited to 3 machines per key.

package/dist/audio/monitor.d.ts

@@ -0,0 +1,15 @@
+import { EventEmitter } from 'events';
+export declare class AudioMonitor extends EventEmitter {
+    private process;
+    private isRunning;
+    private silenceTimer;
+    private threshold;
+    private silenceMs;
+    constructor(threshold?: number, silenceMs?: number);
+    start(): void;
+    private tryFallbackMonitor;
+    stop(): void;
+    private handleRMS;
+    setThreshold(threshold: number): void;
+    isActive(): boolean;
+}

package/dist/audio/monitor.js

@@ -0,0 +1,116 @@
+import { spawn } from 'child_process';
+import { EventEmitter } from 'events';
+export class AudioMonitor extends EventEmitter {
+    process = null;
+    isRunning = false;
+    silenceTimer = null;
+    threshold;
+    silenceMs;
+    constructor(threshold = 0.02, silenceMs = 300) {
+        super();
+        this.threshold = threshold;
+        this.silenceMs = silenceMs;
+    }
+    start() {
+        if (this.isRunning)
+            return;
+        this.process = spawn('sox', [
+            '-q',
+            '-d',
+            '-t', 'sox', '-',
+            'stat',
+            '-freq',
+        ], {
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        let buffer = '';
+        this.process.stderr?.on('data', (chunk) => {
+            buffer += chunk.toString();
+            const lines = buffer.split('\n');
+            buffer = lines.pop() || '';
+            for (const line of lines) {
+                const rms = parseRMSLine(line);
+                if (rms !== null) {
+                    this.handleRMS(rms);
+                }
+            }
+        });
+        this.process.on('error', () => {
+            this.tryFallbackMonitor();
+        });
+        this.process.on('exit', () => {
+            this.isRunning = false;
+            this.emit('stopped');
+        });
+        this.isRunning = true;
+        this.emit('started');
+    }
+    tryFallbackMonitor() {
+        const poll = () => {
+            if (!this.isRunning)
+                return;
+            const 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', () => {
+                const rms = parseRMSFromStat(out);
+                if (rms !== null)
+                    this.handleRMS(rms);
+                setTimeout(poll, 100);
+            });
+            proc.on('error', () => {
+                this.emit('error', new Error('sox not found. Install it: brew install sox (macOS) or apt install sox (Linux)'));
+                this.isRunning = false;
+            });
+        };
+        this.isRunning = true;
+        poll();
+    }
+    stop() {
+        this.isRunning = false;
+        if (this.process) {
+            this.process.kill('SIGTERM');
+            this.process = null;
+        }
+        if (this.silenceTimer) {
+            clearTimeout(this.silenceTimer);
+            this.silenceTimer = null;
+        }
+        this.emit('stopped');
+    }
+    handleRMS(rms) {
+        if (rms > this.threshold) {
+            this.emit('voice-detected', rms);
+            if (this.silenceTimer)
+                clearTimeout(this.silenceTimer);
+            this.silenceTimer = setTimeout(() => {
+                this.emit('silence');
+            }, this.silenceMs);
+        }
+    }
+    setThreshold(threshold) {
+        this.threshold = threshold;
+    }
+    isActive() {
+        return this.isRunning;
+    }
+}
+function parseRMSLine(line) {
+    const match = line.match(/RMS 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/audio/overlap.d.ts

@@ -0,0 +1,18 @@
+import { EventEmitter } from 'events';
+export interface VoiceOverlapEvent {
+    partialTTSContent: string;
+    overlapTimestamp: number;
+    rmsLevel: number;
+}
+export declare class VoiceOverlapDetector extends EventEmitter {
+    private monitor;
+    private active;
+    private cooldownUntil;
+    private readonly COOLDOWN_MS;
+    constructor(threshold?: number);
+    start(): void;
+    stop(): void;
+    updateThreshold(threshold: number): void;
+    private handleVoiceDetected;
+    isActive(): boolean;
+}

package/dist/audio/overlap.js

@@ -0,0 +1,51 @@
+import { AudioMonitor } from './monitor.js';
+import { isTTSPlaying, getPartialTTSContent, onTTSEnd } from './tts-tracker.js';
+import { EventEmitter } from 'events';
+export class VoiceOverlapDetector extends EventEmitter {
+    monitor;
+    active = false;
+    cooldownUntil = 0;
+    COOLDOWN_MS = 3000;
+    constructor(threshold = 0.02) {
+        super();
+        this.monitor = new AudioMonitor(threshold);
+        this.monitor.on('voice-detected', (rms) => {
+            this.handleVoiceDetected(rms);
+        });
+        this.monitor.on('error', (err) => {
+            this.emit('monitor-error', err);
+        });
+    }
+    start() {
+        if (this.active)
+            return;
+        this.active = true;
+        this.monitor.start();
+    }
+    stop() {
+        this.active = false;
+        this.monitor.stop();
+    }
+    updateThreshold(threshold) {
+        this.monitor.setThreshold(threshold);
+    }
+    handleVoiceDetected(rms) {
+        if (!isTTSPlaying())
+            return;
+        if (Date.now() < this.cooldownUntil)
+            return;
+        const now = Date.now();
+        this.cooldownUntil = now + this.COOLDOWN_MS;
+        const partialContent = getPartialTTSContent(now);
+        onTTSEnd();
+        const event = {
+            partialTTSContent: partialContent,
+            overlapTimestamp: now,
+            rmsLevel: rms,
+        };
+        this.emit('voice-overlap', event);
+    }
+    isActive() {
+        return this.active;
+    }
+}

package/dist/audio/tts-tracker.d.ts

@@ -0,0 +1,11 @@
+export interface TTSState {
+    isPlaying: boolean;
+    startedAt: number;
+    content: string;
+    estimatedDurationMs: number;
+}
+export declare function onTTSStart(content: string): void;
+export declare function onTTSEnd(): void;
+export declare function isTTSPlaying(): boolean;
+export declare function isTTSTool(toolName: string): boolean;
+export declare function getPartialTTSContent(elapsedMs: number): string;

package/dist/audio/tts-tracker.js

@@ -0,0 +1,37 @@
+const TTS_TOOL_NAMES = new Set(['speak', 'tts', 'text_to_speech', 'say']);
+const ttsState = {
+    isPlaying: false,
+    startedAt: 0,
+    content: '',
+    estimatedDurationMs: 0,
+};
+function estimateDuration(text) {
+    const words = text.split(/\s+/).length;
+    const durationMs = (words / 2.5) * 1000;
+    return Math.max(500, Math.min(120000, durationMs));
+}
+export function onTTSStart(content) {
+    ttsState.isPlaying = true;
+    ttsState.startedAt = Date.now();
+    ttsState.content = content;
+    ttsState.estimatedDurationMs = estimateDuration(content);
+    setTimeout(() => {
+        if (ttsState.isPlaying && Date.now() - ttsState.startedAt > ttsState.estimatedDurationMs) {
+            ttsState.isPlaying = false;
+        }
+    }, ttsState.estimatedDurationMs + 2000);
+}
+export function onTTSEnd() {
+    ttsState.isPlaying = false;
+}
+export function isTTSPlaying() {
+    return ttsState.isPlaying;
+}
+export function isTTSTool(toolName) {
+    return TTS_TOOL_NAMES.has(toolName.toLowerCase());
+}
+export function getPartialTTSContent(elapsedMs) {
+    const progress = Math.min(elapsedMs / ttsState.estimatedDurationMs, 0.95);
+    const charIndex = Math.floor(ttsState.content.length * progress);
+    return ttsState.content.slice(0, charIndex) + '...[interrupted]';
+}

package/dist/config.d.ts

@@ -0,0 +1,25 @@
+export interface PluginConfig {
+    licenseKey?: string;
+    micThreshold?: number;
+    sensitivity?: 'low' | 'medium' | 'high';
+    timingWindowMs?: number;
+    maxCorrectionLength?: number;
+    minResponseLength?: number;
+    voiceDetection?: boolean;
+    debug?: boolean;
+}
+export interface ResolvedConfig {
+    licenseKey?: string;
+    isLicensed: boolean;
+    micThreshold: number;
+    sensitivity: string;
+    timingWindowMs: number;
+    maxCorrectionLength: number;
+    minResponseLength: number;
+    voiceDetection: boolean;
+    voiceMode: string;
+    debug: boolean;
+}
+export declare const FREE_DEFAULTS: ResolvedConfig;
+export declare const SENSITIVITY_PRESETS: Record<string, Partial<ResolvedConfig>>;
+export declare function resolveConfig(userConfig: PluginConfig, isLicensed: boolean): ResolvedConfig;

package/dist/config.js

@@ -0,0 +1,53 @@
+export const FREE_DEFAULTS = {
+    isLicensed: false,
+    micThreshold: 0.02,
+    sensitivity: 'medium',
+    timingWindowMs: 30000,
+    maxCorrectionLength: 1000,
+    minResponseLength: 200,
+    voiceDetection: true,
+    voiceMode: 'enabled',
+    debug: false,
+};
+export const SENSITIVITY_PRESETS = {
+    low: {
+        timingWindowMs: 15000,
+        maxCorrectionLength: 500,
+        minResponseLength: 100,
+    },
+    medium: {
+        timingWindowMs: 30000,
+        maxCorrectionLength: 1000,
+        minResponseLength: 200,
+    },
+    high: {
+        timingWindowMs: 60000,
+        maxCorrectionLength: 2000,
+        minResponseLength: 400,
+    },
+};
+export function resolveConfig(userConfig, isLicensed) {
+    if (!isLicensed) {
+        return { ...FREE_DEFAULTS };
+    }
+    const base = {
+        ...FREE_DEFAULTS,
+        isLicensed: true,
+        micThreshold: userConfig.micThreshold ?? FREE_DEFAULTS.micThreshold,
+        sensitivity: userConfig.sensitivity ?? FREE_DEFAULTS.sensitivity,
+        timingWindowMs: userConfig.timingWindowMs ?? FREE_DEFAULTS.timingWindowMs,
+        maxCorrectionLength: userConfig.maxCorrectionLength ?? FREE_DEFAULTS.maxCorrectionLength,
+        minResponseLength: userConfig.minResponseLength ?? FREE_DEFAULTS.minResponseLength,
+        voiceDetection: userConfig.voiceDetection ?? FREE_DEFAULTS.voiceDetection,
+        debug: userConfig.debug ?? FREE_DEFAULTS.debug,
+        licenseKey: userConfig.licenseKey,
+    };
+    const preset = SENSITIVITY_PRESETS[base.sensitivity];
+    if (!userConfig.timingWindowMs)
+        base.timingWindowMs = preset.timingWindowMs ?? base.timingWindowMs;
+    if (!userConfig.maxCorrectionLength)
+        base.maxCorrectionLength = preset.maxCorrectionLength ?? base.maxCorrectionLength;
+    if (!userConfig.minResponseLength)
+        base.minResponseLength = preset.minResponseLength ?? base.minResponseLength;
+    return base;
+}

package/dist/detector.d.ts

@@ -0,0 +1,6 @@
+import type { SessionState } from './store.js';
+export interface DetectionResult {
+    detected: boolean;
+    reason: string;
+}
+export declare function detectTextInterruption(userMessage: string, sessionState: SessionState): DetectionResult;

package/dist/detector.js

@@ -0,0 +1,22 @@
+const TEXT_INTERRUPT_PATTERNS = [
+    /\b(stop|wait|hold on|hold up)\b/i,
+    /\b(actually|never mind|forget it|scratch that|disregard)\b/i,
+    /\b(interrupt|break|abort|cancel)\b/i,
+];
+export function detectTextInterruption(userMessage, sessionState) {
+    if (sessionState.wasInterrupted && sessionState.awaitingCorrection) {
+        return {
+            detected: true,
+            reason: `Session marked as interrupted (source: ${sessionState.interruptSource || 'unknown'})`,
+        };
+    }
+    for (const pattern of TEXT_INTERRUPT_PATTERNS) {
+        if (pattern.test(userMessage)) {
+            return {
+                detected: true,
+                reason: `Text matched interruption pattern: ${pattern.source}`,
+            };
+        }
+    }
+    return { detected: false, reason: '' };
+}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+import type { Plugin } from '@opencode-ai/plugin';
+import { type PluginConfig } from './config.js';
+export declare const InterruptPlugin: (userConfig?: PluginConfig) => Plugin;
+declare const _default: Plugin;
+export default _default;
+export { InterruptPlugin as Interrupt };

package/dist/index.js

@@ -0,0 +1,170 @@
+import { resolveConfig } from './config.js';
+import { checkLicense } from './license/guard.js';
+import { getSessionState, updateSessionState, clearSessionState, } from './store.js';
+import { prepareInjection } from './injector.js';
+import { onTTSStart, onTTSEnd, isTTSTool } from './audio/tts-tracker.js';
+import { VoiceOverlapDetector } from './audio/overlap.js';
+import { detectTextInterruption } from './detector.js';
+let activeSessionId = null;
+export const InterruptPlugin = (userConfig = {}) => {
+    return async ({ client }) => {
+        const licenseResult = await checkLicense(userConfig.licenseKey);
+        const config = resolveConfig(userConfig, licenseResult.allowed);
+        if (config.debug) {
+            console.log(`[interrupt] Plugin loaded (${config.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');
+        }
+        const overlapDetector = new VoiceOverlapDetector(config.micThreshold);
+        overlapDetector.on('voice-overlap', (event) => {
+            if (!activeSessionId)
+                return;
+            if (config.debug) {
+                console.log(`[interrupt] Voice overlap (RMS: ${event.rmsLevel.toFixed(4)})`);
+            }
+            updateSessionState(activeSessionId, {
+                wasInterrupted: true,
+                partialContentAtInterrupt: event.partialTTSContent,
+                interruptTimestamp: event.overlapTimestamp,
+                awaitingCorrection: true,
+                interruptSource: 'voice',
+            });
+        });
+        overlapDetector.on('monitor-error', (err) => {
+            if (config.debug) {
+                console.warn(`[interrupt] Audio monitor error: ${err.message}`);
+            }
+        });
+        overlapDetector.start();
+        process.on('exit', () => overlapDetector.stop());
+        return {
+            event: async ({ event }) => {
+                const evt = event;
+                const sessionId = evt.session_id || evt.properties?.info?.id;
+                if (evt.type === 'session.created' && sessionId) {
+                    activeSessionId = sessionId;
+                    getSessionState(sessionId);
+                }
+                if (evt.type === 'session.deleted' && sessionId) {
+                    clearSessionState(sessionId);
+                    if (activeSessionId === sessionId)
+                        activeSessionId = null;
+                }
+            },
+            'chat.message': async (input, output) => {
+                const sessionId = input.sessionID;
+                if (!sessionId)
+                    return;
+                const msg = output.message;
+                const parts = output.parts;
+                if (!msg || !msg.role)
+                    return;
+                if (msg.role === 'assistant') {
+                    const content = extractText(parts);
+                    updateSessionState(sessionId, {
+                        lastAssistantContent: content,
+                        lastAssistantTimestamp: Date.now(),
+                        wasInterrupted: false,
+                    });
+                    return;
+                }
+                if (msg.role === 'user' && !overlapDetector.isActive()) {
+                    const state = getSessionState(sessionId);
+                    const userText = extractText(parts);
+                    const signal = detectTextInterruption(userText, state);
+                    if (signal.detected) {
+                        const partialContent = state.lastAssistantContent;
+                        updateSessionState(sessionId, {
+                            wasInterrupted: true,
+                            partialContentAtInterrupt: partialContent,
+                            interruptTimestamp: Date.now(),
+                            awaitingCorrection: true,
+                            interruptSource: 'text',
+                        });
+                    }
+                }
+            },
+            'experimental.chat.system.transform': async (input, output) => {
+                const sessionId = input.sessionID;
+                if (!sessionId)
+                    return;
+                activeSessionId = sessionId;
+                const sessionState = getSessionState(sessionId);
+                const userMessage = extractUserMessage(input);
+                if (!userMessage)
+                    return;
+                const currentSystem = output.system?.join('\n') || '';
+                const { systemPrompt, result } = prepareInjection(userMessage, currentSystem, sessionState, config);
+                if (result.injected) {
+                    output.system = [systemPrompt];
+                    if (config.debug) {
+                        console.log(`[interrupt] ${result.reason}`);
+                    }
+                    updateSessionState(sessionId, {
+                        wasInterrupted: false,
+                        partialContentAtInterrupt: '',
+                        awaitingCorrection: false,
+                        interruptSource: undefined,
+                    });
+                }
+            },
+            'tool.execute.before': async (input, output) => {
+                const toolName = input.tool || '';
+                const args = output?.args || {};
+                if (isTTSTool(toolName)) {
+                    const text = args.text || args.content || '';
+                    onTTSStart(text);
+                }
+            },
+            'tool.execute.after': async (input, output) => {
+                const toolName = input.tool?.name || '';
+                if (isTTSTool(toolName)) {
+                    onTTSEnd();
+                }
+            },
+        };
+    };
+};
+function extractUserMessage(input) {
+    try {
+        const messages = input.messages || [];
+        const lastUser = [...messages].reverse().find((m) => m.role === 'user');
+        if (!lastUser)
+            return '';
+        return extractContent(lastUser);
+    }
+    catch {
+        return '';
+    }
+}
+function extractContent(obj) {
+    try {
+        const content = obj.content || obj.message?.content;
+        if (typeof content === 'string')
+            return content;
+        if (Array.isArray(content)) {
+            return content.filter((c) => c.type === 'text').map((c) => c.text).join(' ');
+        }
+        return '';
+    }
+    catch {
+        return '';
+    }
+}
+function extractText(parts) {
+    try {
+        if (!Array.isArray(parts))
+            return '';
+        return parts
+            .filter((p) => p.type === 'text')
+            .map((p) => p.text || '')
+            .join(' ');
+    }
+    catch {
+        return '';
+    }
+}
+export default InterruptPlugin();
+export { InterruptPlugin as Interrupt };

package/dist/injector.d.ts

@@ -0,0 +1,11 @@
+import type { SessionState } from './store.js';
+import type { ResolvedConfig } from './config.js';
+export interface InjectionResult {
+    injected: boolean;
+    reason: string;
+}
+export interface InjectionOutput {
+    systemPrompt: string;
+    result: InjectionResult;
+}
+export declare function prepareInjection(userMessage: string, currentSystem: string, sessionState: SessionState, config: ResolvedConfig): InjectionOutput;

package/dist/injector.js

@@ -0,0 +1,45 @@
+const INTERRUPT_TEMPLATE = `
+[INTERRUPTION CONTEXT]
+The user interrupted the previous response.
+{reason}
+The assistant was saying:
+"{partialContent}"
+The user will now correct or clarify. Respond to the correction, not to a blank slate.
+Do not repeat what was interrupted. Acknowledge the interruption in one sentence at most, then address the user's new input directly.
+`;
+export function prepareInjection(userMessage, currentSystem, sessionState, config) {
+    if (!sessionState.wasInterrupted || !sessionState.awaitingCorrection) {
+        return {
+            systemPrompt: currentSystem,
+            result: { injected: false, reason: 'No interruption to inject' },
+        };
+    }
+    const elapsed = Date.now() - sessionState.interruptTimestamp;
+    if (elapsed > config.timingWindowMs) {
+        return {
+            systemPrompt: currentSystem,
+            result: { injected: false, reason: `Interruption window expired (${elapsed}ms > ${config.timingWindowMs}ms)` },
+        };
+    }
+    const partial = sessionState.partialContentAtInterrupt || '(unknown content)';
+    const source = sessionState.interruptSource || 'unknown';
+    const sourceReason = getReasonForSource(source);
+    const contextBlock = INTERRUPT_TEMPLATE
+        .replace('{reason}', sourceReason)
+        .replace('{partialContent}', partial);
+    const separator = currentSystem.trim() ? '\n\n---\n' : '';
+    return {
+        systemPrompt: currentSystem + separator + contextBlock,
+        result: { injected: true, reason: `Injected ${source} interruption context` },
+    };
+}
+function getReasonForSource(source) {
+    switch (source) {
+        case 'voice':
+            return 'The user spoke over the TTS output.';
+        case 'text':
+            return 'The user interrupted via text message.';
+        default:
+            return 'The assistant output was interrupted.';
+    }
+}

package/dist/license/guard.d.ts

@@ -0,0 +1,5 @@
+export interface GuardResult {
+    allowed: boolean;
+    email?: string;
+}
+export declare function checkLicense(providedKey?: string): Promise<GuardResult>;

package/dist/license/guard.js

@@ -0,0 +1,54 @@
+import os from 'os';
+import { readLicense, writeLicense, clearLicense, } from './storage.js';
+import { activateLicense, validateLicense, getOfflineGraceDate, isWithinGracePeriod, } from './validator.js';
+function getMachineLabel() {
+    return `${os.hostname()}-${os.platform()}`;
+}
+export async function checkLicense(providedKey) {
+    if (!providedKey) {
+        return { allowed: false };
+    }
+    const stored = await readLicense();
+    if (!stored) {
+        const result = await activateLicense(providedKey, getMachineLabel());
+        if (!result.valid) {
+            console.log(`\n[interrupt] License activation failed: ${result.reason}\n`);
+            return { allowed: false };
+        }
+        await writeLicense({
+            key: providedKey,
+            activationId: result.activationId,
+            activatedAt: new Date().toISOString(),
+            lastValidatedAt: new Date().toISOString(),
+            status: 'active',
+            email: result.email,
+            offlineGraceUntil: getOfflineGraceDate(),
+        });
+        console.log(`\n[interrupt] License activated${result.email ? ` for ${result.email}` : ''}. Premium features enabled.\n`);
+        return { allowed: true, email: result.email };
+    }
+    if (providedKey !== stored.key) {
+        await clearLicense();
+        return checkLicense(providedKey);
+    }
+    const result = await validateLicense(stored.key, stored.activationId);
+    if (result.valid) {
+        await writeLicense({
+            ...stored,
+            lastValidatedAt: new Date().toISOString(),
+            status: 'active',
+            offlineGraceUntil: getOfflineGraceDate(),
+        });
+        return { allowed: true };
+    }
+    if (result.reason === 'OFFLINE') {
+        if (isWithinGracePeriod(stored.offlineGraceUntil)) {
+            console.log(`\n[interrupt] Offline — using cached license (grace period active).\n`);
+            return { allowed: true };
+        }
+        console.log(`\n[interrupt] License validation failed: offline for more than 7 days. Connect to the internet to revalidate.\n`);
+        return { allowed: false };
+    }
+    console.log(`\n[interrupt] License invalid: ${result.reason}\n`);
+    return { allowed: false };
+}

package/dist/license/storage.d.ts

@@ -0,0 +1,12 @@
+export interface LicenseData {
+    key: string;
+    activationId: string;
+    activatedAt: string;
+    lastValidatedAt: string;
+    status: 'active' | 'invalid' | 'expired';
+    email?: string;
+    offlineGraceUntil: string;
+}
+export declare function readLicense(): Promise<LicenseData | null>;
+export declare function writeLicense(data: LicenseData): Promise<void>;
+export declare function clearLicense(): Promise<void>;

package/dist/license/storage.js

@@ -0,0 +1,23 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+const LICENSE_PATH = path.join(os.homedir(), '.config', 'opencode', 'interrupt-voice.license.json');
+export async function readLicense() {
+    try {
+        const raw = await fs.promises.readFile(LICENSE_PATH, 'utf8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+export async function writeLicense(data) {
+    await fs.promises.mkdir(path.dirname(LICENSE_PATH), { recursive: true });
+    await fs.promises.writeFile(LICENSE_PATH, JSON.stringify(data, null, 2), 'utf8');
+}
+export async function clearLicense() {
+    try {
+        await fs.promises.unlink(LICENSE_PATH);
+    }
+    catch { /* already gone */ }
+}

package/dist/license/validator.d.ts

@@ -0,0 +1,10 @@
+export interface ValidationResult {
+    valid: boolean;
+    reason?: string;
+    email?: string;
+    activationId?: string;
+}
+export declare function activateLicense(key: string, machineLabel: string): Promise<ValidationResult>;
+export declare function validateLicense(key: string, activationId: string): Promise<ValidationResult>;
+export declare function getOfflineGraceDate(): string;
+export declare function isWithinGracePeriod(offlineGraceUntil: string): boolean;

package/dist/license/validator.js

@@ -0,0 +1,79 @@
+const POLAR_ORG_ID = '166f4429-84b8-4e41-9c74-eff1b8724873';
+const POLAR_VALIDATE_URL = 'https://api.polar.sh/v1/customer-portal/license-keys/validate';
+const POLAR_ACTIVATE_URL = 'https://api.polar.sh/v1/customer-portal/license-keys/activate';
+const OFFLINE_GRACE_DAYS = 7;
+export async function activateLicense(key, machineLabel) {
+    try {
+        const response = await fetch(POLAR_ACTIVATE_URL, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                key,
+                organization_id: POLAR_ORG_ID,
+                label: machineLabel,
+                conditions: { major_version: 1 },
+            }),
+            signal: AbortSignal.timeout(8000),
+        });
+        if (response.status === 200) {
+            const data = await response.json();
+            return {
+                valid: true,
+                activationId: data.id,
+                email: data.license_key?.customer?.email,
+            };
+        }
+        if (response.status === 403) {
+            return { valid: false, reason: 'License key activation limit reached (max 3 machines). Deactivate another machine first.' };
+        }
+        if (response.status === 404) {
+            return { valid: false, reason: 'License key not found. Check your key and try again.' };
+        }
+        return { valid: false, reason: `Activation failed (status ${response.status})` };
+    }
+    catch (err) {
+        if (err.name === 'TimeoutError') {
+            return { valid: false, reason: 'Network timeout during activation. Check your internet connection.' };
+        }
+        return { valid: false, reason: `Activation error: ${err.message}` };
+    }
+}
+export async function validateLicense(key, activationId) {
+    try {
+        const response = await fetch(POLAR_VALIDATE_URL, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                key,
+                organization_id: POLAR_ORG_ID,
+                activation_id: activationId,
+                conditions: { major_version: 1 },
+            }),
+            signal: AbortSignal.timeout(5000),
+        });
+        if (response.status === 200) {
+            const data = await response.json();
+            const isValid = data.status === 'granted';
+            return {
+                valid: isValid,
+                reason: isValid ? undefined : `License status: ${data.status}`,
+                email: data.customer?.email,
+            };
+        }
+        if (response.status === 404) {
+            return { valid: false, reason: 'License key revoked or not found.' };
+        }
+        return { valid: false, reason: `Validation failed (status ${response.status})` };
+    }
+    catch {
+        return { valid: false, reason: 'OFFLINE' };
+    }
+}
+export function getOfflineGraceDate() {
+    const d = new Date();
+    d.setDate(d.getDate() + OFFLINE_GRACE_DAYS);
+    return d.toISOString();
+}
+export function isWithinGracePeriod(offlineGraceUntil) {
+    return new Date(offlineGraceUntil) > new Date();
+}

package/dist/store.d.ts

@@ -0,0 +1,12 @@
+export interface SessionState {
+    lastAssistantContent: string;
+    lastAssistantTimestamp: number;
+    wasInterrupted: boolean;
+    partialContentAtInterrupt: string;
+    interruptTimestamp: number;
+    awaitingCorrection: boolean;
+    interruptSource?: 'voice' | 'text';
+}
+export declare function getSessionState(sessionId: string): SessionState;
+export declare function updateSessionState(sessionId: string, updates: Partial<SessionState>): SessionState;
+export declare function clearSessionState(sessionId: string): void;

package/dist/store.js

@@ -0,0 +1,23 @@
+const sessions = new Map();
+export function getSessionState(sessionId) {
+    if (!sessions.has(sessionId)) {
+        sessions.set(sessionId, {
+            lastAssistantContent: '',
+            lastAssistantTimestamp: 0,
+            wasInterrupted: false,
+            partialContentAtInterrupt: '',
+            interruptTimestamp: 0,
+            awaitingCorrection: false,
+        });
+    }
+    return sessions.get(sessionId);
+}
+export function updateSessionState(sessionId, updates) {
+    const state = getSessionState(sessionId);
+    Object.assign(state, updates);
+    sessions.set(sessionId, state);
+    return state;
+}
+export function clearSessionState(sessionId) {
+    sessions.delete(sessionId);
+}

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "opencode-interrupt-plugin",
+  "version": "0.3.1",
+  "description": "Voice interruption for OpenCode. Detects when you speak over TTS output and redirects the AI mid-response.",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist/"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "prepublishOnly": "tsc"
+  },
+  "dependencies": {
+    "@opencode-ai/plugin": "latest"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "^5.0.0"
+  },
+  "keywords": [
+    "opencode",
+    "opencode-plugin",
+    "interruption",
+    "voice",
+    "ai",
+    "cli",
+    "tts"
+  ],
+  "license": "SEE LICENSE IN LICENSE"
+}