@otto-assistant/bridge 0.4.92

package/dist/wait-session.js

@@ -0,0 +1,94 @@
+// Wait utilities for polling session completion.
+// Used by `kimaki send --wait` to block until a session finishes,
+// then output the session markdown to stdout.
+import { getThreadSession } from './database.js';
+import { initializeOpencodeForDirectory } from './opencode.js';
+import { ShareMarkdown } from './markdown.js';
+import { createLogger, LogPrefix } from './logger.js';
+const waitLogger = createLogger(LogPrefix.SESSION);
+/**
+ * Poll the kimaki database until a session ID appears for the given thread.
+ * The bot writes this mapping in session-handler.ts:551 when it picks up
+ * the thread and creates/reuses a session.
+ */
+export async function waitForSessionId({ threadId, timeoutMs = 120_000, }) {
+    const startTime = Date.now();
+    const pollIntervalMs = 2_000;
+    while (Date.now() - startTime < timeoutMs) {
+        const sessionId = await getThreadSession(threadId);
+        if (sessionId) {
+            waitLogger.log(`Session ID resolved: ${sessionId}`);
+            return sessionId;
+        }
+        await new Promise((resolve) => {
+            setTimeout(resolve, pollIntervalMs);
+        });
+    }
+    throw new Error(`Timed out waiting for session ID (thread: ${threadId}, timeout: ${timeoutMs}ms)`);
+}
+/**
+ * Poll the OpenCode SDK until the session's last assistant message
+ * has `time.completed` set, meaning the model finished responding.
+ */
+export async function waitForSessionComplete({ projectDirectory, sessionId, timeoutMs = 30 * 60 * 1000, }) {
+    const pollIntervalMs = 3_000;
+    const startTime = Date.now();
+    const getClient = await initializeOpencodeForDirectory(projectDirectory);
+    if (getClient instanceof Error) {
+        throw new Error(`Failed to connect to OpenCode server: ${getClient.message}`, {
+            cause: getClient,
+        });
+    }
+    while (Date.now() - startTime < timeoutMs) {
+        const messagesResponse = await getClient().session.messages({
+            sessionID: sessionId,
+        });
+        const messages = messagesResponse.data || [];
+        // Find the last assistant message
+        const lastAssistant = [...messages]
+            .reverse()
+            .find((m) => m.info.role === 'assistant');
+        if (lastAssistant &&
+            lastAssistant.info.role === 'assistant' &&
+            lastAssistant.info.time.completed) {
+            waitLogger.log(`Session ${sessionId} completed`);
+            return;
+        }
+        await new Promise((resolve) => {
+            setTimeout(resolve, pollIntervalMs);
+        });
+    }
+    throw new Error(`Timed out waiting for session completion (session: ${sessionId}, timeout: ${timeoutMs}ms)`);
+}
+/**
+ * Wait for session completion and output the session markdown to stdout.
+ * Orchestrates the full wait flow: session ID resolution -> completion -> output.
+ */
+export async function waitAndOutputSession({ threadId, projectDirectory, sessionIdTimeoutMs, completionTimeoutMs, }) {
+    waitLogger.log('Waiting for session ID...');
+    const sessionId = await waitForSessionId({
+        threadId,
+        timeoutMs: sessionIdTimeoutMs,
+    });
+    waitLogger.log(`Waiting for session ${sessionId} to complete...`);
+    await waitForSessionComplete({
+        projectDirectory,
+        sessionId,
+        timeoutMs: completionTimeoutMs,
+    });
+    waitLogger.log('Generating session output...');
+    const getClient = await initializeOpencodeForDirectory(projectDirectory);
+    if (getClient instanceof Error) {
+        throw new Error(`Failed to connect to OpenCode server: ${getClient.message}`, {
+            cause: getClient,
+        });
+    }
+    const markdown = new ShareMarkdown(getClient());
+    const result = await markdown.generate({ sessionID: sessionId });
+    if (result instanceof Error) {
+        throw new Error(`Failed to generate session markdown: ${result.message}`, {
+            cause: result,
+        });
+    }
+    process.stdout.write(result);
+}

package/dist/websockify.js

