kimaki 0.4.76 → 0.4.78

package/src/event-stream-real-capture.e2e.test.ts

@@ -3,7 +3,7 @@
 // (task, interruption, permission, action buttons, and question flows).
 
 import fs from 'node:fs'
-import net from 'node:net'
+
 import path from 'node:path'
 import { afterAll, afterEach, beforeAll, describe, expect, test } from 'vitest'
 import { ChannelType, Client, GatewayIntentBits, Partials, type APIMessage } from 'discord.js'
@@ -22,7 +22,7 @@ import {
   type VerbosityLevel,
 } from './database.js'
 import { startHranaServer, stopHranaServer } from './hrana-server.js'
-import { cleanupTestSessions } from './test-utils.js'
+import { chooseLockPort, cleanupTestSessions } from './test-utils.js'
 import { waitForBotMessageContaining, waitForBotReplyAfterUserMessage } from './test-utils.js'
 import { stopOpencodeServer } from './opencode.js'
 import { disposeRuntime, pendingPermissions } from './session-handler/thread-session-runtime.js'
@@ -69,23 +69,7 @@ function createRunDirectories() {
   }
 }
 
-function chooseLockPort(): Promise<number> {
-  return new Promise((resolve, reject) => {
-    const server = net.createServer()
-    server.listen(0, () => {
-      const address = server.address()
-      if (!address || typeof address === 'string') {
-        server.close()
-        reject(new Error('Failed to resolve lock port'))
-        return
-      }
-      const port = address.port
-      server.close(() => {
-        resolve(port)
-      })
-    })
-  })
-}
+
 
 function createDiscordJsClient({ restUrl }: { restUrl: string }) {
   return new Client({
@@ -327,7 +311,7 @@ describe('real event stream capture fixtures (cached provider)', () => {
 
   beforeAll(async () => {
     testStartTime = Date.now()
-    lockPort = await chooseLockPort()
+    lockPort = chooseLockPort({ key: TEXT_CHANNEL_ID })
 
     listJsonlFiles(directories.sessionEventsDir).forEach((fileName) => {
       fs.rmSync(path.join(directories.sessionEventsDir, fileName), {

package/src/gateway-proxy.e2e.test.ts

@@ -36,6 +36,7 @@ import { setDataDir } from './config.js'
 import type { VerbosityLevel } from './database.js'
 import { startDiscordBot } from './discord-bot.js'
 import {
+  chooseLockPort,
   cleanupTestSessions,
   waitForFooterMessage,
 } from './test-utils.js'
@@ -91,10 +92,6 @@ function createRunDirectories() {
   return { root, dataDir, projectDirectory }
 }
 
-function chooseLockPort(): Promise<number> {
-  return getAvailablePort()
-}
-
 function createDiscordJsClient({ restUrl }: { restUrl: string }) {
   return new Client({
     intents: [
@@ -253,7 +250,7 @@ describeIf('gateway-proxy e2e', () => {
 
   beforeAll(async () => {
     testStartTime = Date.now()
-    const lockPort = await chooseLockPort()
+    const lockPort = chooseLockPort({ key: CHANNEL_1_ID })
     directories = createRunDirectories()
     process.env['KIMAKI_LOCK_PORT'] = String(lockPort)
     process.env['KIMAKI_VITEST'] = '1'

package/src/interaction-handler.ts

@@ -90,6 +90,10 @@ import { handleContextUsageCommand } from './commands/context-usage.js'
 import { handleSessionIdCommand } from './commands/session-id.js'
 import { handleUpgradeAndRestartCommand } from './commands/upgrade.js'
 import { handleMcpCommand, handleMcpSelectMenu } from './commands/mcp.js'
+import {
+  handleScreenshareCommand,
+  handleScreenshareStopCommand,
+} from './commands/screenshare.js'
 import { handleModelVariantSelectMenu } from './commands/model.js'
 import {
   handleModelVariantCommand,
@@ -328,6 +332,17 @@ export function registerInteractionHandler({
             case 'mcp':
               await handleMcpCommand({ command: interaction, appId })
               return
+
+            case 'screenshare':
+              await handleScreenshareCommand({ command: interaction, appId })
+              return
+
+            case 'screenshare-stop':
+              await handleScreenshareStopCommand({
+                command: interaction,
+                appId,
+              })
+              return
           }
 
           // Handle quick agent commands (ending with -agent suffix, but not the base /agent command)

package/src/kimaki-digital-twin.e2e.test.ts

@@ -2,7 +2,6 @@
 // Verifies onboarding channel creation, message -> thread creation, and assistant reply.
 
 import fs from 'node:fs'
-import net from 'node:net'
 import path from 'node:path'
 import { expect, test } from 'vitest'
 import { ChannelType, Client, GatewayIntentBits, Partials } from 'discord.js'
@@ -17,7 +16,7 @@ import {
   setChannelDirectory,
 } from './database.js'
 import { startHranaServer, stopHranaServer } from './hrana-server.js'
-import { cleanupTestSessions } from './test-utils.js'
+import { cleanupTestSessions, chooseLockPort } from './test-utils.js'
 import { stopOpencodeServer } from './opencode.js'
 
 const geminiApiKey =
@@ -44,24 +43,6 @@ function createRunDirectories() {
   }
 }
 
-function chooseLockPort(): Promise<number> {
-  return new Promise((resolve, reject) => {
-    const server = net.createServer()
-    server.listen(0, () => {
-      const address = server.address()
-      if (!address || typeof address === 'string') {
-        server.close()
-        reject(new Error('Failed to resolve lock port'))
-        return
-      }
-      const port = address.port
-      server.close(() => {
-        resolve(port)
-      })
-    })
-  })
-}
-
 function createDiscordJsClient({ restUrl }: { restUrl: string }) {
   return new Client({
     intents: [
@@ -88,7 +69,7 @@ e2eTest(
   async () => {
     const testStartTime = Date.now()
     const directories = createRunDirectories()
-    const lockPort = await chooseLockPort()
+    const lockPort = chooseLockPort({ key: 'kimaki-digital-twin-e2e' })
 
     process.env['KIMAKI_LOCK_PORT'] = String(lockPort)
     setDataDir(directories.dataDir)

package/src/message-formatting.ts

@@ -13,6 +13,7 @@ import * as errore from 'errore'
 import { createLogger, LogPrefix } from './logger.js'
 import { FetchError } from './errors.js'
 import { processImage } from './image-utils.js'
+import { parsePatchFileCounts } from './patch-text-parser.js'
 
 // Generic message type compatible with both v1 and v2 SDK
 type GenericSessionMessage = {
@@ -61,73 +62,7 @@ function escapeInlineMarkdown(text: string): string {
   return text.replace(/([*_~|`\\])/g, '\\$1')
 }
 
-/**
- * Parses a patchText string (apply_patch format) and counts additions/deletions per file.
- * Patch format uses `*** Add File:`, `*** Update File:`, `*** Delete File:` headers,
- * with diff lines prefixed by `+` (addition) or `-` (deletion) inside `@@` hunks.
- */
-function parsePatchCounts(
-  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
-}
+// parsePatchCounts → imported from patch-text-parser.ts as parsePatchFileCounts
 
 /**
  * Normalize whitespace: convert newlines to spaces and collapse consecutive spaces.
@@ -299,7 +234,7 @@ export function getToolSummaryText(part: Part): string {
     if (!patchText) {
       return ''
     }
-    const patchCounts = parsePatchCounts(patchText)
+    const patchCounts = parsePatchFileCounts(patchText)
     return [...patchCounts.entries()]
       .map(([filePath, { additions, deletions }]) => {
         const fileName = filePath.split('/').pop() || ''

package/src/onboarding-tutorial-plugin.ts

@@ -58,7 +58,7 @@ const onboardingTutorialPlugin: Plugin = async () => {
           }
 
           output.parts.push({
-            id: crypto.randomUUID(),
+            id: `prt_${crypto.randomUUID()}`,
             sessionID,
             messageID: firstText.messageID,
             type: 'text' as const,

package/src/opencode-command.test.ts

@@ -0,0 +1,70 @@
+// Regression tests for Windows OpenCode command resolution and spawn args.
+
+import { describe, expect, test } from 'vitest'
+import {
+  getSpawnCommandAndArgs,
+  selectResolvedCommand,
+  splitCommandLookupOutput,
+} from './opencode-command.js'
+
+describe('splitCommandLookupOutput', () => {
+  test('splits windows command lookup output into trimmed lines', () => {
+    expect(
+      splitCommandLookupOutput(
+        'C:\\Program Files\\nodejs\\opencode\r\nC:\\Program Files\\nodejs\\opencode.cmd\r\n',
+      ),
+    ).toEqual([
+      'C:\\Program Files\\nodejs\\opencode',
+      'C:\\Program Files\\nodejs\\opencode.cmd',
+    ])
+  })
+})
+
+describe('selectResolvedCommand', () => {
+  test('prefers npm cmd shims on windows', () => {
+    expect(
+      selectResolvedCommand({
+        output: 'C:\\Program Files\\nodejs\\opencode\r\nC:\\Program Files\\nodejs\\opencode.cmd\r\n',
+        isWindows: true,
+      }),
+    ).toBe('C:\\Program Files\\nodejs\\opencode.cmd')
+  })
+
+  test('keeps first result on non-windows platforms', () => {
+    expect(
+      selectResolvedCommand({
+        output: '/usr/local/bin/opencode\n/opt/homebrew/bin/opencode\n',
+        isWindows: false,
+      }),
+    ).toBe('/usr/local/bin/opencode')
+  })
+})
+
+describe('getSpawnCommandAndArgs', () => {
+  test('wraps windows cmd shims through cmd.exe without double-quoting by node', () => {
+    expect(
+      getSpawnCommandAndArgs({
+        resolvedCommand: 'C:\\Program Files\\nodejs\\opencode.cmd',
+        baseArgs: ['serve', '--port', '4096'],
+        platform: 'win32',
+      }),
+    ).toEqual({
+      command: 'cmd.exe',
+      args: ['/d', '/s', '/c', '"C:\\Program Files\\nodejs\\opencode.cmd"', 'serve', '--port', '4096'],
+      windowsVerbatimArguments: true,
+    })
+  })
+
+  test('leaves direct executables unchanged on windows', () => {
+    expect(
+      getSpawnCommandAndArgs({
+        resolvedCommand: 'C:\\tools\\opencode.exe',
+        baseArgs: ['serve', '--port', '4096'],
+        platform: 'win32',
+      }),
+    ).toEqual({
+      command: 'C:\\tools\\opencode.exe',
+      args: ['serve', '--port', '4096'],
+    })
+  })
+})

package/src/opencode-command.ts

@@ -0,0 +1,188 @@
+// Shared OpenCode and Kimaki command resolution helpers.
+// Normalizes `which`/`where` output across platforms, builds safe spawn
+// arguments for Windows npm `.cmd` shims without relying on `shell: true`,
+// and creates a stable `kimaki` shim for OpenCode child processes.
+
+import fs from 'node:fs'
+import path from 'node:path'
+
+const WINDOWS_CMD_SHIM_REGEX = /\.(cmd|bat)$/i
+
+function quotePosixShellSegment(value: string): string {
+  return `'${value.replaceAll("'", `'\\''`)}'`
+}
+
+export function splitCommandLookupOutput(output: string): string[] {
+  return output
+    .split(/\r?\n/g)
+    .map((line) => {
+      return line.trim()
+    })
+    .filter((line) => {
+      return line.length > 0
+    })
+}
+
+export function selectResolvedCommand({
+  output,
+  isWindows,
+}: {
+  output: string
+  isWindows: boolean
+}): string | null {
+  const lines = splitCommandLookupOutput(output)
+  if (lines.length === 0) {
+    return null
+  }
+  if (!isWindows) {
+    return lines[0] || null
+  }
+  const cmdShim = lines.find((line) => {
+    return WINDOWS_CMD_SHIM_REGEX.test(line)
+  })
+  return cmdShim || lines[0] || null
+}
+
+function quoteWindowsCommandSegment(value: string): string {
+  if (!/[\s"]/u.test(value)) {
+    return value
+  }
+  return `"${value.replaceAll('"', '\\"')}"`
+}
+
+export function getSpawnCommandAndArgs({
+  resolvedCommand,
+  baseArgs,
+  platform,
+}: {
+  resolvedCommand: string
+  baseArgs: string[]
+  platform?: NodeJS.Platform
+}): {
+  command: string
+  args: string[]
+  windowsVerbatimArguments?: boolean
+} {
+  const effectivePlatform = platform || process.platform
+  if (effectivePlatform !== 'win32') {
+    return { command: resolvedCommand, args: baseArgs }
+  }
+
+  if (!WINDOWS_CMD_SHIM_REGEX.test(resolvedCommand)) {
+    return { command: resolvedCommand, args: baseArgs }
+  }
+
+  return {
+    command: 'cmd.exe',
+    args: [
+      '/d',
+      '/s',
+      '/c',
+      quoteWindowsCommandSegment(resolvedCommand),
+      ...baseArgs.map((arg) => {
+        return quoteWindowsCommandSegment(arg)
+      }),
+    ],
+    // Let cmd.exe receive the command line exactly as constructed above.
+    // Without this, Node re-quotes the executable segment and npm shim paths
+    // like `C:\Program Files\nodejs\opencode.cmd` break again.
+    windowsVerbatimArguments: true,
+  }
+}
+
+export function ensureKimakiCommandShim({
+  dataDir,
+  execPath,
+  execArgv,
+  entryScript,
+  platform,
+}: {
+  dataDir: string
+  execPath: string
+  execArgv: string[]
+  entryScript: string
+  platform?: NodeJS.Platform
+}): string | Error {
+  const effectivePlatform = platform || process.platform
+  const shimDirectory = path.join(dataDir, 'bin')
+
+  try {
+    fs.mkdirSync(shimDirectory, { recursive: true })
+    const launcherArgs = [...execArgv, entryScript]
+
+    if (effectivePlatform === 'win32') {
+      const shimPath = path.join(shimDirectory, 'kimaki.cmd')
+      const shimContent = [
+        '@echo off',
+        [execPath, ...launcherArgs].map((segment) => {
+          return `"${segment.replaceAll('"', '""')}"`
+        }).join(' ') + ' %*',
+        '',
+      ].join('\r\n')
+      writeShimIfNeeded({
+        shimPath,
+        shimContent,
+      })
+      return shimDirectory
+    }
+
+    const shimPath = path.join(shimDirectory, 'kimaki')
+    const shimContent = [
+      '#!/bin/sh',
+      `exec ${[execPath, ...launcherArgs].map((segment) => {
+        return quotePosixShellSegment(segment)
+      }).join(' ')} "$@"`,
+      '',
+    ].join('\n')
+    writeShimIfNeeded({
+      shimPath,
+      shimContent,
+      mode: 0o755,
+    })
+    return shimDirectory
+  } catch (cause) {
+    return new Error('Failed to create kimaki command shim', { cause })
+  }
+}
+
+export function prependPathEntry({
+  entry,
+  existingPath,
+}: {
+  entry: string
+  existingPath?: string
+}): string {
+  const pathEntries = (existingPath || '').split(path.delimiter).filter((segment) => {
+    return segment.length > 0
+  })
+  if (pathEntries.includes(entry)) {
+    return existingPath || entry
+  }
+  return [entry, ...pathEntries].join(path.delimiter)
+}
+
+export function getPathEnvKey(env: NodeJS.ProcessEnv): string {
+  return Object.keys(env).find((key) => {
+    return key.toLowerCase() === 'path'
+  }) || 'PATH'
+}
+
+function writeShimIfNeeded({
+  shimPath,
+  shimContent,
+  mode,
+}: {
+  shimPath: string
+  shimContent: string
+  mode?: number
+}): void {
+  const existingContent = fs.existsSync(shimPath)
+    ? fs.readFileSync(shimPath, 'utf8')
+    : null
+  if (existingContent !== shimContent) {
+    fs.writeFileSync(shimPath, shimContent, 'utf8')
+  }
+  if (mode !== undefined) {
+    fs.chmodSync(shimPath, mode)
+  }
+}

package/src/opencode-interrupt-plugin.test.ts

@@ -121,11 +121,6 @@ function createChatOutput({
       sessionID,
       role: 'user',
       time: { created: Date.now() },
-      agent: 'build',
-      model: {
-        providerID: 'deterministic-provider',
-        modelID: 'deterministic-v2',
-      },
     },
     parts: parts || [{ type: 'text', text: 'user message' }],
   } as InterruptChatOutput

package/src/opencode-interrupt-plugin.ts

@@ -13,6 +13,13 @@ type PendingMessage = {
   started: boolean
   timer: ReturnType<typeof setTimeout>
   abortAfterStepMessageID: string | undefined
+  agent: string | undefined
+  model:
+    | {
+        providerID: string
+        modelID: string
+      }
+    | undefined
 }
 
 type EventWaiter = {
@@ -100,6 +107,8 @@ const interruptOpencodeSessionOnUserMessage: Plugin = async (ctx) => {
       started: false,
       timer,
       abortAfterStepMessageID: latestAssistantMessageIDBySession.get(sessionID),
+      agent: undefined,
+      model: undefined,
     })
   }
 
@@ -176,9 +185,27 @@ 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: []
+        agent?: string
+        model?: {
+          providerID: string
+          modelID: string
+        }
+      } = { parts: [] }
+      if (currentPending.agent) {
+        resumeBody.agent = currentPending.agent
+      }
+      if (currentPending.model) {
+        resumeBody.model = currentPending.model
+      }
+
       await ctx.client.session.promptAsync({
         path: { id: sessionID },
-        body: { parts: [] },
+        body: resumeBody,
       })
       clearPendingByMessageId({ messageID })
 
@@ -287,6 +314,12 @@ const interruptOpencodeSessionOnUserMessage: Plugin = async (ctx) => {
         sessionID,
         delayMs: interruptStepTimeoutMs,
       })
+      const pending = pendingByMessageId.get(messageID)
+      if (!pending) {
+        return
+      }
+      pending.agent = output.message.agent
+      pending.model = output.message.model
     },
   }
 }

package/src/opencode-plugin-loading.e2e.test.ts

@@ -5,31 +5,15 @@
 
 import { spawn, type ChildProcess } from 'node:child_process'
 import fs from 'node:fs'
-import net from 'node:net'
 import path from 'node:path'
 import { fileURLToPath } from 'node:url'
 import { test, expect } from 'vitest'
 import { resolveOpencodeCommand } from './opencode.js'
+import { getSpawnCommandAndArgs } from './opencode-command.js'
+import { chooseLockPort } from './test-utils.js'
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url))
 
-async function getOpenPort(): Promise<number> {
-  return new Promise((resolve, reject) => {
-    const server = net.createServer()
-    server.listen(0, () => {
-      const address = server.address()
-      if (address && typeof address === 'object') {
-        server.close(() => {
-          resolve(address.port)
-        })
-      } else {
-        reject(new Error('Failed to get port'))
-      }
-    })
-    server.on('error', reject)
-  })
-}
-
 async function waitForHealth({
   port,
   maxAttempts = 30,
@@ -59,27 +43,33 @@ test(
     const projectDir = path.resolve(process.cwd(), 'tmp', 'plugin-loading-e2e')
     fs.mkdirSync(projectDir, { recursive: true })
 
-    const port = await getOpenPort()
+    const port = chooseLockPort({ key: 'opencode-plugin-loading-e2e' })
     const pluginPath = new URL('../src/opencode-plugin.ts', import.meta.url).href
     const stderrLines: string[] = []
 
-    const serverProcess: ChildProcess = spawn(
-      resolveOpencodeCommand(),
-      ['serve', '--port', port.toString(), '--print-logs', '--log-level', 'DEBUG'],
-      {
-        stdio: 'pipe',
-        cwd: projectDir,
-        env: {
-          ...process.env,
-          OPENCODE_CONFIG_CONTENT: JSON.stringify({
-            $schema: 'https://opencode.ai/config.json',
-            lsp: false,
-            formatter: false,
-            plugin: [pluginPath],
-          }),
-        },
+    const {
+      command,
+      args,
+      windowsVerbatimArguments,
+    } = getSpawnCommandAndArgs({
+      resolvedCommand: resolveOpencodeCommand(),
+      baseArgs: ['serve', '--port', port.toString(), '--print-logs', '--log-level', 'DEBUG'],
+    })
+
+    const serverProcess: ChildProcess = spawn(command, args, {
+      stdio: 'pipe',
+      cwd: projectDir,
+      windowsVerbatimArguments,
+      env: {
+        ...process.env,
+        OPENCODE_CONFIG_CONTENT: JSON.stringify({
+          $schema: 'https://opencode.ai/config.json',
+          lsp: false,
+          formatter: false,
+          plugin: [pluginPath],
+        }),
       },
-    )
+    })
 
     serverProcess.stderr?.on('data', (data) => {
       stderrLines.push(...data.toString().split('\n').filter(Boolean))