@otto-assistant/bridge 0.4.92

package/src/db.test.ts

@@ -0,0 +1,162 @@
+// Tests for Prisma client initialization and schema migration.
+// Auto-isolated via VITEST guards in config.ts (temp data dir) and db.ts (clears KIMAKI_DB_URL).
+
+import { afterAll, describe, expect, test } from 'vitest'
+import { getPrisma, closePrisma } from './db.js'
+import {
+  appendSessionEventsSinceLastTimestamp,
+  createPendingWorktree,
+  getSessionEventSnapshot,
+} from './database.js'
+
+afterAll(async () => {
+  await closePrisma()
+})
+
+describe('getPrisma', () => {
+  test('creates sqlite file and migrates schema automatically', async () => {
+    const prisma = await getPrisma()
+
+    const session = await prisma.thread_sessions.create({
+      data: { thread_id: 'test-thread-123', session_id: 'test-session-456' },
+    })
+    expect(session.thread_id).toBe('test-thread-123')
+    expect(session.created_at).toBeInstanceOf(Date)
+
+    const found = await prisma.thread_sessions.findUnique({
+      where: { thread_id: session.thread_id },
+    })
+    expect(found?.session_id).toBe('test-session-456')
+
+    // Cleanup test data
+    await prisma.thread_sessions.delete({
+      where: { thread_id: 'test-thread-123' },
+    })
+  })
+
+  test('createPendingWorktree creates parent and child rows', async () => {
+    const prisma = await getPrisma()
+    const threadId = `test-worktree-${Date.now()}`
+
+    await createPendingWorktree({
+      threadId,
+      worktreeName: 'regression-worktree',
+      projectDirectory: '/tmp/regression-project',
+    })
+
+    const session = await prisma.thread_sessions.findUnique({
+      where: { thread_id: threadId },
+    })
+    expect(session).toBeTruthy()
+    expect(session?.session_id).toBe('')
+
+    const worktree = await prisma.thread_worktrees.findUnique({
+      where: { thread_id: threadId },
+    })
+    expect(worktree).toBeTruthy()
+    expect(worktree?.worktree_name).toBe('regression-worktree')
+    expect(worktree?.project_directory).toBe('/tmp/regression-project')
+    expect(worktree?.status).toBe('pending')
+
+    await prisma.thread_worktrees.delete({ where: { thread_id: threadId } })
+    await prisma.thread_sessions.delete({ where: { thread_id: threadId } })
+  })
+
+  test('session event persistence uses (timestamp, event_index) ordering for deterministic same-ms replay', async () => {
+    const prisma = await getPrisma()
+    const threadId = 'test-session-events-thread'
+    const sessionId = 'test-session-events-session'
+
+    await prisma.session_events.deleteMany({ where: { session_id: sessionId } })
+    await prisma.thread_sessions.deleteMany({ where: { thread_id: threadId } })
+
+    await prisma.thread_sessions.create({
+      data: { thread_id: threadId, session_id: sessionId },
+    })
+
+    const baseTimestamp = 1_700_000_000_000n
+
+    const inserted1 = await appendSessionEventsSinceLastTimestamp({
+      sessionId,
+      events: [
+        {
+          session_id: sessionId,
+          thread_id: threadId,
+          timestamp: baseTimestamp,
+          event_index: 2,
+          event_json: JSON.stringify({ id: 'e2' }),
+        },
+        {
+          session_id: sessionId,
+          thread_id: threadId,
+          timestamp: baseTimestamp,
+          event_index: 0,
+          event_json: JSON.stringify({ id: 'e0' }),
+        },
+        {
+          session_id: sessionId,
+          thread_id: threadId,
+          timestamp: baseTimestamp,
+          event_index: 1,
+          event_json: JSON.stringify({ id: 'e1' }),
+        },
+      ],
+    })
+
+    const inserted2 = await appendSessionEventsSinceLastTimestamp({
+      sessionId,
+      events: [
+        {
+          session_id: sessionId,
+          thread_id: threadId,
+          timestamp: baseTimestamp,
+          event_index: 0,
+          event_json: JSON.stringify({ id: 'e0' }),
+        },
+        {
+          session_id: sessionId,
+          thread_id: threadId,
+          timestamp: baseTimestamp,
+          event_index: 1,
+          event_json: JSON.stringify({ id: 'e1' }),
+        },
+        {
+          session_id: sessionId,
+          thread_id: threadId,
+          timestamp: baseTimestamp,
+          event_index: 2,
+          event_json: JSON.stringify({ id: 'e2' }),
+        },
+        {
+          session_id: sessionId,
+          thread_id: threadId,
+          timestamp: baseTimestamp,
+          event_index: 3,
+          event_json: JSON.stringify({ id: 'e3' }),
+        },
+      ],
+    })
+
+    const rows = await getSessionEventSnapshot({ sessionId })
+    const orderedIds = rows.map((row) => {
+      const parsed = JSON.parse(row.event_json) as { id: string }
+      return parsed.id
+    })
+
+    expect({ inserted1, inserted2, orderedIds }).toMatchInlineSnapshot(`
+      {
+        "inserted1": 3,
+        "inserted2": 1,
+        "orderedIds": [
+          "e0",
+          "e1",
+          "e2",
+          "e3",
+        ],
+      }
+    `)
+
+    await prisma.session_events.deleteMany({ where: { session_id: sessionId } })
+    await prisma.thread_sessions.deleteMany({ where: { thread_id: threadId } })
+  })
+})

