@otto-assistant/bridge 0.4.92

package/dist/openai-realtime.js

@@ -0,0 +1,224 @@
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+/* istanbul ignore file */
+// @ts-nocheck
+import { RealtimeClient } from '@openai/realtime-api-beta';
+import { writeFile } from 'fs';
+import { createLogger, LogPrefix } from './logger.js';
+const openaiLogger = createLogger(LogPrefix.OPENAI);
+const audioParts = [];
+function saveBinaryFile(fileName, content) {
+    writeFile(fileName, content, 'utf8', (err) => {
+        if (err) {
+            openaiLogger.error(`Error writing file ${fileName}:`, err);
+            return;
+        }
+        openaiLogger.log(`Appending stream content to file ${fileName}.`);
+    });
+}
+function convertToWav(rawData, mimeType) {
+    const options = parseMimeType(mimeType);
+    const dataLength = rawData.reduce((a, b) => a + b.length, 0);
+    const wavHeader = createWavHeader(dataLength, options);
+    const buffer = Buffer.concat(rawData);
+    return Buffer.concat([wavHeader, buffer]);
+}
+function parseMimeType(mimeType) {
+    const [fileType, ...params] = mimeType.split(';').map((s) => s.trim());
+    const [_, format] = fileType?.split('/') || [];
+    const options = {
+        numChannels: 1,
+        bitsPerSample: 16,
+    };
+    if (format && format.startsWith('L')) {
+        const bits = parseInt(format.slice(1), 10);
+        if (!isNaN(bits)) {
+            options.bitsPerSample = bits;
+        }
+    }
+    for (const param of params) {
+        const [key, value] = param.split('=').map((s) => s.trim());
+        if (key === 'rate') {
+            options.sampleRate = parseInt(value || '', 10);
+        }
+    }
+    return options;
+}
+function createWavHeader(dataLength, options) {
+    const { numChannels, sampleRate, bitsPerSample } = options;
+    // http://soundfile.sapp.org/doc/WaveFormat
+    const byteRate = (sampleRate * numChannels * bitsPerSample) / 8;
+    const blockAlign = (numChannels * bitsPerSample) / 8;
+    const buffer = Buffer.alloc(44);
+    buffer.write('RIFF', 0); // ChunkID
+    buffer.writeUInt32LE(36 + dataLength, 4); // ChunkSize
+    buffer.write('WAVE', 8); // Format
+    buffer.write('fmt ', 12); // Subchunk1ID
+    buffer.writeUInt32LE(16, 16); // Subchunk1Size (PCM)
+    buffer.writeUInt16LE(1, 20); // AudioFormat (1 = PCM)
+    buffer.writeUInt16LE(numChannels, 22); // NumChannels
+    buffer.writeUInt32LE(sampleRate, 24); // SampleRate
+    buffer.writeUInt32LE(byteRate, 28); // ByteRate
+    buffer.writeUInt16LE(blockAlign, 32); // BlockAlign
+    buffer.writeUInt16LE(bitsPerSample, 34); // BitsPerSample
+    buffer.write('data', 36); // Subchunk2ID
+    buffer.writeUInt32LE(dataLength, 40); // Subchunk2Size
+    return buffer;
+}
+function defaultAudioChunkHandler({ data, mimeType, }) {
+    audioParts.push(data);
+    const fileName = 'audio.wav';
+    const buffer = convertToWav(audioParts, mimeType);
+    saveBinaryFile(fileName, buffer);
+}
+export async function startGenAiSession({ onAssistantAudioChunk, onAssistantStartSpeaking, onAssistantStopSpeaking, onAssistantInterruptSpeaking, systemMessage, tools, } = {}) {
+    if (!process.env.OPENAI_API_KEY) {
+        throw new Error('OPENAI_API_KEY environment variable is required');
+    }
+    const client = new RealtimeClient({
+        apiKey: process.env.OPENAI_API_KEY,
+    });
+    const audioChunkHandler = onAssistantAudioChunk || defaultAudioChunkHandler;
+    let isAssistantSpeaking = false;
+    // Configure session with 24kHz sample rate
+    client.updateSession({
+        instructions: systemMessage || '',
+        voice: 'alloy',
+        input_audio_format: 'pcm16',
+        output_audio_format: 'pcm16',
+        input_audio_transcription: { model: 'whisper-1' },
+        turn_detection: { type: 'server_vad' },
+        modalities: ['text', 'audio'],
+        temperature: 0.8,
+    });
+    // Add tools if provided
+    if (tools) {
+        for (const [name, tool] of Object.entries(tools)) {
+            // Convert AI SDK tool to OpenAI Realtime format
+            // The tool.inputSchema is a Zod schema, we need to convert it to JSON Schema
+            let parameters = {
+                type: 'object',
+                properties: {},
+                required: [],
+            };
+            // If the tool has a Zod schema, we can try to extract basic structure
+            // For now, we'll use a simple placeholder
+            if (tool.description?.includes('session')) {
+                parameters = {
+                    type: 'object',
+                    properties: {
+                        sessionId: { type: 'string', description: 'The session ID' },
+                        message: { type: 'string', description: 'The message text' },
+                    },
+                    required: ['sessionId'],
+                };
+            }
+            client.addTool({
+                type: 'function',
+                name,
+                description: tool.description || '',
+                parameters,
+            }, async (params) => {
+                try {
+                    if (!tool.execute || typeof tool.execute !== 'function') {
+                        return { error: 'Tool execute function not found' };
+                    }
+                    // Call the execute function with params
+                    // The Tool type from 'ai' expects (input, options) but we need to handle this safely
+                    const result = await tool.execute(params, {
+                        abortSignal: new AbortController().signal,
+                        toolCallId: '',
+                        messages: [],
+                    });
+                    return result;
+                }
+                catch (error) {
+                    openaiLogger.error(`Tool ${name} execution error:`, error);
+                    return { error: String(error) };
+                }
+            });
+        }
+    }
+    // Set up event handlers
+    client.on('conversation.item.created', ({ item }) => {
+        if (item.role === 'assistant' &&
+            item.type === 'message') {
+            // Check if this is the first audio content
+            const hasAudio = Array.isArray(item.content) &&
+                item.content.some((c) => c.type === 'audio');
+            if (hasAudio && !isAssistantSpeaking && onAssistantStartSpeaking) {
+                isAssistantSpeaking = true;
+                onAssistantStartSpeaking();
+            }
+        }
+    });
+    client.on('conversation.updated', ({ item, delta, }) => {
+        // Handle audio chunks
+        if (delta?.audio && item.role === 'assistant') {
+            if (!isAssistantSpeaking && onAssistantStartSpeaking) {
+                isAssistantSpeaking = true;
+                onAssistantStartSpeaking();
+            }
+            // OpenAI provides audio as Int16Array or base64
+            let audioBuffer;
+            if (delta.audio instanceof Int16Array) {
+                audioBuffer = Buffer.from(delta.audio.buffer);
+            }
+            else {
+                // Assume base64 string
+                audioBuffer = Buffer.from(delta.audio, 'base64');
+            }
+            // OpenAI uses 24kHz PCM16 format
+            audioChunkHandler({
+                data: audioBuffer,
+                mimeType: 'audio/pcm;rate=24000',
+            });
+        }
+        // Handle transcriptions
+        if (delta?.transcript) {
+            if (item.role === 'user') {
+                openaiLogger.log('User transcription:', delta.transcript);
+            }
+            else if (item.role === 'assistant') {
+                openaiLogger.log('Assistant transcription:', delta.transcript);
+            }
+        }
+    });
+    client.on('conversation.item.completed', ({ item }) => {
+        if ('role' in item &&
+            item.role === 'assistant' &&
+            isAssistantSpeaking &&
+            onAssistantStopSpeaking) {
+            isAssistantSpeaking = false;
+            onAssistantStopSpeaking();
+        }
+    });
+    client.on('conversation.interrupted', () => {
+        openaiLogger.log('Assistant was interrupted');
+        if (isAssistantSpeaking && onAssistantInterruptSpeaking) {
+            isAssistantSpeaking = false;
+            onAssistantInterruptSpeaking();
+        }
+    });
+    // Connect to the Realtime API
+    await client.connect();
+    const sessionResult = {
+        session: {
+            send: (audioData) => {
+                // Convert ArrayBuffer to Int16Array for OpenAI
+                const int16Data = new Int16Array(audioData);
+                client.appendInputAudio(int16Data);
+            },
+            sendText: (text) => {
+                // Send text message to OpenAI
+                client.sendUserMessageContent([{ type: 'input_text', text }]);
+            },
+            close: () => {
+                client.disconnect();
+            },
+        },
+        stop: () => {
+            client.disconnect();
+        },
+    };
+    return sessionResult;
+}

