kimaki 0.4.25 → 0.4.26

package/src/message-formatting.ts

@@ -2,12 +2,31 @@
 // Converts SDK message parts (text, tools, reasoning) to Discord-friendly format,
 // handles file attachments, and provides tool summary generation.
 
-import type { Part, FilePartInput, SessionMessagesResponse } from '@opencode-ai/sdk'
+import type { Part } from '@opencode-ai/sdk/v2'
+import type { FilePartInput } from '@opencode-ai/sdk'
 import type { Message } from 'discord.js'
+import fs from 'node:fs'
+import path from 'node:path'
 import { createLogger } from './logger.js'
 
+// Generic message type compatible with both v1 and v2 SDK
+type GenericSessionMessage = {
+  info: { role: string; id?: string }
+  parts: Part[]
+}
+
+const ATTACHMENTS_DIR = path.join(process.cwd(), 'tmp', 'discord-attachments')
+
 const logger = createLogger('FORMATTING')
 
+/**
+ * Escapes Discord inline markdown characters so dynamic content
+ * doesn't break formatting when wrapped in *, _, **, etc.
+ */
+function escapeInlineMarkdown(text: string): string {
+  return text.replace(/([*_~|`\\])/g, '\\$1')
+}
+
 /**
  * Collects and formats the last N assistant parts from session messages.
  * Used by both /resume and /fork to show recent assistant context.
@@ -16,7 +35,7 @@ export function collectLastAssistantParts({
   messages,
   limit = 30,
 }: {
-  messages: SessionMessagesResponse
+  messages: GenericSessionMessage[]
   limit?: number
 }): { partIds: string[]; content: string; skippedCount: number } {
   const allAssistantParts: { id: string; content: string }[] = []
@@ -85,7 +104,7 @@ export async function getTextAttachments(message: Message): Promise<string> {
   return textContents.join('\n\n')
 }
 
-export function getFileAttachments(message: Message): FilePartInput[] {
+export async function getFileAttachments(message: Message): Promise<FilePartInput[]> {
   const fileAttachments = Array.from(message.attachments.values()).filter(
     (attachment) => {
       const contentType = attachment.contentType || ''
@@ -95,12 +114,44 @@ export function getFileAttachments(message: Message): FilePartInput[] {
     },
   )
 
-  return fileAttachments.map((attachment) => ({
-    type: 'file' as const,
-    mime: attachment.contentType || 'application/octet-stream',
-    filename: attachment.name,
-    url: attachment.url,
-  }))
+  if (fileAttachments.length === 0) {
+    return []
+  }
+
+  // ensure tmp directory exists
+  if (!fs.existsSync(ATTACHMENTS_DIR)) {
+    fs.mkdirSync(ATTACHMENTS_DIR, { recursive: true })
+  }
+
+  const results = await Promise.all(
+    fileAttachments.map(async (attachment) => {
+      try {
+        const response = await fetch(attachment.url)
+        if (!response.ok) {
+          logger.error(`Failed to fetch attachment ${attachment.name}: ${response.status}`)
+          return null
+        }
+
+        const buffer = Buffer.from(await response.arrayBuffer())
+        const localPath = path.join(ATTACHMENTS_DIR, `${message.id}-${attachment.name}`)
+        fs.writeFileSync(localPath, buffer)
+
+        logger.log(`Downloaded attachment to ${localPath}`)
+
+        return {
+          type: 'file' as const,
+          mime: attachment.contentType || 'application/octet-stream',
+          filename: attachment.name,
+          url: localPath,
+        }
+      } catch (error) {
+        logger.error(`Error downloading attachment ${attachment.name}:`, error)
+        return null
+      }
+    }),
+  )
+
+  return results.filter((r) => r !== null) as FilePartInput[]
 }
 
 export function getToolSummaryText(part: Part): string {
@@ -113,7 +164,7 @@ export function getToolSummaryText(part: Part): string {
     const added = newString.split('\n').length
     const removed = oldString.split('\n').length
     const fileName = filePath.split('/').pop() || ''
-    return fileName ? `*${fileName}* (+${added}-${removed})` : `(+${added}-${removed})`
+    return fileName ? `*${escapeInlineMarkdown(fileName)}* (+${added}-${removed})` : `(+${added}-${removed})`
   }
 
   if (part.tool === 'write') {
@@ -121,35 +172,35 @@ export function getToolSummaryText(part: Part): string {
     const content = (part.state.input?.content as string) || ''
     const lines = content.split('\n').length
     const fileName = filePath.split('/').pop() || ''
-    return fileName ? `*${fileName}* (${lines} line${lines === 1 ? '' : 's'})` : `(${lines} line${lines === 1 ? '' : 's'})`
+    return fileName ? `*${escapeInlineMarkdown(fileName)}* (${lines} line${lines === 1 ? '' : 's'})` : `(${lines} line${lines === 1 ? '' : 's'})`
   }
 
   if (part.tool === 'webfetch') {
     const url = (part.state.input?.url as string) || ''
     const urlWithoutProtocol = url.replace(/^https?:\/\//, '')
-    return urlWithoutProtocol ? `*${urlWithoutProtocol}*` : ''
+    return urlWithoutProtocol ? `*${escapeInlineMarkdown(urlWithoutProtocol)}*` : ''
   }
 
   if (part.tool === 'read') {
     const filePath = (part.state.input?.filePath as string) || ''
     const fileName = filePath.split('/').pop() || ''
-    return fileName ? `*${fileName}*` : ''
+    return fileName ? `*${escapeInlineMarkdown(fileName)}*` : ''
   }
 
   if (part.tool === 'list') {
     const path = (part.state.input?.path as string) || ''
     const dirName = path.split('/').pop() || path
-    return dirName ? `*${dirName}*` : ''
+    return dirName ? `*${escapeInlineMarkdown(dirName)}*` : ''
   }
 
   if (part.tool === 'glob') {
     const pattern = (part.state.input?.pattern as string) || ''
-    return pattern ? `*${pattern}*` : ''
+    return pattern ? `*${escapeInlineMarkdown(pattern)}*` : ''
   }
 
   if (part.tool === 'grep') {
     const pattern = (part.state.input?.pattern as string) || ''
-    return pattern ? `*${pattern}*` : ''
+    return pattern ? `*${escapeInlineMarkdown(pattern)}*` : ''
   }
 
   if (part.tool === 'bash' || part.tool === 'todoread' || part.tool === 'todowrite') {
@@ -158,12 +209,12 @@ export function getToolSummaryText(part: Part): string {
 
   if (part.tool === 'task') {
     const description = (part.state.input?.description as string) || ''
-    return description ? `_${description}_` : ''
+    return description ? `_${escapeInlineMarkdown(description)}_` : ''
   }
 
   if (part.tool === 'skill') {
     const name = (part.state.input?.name as string) || ''
-    return name ? `_${name}_` : ''
+    return name ? `_${escapeInlineMarkdown(name)}_` : ''
   }
 
   if (!part.state.input) return ''
@@ -194,12 +245,25 @@ export function formatTodoList(part: Part): string {
   })
   const activeTodo = todos[activeIndex]
   if (activeIndex === -1 || !activeTodo) return ''
-  return `${activeIndex + 1}. **${activeTodo.content}**`
+  // parenthesized digits ⑴-⒇ for 1-20, fallback to regular number for 21+
+  const parenthesizedDigits = '⑴⑵⑶⑷⑸⑹⑺⑻⑼⑽⑾⑿⒀⒁⒂⒃⒄⒅⒆⒇'
+  const todoNumber = activeIndex + 1
+  const num = todoNumber <= 20 ? parenthesizedDigits[todoNumber - 1] : `(${todoNumber})`
+  const content = activeTodo.content.charAt(0).toLowerCase() + activeTodo.content.slice(1)
+  return `${num} **${escapeInlineMarkdown(content)}**`
 }
 
 export function formatPart(part: Part): string {
   if (part.type === 'text') {
     if (!part.text?.trim()) return ''
+    const trimmed = part.text.trimStart()
+    const firstChar = trimmed[0] || ''
+    const markdownStarters = ['#', '*', '_', '-', '>', '`', '[', '|']
+    const startsWithMarkdown =
+      markdownStarters.includes(firstChar) || /^\d+\./.test(trimmed)
+    if (startsWithMarkdown) {
+      return `\n${part.text}`
+    }
     return `⬥ ${part.text}`
   }
 
@@ -229,6 +293,11 @@ export function formatPart(part: Part): string {
       return formatTodoList(part)
     }
 
+    // Question tool is handled via Discord dropdowns, not text
+    if (part.tool === 'question') {
+      return ''
+    }
+
     if (part.state.status === 'pending') {
       return ''
     }
@@ -243,16 +312,15 @@ export function formatPart(part: Part): string {
       const command = (part.state.input?.command as string) || ''
       const description = (part.state.input?.description as string) || ''
       const isSingleLine = !command.includes('\n')
-      const hasUnderscores = command.includes('_')
-      if (isSingleLine && !hasUnderscores && command.length <= 50) {
-        toolTitle = `_${command}_`
+      if (isSingleLine && command.length <= 50) {
+        toolTitle = `_${escapeInlineMarkdown(command)}_`
       } else if (description) {
-        toolTitle = `_${description}_`
+        toolTitle = `_${escapeInlineMarkdown(description)}_`
       } else if (stateTitle) {
-        toolTitle = `_${stateTitle}_`
+        toolTitle = `_${escapeInlineMarkdown(stateTitle)}_`
       }
     } else if (stateTitle) {
-      toolTitle = `_${stateTitle}_`
+      toolTitle = `_${escapeInlineMarkdown(stateTitle)}_`
     }
 
     const icon = (() => {

package/src/opencode.ts

@@ -3,12 +3,17 @@
 // 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')
@@ -18,6 +23,7 @@ const opencodeServers = new Map<
   {
     process: ChildProcess
     client: OpencodeClient
+    clientV2: OpencodeClientV2
     port: number
   }
 >()
@@ -46,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) {}
+    } catch (e) {
+      // Re-throw fatal errors that won't resolve with retrying
+      if ((e as Error).message?.includes('Server failed to start')) {
+        throw e
+      }
+      opencodeLogger.debug(`Server polling attempt failed: ${(e as Error).message}`)
+    }
     await new Promise((resolve) => setTimeout(resolve, 1000))
   }
   throw new Error(
@@ -85,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,
@@ -113,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
@@ -151,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,
   })
 
@@ -182,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
+}