kimaki 0.4.24 → 0.4.26

package/src/opencode.ts

@@ -1,10 +1,19 @@
+// OpenCode server process manager.
+// Spawns and maintains OpenCode API servers per project directory,
+// handles automatic restarts on failure, and provides typed SDK clients.
+
 import { spawn, type ChildProcess } from 'node:child_process'
+import fs from 'node:fs'
 import net from 'node:net'
 import {
   createOpencodeClient,
   type OpencodeClient,
   type Config,
 } from '@opencode-ai/sdk'
+import {
+  createOpencodeClient as createOpencodeClientV2,
+  type OpencodeClient as OpencodeClientV2,
+} from '@opencode-ai/sdk/v2'
 import { createLogger } from './logger.js'
 
 const opencodeLogger = createLogger('OPENCODE')
@@ -14,6 +23,7 @@ const opencodeServers = new Map<
   {
     process: ChildProcess
     client: OpencodeClient
+    clientV2: OpencodeClientV2
     port: number
   }
 >()
@@ -42,21 +52,36 @@ async function waitForServer(port: number, maxAttempts = 30): Promise<boolean> {
   for (let i = 0; i < maxAttempts; i++) {
     try {
       const endpoints = [
-        `http://localhost:${port}/api/health`,
-        `http://localhost:${port}/`,
-        `http://localhost:${port}/api`,
+        `http://127.0.0.1:${port}/api/health`,
+        `http://127.0.0.1:${port}/`,
+        `http://127.0.0.1:${port}/api`,
       ]
 
       for (const endpoint of endpoints) {
         try {
           const response = await fetch(endpoint)
           if (response.status < 500) {
-            opencodeLogger.log(`Server ready on port `)
             return true
           }
-        } catch (e) {}
+          const body = await response.text()
+          // Fatal errors that won't resolve with retrying
+          if (body.includes('BunInstallFailedError')) {
+            throw new Error(`Server failed to start: ${body.slice(0, 200)}`)
+          }
+        } catch (e) {
+          // Re-throw fatal errors
+          if ((e as Error).message?.includes('Server failed to start')) {
+            throw e
+          }
+        }
+      }
+    } catch (e) {
+      // Re-throw fatal errors that won't resolve with retrying
+      if ((e as Error).message?.includes('Server failed to start')) {
+        throw e
       }
-    } catch (e) {}
+      opencodeLogger.debug(`Server polling attempt failed: ${(e as Error).message}`)
+    }
     await new Promise((resolve) => setTimeout(resolve, 1000))
   }
   throw new Error(
@@ -81,9 +106,17 @@ export async function initializeOpencodeForDirectory(directory: string) {
     }
   }
 
+  // Verify directory exists and is accessible before spawning
+  try {
+    fs.accessSync(directory, fs.constants.R_OK | fs.constants.X_OK)
+  } catch {
+    throw new Error(`Directory does not exist or is not accessible: ${directory}`)
+  }
+
   const port = await getOpenPort()
 
-  const opencodeCommand = process.env.OPENCODE_PATH || 'opencode'
+  const opencodeBinDir = `${process.env.HOME}/.opencode/bin`
+  const opencodeCommand = process.env.OPENCODE_PATH || `${opencodeBinDir}/opencode`
 
   const serverProcess = spawn(
     opencodeCommand,
@@ -109,23 +142,24 @@ export async function initializeOpencodeForDirectory(directory: string) {
     },
   )
 