package/dist/opencode-command-detection.js

@@ -0,0 +1,65 @@
+// Detect a /commandname token on its own line in a user prompt and resolve it
+// to a registered opencode command. Mirrors the Discord slash command flow
+// (commands/user-command.ts) so users can type `/build foo` or `/build-cmd foo`
+// in chat, via `/new-session`, through `kimaki send --prompt`, or scheduled
+// tasks and have it routed to opencode's session.command API instead of going
+// to the model as plain text.
+//
+// Detection is line-based: we scan each line and return the first one whose
+// first non-whitespace token is `/<registered-command>`. This keeps the
+// detector oblivious to prefix lines (`» **kimaki-cli:**`, `Context from
+// thread:`, etc). Producers that add such prefixes must put them on their
+// own line so the user's content starts on a fresh line.
+import { store } from './store.js';
+const DISCORD_SUFFIXES = ['-mcp-prompt', '-skill', '-cmd'];
+function stripDiscordSuffix(token) {
+    for (const suffix of DISCORD_SUFFIXES) {
+        if (token.endsWith(suffix)) {
+            return token.slice(0, -suffix.length);
+        }
+    }
+    return token;
+}
+// Resolve a /token against registeredUserCommands. When the list is empty
+// (gateway startup race), falls back to suffix-stripping so tokens like
+// /build-cmd still route to session.command('build'). Tokens without a
+// recognizable suffix return undefined to avoid false positives.
+function resolveCommandName({ token, registered, }) {
+    const exact = registered.find((c) => {
+        return c.name === token || c.discordCommandName === token;
+    });
+    if (exact)
+        return exact.name;
+    const base = stripDiscordSuffix(token);
+    if (base === token)
+        return undefined;
+    const stripped = registered.find((c) => {
+        return c.name === base || c.discordCommandName === base;
+    });
+    if (stripped)
+        return stripped.name;
+    // Empty registry fallback: suffix was stripped, trust it
+    if (registered.length === 0)
+        return base;
+    return undefined;
+}
+export function extractLeadingOpencodeCommand(prompt, registered = store.getState().registeredUserCommands) {
+    if (!prompt)
+        return null;
+    for (const line of prompt.split('\n')) {
+        const trimmed = line.trimStart();
+        if (!trimmed.startsWith('/'))
+            continue;
+        const match = trimmed.match(/^\/([^\s]+)(?:\s+(.*))?$/);
+        if (!match)
+            continue;
+        const [, token, rest] = match;
+        if (!token)
+            continue;
+        const name = resolveCommandName({ token, registered });
+        if (!name)
+            continue;
+        return { command: { name, arguments: (rest ?? '').trim() } };
+    }
+    return null;
+}

