@otto-assistant/bridge 0.4.92

package/src/opencode-command-detection.ts

@@ -0,0 +1,76 @@
+// Detect a /commandname token on its own line in a user prompt and resolve it
+// to a registered opencode command. Mirrors the Discord slash command flow
+// (commands/user-command.ts) so users can type `/build foo` or `/build-cmd foo`
+// in chat, via `/new-session`, through `kimaki send --prompt`, or scheduled
+// tasks and have it routed to opencode's session.command API instead of going
+// to the model as plain text.
+//
+// Detection is line-based: we scan each line and return the first one whose
+// first non-whitespace token is `/<registered-command>`. This keeps the
+// detector oblivious to prefix lines (`» **kimaki-cli:**`, `Context from
+// thread:`, etc). Producers that add such prefixes must put them on their
+// own line so the user's content starts on a fresh line.
+
+import type { RegisteredUserCommand } from './store.js'
+import { store } from './store.js'
+
+const DISCORD_SUFFIXES = ['-mcp-prompt', '-skill', '-cmd'] as const
+
+function stripDiscordSuffix(token: string): string {
+  for (const suffix of DISCORD_SUFFIXES) {
+    if (token.endsWith(suffix)) {
+      return token.slice(0, -suffix.length)
+    }
+  }
+  return token
+}
+
+// Resolve a /token against registeredUserCommands. When the list is empty
+// (gateway startup race), falls back to suffix-stripping so tokens like
+// /build-cmd still route to session.command('build'). Tokens without a
+// recognizable suffix return undefined to avoid false positives.
+function resolveCommandName({
+  token,
+  registered,
+}: {
+  token: string
+  registered: RegisteredUserCommand[]
+}): string | undefined {
+  const exact = registered.find((c) => {
+    return c.name === token || c.discordCommandName === token
+  })
+  if (exact) return exact.name
+
+  const base = stripDiscordSuffix(token)
+  if (base === token) return undefined
+
+  const stripped = registered.find((c) => {
+    return c.name === base || c.discordCommandName === base
+  })
+  if (stripped) return stripped.name
+
+  // Empty registry fallback: suffix was stripped, trust it
+  if (registered.length === 0) return base
+
+  return undefined
+}
+
+export function extractLeadingOpencodeCommand(
+  prompt: string,
+  registered: RegisteredUserCommand[] = store.getState().registeredUserCommands,
+): { command: { name: string; arguments: string } } | null {
+  if (!prompt) return null
+
+  for (const line of prompt.split('\n')) {
+    const trimmed = line.trimStart()
+    if (!trimmed.startsWith('/')) continue
+    const match = trimmed.match(/^\/([^\s]+)(?:\s+(.*))?$/)
+    if (!match) continue
+    const [, token, rest] = match
+    if (!token) continue
+    const name = resolveCommandName({ token, registered })
+    if (!name) continue
+    return { command: { name, arguments: (rest ?? '').trim() } }
+  }
+  return null
+}

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)
+  }
+}