kimaki 0.4.90 → 0.4.91

package/src/opencode-interrupt-plugin.ts

@@ -10,15 +10,24 @@
 // forgetting to clear a timer.
 
 import type { Plugin } from '@opencode-ai/plugin'
+import type {
+  Part,
+  TextPartInput,
+  FilePartInput,
+  AgentPartInput,
+  SubtaskPartInput,
+} from '@opencode-ai/sdk'
 
 type PluginHooks = Awaited<ReturnType<Plugin>>
 type InterruptEvent = Parameters<NonNullable<PluginHooks['event']>>[0]['event']
+type PromptPartInput = TextPartInput | FilePartInput | AgentPartInput | SubtaskPartInput
 
 type PendingMessage = {
   sessionID: string
   started: boolean
   timer: ReturnType<typeof setTimeout>
   abortAfterStepMessageID: string | undefined
+  parts: PromptPartInput[]
   agent: string | undefined
   model:
     | {
@@ -28,6 +37,62 @@ type PendingMessage = {
     | undefined
 }
 
+type InterruptChatOutput =
+  NonNullable<PluginHooks['chat.message']> extends (
+    input: unknown,
+    output: infer T,
+  ) => Promise<void>
+    ? T
+    : never
+
+function toPromptParts(parts: Part[]): PromptPartInput[] {
+  return parts.reduce<PromptPartInput[]>((acc, part) => {
+    if (part.type === 'text') {
+      acc.push({
+        id: part.id,
+        type: 'text',
+        text: part.text,
+        synthetic: part.synthetic,
+        ignored: part.ignored,
+        time: part.time,
+        metadata: part.metadata,
+      })
+      return acc
+    }
+    if (part.type === 'file') {
+      acc.push({
+        id: part.id,
+        type: 'file',
+        mime: part.mime,
+        filename: part.filename,
+        url: part.url,
+        source: part.source,
+      })
+      return acc
+    }
+    if (part.type === 'agent') {
+      acc.push({
+        id: part.id,
+        type: 'agent',
+        name: part.name,
+        source: part.source,
+      })
+      return acc
+    }
+    if (part.type === 'subtask') {
+      acc.push({
+        id: part.id,
+        type: 'subtask',
+        prompt: part.prompt,
+        description: part.description,
+        agent: part.agent,
+      })
+      return acc
+    }
+    return acc
+  }, [])
+}
+
 type EventWaiter = {
   match: (event: InterruptEvent) => boolean
   finish: () => void
@@ -134,11 +199,13 @@ function createInterruptState() {
     schedulePending({
       messageID,
       sessionID,
+      parts,
       delayMs,
       onTimeout,
     }: {
       messageID: string
       sessionID: string
+      parts: PromptPartInput[]
       delayMs: number
       onTimeout: () => void
     }): void {
@@ -152,6 +219,7 @@ function createInterruptState() {
         started: false,
         timer,
         abortAfterStepMessageID: latestAssistantMessageIDBySession.get(sessionID),
+        parts,
         agent: undefined,
         model: undefined,
       })
@@ -223,6 +291,7 @@ const interruptOpencodeSessionOnUserMessage: Plugin = async (ctx) => {
       state.schedulePending({
         messageID,
         sessionID,
+        parts: pending.parts,
         delayMs: 200,
         onTimeout: () => {
           void interruptPendingMessage(messageID)
@@ -263,24 +332,30 @@ const interruptOpencodeSessionOnUserMessage: Plugin = async (ctx) => {
         return
       }
 
-      // Keep the queued user message execution context across abort+resume.
-      // Without this, OpenCode re-resolves model defaults and can ignore
-      // /model session overrides (issue #77).
-      const resumeBody: {
-        parts: []
+      // Resubmit the original queued user message after abort.
+      // session.abort() clears OpenCode's internal prompt queue, so resuming
+      // with an empty parts array can silently drop the user's message.
+      // Keep the original messageID + parts and preserve agent/model context so
+      // session overrides (issue #77) survive the abort + replay path.
+      const replayBody: {
+        messageID: string
+        parts: PromptPartInput[]
         agent?: string
         model?: { providerID: string; modelID: string }
-      } = { parts: [] }
+      } = {
+        messageID,
+        parts: currentPending.parts,
+      }
       if (currentPending.agent) {
-        resumeBody.agent = currentPending.agent
+        replayBody.agent = currentPending.agent
       }
       if (currentPending.model) {
-        resumeBody.model = currentPending.model
+        replayBody.model = currentPending.model
       }
 
       await ctx.client.session.promptAsync({
         path: { id: sessionID },
-        body: resumeBody,
+        body: replayBody,
       })
       state.clearPending(messageID)
 
@@ -291,6 +366,7 @@ const interruptOpencodeSessionOnUserMessage: Plugin = async (ctx) => {
       state.schedulePending({
         messageID: nextPending.messageID,
         sessionID,
+        parts: nextPending.pending.parts,
         delayMs: 50,
         onTimeout: () => {
           void interruptPendingMessage(nextPending.messageID)
@@ -382,6 +458,7 @@ const interruptOpencodeSessionOnUserMessage: Plugin = async (ctx) => {
       state.schedulePending({
         messageID,
         sessionID,
+        parts: toPromptParts(output.parts),
         delayMs: interruptStepTimeoutMs,
         onTimeout: () => {
           void interruptPendingMessage(messageID)

package/src/opencode.ts

@@ -462,10 +462,14 @@ async function startSingleServer(): Promise<ServerStartError | SingleServer> {
 
   const port = await getOpenPort()
 
-  const serveArgs = ['serve', '--port', port.toString()]
-  if (store.getState().verboseOpencodeServer) {
-    serveArgs.push('--print-logs', '--log-level', 'DEBUG')
-  }
+  const serveArgs = [
+    'serve',
+    '--port',
+    port.toString(),
+    '--print-logs',
+    '--log-level',
+    'WARN',
+  ]
 
   const {
     command: spawnCommand,
@@ -621,7 +625,6 @@ async function startSingleServer(): Promise<ServerStartError | SingleServer> {
   startingServerProcess = serverProcess
 
   // Buffer logs until we know if server started successfully.
-  // Once ready, switch to forwarding if --verbose-opencode-server is set.
   const logBuffer: string[] = []
   const startupStderrTail: string[] = []
   let serverReady = false
@@ -638,10 +641,8 @@ async function startSingleServer(): Promise<ServerStartError | SingleServer> {
         logBuffer.push(...lines.map((line) => `[stdout] ${line}`))
         return
       }
-      if (store.getState().verboseOpencodeServer) {
-        for (const line of lines) {
-          opencodeLogger.log(`[server:${port}] ${line}`)
-        }
+      for (const line of lines) {
+        opencodeLogger.log(line)
       }
     } catch (error) {
       logBuffer.push(`Failed to process stdout startup logs: ${error}`)
@@ -657,10 +658,8 @@ async function startSingleServer(): Promise<ServerStartError | SingleServer> {
         pushStartupStderrTail({ stderrTail: startupStderrTail, chunk })
         return
       }
-      if (store.getState().verboseOpencodeServer) {
-        for (const line of lines) {
-          opencodeLogger.error(`[server:${port}] ${line}`)
-        }
+      for (const line of lines) {
+        opencodeLogger.error(line)
       }
     } catch (error) {
       logBuffer.push(`Failed to process stderr startup logs: ${error}`)
@@ -738,12 +737,10 @@ async function startSingleServer(): Promise<ServerStartError | SingleServer> {
   serverReady = true
   opencodeLogger.log(`Server ready on port ${port}`)
 
-  // When verbose mode is enabled, also dump startup logs so plugin loading
-  // errors and other startup output are visible in kimaki.log.
-  if (store.getState().verboseOpencodeServer) {
-    for (const line of logBuffer) {
-      opencodeLogger.log(`[server:${port}:startup] ${line}`)
-    }
+  // Always dump startup logs so plugin loading errors and other startup output
+  // are visible in kimaki.log.
+  for (const line of logBuffer) {
+    opencodeLogger.log(line)
   }
 
   const server: SingleServer = {
@@ -824,9 +821,6 @@ export async function initializeOpencodeForDirectory(
 
   if (!initializedDirectories.has(directory)) {
     initializedDirectories.add(directory)
-    opencodeLogger.log(
-      `Using shared server on port ${server.port} for directory: ${directory}`,
-    )
   }
 
   return () => {

package/src/plugin-logger.ts

@@ -0,0 +1,68 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import util from 'node:util'
+import { sanitizeSensitiveText, sanitizeUnknownValue } from './privacy-sanitizer.js'
+
+let pluginLogFilePath: string | null = null
+
+export function setPluginLogFilePath(dataDir: string): void {
+  pluginLogFilePath = path.join(dataDir, 'kimaki.log')
+}
+
+function formatArg(arg: unknown): string {
+  if (typeof arg === 'string') {
+    return sanitizeSensitiveText(arg, { redactPaths: false })
+  }
+  const safeArg = sanitizeUnknownValue(arg, { redactPaths: false })
+  return util.inspect(safeArg, { colors: false, depth: 4 })
+}
+
+export function formatPluginErrorWithStack(error: unknown): string {
+  if (error instanceof Error) {
+    return sanitizeSensitiveText(
+      error.stack ?? `${error.name}: ${error.message}`,
+      { redactPaths: false },
+    )
+  }
+  if (typeof error === 'string') {
+    return sanitizeSensitiveText(error, { redactPaths: false })
+  }
+
+  const safeError = sanitizeUnknownValue(error, { redactPaths: false })
+  return sanitizeSensitiveText(util.inspect(safeError, { colors: false, depth: 4 }), {
+    redactPaths: false,
+  })
+}
+
+function writeToFile(level: string, prefix: string, args: unknown[]) {
+  if (!pluginLogFilePath) {
+    return
+  }
+  const timestamp = new Date().toISOString()
+  const message = `[${timestamp}] [${level}] [${prefix}] ${args.map(formatArg).join(' ')}\n`
+  try {
+    fs.appendFileSync(pluginLogFilePath, message)
+  } catch {
+    // Plugin logging must never break the OpenCode plugin process.
+  }
+}
+
+export function createPluginLogger(prefix: string) {
+  return {
+    log: (...args: unknown[]) => {
+      writeToFile('LOG', prefix, args)
+    },
+    info: (...args: unknown[]) => {
+      writeToFile('INFO', prefix, args)
+    },
+    warn: (...args: unknown[]) => {
+      writeToFile('WARN', prefix, args)
+    },
+    error: (...args: unknown[]) => {
+      writeToFile('ERROR', prefix, args)
+    },
+    debug: (...args: unknown[]) => {
+      writeToFile('DEBUG', prefix, args)
+    },
+  }
+}

package/src/queue-advanced-permissions-typing.e2e.test.ts

@@ -121,12 +121,12 @@ describe('queue advanced: typing around permissions', () => {
         "--- from: user (queue-permission-tester)
         PERMISSION_TYPING_MARKER
         --- from: assistant (TestBot)
+        ⬥ requesting external read permission
         ⚠️ **Permission Required**
         **Type:** \`external_directory\`
         Agent is accessing files outside the project. [Learn more](https://opencode.ai/docs/permissions/#external-directories)
         **Pattern:** \`/Users/morse/*\`
         ✅ Permission **accepted**
-        ⬥ requesting external read permission
         [user clicks button]
         ⬥ permission-flow-done
         *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"