@otto-assistant/bridge 0.4.92

package/src/startup-time.e2e.test.ts

@@ -0,0 +1,373 @@
+// Measures time-to-ready for the kimaki Discord bot startup.
+// Used as a baseline to track startup performance and guide optimizations
+// for scale-to-zero deployments where cold start time is critical.
+//
+// Measures each phase independently:
+//   1. Hrana server start (DB + lock port)
+//   2. Database init (Prisma connect via HTTP)
+//   3. Discord.js client creation + login (Gateway READY)
+//   4. startDiscordBot (event handlers + markDiscordGatewayReady)
+//   5. OpenCode server startup (spawn + health poll)
+//   6. Total wall-clock time from zero to "bot ready"
+//
+// Uses discord-digital-twin so Gateway READY is instant (no real Discord).
+// OpenCode startup uses deterministic provider (no real LLM).
+
+import fs from 'node:fs'
+import path from 'node:path'
+import url from 'node:url'
+import { describe, test, expect, afterAll } 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 { startDiscordBot } from './discord-bot.js'
+import {
+  setBotToken,
+  initDatabase,
+  closeDatabase,
+  setChannelDirectory,
+} from './database.js'
+import { startHranaServer, stopHranaServer } from './hrana-server.js'
+import { initializeOpencodeForDirectory, stopOpencodeServer } from './opencode.js'
+import { chooseLockPort, cleanupTestSessions, initTestGitRepo } from './test-utils.js'
+
+interface PhaseTimings {
+  hranaServerMs: number
+  databaseInitMs: number
+  discordLoginMs: number
+  startDiscordBotMs: number
+  opencodeServerMs: number
+  totalMs: number
+}
+
+function createRunDirectories() {
+  const root = path.resolve(process.cwd(), 'tmp', 'startup-time-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 })
+  initTestGitRepo(projectDirectory)
+
+  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',
+    },
+  })
+}
+
+function createMinimalMatchers(): DeterministicMatcher[] {
+  return [
+    {
+      id: 'startup-test-reply',
+      priority: 10,
+      when: {
+        lastMessageRole: 'user',
+        rawPromptIncludes: 'startup-test',
+      },
+      then: {
+        parts: [
+          { type: 'stream-start', warnings: [] },
+          { type: 'text-start', id: 'startup-reply' },
+          { type: 'text-delta', id: 'startup-reply', delta: 'ok' },
+          { type: 'text-end', id: 'startup-reply' },
+          {
+            type: 'finish',
+            finishReason: 'stop',
+            usage: { inputTokens: 1, outputTokens: 1, totalTokens: 2 },
+          },
+        ],
+      },
+    },
+  ]
+}
+
+const TEST_USER_ID = '900000000000000777'
+const TEXT_CHANNEL_ID = '900000000000000778'
+
+describe('startup time measurement', () => {
+  let directories: ReturnType<typeof createRunDirectories>
+  let discord: DigitalDiscord
+  let botClient: Client | null = null
+  const testStartTime = Date.now()
+
+  afterAll(async () => {
+    if (directories) {
+      await cleanupTestSessions({
+        projectDirectory: directories.projectDirectory,
+        testStartTime,
+      })
+    }
+
+    if (botClient) {
+      botClient.destroy()
+    }
+
+    await Promise.all([
+      stopOpencodeServer().catch(() => {}),
+      closeDatabase().catch(() => {}),
+      stopHranaServer().catch(() => {}),
+      discord?.stop().catch(() => {}),
+    ])
+
+    delete process.env['KIMAKI_LOCK_PORT']
+    delete process.env['KIMAKI_DB_URL']
+
+    if (directories) {
+      fs.rmSync(directories.dataDir, { recursive: true, force: true })
+    }
+  })
+
+  test('measures per-phase startup timings', async () => {
+    directories = createRunDirectories()
+    const lockPort = chooseLockPort({ key: 'startup-time-e2e' })
+
+    process.env['KIMAKI_LOCK_PORT'] = String(lockPort)
+    setDataDir(directories.dataDir)
+
+    const digitalDiscordDbPath = path.join(
+      directories.dataDir,
+      'digital-discord.db',
+    )
+
+    discord = new DigitalDiscord({
+      guild: {
+        name: 'Startup Time Guild',
+        ownerId: TEST_USER_ID,
+      },
+      channels: [
+        {
+          id: TEXT_CHANNEL_ID,
+          name: 'startup-time',
+          type: ChannelType.GuildText,
+        },
+      ],
+      users: [
+        {
+          id: TEST_USER_ID,
+          username: 'startup-tester',
+        },
+      ],
+      dbUrl: `file:${digitalDiscordDbPath}`,
+    })
+
+    await discord.start()
+
+    // Write deterministic opencode config
+    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: createMinimalMatchers(),
+      },
+    })
+    fs.writeFileSync(
+      path.join(directories.projectDirectory, 'opencode.json'),
+      JSON.stringify(opencodeConfig, null, 2),
+    )
+
+    // ── Phase timings ──
+    const totalStart = performance.now()
+
+    // Phase 1: Hrana server
+    const hranaStart = performance.now()
+    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
+    const hranaMs = performance.now() - hranaStart
+
+    // Phase 2: Database init
+    const dbStart = performance.now()
+    await initDatabase()
+    await setBotToken(discord.botUserId, discord.botToken)
+    await setChannelDirectory({
+      channelId: TEXT_CHANNEL_ID,
+      directory: directories.projectDirectory,
+      channelType: 'text',
+    })
+    const dbMs = performance.now() - dbStart
+
+    // Phase 3+4: Discord.js login + startDiscordBot
+    // In the real cli.ts flow, login happens first (line 2077), then
+    // startDiscordBot is called with the already-logged-in client (line 2130).
+    // startDiscordBot calls login() again internally (line 1069) which is
+    // a no-op on already-connected clients. We measure them together since
+    // that's the real critical path.
+    const loginStart = performance.now()
+    botClient = createDiscordJsClient({ restUrl: discord.restUrl })
+    // Don't pre-login — let startDiscordBot handle login internally.
+    // This avoids the double-login overhead that inflates measurements.
+    const loginMs = Math.round(performance.now() - loginStart)
+
+    const botStart = performance.now()
+    await startDiscordBot({
+      token: discord.botToken,
+      appId: discord.botUserId,
+      discordClient: botClient,
+    })
+    const botMs = performance.now() - botStart
+
+    // Phase 5: OpenCode server startup (biggest bottleneck)
+    const opencodeStart = performance.now()
+    const opencodeResult = await initializeOpencodeForDirectory(
+      directories.projectDirectory,
+    )
+    if (opencodeResult instanceof Error) {
+      throw opencodeResult
+    }
+    const opencodeMs = performance.now() - opencodeStart
+
+    const totalMs = performance.now() - totalStart
+
+    const timings: PhaseTimings = {
+      hranaServerMs: Math.round(hranaMs),
+      databaseInitMs: Math.round(dbMs),
+      discordLoginMs: Math.round(loginMs),
+      startDiscordBotMs: Math.round(botMs),
+      opencodeServerMs: Math.round(opencodeMs),
+      totalMs: Math.round(totalMs),
+    }
+
+    // Print timings for CI/local visibility
+    console.log('\n┌─────────────────────────────────────────────┐')
+    console.log('│         Kimaki Startup Time Breakdown       │')
+    console.log('├─────────────────────────────────────────────┤')
+    console.log(`│  Hrana server:       ${String(timings.hranaServerMs).padStart(6)} ms             │`)
+    console.log(`│  Database init:      ${String(timings.databaseInitMs).padStart(6)} ms             │`)
+    console.log(`│  Discord.js login:   ${String(timings.discordLoginMs).padStart(6)} ms             │`)
+    console.log(`│  startDiscordBot:    ${String(timings.startDiscordBotMs).padStart(6)} ms             │`)
+    console.log(`│  OpenCode server:    ${String(timings.opencodeServerMs).padStart(6)} ms             │`)
+    console.log('├─────────────────────────────────────────────┤')
+    console.log(`│  TOTAL:              ${String(timings.totalMs).padStart(6)} ms             │`)
+    console.log('└─────────────────────────────────────────────┘\n')
+
+    // Sanity assertions — these are baselines, not targets yet.
+    // Each phase should complete (no infinite hang).
+    expect(timings.hranaServerMs).toBeLessThan(5_000)
+    expect(timings.databaseInitMs).toBeLessThan(5_000)
+    expect(timings.discordLoginMs).toBeLessThan(10_000)
+    expect(timings.startDiscordBotMs).toBeLessThan(5_000)
+    expect(timings.opencodeServerMs).toBeLessThan(30_000)
+    expect(timings.totalMs).toBeLessThan(60_000)
+
+    // Verify the bot is actually functional by sending a message
+    // and getting a response (validates the full pipeline works)
+    await discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
+      content: 'startup-test ping',
+    })
+
+    const thread = await discord.channel(TEXT_CHANNEL_ID).waitForThread({
+      timeout: 10_000,
+    })
+
+    const reply = await discord.thread(thread.id).waitForBotReply({
+      timeout: 30_000,
+    })
+
+    expect(reply.content.length).toBeGreaterThan(0)
+    expect(thread.id.length).toBeGreaterThan(0)
+  }, 120_000)
+
+  test('measures parallel startup (discord + opencode simultaneously)', async () => {
+    // This test reuses the infrastructure from test 1 (hrana, db already up)
+    // to measure what happens when we run Discord login + OpenCode in parallel.
+    // In a fresh cold start, hrana+db init would add ~50ms on top.
+
+    // Stop opencode server from test 1 so we get a fresh measurement
+    await stopOpencodeServer().catch(() => {})
+
+    // Destroy and recreate bot client for a clean login measurement
+    if (botClient) {
+      botClient.destroy()
+      botClient = null
+    }
+
+    // ── Parallel phase: Discord login + OpenCode server simultaneously ──
+    const parallelStart = performance.now()
+
+    const [discordResult, opencodeResult] = await Promise.all([
+      // Discord path: create client, login, start bot
+      (async () => {
+        const loginStart = performance.now()
+        const client = createDiscordJsClient({ restUrl: discord.restUrl })
+        await startDiscordBot({
+          token: discord.botToken,
+          appId: discord.botUserId,
+          discordClient: client,
+        })
+        return {
+          client,
+          totalMs: Math.round(performance.now() - loginStart),
+        }
+      })(),
+      // OpenCode path: spawn server + wait for health
+      (async () => {
+        const start = performance.now()
+        const result = await initializeOpencodeForDirectory(
+          directories.projectDirectory,
+        )
+        if (result instanceof Error) {
+          throw result
+        }
+        return { ms: Math.round(performance.now() - start) }
+      })(),
+    ])
+
+    const parallelMs = Math.round(performance.now() - parallelStart)
+    botClient = discordResult.client
+
+    console.log('\n┌─────────────────────────────────────────────┐')
+    console.log('│      Parallel Startup Time Breakdown        │')
+    console.log('├─────────────────────────────────────────────┤')
+    console.log(`│  Discord login+bot:  ${String(discordResult.totalMs).padStart(6)} ms             │`)
+    console.log(`│  OpenCode server:    ${String(opencodeResult.ms).padStart(6)} ms             │`)
+    console.log('├─────────────────────────────────────────────┤')
+    console.log(`│  PARALLEL TOTAL:     ${String(parallelMs).padStart(6)} ms             │`)
+    console.log(`│  (vs sequential:     ${String(discordResult.totalMs + opencodeResult.ms).padStart(6)} ms)            │`)
+    console.log('└─────────────────────────────────────────────┘\n')
+
+    // Parallel total should be dominated by the slower path,
+    // not the sum of both.
+    const maxSingle = Math.max(discordResult.totalMs, opencodeResult.ms)
+    expect(parallelMs).toBeLessThan(maxSingle + 500)
+  }, 120_000)
+})