package/dist/opencode-command-detection.test.js

@@ -0,0 +1,240 @@
+import { describe, test, expect } from 'vitest';
+import { extractLeadingOpencodeCommand } from './opencode-command-detection.js';
+const fixtures = [
+    {
+        name: 'build',
+        discordCommandName: 'build-cmd',
+        description: 'build the project',
+        source: 'command',
+    },
+    {
+        name: 'namespace:foo',
+        discordCommandName: 'namespace-foo-cmd',
+        description: 'namespaced',
+        source: 'command',
+    },
+    {
+        name: 'review',
+        discordCommandName: 'review-skill',
+        description: 'review skill',
+        source: 'skill',
+    },
+    {
+        name: 'plan',
+        discordCommandName: 'plan-mcp-prompt',
+        description: 'plan via mcp',
+        source: 'mcp',
+    },
+];
+describe('extractLeadingOpencodeCommand', () => {
+    test('plain /build with args', () => {
+        expect(extractLeadingOpencodeCommand('/build foo bar', fixtures)).toMatchInlineSnapshot(`
+      {
+        "command": {
+          "arguments": "foo bar",
+          "name": "build",
+        },
+      }
+    `);
+    });
+    test('plain /build no args', () => {
+        expect(extractLeadingOpencodeCommand('/build', fixtures))
+            .toMatchInlineSnapshot(`
+      {
+        "command": {
+          "arguments": "",
+          "name": "build",
+        },
+      }
+    `);
+    });
+    test('/build-cmd suffix resolves to build', () => {
+        expect(extractLeadingOpencodeCommand('/build-cmd hello world', fixtures)).toMatchInlineSnapshot(`
+      {
+        "command": {
+          "arguments": "hello world",
+          "name": "build",
+        },
+      }
+    `);
+    });
+    test('-skill suffix', () => {
+        expect(extractLeadingOpencodeCommand('/review-skill a b', fixtures)).toMatchInlineSnapshot(`
+      {
+        "command": {
+          "arguments": "a b",
+          "name": "review",
+        },
+      }
+    `);
+    });
+    test('-mcp-prompt suffix', () => {
+        expect(extractLeadingOpencodeCommand('/plan-mcp-prompt go', fixtures)).toMatchInlineSnapshot(`
+      {
+        "command": {
+          "arguments": "go",
+          "name": "plan",
+        },
+      }
+    `);
+    });
+    test('original namespaced name with colon', () => {
+        expect(extractLeadingOpencodeCommand('/namespace:foo arg', fixtures)).toMatchInlineSnapshot(`
+      {
+        "command": {
+          "arguments": "arg",
+          "name": "namespace:foo",
+        },
+      }
+    `);
+    });
+    test('discord-sanitized namespaced name', () => {
+        expect(extractLeadingOpencodeCommand('/namespace-foo-cmd arg', fixtures)).toMatchInlineSnapshot(`
+      {
+        "command": {
+          "arguments": "arg",
+          "name": "namespace:foo",
+        },
+      }
+    `);
+    });
+    test('kimaki-cli prefix on its own line', () => {
+        expect(extractLeadingOpencodeCommand('» **kimaki-cli:**\n/build foo bar', fixtures)).toMatchInlineSnapshot(`
+      {
+        "command": {
+          "arguments": "foo bar",
+          "name": "build",
+        },
+      }
+    `);
+    });
+    test('queue-style user prefix on its own line', () => {
+        expect(extractLeadingOpencodeCommand('» **Tommy:**\n/build hey', fixtures)).toMatchInlineSnapshot(`
+      {
+        "command": {
+          "arguments": "hey",
+          "name": "build",
+        },
+      }
+    `);
+    });
+    test('username containing asterisk on its own line', () => {
+        expect(extractLeadingOpencodeCommand('» **A*B:**\n/build hi', fixtures)).toMatchInlineSnapshot(`
+      {
+        "command": {
+          "arguments": "hi",
+          "name": "build",
+        },
+      }
+    `);
+    });
+    test('Context from thread wrapping still detects command', () => {
+        const wrapped = 'Context from thread:\nsome starter text\n\nUser request:\n/build foo';
+        expect(extractLeadingOpencodeCommand(wrapped, fixtures))
+            .toMatchInlineSnapshot(`
+      {
+        "command": {
+          "arguments": "foo",
+          "name": "build",
+        },
+      }
+    `);
+    });
+    test('unknown command returns null', () => {
+        expect(extractLeadingOpencodeCommand('/nothing here', fixtures)).toMatchInlineSnapshot(`null`);
+    });
+    test('no leading slash on any line returns null', () => {
+        expect(extractLeadingOpencodeCommand('hello /build\nmore text', fixtures)).toMatchInlineSnapshot(`null`);
+    });
+    test('just slash returns null', () => {
+        expect(extractLeadingOpencodeCommand('/', fixtures)).toMatchInlineSnapshot(`null`);
+    });
+    test('empty string returns null', () => {
+        expect(extractLeadingOpencodeCommand('', fixtures)).toMatchInlineSnapshot(`null`);
+    });
+    test('empty registry returns null for tokens without Discord suffix', () => {
+        expect(extractLeadingOpencodeCommand('/build foo', [])).toMatchInlineSnapshot(`null`);
+    });
+    test('empty registry fallback: -cmd suffix strips and returns base name', () => {
+        expect(extractLeadingOpencodeCommand('/hello-test-cmd', [])).toMatchInlineSnapshot(`
+      {
+        "command": {
+          "arguments": "",
+          "name": "hello-test",
+        },
+      }
+    `);
+    });
+    test('empty registry fallback: -skill suffix with args', () => {
+        expect(extractLeadingOpencodeCommand('/review-skill check auth', [])).toMatchInlineSnapshot(`
+      {
+        "command": {
+          "arguments": "check auth",
+          "name": "review",
+        },
+      }
+    `);
+    });
+    test('empty registry fallback skips non-suffixed, matches suffixed on next line', () => {
+        expect(extractLeadingOpencodeCommand('/unknown\n/deploy-cmd now', [])).toMatchInlineSnapshot(`
+      {
+        "command": {
+          "arguments": "now",
+          "name": "deploy",
+        },
+      }
+    `);
+    });
+    test('leading whitespace before slash still matches', () => {
+        expect(extractLeadingOpencodeCommand('   /build foo', fixtures)).toMatchInlineSnapshot(`
+      {
+        "command": {
+          "arguments": "foo",
+          "name": "build",
+        },
+      }
+    `);
+    });
+    test('first matching line wins', () => {
+        const prompt = 'noise line\n/build first args\n/review second args';
+        expect(extractLeadingOpencodeCommand(prompt, fixtures))
+            .toMatchInlineSnapshot(`
+      {
+        "command": {
+          "arguments": "first args",
+          "name": "build",
+        },
+      }
+    `);
+    });
+    test('unknown command on one line, known on next', () => {
+        const prompt = '/unknown foo\n/build bar';
+        expect(extractLeadingOpencodeCommand(prompt, fixtures))
+            .toMatchInlineSnapshot(`
+      {
+        "command": {
+          "arguments": "bar",
+          "name": "build",
+        },
+      }
+    `);
+    });
+    test('suffix strip does not clobber a command whose name happens to end in -cmd', () => {
+        const custom = [
+            {
+                name: 'deploy-cmd',
+                discordCommandName: 'deploy-cmd-cmd',
+                description: '',
+                source: 'command',
+            },
+        ];
+        expect(extractLeadingOpencodeCommand('/deploy-cmd now', custom)).toMatchInlineSnapshot(`
+      {
+        "command": {
+          "arguments": "now",
+          "name": "deploy-cmd",
+        },
+      }
+    `);
+    });
+});

