kimaki 0.4.76 → 0.4.78

package/src/opencode-plugin.ts

@@ -344,7 +344,7 @@ const kimakiPlugin: Plugin = async ({ directory }) => {
             if (memoryContent) {
               const condensed = condenseMemoryMd(memoryContent)
               output.parts.push({
-                id: crypto.randomUUID(),
+                id: `prt_${crypto.randomUUID()}`,
                 sessionID,
                 messageID,
                 type: 'text' as const,
@@ -386,7 +386,7 @@ const kimakiPlugin: Plugin = async ({ directory }) => {
               })
 
               output.parts.push({
-                id: crypto.randomUUID(),
+                id: `prt_${crypto.randomUUID()}`,
                 sessionID,
                 messageID,
                 type: 'text' as const,
@@ -398,7 +398,7 @@ const kimakiPlugin: Plugin = async ({ directory }) => {
               // When the user comes back after a long break, remind the model
               // to save any important context from the previous conversation.
               output.parts.push({
-                id: crypto.randomUUID(),
+                id: `prt_${crypto.randomUUID()}`,
                 sessionID,
                 messageID,
                 type: 'text' as const,
@@ -425,7 +425,7 @@ const kimakiPlugin: Plugin = async ({ directory }) => {
 
               sessionGitStates.set(sessionID, gitState)
               output.parts.push({
-                id: crypto.randomUUID(),
+                id: `prt_${crypto.randomUUID()}`,
                 sessionID,
                 messageID,
                 type: 'text' as const,
@@ -481,3 +481,4 @@ const kimakiPlugin: Plugin = async ({ directory }) => {
 export { kimakiPlugin }
 export { interruptOpencodeSessionOnUserMessage } from './opencode-interrupt-plugin.js'
 export { onboardingTutorialPlugin } from './onboarding-tutorial-plugin.js'
+

package/src/opencode.ts

@@ -57,6 +57,13 @@ import {
   FetchError,
   type OpenCodeErrors,
 } from './errors.js'
+import {
+  ensureKimakiCommandShim,
+  getPathEnvKey,
+  getSpawnCommandAndArgs,
+  prependPathEntry,
+  selectResolvedCommand,
+} from './opencode-command.js'
 
 const opencodeLogger = createLogger(LogPrefix.OPENCODE)
 
@@ -181,6 +188,8 @@ type ServerLifecycleEvent =
 let singleServer: SingleServer | null = null
 let serverRetryCount = 0
 const serverLifecycleListeners = new Set<(event: ServerLifecycleEvent) => void>()
+let processCleanupHandlersRegistered = false
+let startingServerProcess: ChildProcess | null = null
 
 // Cached SDK clients per directory. Each client has a fixed
 // x-opencode-directory header pointing to its project directory.
@@ -201,6 +210,107 @@ export function subscribeOpencodeServerLifecycle(
   }
 }
 
+function killSingleServerProcessNow({
+  reason,
+}: {
+  reason: string
+}): void {
+  if (!singleServer) {
+    return
+  }
+
+  const serverProcess = singleServer.process
+  const pid = serverProcess.pid
+  if (!pid || serverProcess.killed) {
+    return
+  }
+
+  const killResult = errore.try({
+    try: () => {
+      serverProcess.kill('SIGTERM')
+    },
+    catch: (error) => {
+      return new Error('Failed to send SIGTERM to opencode server', {
+        cause: error,
+      })
+    },
+  })
+
+  if (killResult instanceof Error) {
+    opencodeLogger.warn(
+      `[cleanup:${reason}] ${killResult.message} (pid: ${pid}, port: ${singleServer.port})`,
+    )
+    return
+  }
+
+  opencodeLogger.log(
+    `[cleanup:${reason}] Sent SIGTERM to opencode server (pid: ${pid}, port: ${singleServer.port})`,
+  )
+}
+
+function killStartingServerProcessNow({
+  reason,
+}: {
+  reason: string
+}): void {
+  const serverProcess = startingServerProcess
+  if (!serverProcess) {
+    return
+  }
+
+  const pid = serverProcess.pid
+  if (!pid || serverProcess.killed) {
+    return
+  }
+
+  const killResult = errore.try({
+    try: () => {
+      serverProcess.kill('SIGTERM')
+    },
+    catch: (error) => {
+      return new Error('Failed to send SIGTERM to starting opencode server', {
+        cause: error,
+      })
+    },
+  })
+
+  if (killResult instanceof Error) {
+    opencodeLogger.warn(
+      `[cleanup:${reason}] ${killResult.message} (pid: ${pid})`,
+    )
+    return
+  }
+
+  opencodeLogger.log(
+    `[cleanup:${reason}] Sent SIGTERM to starting opencode server (pid: ${pid})`,
+  )
+}
+
+function ensureProcessCleanupHandlersRegistered(): void {
+  if (processCleanupHandlersRegistered) {
+    return
+  }
+  processCleanupHandlersRegistered = true
+
+  opencodeLogger.log('Registering process cleanup handlers for opencode server')
+
+  process.on('exit', () => {
+    killSingleServerProcessNow({ reason: 'process-exit' })
+    killStartingServerProcessNow({ reason: 'process-exit' })
+  })
+
+  // Fallback for short-lived CLI subcommands that call process.exit without
+  // running discord-bot.ts shutdown handlers.
+  process.on('SIGINT', () => {
+    killSingleServerProcessNow({ reason: 'sigint' })
+    killStartingServerProcessNow({ reason: 'sigint' })
+  })
+  process.on('SIGTERM', () => {
+    killSingleServerProcessNow({ reason: 'sigterm' })
+    killStartingServerProcessNow({ reason: 'sigterm' })
+  })
+}
+
 // ── Resolve opencode binary ──────────────────────────────────────
 // Resolve the full path to the opencode binary so we can spawn without
 // shell: true. Using shell: true creates an intermediate sh process — when
@@ -216,18 +326,32 @@ export function resolveOpencodeCommand(): string {
 
   const envPath = process.env.OPENCODE_PATH
   if (envPath) {
-    resolvedOpencodeCommand = envPath
-    return envPath
+    const resolvedFromEnv = selectResolvedCommand({
+      output: envPath,
+      isWindows: process.platform === 'win32',
+    })
+    if (resolvedFromEnv) {
+      resolvedOpencodeCommand = resolvedFromEnv
+      return resolvedFromEnv
+    }
   }
 
   const isWindows = process.platform === 'win32'
   const whichCmd = isWindows ? 'where' : 'which'
-  const result = errore.tryFn({
+  const result = errore.try({
     try: () => {
-      return execFileSync(whichCmd, ['opencode'], {
+      const commandOutput = execFileSync(whichCmd, ['opencode'], {
         encoding: 'utf8',
         timeout: 5000,
-      }).trim().split('\n')[0]!.trim()
+      })
+      const resolved = selectResolvedCommand({
+        output: commandOutput,
+        isWindows,
+      })
+      if (resolved) {
+        return resolved
+      }
+      throw new Error('opencode not found in PATH')
     },
     catch: () => new Error('opencode not found in PATH'),
   })
@@ -243,25 +367,6 @@ export function resolveOpencodeCommand(): string {
   opencodeLogger.log(`Resolved opencode binary: ${result}`)
   return result
 }
-
-/**
- * Build the spawn command and args, handling Windows .cmd shims.
- * On Windows, .cmd/.bat files can't be spawned directly without a shell —
- * we wrap them with cmd.exe /d /s /c instead of using shell: true
- * (which creates an intermediate sh process that eats SIGTERM).
- */
-function getSpawnCommandAndArgs(baseArgs: string[]): { command: string; args: string[] } {
-  const resolved = resolveOpencodeCommand()
-  if (process.platform !== 'win32') {
-    return { command: resolved, args: baseArgs }
-  }
-  const lower = resolved.toLowerCase()
-  if (lower.endsWith('.cmd') || lower.endsWith('.bat')) {
-    return { command: 'cmd.exe', args: ['/d', '/s', '/c', `"${resolved}"`, ...baseArgs] }
-  }
-  return { command: resolved, args: baseArgs }
-}
-
 async function getOpenPort(): Promise<number> {
   return new Promise((resolve, reject) => {
     const server = net.createServer()
@@ -346,6 +451,8 @@ async function ensureSingleServer(): Promise<ServerStartError | SingleServer> {
 }
 
 async function startSingleServer(): Promise<ServerStartError | SingleServer> {
+  ensureProcessCleanupHandlersRegistered()
+
   const port = await getOpenPort()
 
   const serveArgs = ['serve', '--port', port.toString()]
@@ -353,7 +460,14 @@ async function startSingleServer(): Promise<ServerStartError | SingleServer> {
     serveArgs.push('--print-logs', '--log-level', 'DEBUG')
   }
 
-  const { command: spawnCommand, args: spawnArgs } = getSpawnCommandAndArgs(serveArgs)
+  const {
+    command: spawnCommand,
+    args: spawnArgs,
+    windowsVerbatimArguments,
+  } = getSpawnCommandAndArgs({
+    resolvedCommand: resolveOpencodeCommand(),
+    baseArgs: serveArgs,
+  })
 
   // Server config uses permissive defaults. Per-directory external_directory
   // permissions are set at session creation time via session.create({ permission }).
@@ -380,6 +494,22 @@ async function startSingleServer(): Promise<ServerStartError | SingleServer> {
     [kimakiDataDir]: 'allow',
     [`${kimakiDataDir}/*`]: 'allow',
   }
+  const kimakiShimDirectory = ensureKimakiCommandShim({
+    dataDir: getDataDir(),
+    execPath: process.execPath,
+    execArgv: process.execArgv,
+    entryScript: process.argv[1] || fileURLToPath(new URL('../bin.js', import.meta.url)),
+  })
+  const pathEnvKey = getPathEnvKey(process.env)
+  const pathEnv = kimakiShimDirectory instanceof Error
+    ? process.env[pathEnvKey]
+    : prependPathEntry({
+        entry: kimakiShimDirectory,
+        existingPath: process.env[pathEnvKey],
+      })
+  if (kimakiShimDirectory instanceof Error) {
+    opencodeLogger.warn(kimakiShimDirectory.message)
+  }
 
   const serverProcess = spawn(
     spawnCommand,
@@ -387,6 +517,7 @@ async function startSingleServer(): Promise<ServerStartError | SingleServer> {
     {
       stdio: 'pipe',
       detached: false,
+      windowsVerbatimArguments,
       // No project-specific cwd — the server handles all directories via
       // x-opencode-directory header. Use home dir as a neutral working dir.
       cwd: os.homedir(),
@@ -437,10 +568,13 @@ async function startSingleServer(): Promise<ServerStartError | SingleServer> {
         ...(process.env.KIMAKI_SENTRY_DSN && {
           KIMAKI_SENTRY_DSN: process.env.KIMAKI_SENTRY_DSN,
         }),
+        ...(pathEnv && { [pathEnvKey]: pathEnv }),
       },
     },
   )
 
+  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[] = []
@@ -493,6 +627,10 @@ async function startSingleServer(): Promise<ServerStartError | SingleServer> {
   })
 
   serverProcess.on('exit', (code, signal) => {
+    if (startingServerProcess === serverProcess) {
+      startingServerProcess = null
+    }
+
     opencodeLogger.log(
       `Opencode server exited with code: ${code}, signal: ${signal}`,
     )
@@ -538,6 +676,11 @@ async function startSingleServer(): Promise<ServerStartError | SingleServer> {
     startupStderrTail,
   })
   if (waitResult instanceof Error) {
+    killStartingServerProcessNow({ reason: 'startup-failed' })
+    if (startingServerProcess === serverProcess) {
+      startingServerProcess = null
+    }
+
     // Dump buffered logs on failure
     opencodeLogger.error(`Server failed to start:`)
     for (const line of logBuffer) {
@@ -561,6 +704,9 @@ async function startSingleServer(): Promise<ServerStartError | SingleServer> {
     port,
     baseUrl: `http://127.0.0.1:${port}`,
   }
+  if (startingServerProcess === serverProcess) {
+    startingServerProcess = null
+  }
   singleServer = server
   notifyServerLifecycle({ type: 'started', port })
   return server
@@ -700,6 +846,24 @@ export function buildSessionPermissions({
     { permission: 'external_directory', pattern: `${kimakiDataDir}/*`, action: 'allow' },
   )
 
+  // Allow opencode tool output artifacts under XDG data so agents can inspect
+  // prior tool outputs without interactive permission prompts.
+  const opencodeToolOutputDir = path
+    .join(os.homedir(), '.local', 'share', 'opencode', 'tool-output')
+    .replaceAll('\\', '/')
+  rules.push(
+    {
+      permission: 'external_directory',
+      pattern: opencodeToolOutputDir,
+      action: 'allow',
+    },
+    {
+      permission: 'external_directory',
+      pattern: `${opencodeToolOutputDir}/*`,
+      action: 'allow',
+    },
+  )
+
   // For worktrees: allow access to the original repository directory
   if (originalRepo) {
     rules.push(
@@ -737,19 +901,19 @@ export async function stopOpencodeServer(): Promise<boolean> {
     return false
   }
 
+  const server = singleServer
   opencodeLogger.log(
-    `Stopping opencode server (pid: ${singleServer.process.pid}, port: ${singleServer.port})`,
+    `Stopping opencode server (pid: ${server.process.pid}, port: ${server.port})`,
   )
-  if (!singleServer.process.killed) {
+  if (!server.process.killed) {
     const killResult = errore.try({
       try: () => {
-        singleServer!.process.kill('SIGTERM')
+        server.process.kill('SIGTERM')
       },
       catch: (error) => {
-        return new Error(
-          `Failed to send SIGTERM to opencode server`,
-          { cause: error },
-        )
+        return new Error('Failed to send SIGTERM to opencode server', {
+          cause: error,
+        })
       },
     })
     if (killResult instanceof Error) {
@@ -757,6 +921,9 @@ export async function stopOpencodeServer(): Promise<boolean> {
     }
   }
 
+  killStartingServerProcessNow({ reason: 'stop-opencode-server' })
+  startingServerProcess = null
+
   singleServer = null
   clientCache.clear()
   serverRetryCount = 0

package/src/patch-text-parser.ts

@@ -0,0 +1,107 @@
+// Shared apply_patch text parsing utilities.
+// Used by diff-patch-plugin.ts (file path extraction for snapshots) and
+// message-formatting.ts (per-file addition/deletion counts for Discord display).
+//
+// The apply_patch tool uses three path header formats:
+//   *** Add File: path    — new file
+//   *** Update File: path — existing file edit
+//   *** Delete File: path — file removal
+//   *** Move to: path     — rename destination
+//   --- a/path / +++ b/path — unified diff headers (fallback)
+
+/**
+ * Extract all file paths referenced in a patchText string.
+ * Handles custom apply_patch headers, move targets, and unified diff headers.
+ * Returns deduplicated paths.
+ */
+export function extractPatchFilePaths(patchText: string): string[] {
+  const custom = [
+    ...patchText.matchAll(
+      /^\*\*\* (?:Add|Update|Delete) File:\s+(.+)$/gm,
+    ),
+  ].map((m) => {
+    return (m[1] ?? '').trim()
+  })
+  const moved = [
+    ...patchText.matchAll(/^\*\*\* Move to:\s+(.+)$/gm),
+  ].map((m) => {
+    return (m[1] ?? '').trim()
+  })
+  const unified = [
+    ...patchText.matchAll(/^(?:---|\+\+\+) [ab]\/(.+)$/gm),
+  ].map((m) => {
+    return (m[1] ?? '').trim()
+  })
+  const all = [...custom, ...moved, ...unified].filter(Boolean)
+  return all.filter((v, i, a) => {
+    return a.indexOf(v) === i
+  })
+}
+
+/**
+ * Parse a patchText string and count additions/deletions per file.
+ * Patch format uses `*** Add File:`, `*** Update File:`, `*** Delete File:` headers,
+ * with diff lines prefixed by `+` (addition) or `-` (deletion) inside `@@` hunks.
+ */
+export function parsePatchFileCounts(
+  patchText: string,
+): Map<string, { additions: number; deletions: number }> {
+  const counts = new Map<string, { additions: number; deletions: number }>()
+  const lines = patchText.split('\n')
+  let currentFile = ''
+  let currentType = ''
+  let inHunk = false
+
+  for (const line of lines) {
+    const addMatch = line.match(/^\*\*\* Add File:\s*(.+)/)
+    const updateMatch = line.match(/^\*\*\* Update File:\s*(.+)/)
+    const deleteMatch = line.match(/^\*\*\* Delete File:\s*(.+)/)
+
+    if (addMatch || updateMatch || deleteMatch) {
+      const match = addMatch || updateMatch || deleteMatch
+      currentFile = (match?.[1] ?? '').trim()
+      currentType = addMatch ? 'add' : updateMatch ? 'update' : 'delete'
+      counts.set(currentFile, { additions: 0, deletions: 0 })
+      inHunk = false
+      continue
+    }
+
+    if (line.startsWith('@@')) {
+      inHunk = true
+      continue
+    }
+
+    if (line.startsWith('*** ')) {
+      inHunk = false
+      continue
+    }
+
+    if (!currentFile) {
+      continue
+    }
+
+    const entry = counts.get(currentFile)
+    if (!entry) {
+      continue
+    }
+
+    if (currentType === 'add') {
+      // all content lines in Add File are additions
+      if (line.length > 0 && !line.startsWith('*** ')) {
+        entry.additions++
+      }
+    } else if (currentType === 'delete') {
+      // all content lines in Delete File are deletions
+      if (line.length > 0 && !line.startsWith('*** ')) {
+        entry.deletions++
+      }
+    } else if (inHunk) {
+      if (line.startsWith('+')) {
+        entry.additions++
+      } else if (line.startsWith('-')) {
+        entry.deletions++
+      }
+    }
+  }
+  return counts
+}