ocpipe 0.6.10 → 0.6.12

package/src/agent.ts

@@ -1,41 +1,40 @@
 /**
  * ocpipe agent integration.
  *
- * Dispatches to OpenCode CLI, Claude Code SDK, Codex SDK, or Pi based on backend
- * configuration.
+ * Dispatches prompts to configured coding-agent backends.
  */
 
-import { spawn } from 'child_process'
-import { mkdir, writeFile, unlink } from 'fs/promises'
+import { spawn, type ChildProcess } from 'child_process'
+import { createWriteStream, type WriteStream } from 'fs'
+import { randomUUID } from 'crypto'
+import { mkdir, readFile, unlink, writeFile } from 'fs/promises'
 import { join } from 'path'
+import { OutputLimitError } from './errors.js'
 import { PROJECT_ROOT, TMP_DIR } from './paths.js'
+import type { RunAgentOptions, RunAgentResult } from './types.js'
 import { runOmpAgent } from './omp.js'
 import { runPiAgent } from './pi.js'
-import type { RunAgentOptions, RunAgentResult } from './types.js'
 
-/** Get command and args to invoke opencode from PATH */
-function getOpencodeCommand(args: string[]): { cmd: string; args: string[] } {
-  return { cmd: 'opencode', args }
-}
-
-/** runAgent dispatches to the appropriate backend based on model configuration. */
+/** runAgent dispatches to the selected backend. */
 export async function runAgent(
   options: RunAgentOptions,
 ): Promise<RunAgentResult> {
-  const backend = options.model.backend ?? 'opencode'
+  const backend = options.model.backend ?? 'omp'
 
   if (backend === 'claude-code') {
-    // Dynamic import is required: @anthropic-ai/claude-agent-sdk is an optional peer absent for other backends.
     const { runClaudeCodeAgent } = await import('./claude-code.js')
     return runClaudeCodeAgent(options)
   }
 
   if (backend === 'codex') {
-    // Dynamic import is required: @openai/codex-sdk is an optional peer absent for other backends.
     const { runCodexAgent } = await import('./codex.js')
     return runCodexAgent(options)
   }
 
+  if (backend === 'opencode') {
+    return runOpencodeAgent(options)
+  }
+
   if (backend === 'pi') {
     return runPiAgent(options)
   }
@@ -44,52 +43,257 @@ export async function runAgent(
     return runOmpAgent(options)
   }
 
-  return runOpencodeAgent(options)
+  const unreachable: never = backend
+  throw new Error(`Unsupported backend: ${unreachable}`)
+}
+const MAX_CHILD_OUTPUT_BYTES = 512 * 1024 * 1024
+const MAX_STDERR_LINE_BYTES = 8 * 1024 * 1024
+
+class OutputBudget {
+  private usedBytes = 0
+
+  reserve(bytes: number, source: string): void {
+    if (this.usedBytes + bytes > MAX_CHILD_OUTPUT_BYTES) {
+      throw new OutputLimitError(
+        `OpenCode ${source} output`,
+        MAX_CHILD_OUTPUT_BYTES,
+      )
+    }
+    this.usedBytes += bytes
+  }
+}
+
+class OutputFile {
+  private readonly stream: WriteStream
+  private readonly onError: (error: Error) => void
+  private error: Error | undefined
+  private closePromise: Promise<void> | undefined
+
+  constructor(
+    readonly path: string,
+    budget: OutputBudget,
+    source: string,
+    onError: (error: Error) => void,
+  ) {
+    this.onError = onError
+    this.stream = createWriteStream(path, { mode: 0o600 })
+    this.stream.on('error', (error) => {
+      this.fail(error)
+    })
+    this.budget = budget
+    this.source = source
+  }
+
+  private readonly budget: OutputBudget
+  private readonly source: string
+
+  get failed(): boolean {
+    return this.error !== undefined
+  }
+
+  write(chunk: Buffer): boolean {
+    if (this.error) return false
+    try {
+      this.budget.reserve(chunk.byteLength, this.source)
+    } catch (error) {
+      this.fail(error)
+      return false
+    }
+    return this.stream.write(chunk)
+  }
+
+  async waitForDrain(): Promise<void> {
+    if (!this.stream.writableNeedDrain || this.error) return
+    await new Promise<void>((resolve) => {
+      const done = () => {
+        this.stream.removeListener('drain', done)
+        this.stream.removeListener('error', done)
+        resolve()
+      }
+      this.stream.once('drain', done)
+      this.stream.once('error', done)
+    })
+  }
+
+  close(): Promise<void> {
+    if (this.closePromise) return this.closePromise
+    this.closePromise = new Promise<void>((resolve) => {
+      const done = () => {
+        this.stream.removeListener('finish', done)
+        this.stream.removeListener('close', done)
+        this.stream.removeListener('error', done)
+        resolve()
+      }
+      if (this.stream.destroyed || this.stream.writableFinished) {
+        resolve()
+        return
+      }
+      this.stream.once('finish', done)
+      this.stream.once('close', done)
+      this.stream.once('error', done)
+      this.stream.end()
+    })
+    return this.closePromise
+  }
+
+  private fail(error: unknown): void {
+    if (this.error) return
+    this.error = error instanceof Error ? error : new Error(String(error))
+    this.onError(this.error)
+  }
+}
+
+async function writeChildChunk(
+  stream: { pause?: () => unknown; resume?: () => unknown },
+  file: OutputFile,
+  chunk: Buffer,
+): Promise<void> {
+  if (file.write(chunk) && !file.failed) return
+  if (file.failed) return
+  stream.pause?.()
+  await file.waitForDrain()
+  if (!file.failed) stream.resume?.()
+}
+async function writeConsoleChunk(chunk: Buffer): Promise<void> {
+  if (process.stderr.write(chunk)) return
+  await new Promise<void>((resolve) => {
+    process.stderr.once('drain', resolve)
+  })
+}
+
+class StderrTracker {
+  private pending = ''
+  private readonly diagnosticLines: string[] = []
+  private readonly lastLines: string[] = []
+  private matchedErrorPattern: RegExp | undefined
+  private knownError = false
+  private sawError = false
+  private sessionId = ''
+
+  consume(text: string): void {
+    let cursor = 0
+    while (cursor < text.length) {
+      const newline = text.indexOf('\n', cursor)
+      if (newline < 0) {
+        this.append(text.slice(cursor))
+        return
+      }
+      this.append(text.slice(cursor, newline))
+      cursor = newline + 1
+      this.recordLine(this.pending)
+      this.pending = ''
+    }
+  }
+
+  finish(): void {
+    if (this.pending) {
+      this.recordLine(this.pending)
+      this.pending = ''
+    }
+  }
+
+  get hasKnownError(): boolean {
+    return this.knownError
+  }
+  get knownErrorPattern(): RegExp | undefined {
+    return this.matchedErrorPattern
+  }
+
+  get hasError(): boolean {
+    return this.sawError
+  }
+
+  get newSessionId(): string {
+    return this.sessionId
+  }
+
+  getLastLines(count: number): string {
+    return this.lastLines.slice(-count).join('\n')
+  }
+
+  getDiagnosticLines(): string {
+    return this.diagnosticLines.join('\n')
+  }
+
+  private append(text: string): void {
+    if (
+      Buffer.byteLength(this.pending, 'utf8') +
+        Buffer.byteLength(text, 'utf8') >
+      MAX_STDERR_LINE_BYTES
+    ) {
+      throw new OutputLimitError('OpenCode stderr line', MAX_STDERR_LINE_BYTES)
+    }
+    this.pending += text
+  }
+
+  private recordLine(line: string): void {
+    this.lastLines.push(line)
+    if (this.lastLines.length > 10) this.lastLines.shift()
+    if (line.includes('Error')) this.sawError = true
+
+    if (line.startsWith('[session:')) {
+      this.sessionId = line.trim().slice(9, -1)
+      return
+    }
+    for (const { pattern } of knownOpenCodeErrors) {
+      if (pattern.test(line)) {
+        this.knownError = true
+        this.matchedErrorPattern ??= pattern
+      }
+    }
+
+    if (
+      line.includes('Error') ||
+      line.includes('error:') ||
+      knownOpenCodeErrors.some(({ pattern }) => pattern.test(line))
+    ) {
+      if (this.diagnosticLines.length < 5) this.diagnosticLines.push(line)
+    }
+  }
 }
 