package/dist/opencode-command.js

@@ -0,0 +1,129 @@
+// Shared OpenCode and Kimaki command resolution helpers.
+// Normalizes `which`/`where` output across platforms, builds safe spawn
+// arguments for Windows npm `.cmd` shims without relying on `shell: true`,
+// and creates a stable `kimaki` shim for OpenCode child processes.
+import fs from 'node:fs';
+import path from 'node:path';
+const WINDOWS_CMD_SHIM_REGEX = /\.(cmd|bat)$/i;
+function quotePosixShellSegment(value) {
+    return `'${value.replaceAll("'", `'\\''`)}'`;
+}
+export function splitCommandLookupOutput(output) {
+    return output
+        .split(/\r?\n/g)
+        .map((line) => {
+        return line.trim();
+    })
+        .filter((line) => {
+        return line.length > 0;
+    });
+}
+export function selectResolvedCommand({ output, isWindows, }) {
+    const lines = splitCommandLookupOutput(output);
+    if (lines.length === 0) {
+        return null;
+    }
+    if (!isWindows) {
+        return lines[0] || null;
+    }
+    const cmdShim = lines.find((line) => {
+        return WINDOWS_CMD_SHIM_REGEX.test(line);
+    });
+    return cmdShim || lines[0] || null;
+}
+function quoteWindowsCommandSegment(value) {
+    if (!/[\s"]/u.test(value)) {
+        return value;
+    }
+    return `"${value.replaceAll('"', '\\"')}"`;
+}
+export function getSpawnCommandAndArgs({ resolvedCommand, baseArgs, platform, }) {
+    const effectivePlatform = platform || process.platform;
+    if (effectivePlatform !== 'win32') {
+        return { command: resolvedCommand, args: baseArgs };
+    }
+    if (!WINDOWS_CMD_SHIM_REGEX.test(resolvedCommand)) {
+        return { command: resolvedCommand, args: baseArgs };
+    }
+    return {
+        command: 'cmd.exe',
+        args: [
+            '/d',
+            '/s',
+            '/c',
+            quoteWindowsCommandSegment(resolvedCommand),
+            ...baseArgs.map((arg) => {
+                return quoteWindowsCommandSegment(arg);
+            }),
+        ],
+        // Let cmd.exe receive the command line exactly as constructed above.
+        // Without this, Node re-quotes the executable segment and npm shim paths
+        // like `C:\Program Files\nodejs\opencode.cmd` break again.
+        windowsVerbatimArguments: true,
+    };
+}
+export function ensureKimakiCommandShim({ dataDir, execPath, execArgv, entryScript, platform, }) {
+    const effectivePlatform = platform || process.platform;
+    const shimDirectory = path.join(dataDir, 'bin');
+    try {
+        fs.mkdirSync(shimDirectory, { recursive: true });
+        const launcherArgs = [...execArgv, entryScript];
+        if (effectivePlatform === 'win32') {
+            const shimPath = path.join(shimDirectory, 'kimaki.cmd');
+            const shimContent = [
+                '@echo off',
+                [execPath, ...launcherArgs].map((segment) => {
+                    return `"${segment.replaceAll('"', '""')}"`;
+                }).join(' ') + ' %*',
+                '',
+            ].join('\r\n');
+            writeShimIfNeeded({
+                shimPath,
+                shimContent,
+            });
+            return shimDirectory;
+        }
+        const shimPath = path.join(shimDirectory, 'kimaki');
+        const shimContent = [
+            '#!/bin/sh',
+            `exec ${[execPath, ...launcherArgs].map((segment) => {
+                return quotePosixShellSegment(segment);
+            }).join(' ')} "$@"`,
+            '',
+        ].join('\n');
+        writeShimIfNeeded({
+            shimPath,
+            shimContent,
+            mode: 0o755,
+        });
+        return shimDirectory;
+    }
+    catch (cause) {
+        return new Error('Failed to create kimaki command shim', { cause });
+    }
+}
+export function prependPathEntry({ entry, existingPath, }) {
+    const pathEntries = (existingPath || '').split(path.delimiter).filter((segment) => {
+        return segment.length > 0;
+    });
+    if (pathEntries.includes(entry)) {
+        return existingPath || entry;
+    }
+    return [entry, ...pathEntries].join(path.delimiter);
+}
+export function getPathEnvKey(env) {
+    return Object.keys(env).find((key) => {
+        return key.toLowerCase() === 'path';
+    }) || 'PATH';
+}
+function writeShimIfNeeded({ shimPath, shimContent, mode, }) {
+    const existingContent = fs.existsSync(shimPath)
+        ? fs.readFileSync(shimPath, 'utf8')
+        : null;
+    if (existingContent !== shimContent) {
+        fs.writeFileSync(shimPath, shimContent, 'utf8');
+    }
+    if (mode !== undefined) {
+        fs.chmodSync(shimPath, mode);
+    }
+}