package/src/db.ts

@@ -0,0 +1,286 @@
+// Prisma client initialization with libsql adapter.
+// Uses KIMAKI_DB_URL env var when set (plugin process → Hrana HTTP),
+// otherwise falls back to direct file: access (bot process, CLI subcommands).
+
+import fs from 'node:fs'
+import path from 'node:path'
+import crypto from 'node:crypto'
+import { PrismaLibSql } from '@prisma/adapter-libsql'
+import { PrismaClient, Prisma } from './generated/client.js'
+import { getDataDir } from './config.js'
+import { createLogger, formatErrorWithStack, LogPrefix } from './logger.js'
+import { fileURLToPath } from 'node:url'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
+
+export type { Prisma }
+export { PrismaClient }
+
+// Under vitest, clear any inherited KIMAKI_DB_URL from the parent bot process
+// so tests default to file-based access using the auto-isolated temp data dir.
+// Tests that need Hrana (like the e2e test) can set KIMAKI_DB_URL explicitly
+// after import — getDbUrl() reads process.env dynamically on each call.
+if (process.env.KIMAKI_VITEST) {
+  delete process.env['KIMAKI_DB_URL']
+}
+
+const dbLogger = createLogger(LogPrefix.DB)
+
+let prismaInstance: PrismaClient | null = null
+let initPromise: Promise<PrismaClient> | null = null
+
+/**
+ * Get the singleton Prisma client instance.
+ * Initializes the database on first call, running schema setup if needed.
+ */
+export function getPrisma(): Promise<PrismaClient> {
+  if (prismaInstance) {
+    return Promise.resolve(prismaInstance)
+  }
+  if (initPromise) {
+    return initPromise
+  }
+  initPromise = initializePrisma()
+  return initPromise
+}
+
+/**
+ * Build the libsql connection URL.
+ * KIMAKI_DB_URL is set by the bot when spawning opencode plugin processes,
+ * pointing them at the in-process Hrana HTTP server. Future-proof for remote
+ * opencode processes on different machines.
+ * Without the env var (bot process, CLI subcommands), uses direct file: access.
+ */
+function getDbUrl(): string {
+  if (process.env.KIMAKI_DB_URL) {
+    return process.env.KIMAKI_DB_URL
+  }
+  const dataDir = getDataDir()
+  const dbPath = path.join(dataDir, 'discord-sessions.db')
+  return `file:${dbPath}`
+}
+
+function getDbAuthToken(): string | undefined {
+  const token = process.env.KIMAKI_DB_AUTH_TOKEN
+  if (!token) {
+    return undefined
+  }
+  return token
+}
+
+async function initializePrisma(): Promise<PrismaClient> {
+  const dbUrl = getDbUrl()
+  const isFileMode = dbUrl.startsWith('file:')
+
+  if (isFileMode) {
+    const dataDir = getDataDir()
+    try {
+      fs.mkdirSync(dataDir, { recursive: true })
+    } catch (e) {
+      dbLogger.error(
+        `Failed to create data directory ${dataDir}:`,
+        (e as Error).message,
+      )
+    }
+  }
+
+  dbLogger.log(`Opening database via: ${dbUrl}`)
+
+  const dbAuthToken = getDbAuthToken()
+  const adapter = new PrismaLibSql({
+    url: dbUrl,
+    ...(dbAuthToken && { authToken: dbAuthToken }),
+  })
+  const prisma = new PrismaClient({ adapter })
+
+  try {
+    if (isFileMode) {
+      // WAL mode allows concurrent reads while writing instead of blocking.
+      // busy_timeout makes SQLite retry for 5s instead of immediately failing with SQLITE_BUSY.
+      // The Hrana server (serving the plugin process) sets the same pragmas on its own connection.
+      // PRAGMAs are skipped for HTTP connections — they're connection-scoped and the Hrana
+      // server already configures them on its own libsql Database handle.
+      await prisma.$executeRawUnsafe('PRAGMA journal_mode = WAL')
+      await prisma.$executeRawUnsafe('PRAGMA busy_timeout = 5000')
+    }
+
+    // Always run migrations - schema.sql uses IF NOT EXISTS so it's idempotent
+    dbLogger.log('Running schema migrations...')
+    await migrateSchema(prisma)
+    dbLogger.log('Schema migration complete')
+  } catch (error) {
+    dbLogger.error('Prisma init failed:', formatErrorWithStack(error))
+    throw error
+  }
+
+  prismaInstance = prisma
+  return prisma
+}
+
+async function migrateSchema(prisma: PrismaClient): Promise<void> {
+  const schemaPath = path.join(__dirname, '../src/schema.sql')
+  const sql = fs.readFileSync(schemaPath, 'utf-8')
+  const statements = sql
+    .split(';')
+    .map((s) =>
+      s
+        .split('\n')
+        .filter((line) => !line.trimStart().startsWith('--'))
+        .join('\n')
+        .trim(),
+    )
+    .filter(
+      (s) =>
+        s.length > 0 &&
+        !/^CREATE\s+TABLE\s+["']?sqlite_sequence["']?\s*\(/i.test(s),
+    )
+    // Make CREATE INDEX idempotent
+    .map((s) =>
+      s
+        .replace(
+          /^CREATE\s+UNIQUE\s+INDEX\b(?!\s+IF)/i,
+          'CREATE UNIQUE INDEX IF NOT EXISTS',
+        )
+        .replace(/^CREATE\s+INDEX\b(?!\s+IF)/i, 'CREATE INDEX IF NOT EXISTS'),
+    )
+  for (const statement of statements) {
+    await prisma.$executeRawUnsafe(statement)
+  }
+
+  // Migration: add variant column to model tables (for thinking/reasoning level).
+  // ALTERs throw if column already exists, so each is wrapped in try/catch.
+  const alterStatements = [
+    'ALTER TABLE channel_models ADD COLUMN variant TEXT',
+    'ALTER TABLE session_models ADD COLUMN variant TEXT',
+    'ALTER TABLE global_models ADD COLUMN variant TEXT',
+  ]
+  for (const stmt of alterStatements) {
+    try {
+      await prisma.$executeRawUnsafe(stmt)
+    } catch {
+      // Column already exists – expected on subsequent runs
+    }
+  }
+
+  // Migration: add openai_api_key column to bot_api_keys.
+  try {
+    await prisma.$executeRawUnsafe(
+      'ALTER TABLE bot_api_keys ADD COLUMN openai_api_key TEXT',
+    )
+  } catch {
+    // Column already exists
+  }
+
+  // Migration: add gateway bot mode columns to bot_tokens.
+  // bot_mode distinguishes "self_hosted" (user's own bot) from "gateway" (gateway Kimaki bot).
+  // client_id + client_secret are the credentials used for gateway proxy auth.
+  // proxy_url stores the gateway-proxy REST base URL.
+  const botTokenAlters = [
+    "ALTER TABLE bot_tokens ADD COLUMN bot_mode TEXT DEFAULT 'self_hosted'",
+    'ALTER TABLE bot_tokens ADD COLUMN client_id TEXT',
+    'ALTER TABLE bot_tokens ADD COLUMN client_secret TEXT',
+    'ALTER TABLE bot_tokens ADD COLUMN proxy_url TEXT',
+    'ALTER TABLE bot_tokens ADD COLUMN last_used_at DATETIME',
+  ]
+  for (const stmt of botTokenAlters) {
+    try {
+      await prisma.$executeRawUnsafe(stmt)
+    } catch {
+      // Column already exists
+    }
+  }
+
+  try {
+    await prisma.$executeRawUnsafe(
+      "ALTER TABLE thread_sessions ADD COLUMN source TEXT DEFAULT 'kimaki'",
+    )
+  } catch {
+    // Column already exists
+  }
+
+  // Migration: move session_thinking data into session_models.variant.
+  // session_thinking table is left in place (not dropped) so older kimaki versions
+  // that still reference it won't crash on the same database.
+  try {
+    // For sessions that already have a model row, copy the thinking value
+    await prisma.$executeRawUnsafe(`
+      UPDATE session_models SET variant = (
+        SELECT thinking_value FROM session_thinking
+        WHERE session_thinking.session_id = session_models.session_id
+      ) WHERE variant IS NULL AND EXISTS (
+        SELECT 1 FROM session_thinking WHERE session_thinking.session_id = session_models.session_id
+      )
+    `)
+  } catch {
+    // session_thinking table may not exist in fresh installs
+  }
+
+  // Migration: rename hyphenated verbosity values to underscored for Prisma enum.
+  // Old DBs have 'tools-and-text', 'text-and-essential-tools', 'text-only'.
+  const verbosityRenames = [
+    "UPDATE channel_verbosity SET verbosity = 'tools_and_text' WHERE verbosity = 'tools-and-text'",
+    "UPDATE channel_verbosity SET verbosity = 'text_and_essential_tools' WHERE verbosity = 'text-and-essential-tools'",
+    "UPDATE channel_verbosity SET verbosity = 'text_only' WHERE verbosity = 'text-only'",
+  ]
+  for (const stmt of verbosityRenames) {
+    try {
+      await prisma.$executeRawUnsafe(stmt)
+    } catch {
+      // Table may not exist on first run
+    }
+  }
+
+  // Defensive migration: rename legacy 'self-hosted' bot_mode to 'self_hosted'.
+  // Also fix NULL worktree status rows that predate the required enum.
+  const defensiveMigrations = [
+    "UPDATE bot_tokens SET bot_mode = 'self_hosted' WHERE bot_mode = 'self-hosted'",
+    "UPDATE thread_worktrees SET status = 'pending' WHERE status IS NULL",
+  ]
+  for (const stmt of defensiveMigrations) {
+    try {
+      await prisma.$executeRawUnsafe(stmt)
+    } catch {
+      // Table may not exist on first run
+    }
+  }
+
+  // Migration: ensure every bot row has service auth credentials.
+  // These credentials are used for local/internet control-plane auth.
+  try {
+    const botRows = await prisma.bot_tokens.findMany({
+      select: {
+        app_id: true,
+        client_id: true,
+        client_secret: true,
+      },
+    })
+    for (const botRow of botRows) {
+      if (botRow.client_id && botRow.client_secret) {
+        continue
+      }
+      await prisma.bot_tokens.update({
+        where: { app_id: botRow.app_id },
+        data: {
+          client_id: crypto.randomUUID(),
+          client_secret: crypto.randomBytes(32).toString('hex'),
+        },
+      })
+    }
+  } catch {
+    // Defensive migration only; ignore if table shape is not ready yet.
+  }
+
+}
+
+/**
+ * Close the Prisma connection.
+ */
+export async function closePrisma(): Promise<void> {
+  if (prismaInstance) {
+    await prismaInstance.$disconnect()
+    prismaInstance = null
+    initPromise = null
+    dbLogger.log('Prisma connection closed')
+  }
+}

package/src/debounce-timeout.ts

@@ -0,0 +1,43 @@
+// Reusable debounce helper for timeout-based callbacks.
+// Encapsulates the timer handle and exposes trigger/clear/isPending so callers
+// can batch clustered events without leaking timeout state into domain logic.
+
+export function createDebouncedTimeout({
+  delayMs,
+  callback,
+}: {
+  delayMs: number
+  callback: () => void
+}): {
+  trigger: () => void
+  clear: () => void
+  isPending: () => boolean
+} {
+  let timeout: ReturnType<typeof setTimeout> | null = null
+
+  function clear(): void {
+    if (!timeout) {
+      return
+    }
+    clearTimeout(timeout)
+    timeout = null
+  }
+
+  function trigger(): void {
+    clear()
+    timeout = setTimeout(() => {
+      timeout = null
+      callback()
+    }, delayMs)
+  }
+
+  function isPending(): boolean {
+    return timeout !== null
+  }
+
+  return {
+    trigger,
+    clear,
+    isPending,
+  }
+}

package/src/debounced-process-flush.ts

@@ -0,0 +1,104 @@
+// Debounced async callback with centralized shutdown flushing.
+// Used for persistence paths that should batch writes during runtime
+// while allowing the bot's single SIGTERM/SIGINT handler to flush all callbacks.
+
+type FlushCallback = () => Promise<void>
+
+const processFlushCallbacks = new Set<FlushCallback>()
+
+export async function flushDebouncedProcessCallbacks(): Promise<void> {
+  const callbacks = [...processFlushCallbacks]
+  await Promise.allSettled(
+    callbacks.map((callback) => {
+      return callback()
+    }),
+  )
+}
+
+export function createDebouncedProcessFlush({
+  waitMs,
+  callback,
+  onError,
+}: {
+  waitMs: number
+  callback: () => Promise<void>
+  onError?: (error: Error) => void
+}): {
+  trigger: () => void
+  flush: () => Promise<void>
+  dispose: () => Promise<void>
+} {
+  let timeout: ReturnType<typeof setTimeout> | undefined
+  let inFlight: Promise<void> | undefined
+  let dirty = false
+
+  async function run(): Promise<void> {
+    if (!dirty) {
+      return
+    }
+    if (inFlight) {
+      await inFlight
+      if (!dirty) {
+        return
+      }
+    }
+
+    dirty = false
+    const current = Promise.resolve()
+      .then(() => {
+        return callback()
+      })
+      .catch((error) => {
+        if (onError) {
+          const wrappedError =
+            error instanceof Error
+              ? error
+              : new Error('Debounced process flush failed', { cause: error })
+          onError(wrappedError)
+        }
+      })
+    inFlight = current
+    await current
+    if (inFlight === current) {
+      inFlight = undefined
+    }
+    if (dirty) {
+      await run()
+    }
+  }
+
+  function trigger(): void {
+    dirty = true
+    if (timeout) {
+      return
+    }
+    timeout = setTimeout(() => {
+      timeout = undefined
+      void run()
+    }, waitMs)
+  }
+
+  async function flush(): Promise<void> {
+    if (timeout) {
+      clearTimeout(timeout)
+      timeout = undefined
+    }
+    await run()
+  }
+
+  const processFlushCallback: FlushCallback = async () => {
+    await flush()
+  }
+  processFlushCallbacks.add(processFlushCallback)
+
+  async function dispose(): Promise<void> {
+    processFlushCallbacks.delete(processFlushCallback)
+    await flush()
+  }
+
+  return {
+    trigger,
+    flush,
+    dispose,
+  }
+}