@brianli/kimaki 0.4.72-brianli.1

package/src/db.test.ts

@@ -0,0 +1,60 @@
+// 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 { createPendingWorktree } 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 } })
+  })
+})

package/src/db.ts

@@ -0,0 +1,190 @@
+// 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 { 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}`
+}
+
+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 adapter = new PrismaLibSql({ url: dbUrl })
+  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: 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
+  }
+}
+
+/**
+ * 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/discord-api.ts

@@ -0,0 +1,35 @@
+import { REST } from 'discord.js'
+
+const DISCORD_API_BASE_URL = 'https://discord.com/api'
+
+function normalizeApiBaseUrl(rawValue: string | undefined): string {
+  const trimmed = rawValue?.trim()
+  if (!trimmed) {
+    return DISCORD_API_BASE_URL
+  }
+
+  const withoutTrailingSlash = trimmed.replace(/\/+$/, '')
+  if (withoutTrailingSlash.endsWith('/api')) {
+    return withoutTrailingSlash
+  }
+
+  return `${withoutTrailingSlash}/api`
+}
+
+export function getDiscordApiBaseUrl(): string {
+  return normalizeApiBaseUrl(process.env.KIMAKI_DISCORD_HTTP_URL)
+}
+
+export function getDiscordApiV10BaseUrl(): string {
+  return `${getDiscordApiBaseUrl()}/v10`
+}
+
+export function createDiscordRest(token?: string): REST {
+  const rest = new REST({
+    api: getDiscordApiBaseUrl(),
+  })
+  if (token) {
+    rest.setToken(token)
+  }
+  return rest
+}