+  // Buffer logs until we know if server started successfully
+  const logBuffer: string[] = []
+  logBuffer.push(`Spawned opencode serve --port ${port} in ${directory} (pid: ${serverProcess.pid})`)
+
   serverProcess.stdout?.on('data', (data) => {
-    opencodeLogger.log(`opencode ${directory}: ${data.toString().trim()}`)
+    logBuffer.push(`[stdout] ${data.toString().trim()}`)
   })
 
   serverProcess.stderr?.on('data', (data) => {
-    opencodeLogger.error(`opencode ${directory}: ${data.toString().trim()}`)
+    logBuffer.push(`[stderr] ${data.toString().trim()}`)
   })
 
   serverProcess.on('error', (error) => {
-    opencodeLogger.error(`Failed to start server on port :`, port, error)
+    logBuffer.push(`Failed to start server on port ${port}: ${error}`)
   })
 
   serverProcess.on('exit', (code) => {
-    opencodeLogger.log(
-      `Opencode server on ${directory} exited with code:`,
-      code,
-    )
+    opencodeLogger.log(`Opencode server on ${directory} exited with code:`, code)
     opencodeServers.delete(directory)
     if (code !== 0) {
       const retryCount = serverRetryCount.get(directory) || 0
@@ -147,20 +181,39 @@ export async function initializeOpencodeForDirectory(directory: string) {
     }
   })
 
-  await waitForServer(port)
+  try {
+    await waitForServer(port)
+    opencodeLogger.log(`Server ready on port ${port}`)
+  } catch (e) {
+    // Dump buffered logs on failure
+    opencodeLogger.error(`Server failed to start for ${directory}:`)
+    for (const line of logBuffer) {
+      opencodeLogger.error(`  ${line}`)
+    }
+    throw e
+  }
+
+  const baseUrl = `http://127.0.0.1:${port}`
+  const fetchWithTimeout = (request: Request) =>
+    fetch(request, {
+      // @ts-ignore
+      timeout: false,
+    })
 
   const client = createOpencodeClient({
-    baseUrl: `http://localhost:${port}`,
-    fetch: (request: Request) =>
-      fetch(request, {
-        // @ts-ignore
-        timeout: false,
-      }),
+    baseUrl,
+    fetch: fetchWithTimeout,
+  })
+
+  const clientV2 = createOpencodeClientV2({
+    baseUrl,
+    fetch: fetchWithTimeout as typeof fetch,
   })
 
   opencodeServers.set(directory, {
     process: serverProcess,
     client,
+    clientV2,
     port,
   })
 
@@ -178,3 +231,13 @@ export async function initializeOpencodeForDirectory(directory: string) {
 export function getOpencodeServers() {
   return opencodeServers
 }
+
+export function getOpencodeServerPort(directory: string): number | null {
+  const entry = opencodeServers.get(directory)
+  return entry?.port ?? null
+}
+
+export function getOpencodeClientV2(directory: string): OpencodeClientV2 | null {
+  const entry = opencodeServers.get(directory)
+  return entry?.clientV2 ?? null
+}

package/src/session-handler.ts

@@ -1,46 +1,136 @@
-import type { Part, FilePartInput, Permission } from '@opencode-ai/sdk'
+// OpenCode session lifecycle manager.
+// Creates, maintains, and sends prompts to OpenCode sessions from Discord threads.
+// Handles streaming events, permissions, abort signals, and message queuing.
+
+import type { Part, PermissionRequest } from '@opencode-ai/sdk/v2'
+import type { FilePartInput } from '@opencode-ai/sdk'
 import type { Message, ThreadChannel } from 'discord.js'
 import prettyMilliseconds from 'pretty-ms'
-import { getDatabase, getSessionModel, getChannelModel } from './database.js'
-import { initializeOpencodeForDirectory, getOpencodeServers } from './opencode.js'
-import { sendThreadMessage } from './discord-utils.js'
+import { getDatabase, getSessionModel, getChannelModel, getSessionAgent, getChannelAgent } from './database.js'
+import { initializeOpencodeForDirectory, getOpencodeServers, getOpencodeClientV2 } from './opencode.js'
+import { sendThreadMessage, NOTIFY_MESSAGE_FLAGS } from './discord-utils.js'
 import { formatPart } from './message-formatting.js'
 import { getOpencodeSystemMessage } from './system-message.js'
 import { createLogger } from './logger.js'
 import { isAbortError } from './utils.js'
+import { showAskUserQuestionDropdowns } from './commands/ask-question.js'
 
 const sessionLogger = createLogger('SESSION')
 const voiceLogger = createLogger('VOICE')
 const discordLogger = createLogger('DISCORD')
 
-export type ParsedCommand = {
-  isCommand: true
-  command: string
-  arguments: string
-} | {
-  isCommand: false
+export const abortControllers = new Map<string, AbortController>()
+
+export const pendingPermissions = new Map<
+  string,
+  { permission: PermissionRequest; messageId: string; directory: string }
+>()
+
+export type QueuedMessage = {
+  prompt: string
+  userId: string
+  username: string
+  queuedAt: number
+  images?: FilePartInput[]
+}
+
+// Queue of messages waiting to be sent after current response finishes
+// Key is threadId, value is array of queued messages
+export const messageQueue = new Map<string, QueuedMessage[]>()
+
+export function addToQueue({
+  threadId,
+  message,
+}: {
+  threadId: string
+  message: QueuedMessage
+}): number {
+  const queue = messageQueue.get(threadId) || []
+  queue.push(message)
+  messageQueue.set(threadId, queue)
+  return queue.length
+}
+
+export function getQueueLength(threadId: string): number {
+  return messageQueue.get(threadId)?.length || 0
 }
 
-export function parseSlashCommand(text: string): ParsedCommand {
-  const trimmed = text.trim()
-  if (!trimmed.startsWith('/')) {
-    return { isCommand: false }
+export function clearQueue(threadId: string): void {
+  messageQueue.delete(threadId)
+}
+
+/**
+ * Abort a running session and retry with the last user message.
+ * Used when model preference changes mid-request.
+ * Fetches last user message from OpenCode API instead of tracking in memory.
+ * @returns true if aborted and retry scheduled, false if no active request
+ */
+export async function abortAndRetrySession({
+  sessionId,
+  thread,
+  projectDirectory,
+}: {
+  sessionId: string
+  thread: ThreadChannel
+  projectDirectory: string
+}): Promise<boolean> {
+  const controller = abortControllers.get(sessionId)
+
+  if (!controller) {
+    sessionLogger.log(`[ABORT+RETRY] No active request for session ${sessionId}`)
+    return false
   }
-  const match = trimmed.match(/^\/(\S+)(?:\s+(.*))?$/)
-  if (!match) {
-    return { isCommand: false }
+
+  sessionLogger.log(`[ABORT+RETRY] Aborting session ${sessionId} for model change`)
+
+  // Abort with special reason so we don't show "completed" message
+  controller.abort('model-change')
+
+  // Also call the API abort endpoint
+  const getClient = await initializeOpencodeForDirectory(projectDirectory)
+  try {
+    await getClient().session.abort({ path: { id: sessionId } })
+  } catch (e) {
+    sessionLogger.log(`[ABORT+RETRY] API abort call failed (may already be done):`, e)
   }
-  const command = match[1]!
-  const args = match[2]?.trim() || ''
-  return { isCommand: true, command, arguments: args }
-}
 
-export const abortControllers = new Map<string, AbortController>()
+  // Small delay to let the abort propagate
+  await new Promise((resolve) => { setTimeout(resolve, 300) })
 
-export const pendingPermissions = new Map<
-  string,
-  { permission: Permission; messageId: string; directory: string }
->()
+  // Fetch last user message from API
+  sessionLogger.log(`[ABORT+RETRY] Fetching last user message for session ${sessionId}`)
+  const messagesResponse = await getClient().session.messages({ path: { id: sessionId } })
+  const messages = messagesResponse.data || []
+  const lastUserMessage = [...messages].reverse().find((m) => m.info.role === 'user')
+
+  if (!lastUserMessage) {
+    sessionLogger.log(`[ABORT+RETRY] No user message found in session ${sessionId}`)
+    return false
+  }
+
+  // Extract text and images from parts
+  const textPart = lastUserMessage.parts.find((p) => p.type === 'text') as { type: 'text'; text: string } | undefined
+  const prompt = textPart?.text || ''
+  const images = lastUserMessage.parts.filter((p) => p.type === 'file') as FilePartInput[]
+
+  sessionLogger.log(`[ABORT+RETRY] Re-triggering session ${sessionId} with new model`)
+
+  // Use setImmediate to avoid blocking
+  setImmediate(() => {
+    handleOpencodeSession({
+      prompt,
+      thread,
+      projectDirectory,
+      images,
+    }).catch(async (e) => {
+      sessionLogger.error(`[ABORT+RETRY] Failed to retry:`, e)
+      const errorMsg = e instanceof Error ? e.message : String(e)
+      await sendThreadMessage(thread, `✗ Failed to retry with new model: ${errorMsg.slice(0, 200)}`)
+    })
+  })
+
+  return true
+}
 
 export async function handleOpencodeSession({
   prompt,
@@ -48,16 +138,17 @@ export async function handleOpencodeSession({
   projectDirectory,
   originalMessage,
   images = [],
-  parsedCommand,
   channelId,
+  command,
 }: {
   prompt: string
   thread: ThreadChannel
   projectDirectory?: string
   originalMessage?: Message
   images?: FilePartInput[]
-  parsedCommand?: ParsedCommand
   channelId?: string
+  /** If set, uses session.command API instead of session.prompt */
+  command?: { name: string; arguments: string }
 }): Promise<{ sessionID: string; result: any; port?: number } | undefined> {
   voiceLogger.log(
     `[OPENCODE SESSION] Starting for thread ${thread.id} with prompt: "${prompt.slice(0, 50)}${prompt.length > 50 ? '...' : ''}"`,
@@ -160,9 +251,15 @@ export async function handleOpencodeSession({
     return
   }
 
-  const eventsResult = await getClient().event.subscribe({
-    signal: abortController.signal,
-  })
+  // Use v2 client for event subscription (has proper types for question.asked events)
+  const clientV2 = getOpencodeClientV2(directory)
+  if (!clientV2) {
+    throw new Error(`OpenCode v2 client not found for directory: ${directory}`)
+  }
+  const eventsResult = await clientV2.event.subscribe(
+    { directory },
+    { signal: abortController.signal }
+  )
 
   if (abortController.signal.aborted) {
     sessionLogger.log(`[DEBOUNCE] Aborted during subscribe, exiting`)
@@ -183,6 +280,7 @@ export async function handleOpencodeSession({
   let stopTyping: (() => void) | null = null
   let usedModel: string | undefined
   let usedProviderID: string | undefined
+  let usedAgent: string | undefined
   let tokensUsedInSession = 0
   let lastDisplayedContextPercentage = 0
   let modelContextLimit: number | undefined
@@ -233,7 +331,7 @@ export async function handleOpencodeSession({
   const sendPartMessage = async (part: Part) => {
     const content = formatPart(part) + '\n\n'
     if (!content.trim() || content.length === 0) {
-      discordLogger.log(`SKIP: Part ${part.id} has no content`)
+      // discordLogger.log(`SKIP: Part ${part.id} has no content`)
       return
     }
 
@@ -276,6 +374,7 @@ export async function handleOpencodeSession({
             assistantMessageId = msg.id
             usedModel = msg.modelID
             usedProviderID = msg.providerID
+            usedAgent = msg.mode
 
             if (tokensUsedInSession > 0 && usedProviderID && usedModel) {
               if (!modelContextLimit) {
@@ -296,7 +395,7 @@ export async function handleOpencodeSession({
                 const thresholdCrossed = Math.floor(currentPercentage / 10) * 10
                 if (thresholdCrossed > lastDisplayedContextPercentage && thresholdCrossed >= 10) {
                   lastDisplayedContextPercentage = thresholdCrossed
-                  await sendThreadMessage(thread, `◼︎ context usage ${currentPercentage}%`)
+                  await sendThreadMessage(thread, `⬥ context usage ${currentPercentage}%`)
                 }
               }
             }
@@ -372,7 +471,7 @@ export async function handleOpencodeSession({
             )
           }
           break
-        } else if (event.type === 'permission.updated') {
+        } else if (event.type === 'permission.asked') {
           const permission = event.properties
           if (permission.sessionID !== session.id) {
             voiceLogger.log(
@@ -382,18 +481,15 @@ export async function handleOpencodeSession({
           }
 
           sessionLogger.log(
-            `Permission requested: type=${permission.type}, title=${permission.title}`,
+            `Permission requested: permission=${permission.permission}, patterns=${permission.patterns.join(', ')}`,
           )
 
-          const patternStr = Array.isArray(permission.pattern)
-            ? permission.pattern.join(', ')
-            : permission.pattern || ''
+          const patternStr = permission.patterns.join(', ')
 
           const permissionMessage = await sendThreadMessage(
             thread,
             `⚠️ **Permission Required**\n\n` +
-              `**Type:** \`${permission.type}\`\n` +
-              `**Action:** ${permission.title}\n` +
+              `**Type:** \`${permission.permission}\`\n` +
               (patternStr ? `**Pattern:** \`${patternStr}\`\n` : '') +
               `\nUse \`/accept\` or \`/reject\` to respond.`,
           )
@@ -404,19 +500,40 @@ export async function handleOpencodeSession({
             directory,
           })
         } else if (event.type === 'permission.replied') {
-          const { permissionID, response, sessionID } = event.properties
+          const { requestID, reply, sessionID } = event.properties
           if (sessionID !== session.id) {
             continue
           }
 
           sessionLogger.log(
-            `Permission ${permissionID} replied with: ${response}`,
+            `Permission ${requestID} replied with: ${reply}`,
           )
 
           const pending = pendingPermissions.get(thread.id)
-          if (pending && pending.permission.id === permissionID) {
+          if (pending && pending.permission.id === requestID) {
             pendingPermissions.delete(thread.id)
           }
+        } else if (event.type === 'question.asked') {
+          const questionRequest = event.properties
+
+          if (questionRequest.sessionID !== session.id) {
+            sessionLogger.log(
+              `[QUESTION IGNORED] Question for different session (expected: ${session.id}, got: ${questionRequest.sessionID})`,
+            )
+            continue
+          }
+
+          sessionLogger.log(
+            `Question requested: id=${questionRequest.id}, questions=${questionRequest.questions.length}`,
+          )
+
+          await showAskUserQuestionDropdowns({
+            thread,
+            sessionId: session.id,
+            directory,
+            requestId: questionRequest.id,
+            input: { questions: questionRequest.questions },
+          })
         }
       }
     } catch (e) {
@@ -453,6 +570,7 @@ export async function handleOpencodeSession({
         )
         const attachCommand = port ? ` ⋅ ${session.id}` : ''
         const modelInfo = usedModel ? ` ⋅ ${usedModel}` : ''
+        const agentInfo = usedAgent && usedAgent.toLowerCase() !== 'build' ? ` ⋅ **${usedAgent}**` : ''
         let contextInfo = ''
 
         try {
@@ -467,8 +585,38 @@ export async function handleOpencodeSession({
           sessionLogger.error('Failed to fetch provider info for context percentage:', e)
         }
 
-        await sendThreadMessage(thread, `_Completed in ${sessionDuration}${contextInfo}_${attachCommand}${modelInfo}`)
+        await sendThreadMessage(thread, `_Completed in ${sessionDuration}${contextInfo}_${attachCommand}${modelInfo}${agentInfo}`, { flags: NOTIFY_MESSAGE_FLAGS })
         sessionLogger.log(`DURATION: Session completed in ${sessionDuration}, port ${port}, model ${usedModel}, tokens ${tokensUsedInSession}`)
+
+        // Process queued messages after completion
+        const queue = messageQueue.get(thread.id)
+        if (queue && queue.length > 0) {
+          const nextMessage = queue.shift()!
+          if (queue.length === 0) {
+            messageQueue.delete(thread.id)
+          }
+
+          sessionLogger.log(`[QUEUE] Processing queued message from ${nextMessage.username}`)
+
+          // Show that queued message is being sent
+          await sendThreadMessage(thread, `» **${nextMessage.username}:** ${nextMessage.prompt.slice(0, 150)}${nextMessage.prompt.length > 150 ? '...' : ''}`)
+
+          // Send the queued message as a new prompt (recursive call)
+          // Use setImmediate to avoid blocking and allow this finally to complete
+          setImmediate(() => {
+            handleOpencodeSession({
+              prompt: nextMessage.prompt,
+              thread,
+              projectDirectory,
+              images: nextMessage.images,
+              channelId,
+            }).catch(async (e) => {
+              sessionLogger.error(`[QUEUE] Failed to process queued message:`, e)
+              const errorMsg = e instanceof Error ? e.message : String(e)
+              await sendThreadMessage(thread, `✗ Queued message failed: ${errorMsg.slice(0, 200)}`)
+            })
+          })
+        }
       } else {
         sessionLogger.log(
           `Session was aborted (reason: ${abortController.signal.reason}), skipping duration message`,
@@ -487,56 +635,65 @@ export async function handleOpencodeSession({
 
     stopTyping = startTyping()
 
-    let response: { data?: unknown; error?: unknown; response: Response }
-    if (parsedCommand?.isCommand) {
-      sessionLogger.log(
-        `[COMMAND] Sending command /${parsedCommand.command} to session ${session.id} with args: "${parsedCommand.arguments.slice(0, 100)}${parsedCommand.arguments.length > 100 ? '...' : ''}"`,
-      )
-      response = await getClient().session.command({
-        path: { id: session.id },
-        body: {
-          command: parsedCommand.command,
-          arguments: parsedCommand.arguments,
-        },
-        signal: abortController.signal,
-      })
-    } else {
-      voiceLogger.log(
-        `[PROMPT] Sending prompt to session ${session.id}: "${prompt.slice(0, 100)}${prompt.length > 100 ? '...' : ''}"`,
-      )
-      if (images.length > 0) {
-        sessionLogger.log(`[PROMPT] Sending ${images.length} image(s):`, images.map((img) => ({ mime: img.mime, filename: img.filename, url: img.url.slice(0, 100) })))
+    voiceLogger.log(
+      `[PROMPT] Sending prompt to session ${session.id}: "${prompt.slice(0, 100)}${prompt.length > 100 ? '...' : ''}"`,
+    )
+    // append image paths to prompt so ai knows where they are on disk
+    const promptWithImagePaths = (() => {
+      if (images.length === 0) {
+        return prompt
       }
-
-      const parts = [{ type: 'text' as const, text: prompt }, ...images]
-      sessionLogger.log(`[PROMPT] Parts to send:`, parts.length)
-
-      // Get model preference: session-level overrides channel-level
-      const modelPreference = getSessionModel(session.id) || (channelId ? getChannelModel(channelId) : undefined)
-      const modelParam = (() => {
-        if (!modelPreference) {
-          return undefined
-        }
-        const [providerID, ...modelParts] = modelPreference.split('/')
-        const modelID = modelParts.join('/')
-        if (!providerID || !modelID) {
-          return undefined
-        }
-        sessionLogger.log(`[MODEL] Using model preference: ${modelPreference}`)
-        return { providerID, modelID }
-      })()
-
-      response = await getClient().session.prompt({
-        path: { id: session.id },
-        body: {
-          parts,
-          system: getOpencodeSystemMessage({ sessionId: session.id }),
-          model: modelParam,
-        },
-        signal: abortController.signal,
-      })
+      sessionLogger.log(`[PROMPT] Sending ${images.length} image(s):`, images.map((img) => ({ mime: img.mime, filename: img.filename, url: img.url.slice(0, 100) })))
+      const imagePathsList = images.map((img) => `- ${img.filename}: ${img.url}`).join('\n')
+      return `${prompt}\n\n**attached images:**\n${imagePathsList}`
+    })()
+
+    const parts = [{ type: 'text' as const, text: promptWithImagePaths }, ...images]
+    sessionLogger.log(`[PROMPT] Parts to send:`, parts.length)
+
+    // Get model preference: session-level overrides channel-level
+    const modelPreference = getSessionModel(session.id) || (channelId ? getChannelModel(channelId) : undefined)
+    const modelParam = (() => {
+      if (!modelPreference) {
+        return undefined
+      }
+      const [providerID, ...modelParts] = modelPreference.split('/')
+      const modelID = modelParts.join('/')
+      if (!providerID || !modelID) {
+        return undefined
+      }
+      sessionLogger.log(`[MODEL] Using model preference: ${modelPreference}`)
+      return { providerID, modelID }
+    })()
+
+    // Get agent preference: session-level overrides channel-level
+    const agentPreference = getSessionAgent(session.id) || (channelId ? getChannelAgent(channelId) : undefined)
+    if (agentPreference) {
+      sessionLogger.log(`[AGENT] Using agent preference: ${agentPreference}`)
     }
 
+    // Use session.command API for slash commands, session.prompt for regular messages
+    const response = command
+      ? await getClient().session.command({
+          path: { id: session.id },
+          body: {
+            command: command.name,
+            arguments: command.arguments,
+            agent: agentPreference,
+          },
+          signal: abortController.signal,
+        })
+      : await getClient().session.prompt({
+          path: { id: session.id },
+          body: {
+            parts,
+            system: getOpencodeSystemMessage({ sessionId: session.id }),
+            model: modelParam,
+            agent: agentPreference,
+          },
+          signal: abortController.signal,
+        })
+
     if (response.error) {
       const errorMessage = (() => {
         const err = response.error