@otto-assistant/bridge 0.4.92

package/src/wait-session.ts

@@ -0,0 +1,147 @@
+// 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,
+}: {
+  threadId: string
+  timeoutMs?: number
+}): Promise<string> {
+  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,
+}: {
+  projectDirectory: string
+  sessionId: string
+  timeoutMs?: number
+}): Promise<void> {
+  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,
+}: {
+  threadId: string
+  projectDirectory: string
+  sessionIdTimeoutMs?: number
+  completionTimeoutMs?: number
+}): Promise<void> {
+  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/src/websockify.ts

@@ -0,0 +1,101 @@
+// 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')
+
+type WebsockifyOptions = {
+  /** Port for the WebSocket server (0 = auto-assign) */
+  wsPort: number
+  /** TCP target host */
+  tcpHost: string
+  /** TCP target port */
+  tcpPort: number
+}
+
+type WebsockifyInstance = {
+  wss: WebSocketServer
+  /** Resolved port (useful when wsPort=0) */
+  port: number
+  close: () => void
+}
+
+export function startWebsockify({
+  wsPort,
+  tcpHost,
+  tcpPort,
+}: WebsockifyOptions): Promise<WebsockifyInstance> {
+  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: Buffer) => {
+        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/src/worker-types.ts

@@ -0,0 +1,64 @@
+// 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.
+
+// Messages sent from main thread to worker
+export type WorkerInMessage =
+  | {
+      type: 'init'
+      directory: string // Project directory for tools
+      systemMessage?: string
+      guildId: string
+      channelId: string
+      appId: string
+      geminiApiKey?: string | null
+    }
+  | {
+      type: 'sendRealtimeInput'
+      audio?: {
+        mimeType: string
+        data: string // base64
+      }
+      audioStreamEnd?: boolean
+    }
+  | {
+      type: 'sendTextInput'
+      text: string
+    }
+  | {
+      type: 'interrupt'
+    }
+  | {
+      type: 'stop'
+    }
+
+// Messages sent from worker to main thread via parentPort
+export type WorkerOutMessage =
+  | {
+      type: 'assistantOpusPacket'
+      packet: ArrayBuffer // Opus encoded audio packet
+    }
+  | {
+      type: 'assistantStartSpeaking'
+    }
+  | {
+      type: 'assistantStopSpeaking'
+    }
+  | {
+      type: 'assistantInterruptSpeaking'
+    }
+  | {
+      type: 'toolCallCompleted'
+      sessionId: string
+      messageId: string
+      data?: unknown
+      error?: unknown
+      markdown?: string
+    }
+  | {
+      type: 'error'
+      error: string
+    }
+  | {
+      type: 'ready'
+    }

package/src/worktree-lifecycle.e2e.test.ts

@@ -0,0 +1,391 @@
+// 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,
+  type DeterministicMatcher,
+} 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,
+  type VerbosityLevel,
+} 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 }: { restUrl: string }) {
+  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: string): Promise<void> {
+  // 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(): DeterministicMatcher[] {
+  const userReplyMatcher: DeterministicMatcher = {
+    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: ReturnType<typeof createRunDirectories>
+  let discord: DigitalDiscord
+  let botClient: Client
+  let previousDefaultVerbosity: VerbosityLevel | null = 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/src/worktree-utils.ts

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