@@ -0,0 +1,69 @@
+// In-process WebSocket-to-TCP bridge (websockify replacement).
+// Accepts WebSocket connections and pipes raw bytes to/from a TCP target.
+// Used by /screenshare to bridge noVNC (WebSocket) to a VNC server (TCP).
+// Supports the 'binary' subprotocol required by noVNC.
+import { WebSocketServer, WebSocket } from 'ws';
+import net from 'node:net';
+import { createLogger } from './logger.js';
+const logger = createLogger('SCREEN');
+export function startWebsockify({ wsPort, tcpHost, tcpPort, }) {
+    return new Promise((resolve, reject) => {
+        const wss = new WebSocketServer({
+            port: wsPort,
+            // noVNC negotiates the 'binary' subprotocol
+            handleProtocols: (protocols) => {
+                if (protocols.has('binary')) {
+                    return 'binary';
+                }
+                return false;
+            },
+        });
+        wss.on('listening', () => {
+            const addr = wss.address();
+            const port = typeof addr === 'object' && addr ? addr.port : wsPort;
+            logger.log(`Websockify listening on port ${port} → ${tcpHost}:${tcpPort}`);
+            resolve({
+                wss,
+                port,
+                close: () => {
+                    for (const client of wss.clients) {
+                        client.close();
+                    }
+                    wss.close();
+                },
+            });
+        });
+        wss.on('error', (err) => {
+            reject(new Error('Websockify failed to start', { cause: err }));
+        });
+        wss.on('connection', (ws) => {
+            const tcp = net.createConnection(tcpPort, tcpHost, () => {
+                logger.log(`TCP connection established to ${tcpHost}:${tcpPort}`);
+            });
+            tcp.on('data', (data) => {
+                if (ws.readyState === WebSocket.OPEN) {
+                    ws.send(data);
+                }
+            });
+            ws.on('message', (data) => {
+                if (!tcp.destroyed) {
+                    tcp.write(data);
+                }
+            });
+            ws.on('close', () => {
+                tcp.destroy();
+            });
+            ws.on('error', (err) => {
+                logger.error('WebSocket error:', err);
+                tcp.destroy();
+            });
+            tcp.on('close', () => {
+                ws.close();
+            });
+            tcp.on('error', (err) => {
+                logger.error('TCP connection error:', err);
+                ws.close();
+            });
+        });
+    });
+}

package/dist/worker-types.js

@@ -0,0 +1,4 @@
+// Type definitions for worker thread message passing.
+// Defines the protocol between main thread and GenAI worker for
+// audio streaming, tool calls, and session lifecycle management.
+export {};

package/dist/worktree-lifecycle.e2e.test.js

