ocpipe 0.6.11 → 0.6.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ocpipe",
-  "version": "0.6.11",
+  "version": "0.6.13",
   "description": "SDK for LLM pipelines with OpenCode, OMP, Codex, Claude Code, Pi, and Zod",
   "type": "module",
   "main": "src/index.ts",

package/src/agent.ts

@@ -4,10 +4,12 @@
  * Dispatches prompts to configured coding-agent backends.
  */
 
-import { spawn } from 'child_process'
+import { spawn, type ChildProcess } from 'child_process'
+import { createWriteStream, type WriteStream } from 'fs'
 import { randomUUID } from 'crypto'
-import { mkdir, unlink, writeFile } from 'fs/promises'
+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'
@@ -44,6 +46,211 @@ export async function runAgent(
   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)
+    }
+  }
+}
 
 async function runOpencodeAgent(
   options: RunAgentOptions,
@@ -76,7 +283,11 @@ async function runOpencodeAgent(
 
   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 = [
@@ -104,124 +315,192 @@ async function runOpencodeAgent(
 
   const command = opencode?.command ?? 'opencode'
   console.error(`[DEBUG] Running: ${command} ${args.join(' ')}`)
-  const proc = spawn(command, args, {
-    cwd,
-    stdio: ['ignore', 'pipe', 'pipe'],
-    env: { ...process.env, ...opencode?.env },
-  })
 
   const { promise, resolve, reject } = Promise.withResolvers<RunAgentResult>()
-  let newSessionId = sessionId || ''
-  const stdoutChunks: string[] = []
-  const stderrChunks: string[] = []
-  let aborted = false
+  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
+  }
 
-  const abortHandler = () => {
-    if (aborted) return
-    aborted = true
-    console.error(`\n[abort] Killing OpenCode subprocess...`)
+  const cleanup = (): Promise<void> => {
+    if (!cleanupPromise) {
+      cleanupPromise = (async () => {
+        await closeFiles()
+        await Promise.all(
+          [promptFile, stdoutPath, stderrPath].map((path) =>
+            unlink(path).catch(() => {}),
+          ),
+        )
+      })()
+    }
+    return cleanupPromise
+  }
+
+  const stopProcess = () => {
+    if (!proc || proc.killed) return
     proc.kill('SIGTERM')
-    setTimeout(() => {
-      if (!proc.killed) proc.kill('SIGKILL')
+    killTimer = setTimeout(() => {
+      if (proc && !proc.killed) proc.kill('SIGKILL')
     }, 1000)
-    void unlink(promptFile).catch(() => {})
-    reject(new Error('Request aborted'))
   }
-  signal?.addEventListener('abort', abortHandler, { once: true })
 
-  proc.stderr.on('data', (data: Buffer) => {
-    const text = data.toString()
-    stderrChunks.push(text)
+  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()
+  }
 
-    for (const line of text.split('\n')) {
-      if (line.startsWith('[session:')) {
-        newSessionId = line.trim().slice(9, -1)
-        continue
-      }
-      if (line.includes('baseline-browser-mapping')) continue
-      if (line.startsWith('$ bun run')) continue
-      if (line.trim()) {
-        process.stderr.write(line + '\n')
+  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
+  }
+
+  if (!proc.stdout || !proc.stderr) {
+    fail(new Error('OpenCode subprocess did not provide output streams'))
+    return promise
+  }
+
+  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)
       }
-    }
+    })()
   })
 
-  proc.stdout.on('data', (data: Buffer) => {
-    const text = data.toString()
-    stdoutChunks.push(text)
-    process.stderr.write(text)
+  stdoutStream.on('data', (data: Buffer) => {
+    if (settled) return
+    void (async () => {
+      try {
+        await writeChildChunk(stdoutStream, stdoutFile, data)
+        await writeConsoleChunk(data)
+      } catch (error) {
+        fail(error)
+      }
+    })()
   })
 
-  const timeout =
+  timers.timeout =
     timeoutSec > 0 ?
       setTimeout(() => {
-        proc.kill()
-        void unlink(promptFile).catch(() => {})
-        reject(new Error(`Timeout after ${timeoutSec}s`))
+        fail(new Error(`Timeout after ${timeoutSec}s`))
       }, timeoutSec * 1000)
     : undefined
+  signal?.addEventListener('abort', abortHandler, { once: true })
 
-  proc.on('close', async (code) => {
-    clearTimeout(timeout)
-    signal?.removeEventListener('abort', abortHandler)
-    if (aborted) return
-
-    void unlink(promptFile).catch(() => {})
-    const stderr = stderrChunks.join('').trim()
+  proc.on('close', (code) => {
+    void (async () => {
+      clearTimeout(timers.timeout)
+      clearTimeout(killTimer)
+      signal?.removeEventListener('abort', abortHandler)
+      await closeFiles()
+      if (settled) {
+        await cleanup()
+        return
+      }
 
-    if (code !== 0) {
-      const lastLines = stderr.split('\n').slice(-5).join('\n')
-      const detail = lastLines ? `\n${lastLines}` : ''
-      reject(new Error(`OpenCode exited with code ${code}${detail}`))
-      return
-    }
+      stderrTracker.finish()
+      if (code !== 0) {
+        const lastLines = stderrTracker.getLastLines(5)
+        const detail = lastLines ? `\n${lastLines}` : ''
+        fail(new Error(`OpenCode exited with code ${code}${detail}`))
+        return
+      }
 
-    for (const { pattern, message } of knownOpenCodeErrors) {
-      if (pattern.test(stderr)) {
-        const errorLines = stderr
-          .split('\n')
-          .filter(
-            (line) =>
-              pattern.test(line) ||
-              line.includes('Error') ||
-              line.includes('error:'),
+      if (stderrTracker.hasKnownError) {
+        const knownError = knownOpenCodeErrors.find(
+          ({ pattern }) => pattern === stderrTracker.knownErrorPattern,
+        )
+        if (knownError) {
+          fail(
+            new Error(
+              `OpenCode ${knownError.message}:\n${stderrTracker.getDiagnosticLines()}`,
+            ),
           )
-          .slice(0, 5)
-          .join('\n')
-        reject(new Error(`OpenCode ${message}:\n${errorLines}`))
+          return
+        }
+      }
+
+      let response: string
+      try {
+        response = (await readFile(stdoutPath, 'utf8')).trim()
+      } catch (error) {
+        fail(error)
         return
       }
-    }
+      const newSessionId =
+        stderrTracker.newSessionId || (sessionId ? sessionId : '')
+      if (newSessionId) {
+        response =
+          (await exportSession(newSessionId, cwd, command, opencode?.env)) ??
+          response
+      }
 
-    let response = stdoutChunks.join('').trim()
-    if (newSessionId) {
-      response =
-        (await exportSession(newSessionId, cwd, command, opencode?.env)) ??
-        response
-    }
+      if (response.length === 0 && stderrTracker.hasError) {
+        const lastLines = stderrTracker.getLastLines(10)
+        fail(
+          new Error(
+            `OpenCode returned empty response with errors:\n${lastLines}`,
+          ),
+        )
+        return
+      }
 
-    if (response.length === 0 && stderr.includes('Error')) {
-      const lastLines = stderr.split('\n').slice(-10).join('\n')
-      reject(
-        new Error(
-          `OpenCode returned empty response with errors:\n${lastLines}`,
-        ),
+      const sessionStr = newSessionId || 'none'
+      console.error(
+        `<<< OpenCode done (${response.length} chars) [session:${sessionStr}]`,
       )
-      return
-    }
-
-    const sessionStr = newSessionId || 'none'
-    console.error(
-      `<<< OpenCode done (${response.length} chars) [session:${sessionStr}]`,
-    )
-    resolve({ text: response, sessionId: newSessionId })
+      settled = true
+      await cleanup()
+      resolve({ text: response, sessionId: newSessionId })
+    })().catch(fail)
   })
 
-  proc.on('error', (err) => {
-    clearTimeout(timeout)
-    signal?.removeEventListener('abort', abortHandler)
-    void unlink(promptFile).catch(() => {})
-    reject(err)
+  proc.on('error', (error) => {
+    fail(error)
   })
 
   return promise

package/src/codex.ts

@@ -10,6 +10,7 @@ import {
   type RunResult,
   type ThreadOptions,
 } from '@openai/codex-sdk'
+import { OutputLimitError } from './errors.js'
 import { PROJECT_ROOT } from './paths.js'
 import type {
   CodexOptions,
@@ -18,22 +19,29 @@ import type {
   RunAgentResult,
 } from './types.js'
 
+const MAX_CODEX_LOG_LINE_BYTES = 1024 * 1024
+
 class CodexLogFilter {
   private buf = ''
   private suppressHtml = false
 
   write(text: string): string {
-    this.buf += text
     let out = ''
-    for (;;) {
-      const idx = this.buf.indexOf('\n')
+    let cursor = 0
+    while (cursor < text.length) {
+      const idx = text.indexOf('\n', cursor)
       if (idx < 0) {
-        return out
+        this.append(text.slice(cursor))
+        break
       }
-      const line = this.buf.slice(0, idx + 1)
-      this.buf = this.buf.slice(idx + 1)
-      out += this.filterLine(line)
+
+      const line = text.slice(cursor, idx + 1)
+      cursor = idx + 1
+      this.append(line)
+      out += this.filterLine(this.buf)
+      this.buf = ''
     }
+    return out
   }
 
   flush(): string {
@@ -42,6 +50,16 @@ class CodexLogFilter {
     return this.filterLine(line)
   }
 
+  private append(text: string): void {
+    if (
+      Buffer.byteLength(this.buf, 'utf8') + Buffer.byteLength(text, 'utf8') >
+      MAX_CODEX_LOG_LINE_BYTES
+    ) {
+      throw new OutputLimitError('Codex log line', MAX_CODEX_LOG_LINE_BYTES)
+    }
+    this.buf += text
+  }
+
   private filterLine(line: string): string {
     if (this.suppressHtml) {
       if (line.includes('</html>')) {
@@ -239,7 +257,9 @@ export function formatCodexRunSummary(summary: CodexRunSummary): string {
   return lines.join('\n')
 }
 
-function isFailedCommand(command: CodexRunSummary['commands'][number]): boolean {
+function isFailedCommand(
+  command: CodexRunSummary['commands'][number],
+): boolean {
   return (
     command.status === 'failed' ||
     (command.exitCode !== null && command.exitCode !== 0)

package/src/errors.ts

@@ -0,0 +1,19 @@
+/** ocpipe typed runtime errors. */
+
+function formatBytes(bytes: number): string {
+  if (bytes >= 1024 * 1024 * 1024) return `${bytes / (1024 * 1024 * 1024)} GiB`
+  if (bytes >= 1024 * 1024) return `${bytes / (1024 * 1024)} MiB`
+  if (bytes >= 1024) return `${bytes / 1024} KiB`
+  return `${bytes} bytes`
+}
+
+/** OutputLimitError reports a bounded output buffer or file limit breach. */
+export class OutputLimitError extends Error {
+  constructor(
+    public readonly source: string,
+    public readonly limitBytes: number,
+  ) {
+    super(`${source} exceeded ${formatBytes(limitBytes)} limit`)
+    this.name = 'OutputLimitError'
+  }
+}

package/src/index.ts

@@ -50,6 +50,7 @@ export { createSessionId, createBaseState, extendBaseState } from './state.js'
 // Agent integration
 export { runAgent, logStep } from './agent.js'
 export { buildCodexRunSummary, formatCodexRunSummary } from './codex.js'
+export { OutputLimitError } from './errors.js'
 
 // Response parsing
 export {

package/src/omp.ts

@@ -176,6 +176,9 @@ function buildOmpArgs(
   if (thinking) {
     args.push('--thinking', thinking)
   }
+  if (omp?.serviceTier) {
+    args.push('--service-tier', omp.serviceTier)
+  }
   args.push(...(omp?.extraArgs ?? []))
   if (prompt) {
     args.push('--', prompt)

package/src/types.ts

@@ -148,6 +148,8 @@ export interface OmpOptions {
   approvalMode?: string
   /** Thinking effort passed with `--thinking` (default: `high`). */
   thinking?: string
+  /** OpenAI service tier passed with `--service-tier` (for example `priority`); omitted when unset. */
+  serviceTier?: string
   /** Run Oh My Pi as a continuing headless goal. */
   goalMode?: boolean
   /** Goal objective; setting this also enables goal mode. */