package/src/store.ts

@@ -0,0 +1,122 @@
+// Centralized zustand/vanilla store for global bot state.
+// Replaces scattered module-level `let` variables, process.env mutations,
+// and mutable arrays with a single immutable state atom.
+// See cli/skills/zustand-centralized-state/SKILL.md for the pattern.
+
+import { createStore } from 'zustand/vanilla'
+import type { VerbosityLevel } from './generated/client.js'
+import type { ThreadRunState } from './session-handler/thread-runtime-state.js'
+
+// Registered user commands, populated by registerCommands() in cli.ts.
+// discordCommandName is the full sanitized Discord slash command name
+// (including -cmd or -skill suffix), while name is the original OpenCode
+// command name (may contain :, /, etc).
+export type RegisteredUserCommand = {
+  name: string
+  discordCommandName: string
+  description: string
+  source?: 'command' | 'mcp' | 'skill'
+}
+
+// Deterministic transcription config for e2e tests.
+// When set, processVoiceAttachment() skips the real AI model call and
+// returns this canned result after sleeping for delayMs. This lets tests
+// control transcription output, timing, and queue behavior deterministically.
+export type DeterministicTranscriptionConfig = {
+  transcription: string
+  queueMessage: boolean
+  /** Agent name extracted from voice message. Only set if user explicitly requested an agent. */
+  agent?: string
+  /** Artificial delay before returning the result (ms). Default 0. */
+  delayMs?: number
+}
+
+export type KimakiState = {
+  // ── Config state (set once at CLI startup, read everywhere) ──────────
+
+  // Path to the kimaki data directory (default ~/.kimaki).
+  // Changes: set once at startup by setDataDir() or auto-created on first
+  // getDataDir() call. Under vitest, auto-creates a temp dir.
+  // Read by: database paths, heap snapshot dir, log file path, hrana server.
+  dataDir: string | null
+
+  // Custom projects directory override (default: <dataDir>/projects).
+  // When set via --projects-dir CLI flag, project create commands will
+  // create new project folders here instead of ~/.kimaki/projects/.
+  // Changes: set once at startup from --projects-dir CLI flag.
+  // Read by: config.ts getProjectsDir().
+  projectsDir: string | null
+
+  // Default output verbosity for sessions when no channel-level override
+  // exists in the DB. Controls which tool outputs are shown in Discord.
+  // Changes: set once at startup from --verbosity CLI flag.
+  // Read by: database.ts (fallback in getChannelVerbosity), message formatting.
+  defaultVerbosity: VerbosityLevel
+
+  // When true, the bot only responds to messages that @mention it in text
+  // channels (threads are unaffected). Fallback when no channel override in DB.
+  // Changes: set once at startup from --mention-mode CLI flag.
+  // Read by: database.ts (fallback in getChannelMentionMode), discord-bot.ts guard.
+  defaultMentionMode: boolean
+
+  // Whether critique.work diff URL generation is enabled. When false,
+  // the system message omits critique instructions from the AI context.
+  // Changes: set once at startup from --no-critique CLI flag.
+  // Read by: system-message.ts (conditionally appends critique instructions).
+  critiqueEnabled: boolean
+
+  // Base URL for Discord REST API calls (default https://discord.com).
+  // Overridden when using a gateway-proxy or gateway Discord mode.
+  // Changes: set by getBotTokenWithMode() which runs at startup and on
+  // multiple runtime paths (CLI init, opencode spawn). May be updated
+  // whenever bot credentials are re-read from the DB.
+  // Read by: discord-urls.ts (getDiscordRestApiUrl), REST client construction.
+  discordBaseUrl: string
+
+  // Service auth token (client_id:client_secret) used to authenticate
+  // control-plane requests like /kimaki/wake. Always set at startup in all
+  // modes so localhost and internet paths share one auth model.
+  // Changes: set in cli.ts after credential resolution and persisted in sqlite.
+  // Read by: hrana-server.ts to validate Authorization bearer token.
+  gatewayToken: string | null
+
+  // User-defined slash commands registered with Discord, populated after
+  // registerCommands() completes during startup. Maps sanitized Discord
+  // command names back to original OpenCode command names.
+  // Changes: set once during startup after Discord API registration.
+  // Read by: /queue-command autocomplete, user-command handler dispatch.
+  registeredUserCommands: RegisteredUserCommand[]
+
+  // ── Per-thread runtime state ────────────────────────────────────────
+  // The main mutable state at runtime. One ThreadRunState per active thread.
+  // All mutations are immutable: each updateThread() creates a new Map + new
+  // ThreadRunState object via store.setState(). See thread-runtime-state.ts.
+  // Changes: on every message enqueue, prompt dispatch, phase transition,
+  // abort, and finish.
+  // Read by: runtime state helpers (isRunActive, canDispatchNext), session
+  // orchestration in ThreadSessionRuntime, /abort and /queue via runtime APIs.
+  threads: Map<string, ThreadRunState>
+
+  // ── Test-only state ─────────────────────────────────────────────────
+  test: {
+    // When set, processVoiceAttachment() skips the real AI transcription
+    // call and returns this canned result after sleeping delayMs.
+    // Lets e2e tests control transcription output and timing.
+    // Changes: set/cleared by e2e test setup/teardown only.
+    // Read by: voice-handler.ts processVoiceAttachment().
+    deterministicTranscription: DeterministicTranscriptionConfig | null
+  }
+}
+
+export const store = createStore<KimakiState>(() => ({
+  dataDir: null,
+  projectsDir: null,
+  defaultVerbosity: 'text_and_essential_tools',
+  defaultMentionMode: false,
+  critiqueEnabled: true,
+  discordBaseUrl: 'https://discord.com',
+  gatewayToken: null,
+  registeredUserCommands: [],
+  threads: new Map(),
+  test: { deterministicTranscription: null },
+}))