-/** runOpencodeAgent executes an OpenCode agent with a prompt, streaming output in real-time. */
 async function runOpencodeAgent(
   options: RunAgentOptions,
 ): Promise<RunAgentResult> {
   const {
     prompt,
-    agent,
     model,
     sessionId,
     timeoutSec = 3600,
     workdir,
+    opencode,
     signal,
   } = options
 
   if (!model.providerID) {
     throw new Error('providerID is required for OpenCode backend')
   }
-  const modelStr = `${model.providerID}/${model.modelID}`
-  const sessionInfo = sessionId ? `[session:${sessionId}]` : '[new session]'
-  const promptPreview = prompt.slice(0, 50).replace(/\n/g, ' ')
 
-  console.error(
-    `\n>>> OpenCode [${agent}] [${modelStr}] ${sessionInfo}: ${promptPreview}...`,
-  )
-
-  // Check if already aborted
   if (signal?.aborted) {
     throw new Error('Request aborted')
   }
 
-  // Write prompt to .opencode/prompts/ within the working directory
   const cwd = workdir ?? PROJECT_ROOT
-  const promptsDir = join(cwd, '.opencode', 'prompts')
-  await mkdir(promptsDir, { recursive: true })
-  const promptFile = join(promptsDir, `prompt_${Date.now()}.txt`)
+  const modelStr = `${model.providerID}/${model.modelID}`
+  const sessionInfo = sessionId ? `[session:${sessionId}]` : '[new session]'
+  const promptPreview = prompt.slice(0, 50).replace(/\n/g, ' ')
+  console.error(
+    `\n>>> OpenCode [${modelStr}] ${sessionInfo}: ${promptPreview}...`,
+  )
+
+  const promptDir = opencode?.promptDir ?? TMP_DIR
+  await mkdir(promptDir, { recursive: true })
+  await mkdir(TMP_DIR, { recursive: true })
+  const promptFile = join(promptDir, `ocpipe_prompt_${randomUUID()}.txt`)
+  const outputId = randomUUID()
+  const stdoutPath = join(TMP_DIR, `ocpipe_output_${outputId}.stdout`)
+  const stderrPath = join(TMP_DIR, `ocpipe_output_${outputId}.stderr`)
   await writeFile(promptFile, prompt)
 
   const args = [
     'run',
     '--format',
     'default',
-    '--agent',
-    agent,
     '--model',
     modelStr,
     '--prompt-file',
@@ -99,11 +303,9 @@ async function runOpencodeAgent(
   if (sessionId) {
     args.push('--session', sessionId)
   }
-
   if (model.variant) {
     args.push('--model-variant', model.variant)
   }
-
   if (model.variantThinkingBudget !== undefined) {
     args.push(
       '--model-variant-thinking-budget',
@@ -111,139 +313,175 @@ async function runOpencodeAgent(
     )
   }
 
-  return new Promise((resolve, reject) => {
-    const opencodeCmd = getOpencodeCommand(args)
-    console.error(
-      `[DEBUG] Running: ${opencodeCmd.cmd} ${opencodeCmd.args.join(' ')}`,
-    )
-    const proc = spawn(opencodeCmd.cmd, opencodeCmd.args, {
-      cwd,
-      stdio: ['ignore', 'pipe', 'pipe'],
-    })
+  const command = opencode?.command ?? 'opencode'
+  console.error(`[DEBUG] Running: ${command} ${args.join(' ')}`)
+
+  const { promise, resolve, reject } = Promise.withResolvers<RunAgentResult>()
+  const budget = new OutputBudget()
+  const stderrTracker = new StderrTracker()
+  let proc: ChildProcess | undefined
+  const timers: { timeout?: NodeJS.Timeout } = {}
+  let settled = false
+  let closeFilesPromise: Promise<void> | undefined
+  let killTimer: NodeJS.Timeout | undefined
+  let cleanupPromise: Promise<void> | undefined
+
+  const closeFiles = (): Promise<void> => {
+    if (!closeFilesPromise) {
+      closeFilesPromise = Promise.all([
+        stdoutFile.close(),
+        stderrFile.close(),
+      ]).then(() => undefined)
+    }
+    return closeFilesPromise
+  }
 
-    let newSessionId = sessionId || ''
-    const stdoutChunks: string[] = []
-    const stderrChunks: string[] = []
-    let aborted = false
-
-    // Handle abort signal - kill subprocess when aborted
-    const abortHandler = async () => {
-      if (aborted) return
-      aborted = true
-      console.error(`\n[abort] Killing OpenCode subprocess...`)
-      proc.kill('SIGTERM')
-      // Give it a moment to clean up, then force kill
-      setTimeout(() => {
-        if (!proc.killed) proc.kill('SIGKILL')
-      }, 1000)
-      await unlink(promptFile).catch(() => {})
-      reject(new Error('Request aborted'))
+  const cleanup = (): Promise<void> => {
+    if (!cleanupPromise) {
+      cleanupPromise = (async () => {
+        await closeFiles()
+        await Promise.all(
+          [promptFile, stdoutPath, stderrPath].map((path) =>
+            unlink(path).catch(() => {}),
+          ),
+        )
+      })()
     }
-    signal?.addEventListener('abort', abortHandler, { once: true })
-
-    // Stream stderr in real-time (OpenCode progress output)
-    proc.stderr.on('data', (data: Buffer) => {
-      const text = data.toString()
-      stderrChunks.push(text)
-
-      // Parse session ID from output
-      for (const line of text.split('\n')) {
-        if (line.startsWith('[session:')) {
-          newSessionId = line.trim().slice(9, -1)
-          continue
-        }
-        // Filter noise
-        if (line.includes('baseline-browser-mapping')) continue
-        if (line.startsWith('$ bun run')) continue
-        if (line.trim()) {
-          process.stderr.write(line + '\n')
-        }
-      }
-    })
+    return cleanupPromise
+  }
+
+  const stopProcess = () => {
+    if (!proc || proc.killed) return
+    proc.kill('SIGTERM')
+    killTimer = setTimeout(() => {
+      if (proc && !proc.killed) proc.kill('SIGKILL')
+    }, 1000)
+  }
+
+  const fail = (error: unknown): void => {
+    if (settled) return
+    settled = true
+    clearTimeout(timers.timeout)
+    clearTimeout(killTimer)
+    signal?.removeEventListener('abort', abortHandler)
+    stopProcess()
+    const cause = error instanceof Error ? error : new Error(String(error))
+    reject(cause)
+    void cleanup()
+  }
 
-    // Collect stdout
-    proc.stdout.on('data', (data: Buffer) => {
-      const text = data.toString()
-      stdoutChunks.push(text)
-      process.stderr.write(text)
+  const stdoutFile = new OutputFile(stdoutPath, budget, 'stdout', fail)
+  const stderrFile = new OutputFile(stderrPath, budget, 'stderr', fail)
+
+  const abortHandler = () => {
+    if (settled) return
+    console.error(`\n[abort] Killing OpenCode subprocess...`)
+    fail(new Error('Request aborted'))
+  }
+
+  try {
+    proc = spawn(command, args, {
+      cwd,
+      stdio: ['ignore', 'pipe', 'pipe'],
+      env: { ...process.env, ...opencode?.env },
     })
+  } catch (error) {
+    fail(error)
+    return promise
+  }
 
-    // Timeout handling (0 = no timeout)
-    const timeout =
-      timeoutSec > 0 ?
-        setTimeout(async () => {
-          proc.kill()
-          await unlink(promptFile).catch(() => {})
-          reject(new Error(`Timeout after ${timeoutSec}s`))
-        }, timeoutSec * 1000)
-      : null
-
-    proc.on('close', async (code) => {
-      if (timeout) clearTimeout(timeout)
-      signal?.removeEventListener('abort', abortHandler)
+  if (!proc.stdout || !proc.stderr) {
+    fail(new Error('OpenCode subprocess did not provide output streams'))
+    return promise
+  }
 
-      // If aborted, we already rejected
-      if (aborted) return
+  const stdoutStream = proc.stdout
+  const stderrStream = proc.stderr
+
+  stderrStream.on('data', (data: Buffer) => {
+    if (settled) return
+    void (async () => {
+      try {
+        const text = data.toString()
+        stderrTracker.consume(text)
+        await writeChildChunk(stderrStream, stderrFile, data)
+      } catch (error) {
+        fail(error)
+      }
+    })()
+  })
 
-      // Clean up prompt file
-      await unlink(promptFile).catch(() => {})
+  stdoutStream.on('data', (data: Buffer) => {
+    if (settled) return
+    void (async () => {
+      try {
+        await writeChildChunk(stdoutStream, stdoutFile, data)
+        await writeConsoleChunk(data)
+      } catch (error) {
+        fail(error)
+      }
+    })()
+  })
 
-      const stderr = stderrChunks.join('').trim()
+  timers.timeout =
+    timeoutSec > 0 ?
+      setTimeout(() => {
+        fail(new Error(`Timeout after ${timeoutSec}s`))
+      }, timeoutSec * 1000)
+    : undefined
+  signal?.addEventListener('abort', abortHandler, { once: true })
+
+  proc.on('close', (code) => {
+    void (async () => {
+      clearTimeout(timers.timeout)
+      clearTimeout(killTimer)
+      signal?.removeEventListener('abort', abortHandler)
+      await closeFiles()
+      if (settled) {
+        await cleanup()
+        return
+      }
 
+      stderrTracker.finish()
       if (code !== 0) {
-        const lastLines = stderr.split('\n').slice(-5).join('\n')
+        const lastLines = stderrTracker.getLastLines(5)
         const detail = lastLines ? `\n${lastLines}` : ''
-        reject(new Error(`OpenCode exited with code ${code}${detail}`))
+        fail(new Error(`OpenCode exited with code ${code}${detail}`))
         return
       }
 
-      // Check for OpenCode errors that exit with code 0 but produce no output
-      const knownErrors = [
-        {
-          pattern: /ProviderModelNotFoundError/,
-          message: 'Provider/model not found',
-        },
-        { pattern: /ModelNotFoundError/, message: 'Model not found' },
-        { pattern: /ProviderNotFoundError/, message: 'Provider not found' },
-        { pattern: /API key.*not.*found/i, message: 'API key not configured' },
-        {
-          pattern: /authentication.*failed/i,
-          message: 'Authentication failed',
-        },
-      ]
-
-      for (const { pattern, message } of knownErrors) {
-        if (pattern.test(stderr)) {
-          // Extract the relevant error lines
-          const errorLines = stderr
-            .split('\n')
-            .filter(
-              (line) =>
-                pattern.test(line) ||
-                line.includes('Error') ||
-                line.includes('error:'),
-            )
-            .slice(0, 5)
-            .join('\n')
-          reject(new Error(`OpenCode ${message}:\n${errorLines}`))
+      if (stderrTracker.hasKnownError) {
+        const knownError = knownOpenCodeErrors.find(
+          ({ pattern }) => pattern === stderrTracker.knownErrorPattern,
+        )
+        if (knownError) {
+          fail(
+            new Error(
+              `OpenCode ${knownError.message}:\n${stderrTracker.getDiagnosticLines()}`,
+            ),
+          )
           return
         }
       }
 
-      // Export session to get structured response
-      let response = stdoutChunks.join('').trim()
-
+      let response: string
+      try {
+        response = (await readFile(stdoutPath, 'utf8')).trim()
+      } catch (error) {
+        fail(error)
+        return
+      }
+      const newSessionId =
+        stderrTracker.newSessionId || (sessionId ? sessionId : '')
       if (newSessionId) {
-        const exported = await exportSession(newSessionId, workdir)
-        if (exported) {
-          response = exported
-        }
+        response =
+          (await exportSession(newSessionId, cwd, command, opencode?.env)) ??
+          response
       }
 
-      // Check for empty response with errors in stderr (likely a silent failure)
-      if (response.length === 0 && stderr.includes('Error')) {
-        const lastLines = stderr.split('\n').slice(-10).join('\n')
-        reject(
+      if (response.length === 0 && stderrTracker.hasError) {
+        const lastLines = stderrTracker.getLastLines(10)
+        fail(
           new Error(
             `OpenCode returned empty response with errors:\n${lastLines}`,
           ),
@@ -255,50 +493,52 @@ async function runOpencodeAgent(
       console.error(
         `<<< OpenCode done (${response.length} chars) [session:${sessionStr}]`,
       )
+      settled = true
+      await cleanup()
+      resolve({ text: response, sessionId: newSessionId })
+    })().catch(fail)
+  })
 
-      resolve({
-        text: response,
-        sessionId: newSessionId,
-      })
-    })
-
-    proc.on('error', async (err) => {
-      if (timeout) clearTimeout(timeout)
-      await unlink(promptFile).catch(() => {})
-      reject(err)
-    })
+  proc.on('error', (error) => {
+    fail(error)
   })
+
+  return promise
 }
 
-/** exportSession exports a session and extracts assistant text responses. */
 async function exportSession(
   sessionId: string,
-  workdir?: string,
+  workdir: string,
+  command: string,
+  env: Record<string, string> | undefined,
 ): Promise<string | null> {
-  const tmpPath = `${TMP_DIR}/opencode_export_${Date.now()}.json`
+  const exportFile = join(TMP_DIR, `opencode_export_${randomUUID()}.json`)
 
   try {
     await mkdir(TMP_DIR, { recursive: true })
-    const opencodeCmd = getOpencodeCommand([
-      'session',
-      'export',
-      sessionId,
-      '--format',
-      'json',
-      '--turn',
-      '-1',
-      '-o',
-      tmpPath,
-    ])
-    const proc = Bun.spawn([opencodeCmd.cmd, ...opencodeCmd.args], {
-      cwd: workdir ?? PROJECT_ROOT,
-      stdout: 'pipe',
-      stderr: 'pipe',
-    })
+    const proc = Bun.spawn(
+      [
+        command,
+        'session',
+        'export',
+        sessionId,
+        '--format',
+        'json',
+        '--turn',
+        '-1',
+        '-o',
+        exportFile,
+      ],
+      {
+        cwd: workdir,
+        stdout: 'pipe',
+        stderr: 'pipe',
+        env: { ...process.env, ...env },
+      },
+    )
 
     await proc.exited
-
-    const file = Bun.file(tmpPath)
+    const file = Bun.file(exportFile)
     if (!(await file.exists())) return null
 
     const data = (await file.json()) as {
@@ -307,29 +547,37 @@ async function exportSession(
         parts?: Array<{ type?: string; text?: string }>
       }>
     }
-    await Bun.write(tmpPath, '') // Clean up
+    void unlink(exportFile).catch(() => {})
 
-    // Extract all assistant text parts from the exported turn.
-    // The --turn -1 flag ensures we only get the last turn's messages.
-    const messages = data.messages || []
     const textParts: string[] = []
-
-    for (const msg of messages) {
-      if (msg.info?.role === 'assistant') {
-        for (const part of msg.parts || []) {
-          if (part.type === 'text' && part.text) {
-            textParts.push(part.text)
-          }
+    for (const msg of data.messages ?? []) {
+      if (msg.info?.role !== 'assistant') continue
+      for (const part of msg.parts ?? []) {
+        if (part.type === 'text' && part.text) {
+          textParts.push(part.text)
         }
       }
     }
 
     return textParts.length > 0 ? textParts.join('\n') : null
   } catch {
+    void unlink(exportFile).catch(() => {})
     return null
   }
 }
 
+const knownOpenCodeErrors: ReadonlyArray<{ pattern: RegExp; message: string }> =
+  [
+    {
+      pattern: /ProviderModelNotFoundError/,
+      message: 'Provider/model not found',
+    },
+    { pattern: /ModelNotFoundError/, message: 'Model not found' },
+    { pattern: /ProviderNotFoundError/, message: 'Provider not found' },
+    { pattern: /API key.*not.*found/i, message: 'API key not configured' },
+    { pattern: /authentication.*failed/i, message: 'Authentication failed' },
+  ]
+
 /** logStep logs a step header for workflow progress. */
 export function logStep(step: number, title: string, detail = ''): void {
   const detailStr = detail ? ` (${detail})` : ''