kimaki 0.4.38 → 0.4.40

package/src/discord-bot.ts

@@ -2,7 +2,7 @@
 // Bridges Discord messages to OpenCode sessions, manages voice connections,
 // and orchestrates the main event loop for the Kimaki bot.
 
-import { getDatabase, closeDatabase } from './database.js'
+import { getDatabase, closeDatabase, getThreadWorktree } from './database.js'
 import { initializeOpencodeForDirectory, getOpencodeServers } from './opencode.js'
 import {
   escapeBackticksInCodeBlocks,
@@ -53,11 +53,15 @@ import {
   type ThreadChannel,
 } from 'discord.js'
 import fs from 'node:fs'
+import * as errore from 'errore'
 import { extractTagsArrays } from './xml.js'
 import { createLogger } from './logger.js'
 import { setGlobalDispatcher, Agent } from 'undici'
 
-setGlobalDispatcher(new Agent({ headersTimeout: 0, bodyTimeout: 0 }))
+// Increase connection pool to prevent deadlock when multiple sessions have open SSE streams.
+// Each session's event.subscribe() holds a connection; without enough connections,
+// regular HTTP requests (question.reply, session.prompt) get blocked → deadlock.
+setGlobalDispatcher(new Agent({ headersTimeout: 0, bodyTimeout: 0, connections: 500 }))
 
 const discordLogger = createLogger('DISCORD')
 const voiceLogger = createLogger('VOICE')
@@ -149,10 +153,12 @@ export async function startDiscordBot({
       }
       if (message.partial) {
         discordLogger.log(`Fetching partial message ${message.id}`)
-        try {
-          await message.fetch()
-        } catch (error) {
-          discordLogger.log(`Failed to fetch partial message ${message.id}:`, error)
+        const fetched = await errore.tryAsync({
+          try: () => message.fetch(),
+          catch: (e) => e as Error,
+        })
+        if (fetched instanceof Error) {
+          discordLogger.log(`Failed to fetch partial message ${message.id}:`, fetched.message)
           return
         }
       }
@@ -201,6 +207,29 @@ export async function startDiscordBot({
           channelAppId = extracted['kimaki.app']?.[0]?.trim()
         }
 
+        // Check if this thread is a worktree thread
+        const worktreeInfo = getThreadWorktree(thread.id)
+        if (worktreeInfo) {
+          if (worktreeInfo.status === 'pending') {
+            await message.reply({
+              content: '⏳ Worktree is still being created. Please wait...',
+              flags: SILENT_MESSAGE_FLAGS,
+            })
+            return
+          }
+          if (worktreeInfo.status === 'error') {
+            await message.reply({
+              content: `❌ Worktree creation failed: ${worktreeInfo.error_message}`,
+              flags: SILENT_MESSAGE_FLAGS,
+            })
+            return
+          }
+          if (worktreeInfo.worktree_directory) {
+            projectDirectory = worktreeInfo.worktree_directory
+            discordLogger.log(`Using worktree directory: ${projectDirectory}`)
+          }
+        }
+
         if (channelAppId && channelAppId !== currentAppId) {
           voiceLogger.log(
             `[IGNORED] Thread belongs to different bot app (expected: ${currentAppId}, got: ${channelAppId})`,
@@ -256,30 +285,41 @@ export async function startDiscordBot({
         if (projectDirectory) {
           try {
             const getClient = await initializeOpencodeForDirectory(projectDirectory)
+            if (getClient instanceof Error) {
+              voiceLogger.error(`[SESSION] Failed to initialize OpenCode client:`, getClient.message)
+              throw new Error(getClient.message)
+            }
             const client = getClient()
 
             // get current session context (without system prompt, it would be duplicated)
             if (row.session_id) {
-              currentSessionContext = await getCompactSessionContext({
+              const result = await getCompactSessionContext({
                 client,
                 sessionId: row.session_id,
                 includeSystemPrompt: false,
                 maxMessages: 15,
               })
+              if (errore.isOk(result)) {
+                currentSessionContext = result
+              }
             }
 
             // get last session context (with system prompt for project context)
-            const lastSessionId = await getLastSessionId({
+            const lastSessionResult = await getLastSessionId({
               client,
               excludeSessionId: row.session_id,
             })
+            const lastSessionId = errore.unwrapOr(lastSessionResult, null)
             if (lastSessionId) {
-              lastSessionContext = await getCompactSessionContext({
+              const result = await getCompactSessionContext({
                 client,
                 sessionId: lastSessionId,
                 includeSystemPrompt: true,
                 maxMessages: 10,
               })
+              if (errore.isOk(result)) {
+                lastSessionContext = result
+              }
             }
           } catch (e) {
             voiceLogger.error(`Could not get session context:`, e)

package/src/discord-utils.ts

@@ -9,6 +9,9 @@ import { formatMarkdownTables } from './format-tables.js'
 import { limitHeadingDepth } from './limit-heading-depth.js'
 import { unnestCodeBlocksFromLists } from './unnest-code-blocks.js'
 import { createLogger } from './logger.js'
+import mime from 'mime'
+import fs from 'node:fs'
+import path from 'node:path'
 
 const discordLogger = createLogger('DISCORD')
 
@@ -302,3 +305,50 @@ export function getKimakiMetadata(textChannel: TextChannel | null): {
 
   return { projectDirectory, channelAppId }
 }
+
+/**
+ * Upload files to a Discord thread/channel in a single message.
+ * Sending all files in one message causes Discord to display images in a grid layout.
+ */
+export async function uploadFilesToDiscord({
+  threadId,
+  botToken,
+  files,
+}: {
+  threadId: string
+  botToken: string
+  files: string[]
+}): Promise<void> {
+  if (files.length === 0) {
+    return
+  }
+
+  // Build attachments array for all files
+  const attachments = files.map((file, index) => ({
+    id: index,
+    filename: path.basename(file),
+  }))
+
+  const formData = new FormData()
+  formData.append('payload_json', JSON.stringify({ attachments }))
+
+  // Append each file with its array index, with correct MIME type for grid display
+  files.forEach((file, index) => {
+    const buffer = fs.readFileSync(file)
+    const mimeType = mime.getType(file) || 'application/octet-stream'
+    formData.append(`files[${index}]`, new Blob([buffer], { type: mimeType }), path.basename(file))
+  })
+
+  const response = await fetch(`https://discord.com/api/v10/channels/${threadId}/messages`, {
+    method: 'POST',
+    headers: {
+      Authorization: `Bot ${botToken}`,
+    },
+    body: formData,
+  })
+
+  if (!response.ok) {
+    const error = await response.text()
+    throw new Error(`Discord API error: ${response.status} - ${error}`)
+  }
+}

package/src/errors.ts

@@ -0,0 +1,138 @@
+// TaggedError definitions for type-safe error handling with errore.
+// Errors are grouped by category: infrastructure, domain, and validation.
+// Use errore.matchError() for exhaustive error handling in command handlers.
+
+import { createTaggedError } from 'errore'
+
+// ═══════════════════════════════════════════════════════════════════════════
+// INFRASTRUCTURE ERRORS - Server, filesystem, external services
+// ═══════════════════════════════════════════════════════════════════════════
+
+export class DirectoryNotAccessibleError extends createTaggedError({
+  name: 'DirectoryNotAccessibleError',
+  message: 'Directory does not exist or is not accessible: $directory',
+}) {}
+
+export class ServerStartError extends createTaggedError({
+  name: 'ServerStartError',
+  message: 'Server failed to start on port $port: $reason',
+}) {}
+
+export class ServerNotFoundError extends createTaggedError({
+  name: 'ServerNotFoundError',
+  message: 'OpenCode server not found for directory: $directory',
+}) {}
+
+export class ServerNotReadyError extends createTaggedError({
+  name: 'ServerNotReadyError',
+  message: 'OpenCode server for directory "$directory" is in an error state (no client available)',
+}) {}
+
+export class ApiKeyMissingError extends createTaggedError({
+  name: 'ApiKeyMissingError',
+  message: '$service API key is required',
+}) {}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// DOMAIN ERRORS - Sessions, messages, transcription
+// ═══════════════════════════════════════════════════════════════════════════
+
+export class SessionNotFoundError extends createTaggedError({
+  name: 'SessionNotFoundError',
+  message: 'Session $sessionId not found',
+}) {}
+
+export class SessionCreateError extends createTaggedError({
+  name: 'SessionCreateError',
+  message: '$message',
+}) {}
+
+export class MessagesNotFoundError extends createTaggedError({
+  name: 'MessagesNotFoundError',
+  message: 'No messages found for session $sessionId',
+}) {}
+
+export class TranscriptionError extends createTaggedError({
+  name: 'TranscriptionError',
+  message: 'Transcription failed: $reason',
+}) {}
+
+export class GrepSearchError extends createTaggedError({
+  name: 'GrepSearchError',
+  message: 'Grep search failed for pattern: $pattern',
+}) {}
+
+export class GlobSearchError extends createTaggedError({
+  name: 'GlobSearchError',
+  message: 'Glob search failed for pattern: $pattern',
+}) {}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// VALIDATION ERRORS - Input validation, format checks
+// ═══════════════════════════════════════════════════════════════════════════
+
+export class InvalidAudioFormatError extends createTaggedError({
+  name: 'InvalidAudioFormatError',
+  message: 'Invalid audio format',
+}) {}
+
+export class EmptyTranscriptionError extends createTaggedError({
+  name: 'EmptyTranscriptionError',
+  message: 'Model returned empty transcription',
+}) {}
+
+export class NoResponseContentError extends createTaggedError({
+  name: 'NoResponseContentError',
+  message: 'No response content from model',
+}) {}
+
+export class NoToolResponseError extends createTaggedError({
+  name: 'NoToolResponseError',
+  message: 'No valid tool responses',
+}) {}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// NETWORK ERRORS - Fetch and HTTP
+// ═══════════════════════════════════════════════════════════════════════════
+
+export class FetchError extends createTaggedError({
+  name: 'FetchError',
+  message: 'Fetch failed for $url',
+}) {}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// API ERRORS - External service responses
+// ═══════════════════════════════════════════════════════════════════════════
+
+export class DiscordApiError extends createTaggedError({
+  name: 'DiscordApiError',
+  message: 'Discord API error: $status $body',
+}) {}
+
+export class OpenCodeApiError extends createTaggedError({
+  name: 'OpenCodeApiError',
+  message: 'OpenCode API error ($status): $body',
+}) {}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// UNION TYPES - For function signatures
+// ═══════════════════════════════════════════════════════════════════════════
+
+export type TranscriptionErrors =
+  | ApiKeyMissingError
+  | InvalidAudioFormatError
+  | TranscriptionError
+  | EmptyTranscriptionError
+  | NoResponseContentError
+  | NoToolResponseError
+
+export type OpenCodeErrors =
+  | DirectoryNotAccessibleError
+  | ServerStartError
+  | ServerNotFoundError
+  | ServerNotReadyError
+
+export type SessionErrors =
+  | SessionNotFoundError
+  | MessagesNotFoundError
+  | OpenCodeApiError

package/src/genai-worker.ts

@@ -4,13 +4,14 @@
 
 import { parentPort, threadId } from 'node:worker_threads'
 import { createWriteStream, type WriteStream } from 'node:fs'
-import { mkdir } from 'node:fs/promises'
 import path from 'node:path'
+import * as errore from 'errore'
 import { Resampler } from '@purinton/resampler'
 import * as prism from 'prism-media'
 import { startGenAiSession } from './genai.js'
 import type { Session } from '@google/genai'
 import { getTools } from './tools.js'
+import { mkdir } from 'node:fs/promises'
 import type { WorkerInMessage, WorkerOutMessage } from './worker-types.js'
 import { createLogger } from './logger.js'
 
@@ -127,26 +128,28 @@ async function createAssistantAudioLogStream(
   const timestamp = new Date().toISOString().replace(/[:.]/g, '-')
   const audioDir = path.join(process.cwd(), 'discord-audio-logs', guildId, channelId)
 
-  try {
-    await mkdir(audioDir, { recursive: true })
+  const mkdirError = await errore.tryAsync({
+    try: () => mkdir(audioDir, { recursive: true }),
+    catch: (e) => e as Error,
+  })
+  if (mkdirError instanceof Error) {
+    workerLogger.error(`Failed to create audio log directory:`, mkdirError.message)
+    return null
+  }
 
-    // Create stream for assistant audio (24kHz mono s16le PCM)
-    const outputFileName = `assistant_${timestamp}.24.pcm`
-    const outputFilePath = path.join(audioDir, outputFileName)
-    const outputAudioStream = createWriteStream(outputFilePath)
+  // Create stream for assistant audio (24kHz mono s16le PCM)
+  const outputFileName = `assistant_${timestamp}.24.pcm`
+  const outputFilePath = path.join(audioDir, outputFileName)
+  const outputAudioStream = createWriteStream(outputFilePath)
 
-    // Add error handler to prevent crashes
-    outputAudioStream.on('error', (error) => {
-      workerLogger.error(`Assistant audio log stream error:`, error)
-    })
+  // Add error handler to prevent crashes
+  outputAudioStream.on('error', (error) => {
+    workerLogger.error(`Assistant audio log stream error:`, error)
+  })
 
-    workerLogger.log(`Created assistant audio log: ${outputFilePath}`)
+  workerLogger.log(`Created assistant audio log: ${outputFilePath}`)
 
-    return outputAudioStream
-  } catch (error) {
-    workerLogger.error(`Failed to create audio log directory:`, error)
-    return null
-  }
+  return outputAudioStream
 }
 
 // Handle encoded Opus packets

package/src/interaction-handler.ts

@@ -4,6 +4,7 @@
 
 import { Events, type Client, type Interaction } from 'discord.js'
 import { handleSessionCommand, handleSessionAutocomplete } from './commands/session.js'
+import { handleNewWorktreeCommand } from './commands/worktree.js'
 import { handleResumeCommand, handleResumeAutocomplete } from './commands/resume.js'
 import { handleAddProjectCommand, handleAddProjectAutocomplete } from './commands/add-project.js'
 import {
@@ -52,7 +53,7 @@ export function registerInteractionHandler({
 
       if (interaction.isAutocomplete()) {
         switch (interaction.commandName) {
-          case 'session':
+          case 'new-session':
             await handleSessionAutocomplete({ interaction, appId })
             return
 
@@ -78,10 +79,14 @@ export function registerInteractionHandler({
         interactionLogger.log(`[COMMAND] Processing: ${interaction.commandName}`)
 
         switch (interaction.commandName) {
-          case 'session':
+          case 'new-session':
             await handleSessionCommand({ command: interaction, appId })
             return
 
+          case 'new-worktree':
+            await handleNewWorktreeCommand({ command: interaction, appId })
+            return
+
           case 'resume':
             await handleResumeCommand({ command: interaction, appId })
             return

package/src/markdown.test.ts

@@ -1,6 +1,7 @@
 import { test, expect, beforeAll, afterAll } from 'vitest'
 import { spawn, type ChildProcess } from 'child_process'
 import { OpencodeClient } from '@opencode-ai/sdk'
+import * as errore from 'errore'
 import { ShareMarkdown, getCompactSessionContext } from './markdown.js'
 
 let serverProcess: ChildProcess
@@ -121,11 +122,14 @@ test('generate markdown from first available session', async () => {
   const exporter = new ShareMarkdown(client)
 
   // Generate markdown with system info
-  const markdown = await exporter.generate({
+  const markdownResult = await exporter.generate({
     sessionID,
     includeSystemInfo: true,
   })
 
+  expect(errore.isOk(markdownResult)).toBe(true)
+  const markdown = errore.unwrap(markdownResult)
+
   console.log(`Generated markdown length: ${markdown.length} characters`)
 
   // Basic assertions
@@ -299,13 +303,16 @@ test('generate markdown from multiple sessions', async () => {
 test.skipIf(process.env.CI)('getCompactSessionContext generates compact format', async () => {
   const sessionId = 'ses_46c2205e8ffeOll1JUSuYChSAM'
 
-  const context = await getCompactSessionContext({
+  const contextResult = await getCompactSessionContext({
     client,
     sessionId,
     includeSystemPrompt: true,
     maxMessages: 15,
   })
 
+  expect(errore.isOk(contextResult)).toBe(true)
+  const context = errore.unwrap(contextResult)
+
   console.log(`Generated compact context length: ${context.length} characters`)
 
   expect(context).toBeTruthy()
@@ -319,13 +326,16 @@ test.skipIf(process.env.CI)('getCompactSessionContext generates compact format',
 test.skipIf(process.env.CI)('getCompactSessionContext without system prompt', async () => {
   const sessionId = 'ses_46c2205e8ffeOll1JUSuYChSAM'
 
-  const context = await getCompactSessionContext({
+  const contextResult = await getCompactSessionContext({
     client,
     sessionId,
     includeSystemPrompt: false,
     maxMessages: 10,
   })
 
+  expect(errore.isOk(contextResult)).toBe(true)
+  const context = errore.unwrap(contextResult)
+
   console.log(`Generated compact context (no system) length: ${context.length} characters`)
 
   expect(context).toBeTruthy()