@@ -0,0 +1,308 @@
+// E2e test for worktree lifecycle: /new-worktree inside an existing thread,
+// then verify the session still works after sdkDirectory switches.
+// Validates that handleDirectoryChanged() reconnects the event listener
+// so events from the worktree Instance reach the runtime (PR #75 fix).
+//
+// Uses opencode-deterministic-provider (no real LLM calls).
+// Poll timeouts: 4s max, 100ms interval (except worktree creation which
+// involves real git operations — 10s timeout there).
+import fs from 'node:fs';
+import path from 'node:path';
+import url from 'node:url';
+import { describe, beforeAll, afterAll, test, expect } from 'vitest';
+import { ChannelType, Client, GatewayIntentBits, Partials } from 'discord.js';
+import { DigitalDiscord } from 'discord-digital-twin/src';
+import { buildDeterministicOpencodeConfig, } from 'opencode-deterministic-provider';
+import { setDataDir } from './config.js';
+import { store } from './store.js';
+import { startDiscordBot } from './discord-bot.js';
+import { getRuntime } from './session-handler/thread-session-runtime.js';
+import { setBotToken, initDatabase, closeDatabase, setChannelDirectory, setChannelVerbosity, } from './database.js';
+import { startHranaServer, stopHranaServer } from './hrana-server.js';
+import { initializeOpencodeForDirectory, stopOpencodeServer, } from './opencode.js';
+import { chooseLockPort, cleanupTestSessions, waitForBotMessageContaining, waitForBotReplyAfterUserMessage, } from './test-utils.js';
+import { execAsync } from './worktrees.js';
+const TEST_USER_ID = '200000000000000901';
+const TEXT_CHANNEL_ID = '200000000000000902';
+// Unique worktree name per run to avoid collisions with leftover worktrees
+const WORKTREE_SUFFIX = Date.now().toString(36).slice(-6);
+const WORKTREE_NAME = `wt-e2e-${WORKTREE_SUFFIX}`;
+function createRunDirectories() {
+    const root = path.resolve(process.cwd(), 'tmp', 'worktree-lifecycle-e2e');
+    fs.mkdirSync(root, { recursive: true });
+    const dataDir = fs.mkdtempSync(path.join(root, 'data-'));
+    const projectDirectory = path.join(root, 'project');
+    fs.mkdirSync(projectDirectory, { recursive: true });
+    return { root, dataDir, projectDirectory };
+}
+function createDiscordJsClient({ restUrl }) {
+    return new Client({
+        intents: [
+            GatewayIntentBits.Guilds,
+            GatewayIntentBits.GuildMessages,
+            GatewayIntentBits.MessageContent,
+            GatewayIntentBits.GuildVoiceStates,
+        ],
+        partials: [
+            Partials.Channel,
+            Partials.Message,
+            Partials.User,
+            Partials.ThreadMember,
+        ],
+        rest: {
+            api: restUrl,
+            version: '10',
+        },
+    });
+}
+/** Initialize a git repo with an initial commit so worktrees can be created. */
+async function initGitRepo(directory) {
+    // Check if already a git repo (directory may persist across runs)
+    const isRepo = fs.existsSync(path.join(directory, '.git'));
+    if (isRepo) {
+        // Commit any new/changed files (opencode.json may have been rewritten)
+        await execAsync('git add -A && git diff --cached --quiet || git commit -m "update"', {
+            cwd: directory,
+        }).catch(() => { return; });
+        return;
+    }
+    await execAsync('git init -b main', { cwd: directory });
+    await execAsync('git config user.email "test@test.com"', { cwd: directory });
+    await execAsync('git config user.name "Test"', { cwd: directory });
+    await execAsync('git add -A && git commit -m "initial"', { cwd: directory });
+}
+function createDeterministicMatchers() {
+    const userReplyMatcher = {
+        id: 'user-reply',
+        priority: 10,
+        when: {
+            lastMessageRole: 'user',
+            rawPromptIncludes: 'Reply with exactly:',
+        },
+        then: {
+            parts: [
+                { type: 'stream-start', warnings: [] },
+                { type: 'text-start', id: 'default-reply' },
+                { type: 'text-delta', id: 'default-reply', delta: 'ok' },
+                { type: 'text-end', id: 'default-reply' },
+                {
+                    type: 'finish',
+                    finishReason: 'stop',
+                    usage: { inputTokens: 1, outputTokens: 1, totalTokens: 2 },
+                },
+            ],
+            partDelaysMs: [0, 100, 0, 0, 0],
+        },
+    };
+    return [userReplyMatcher];
+}
+describe('worktree lifecycle', () => {
+    let directories;
+    let discord;
+    let botClient;
+    let previousDefaultVerbosity = null;
+    let testStartTime = Date.now();
+    beforeAll(async () => {
+        testStartTime = Date.now();
+        directories = createRunDirectories();
+        const lockPort = chooseLockPort({ key: TEXT_CHANNEL_ID });
+        process.env['KIMAKI_LOCK_PORT'] = String(lockPort);
+        setDataDir(directories.dataDir);
+        previousDefaultVerbosity = store.getState().defaultVerbosity;
+        store.setState({ defaultVerbosity: 'tools_and_text' });
+        const digitalDiscordDbPath = path.join(directories.dataDir, 'digital-discord.db');
+        discord = new DigitalDiscord({
+            guild: {
+                name: 'Worktree E2E Guild',
+                ownerId: TEST_USER_ID,
+            },
+            channels: [
+                {
+                    id: TEXT_CHANNEL_ID,
+                    name: 'worktree-e2e',
+                    type: ChannelType.GuildText,
+                },
+            ],
+            users: [
+                {
+                    id: TEST_USER_ID,
+                    username: 'worktree-tester',
+                },
+            ],
+            dbUrl: `file:${digitalDiscordDbPath}`,
+        });
+        await discord.start();
+        const providerNpm = url
+            .pathToFileURL(path.resolve(process.cwd(), '..', 'opencode-deterministic-provider', 'src', 'index.ts'))
+            .toString();
+        const opencodeConfig = buildDeterministicOpencodeConfig({
+            providerName: 'deterministic-provider',
+            providerNpm,
+            model: 'deterministic-v2',
+            smallModel: 'deterministic-v2',
+            settings: {
+                strict: false,
+                matchers: createDeterministicMatchers(),
+            },
+        });
+        fs.writeFileSync(path.join(directories.projectDirectory, 'opencode.json'), JSON.stringify(opencodeConfig, null, 2));
+        // Initialize git repo after writing opencode.json so the initial commit
+        // includes it. Worktrees require at least one commit.
+        await initGitRepo(directories.projectDirectory);
+        const dbPath = path.join(directories.dataDir, 'discord-sessions.db');
+        const hranaResult = await startHranaServer({ dbPath });
+        if (hranaResult instanceof Error) {
+            throw hranaResult;
+        }
+        process.env['KIMAKI_DB_URL'] = hranaResult;
+        await initDatabase();
+        await setBotToken(discord.botUserId, discord.botToken);
+        await setChannelDirectory({
+            channelId: TEXT_CHANNEL_ID,
+            directory: directories.projectDirectory,
+            channelType: 'text',
+        });
+        await setChannelVerbosity(TEXT_CHANNEL_ID, 'tools_and_text');
+        botClient = createDiscordJsClient({ restUrl: discord.restUrl });
+        await startDiscordBot({
+            token: discord.botToken,
+            appId: discord.botUserId,
+            discordClient: botClient,
+        });
+        // Pre-warm the opencode server
+        const warmup = await initializeOpencodeForDirectory(directories.projectDirectory);
+        if (warmup instanceof Error) {
+            throw warmup;
+        }
+    }, 60_000);
+    afterAll(async () => {
+        if (directories) {
+            await cleanupTestSessions({
+                projectDirectory: directories.projectDirectory,
+                testStartTime,
+            });
+        }
+        if (botClient) {
+            botClient.destroy();
+        }
+        await stopOpencodeServer();
+        await Promise.all([
+            closeDatabase().catch(() => { return; }),
+            stopHranaServer().catch(() => { return; }),
+            discord?.stop().catch(() => { return; }),
+        ]);
+        delete process.env['KIMAKI_LOCK_PORT'];
+        delete process.env['KIMAKI_DB_URL'];
+        if (previousDefaultVerbosity) {
+            store.setState({ defaultVerbosity: previousDefaultVerbosity });
+        }
+        // Clean up the git worktree created during the test
+        if (directories) {
+            const worktreeBranch = `opencode/kimaki-${WORKTREE_NAME}`;
+            await execAsync(`git worktree list --porcelain`, { cwd: directories.projectDirectory }).then(({ stdout }) => {
+                // Find and remove any worktree for our test branch
+                const lines = stdout.split('\n');
+                let currentPath = '';
+                for (const line of lines) {
+                    if (line.startsWith('worktree ')) {
+                        currentPath = line.slice('worktree '.length);
+                    }
+                    if (line.startsWith('branch ') && line.includes(worktreeBranch) && currentPath) {
+                        return execAsync(`git worktree remove --force ${JSON.stringify(currentPath)}`, { cwd: directories.projectDirectory });
+                    }
+                }
+            }).catch(() => { return; });
+            await execAsync(`git branch -D ${JSON.stringify(`opencode/kimaki-${WORKTREE_NAME}`)}`, { cwd: directories.projectDirectory }).catch(() => { return; });
+            fs.rmSync(directories.dataDir, { recursive: true, force: true });
+        }
+    }, 10_000);
+    test('session responds after /new-worktree switches sdkDirectory in existing thread', async () => {
+        // 1. Send a message to create a thread and establish a session
+        await discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
+            content: 'Reply with exactly: before-worktree',
+        });
+        const thread = await discord.channel(TEXT_CHANNEL_ID).waitForThread({
+            timeout: 4_000,
+            predicate: (t) => {
+                return t.name === 'Reply with exactly: before-worktree';
+            },
+        });
+        const th = discord.thread(thread.id);
+        // Wait for first run to fully complete (footer appears)
+        await waitForBotMessageContaining({
+            discord,
+            threadId: thread.id,
+            userId: TEST_USER_ID,
+            text: '*project',
+            timeout: 4_000,
+        });
+        // Capture runtime — should survive the directory switch
+        const runtimeBefore = getRuntime(thread.id);
+        expect(runtimeBefore).toBeDefined();
+        expect(runtimeBefore.sdkDirectory).toBe(directories.projectDirectory);
+        // 2. Run /new-worktree inside the thread (in-thread flow).
+        // This creates a pending worktree, then background creates the git worktree,
+        // then marks it ready. Next message will pick up the worktree directory.
+        const { id: interactionId } = await th
+            .user(TEST_USER_ID)
+            .runSlashCommand({
+            name: 'new-worktree',
+            options: [{ name: 'name', type: 3, value: WORKTREE_NAME }],
+        });
+        // Wait for the slash command ack
+        await discord
+            .channel(thread.id)
+            .waitForInteractionAck({ interactionId, timeout: 4_000 });
+        // 3. Wait for worktree to become ready — the background creation
+        // edits the starter message to include the branch name.
+        // Git worktree creation involves real git operations, so allow more time.
+        await waitForBotMessageContaining({
+            discord,
+            threadId: thread.id,
+            userId: TEST_USER_ID,
+            text: 'Branch:',
+            timeout: 10_000,
+        });
+        // 4. Send a message after the worktree is ready.
+        // Without handleDirectoryChanged (PR #75), the event listener is still
+        // subscribed to the old project directory's Instance, so this message
+        // gets processed but the response events never reach the runtime.
+        await th.user(TEST_USER_ID).sendMessage({
+            content: 'Reply with exactly: after-worktree',
+        });
+        // 5. Verify the bot actually responds — this is the core assertion.
+        // If the listener wasn't reconnected, this will time out.
+        await waitForBotReplyAfterUserMessage({
+            discord,
+            threadId: thread.id,
+            userId: TEST_USER_ID,
+            userMessageIncludes: 'after-worktree',
+            timeout: 4_000,
+        });
+        // Wait for the footer to confirm full completion
+        await waitForBotMessageContaining({
+            discord,
+            threadId: thread.id,
+            userId: TEST_USER_ID,
+            text: 'deterministic-v2',
+            afterUserMessageIncludes: 'after-worktree',
+            timeout: 4_000,
+        });
+        // Runtime instance should be the same (not recreated)
+        const runtimeAfter = getRuntime(thread.id);
+        expect(runtimeAfter).toBe(runtimeBefore);
+        // sdkDirectory should now point to the worktree path
+        expect(runtimeAfter.sdkDirectory).not.toBe(directories.projectDirectory);
+        expect(runtimeAfter.sdkDirectory).toContain(`kimaki-${WORKTREE_NAME}`);
+        // Snapshot uses dynamic worktree name so we verify structure, not exact text
+        const text = await th.text();
+        expect(text).toContain('Reply with exactly: before-worktree');
+        expect(text).toContain('⬥ ok');
+        expect(text).toContain('Worktree:');
+        expect(text).toContain('Branch:');
+        expect(text).toContain('Reply with exactly: after-worktree');
+        // The second "⬥ ok" proves the bot responded after the worktree switch
+        const okCount = (text.match(/⬥ ok/g) || []).length;
+        expect(okCount).toBe(2);
+    }, 30_000);
+});

package/dist/worktree-utils.js

@@ -0,0 +1,3 @@
+// Backward-compatible re-export for worktree helpers.
+// New code should import from worktrees.ts.
+export * from './worktrees.js';