ocpipe 0.6.3 → 0.6.5

package/README.md

@@ -49,7 +49,7 @@ type GreetOut = InferOutputs<typeof Greet> // { greeting: string }
 
 ### Backends
 
-ocpipe supports two backends for running LLM agents:
+ocpipe supports three backends for running LLM agents:
 
 **OpenCode** (default) - Requires `opencode` CLI in your PATH. Supports 75+ providers.
 
@@ -76,6 +76,13 @@ defaultModel: { backend: 'claude-code', modelID: 'sonnet' },
 claudeCode: { permissionMode: 'acceptEdits' },
 ```
 
+**Codex** - Uses `@openai/codex`. Install as a peer dependency.
+
+```typescript
+defaultModel: { backend: 'codex', modelID: 'gpt-5.4' },
+codex: { sandbox: 'read-only', ephemeral: true },
+```
+
 ### Requirements
 
 **For OpenCode backend:** Currently requires [this OpenCode fork](https://github.com/paralin/opencode). Once the following PRs are merged, the official release will work:
@@ -89,6 +96,12 @@ claudeCode: { permissionMode: 'acceptEdits' },
 bun add @anthropic-ai/claude-agent-sdk
 ```
 
+**For Codex backend:** Install the Codex CLI package as a peer dependency:
+
+```bash
+bun add @openai/codex
+```
+
 ### Documentation
 
 - [Getting Started](./GETTING_STARTED.md) - Tutorial with examples

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "ocpipe",
-  "version": "0.6.3",
-  "description": "SDK for LLM pipelines with OpenCode and Zod",
+  "version": "0.6.5",
+  "description": "SDK for LLM pipelines with OpenCode, Codex, and Zod",
   "type": "module",
   "main": "src/index.ts",
   "types": "src/index.ts",
@@ -19,6 +19,7 @@
     "dspy",
     "llm",
     "opencode",
+    "codex",
     "typescript",
     "ai",
     "workflow",
@@ -28,27 +29,31 @@
   "engines": {
     "bun": ">=1.0.0"
   },
-  "dependencies": {},
   "peerDependencies": {
-    "zod": "4.4.1",
-    "@anthropic-ai/claude-agent-sdk": "0.2.126"
+    "zod": "4.4.3",
+    "@anthropic-ai/claude-agent-sdk": "0.2.126",
+    "@openai/codex": "0.128.0"
   },
   "peerDependenciesMeta": {
     "@anthropic-ai/claude-agent-sdk": {
       "optional": true
+    },
+    "@openai/codex": {
+      "optional": true
     }
   },
   "devDependencies": {
-    "@anthropic-ai/claude-agent-sdk": "^0.2.126",
+    "@anthropic-ai/claude-agent-sdk": "^0.2.132",
+    "@openai/codex": "^0.128.0",
     "@eslint/js": "^10.0.1",
     "bun-types": "^1.3.13",
-    "eslint": "^10.2.1",
-    "globals": "^17.5.0",
-    "jiti": "^2.6.1",
+    "eslint": "^10.3.0",
+    "globals": "^17.6.0",
+    "jiti": "^2.7.0",
     "prettier": "^3.8.3",
     "typescript": "^6.0.3",
-    "typescript-eslint": "^8.59.1",
-    "@typescript/native-preview": "^7.0.0-dev.20260430.1",
+    "typescript-eslint": "^8.59.2",
+    "@typescript/native-preview": "^7.0.0-dev.20260506.1",
     "vitest": "^4.1.5"
   },
   "scripts": {

package/src/agent.ts

@@ -1,7 +1,8 @@
 /**
  * ocpipe agent integration.
  *
- * Dispatches to OpenCode CLI or Claude Code SDK based on backend configuration.
+ * Dispatches to OpenCode CLI, Claude Code SDK, or Codex CLI based on backend
+ * configuration.
  */
 
 import { spawn } from 'child_process'
@@ -27,6 +28,11 @@ export async function runAgent(
     return runClaudeCodeAgent(options)
   }
 
+  if (backend === 'codex') {
+    const { runCodexAgent } = await import('./codex.js')
+    return runCodexAgent(options)
+  }
+
   return runOpencodeAgent(options)
 }
 

package/src/codex.ts

@@ -0,0 +1,219 @@
+/**
+ * ocpipe Codex CLI integration.
+ *
+ * Runs Codex non-interactively through `codex exec`.
+ */
+
+import { spawn } from 'child_process'
+import { mkdir, readFile, unlink } from 'fs/promises'
+import { join } from 'path'
+import { PROJECT_ROOT, TMP_DIR } from './paths.js'
+import type { RunAgentOptions, RunAgentResult } from './types.js'
+
+class CodexLogFilter {
+  private buf = ''
+
+  write(text: string): string {
+    this.buf += text
+    let out = ''
+    for (;;) {
+      const idx = this.buf.indexOf('\n')
+      if (idx < 0) {
+        return out
+      }
+      const line = this.buf.slice(0, idx + 1)
+      this.buf = this.buf.slice(idx + 1)
+      if (suppressCodexLogLine(line)) {
+        continue
+      }
+      out += line
+    }
+  }
+
+  flush(): string {
+    const line = this.buf
+    this.buf = ''
+    if (suppressCodexLogLine(line)) {
+      return ''
+    }
+    return line
+  }
+}
+
+export function filterCodexLogText(text: string): string {
+  const filter = new CodexLogFilter()
+  return filter.write(text) + filter.flush()
+}
+
+function suppressCodexLogLine(line: string): boolean {
+  return /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d+Z\s+WARN\s+codex_/.test(line)
+}
+
+/** runCodexAgent executes a Codex agent with a prompt. */
+export async function runCodexAgent(
+  options: RunAgentOptions,
+): Promise<RunAgentResult> {
+  const {
+    prompt,
+    model,
+    sessionId,
+    timeoutSec = 3600,
+    workdir,
+    codex,
+    signal,
+  } = options
+
+  if (sessionId) {
+    throw new Error('Codex backend does not support session resume yet')
+  }
+  if (signal?.aborted) {
+    throw new Error('Request aborted')
+  }
+
+  const cwd = workdir ?? PROJECT_ROOT
+  await mkdir(TMP_DIR, { recursive: true })
+  const stamp = `${Date.now()}_${Math.random().toString(36).slice(2)}`
+  const outputFile = join(TMP_DIR, `codex_output_${stamp}.txt`)
+
+  const cmd = codex?.pathToCodexExecutable ?? 'codex'
+  const args = [
+    'exec',
+    '--color',
+    'never',
+    '--model',
+    model.modelID,
+    '--sandbox',
+    codex?.sandbox ?? 'read-only',
+    '--cd',
+    cwd,
+    '--output-last-message',
+    outputFile,
+  ]
+
+  if (codex?.ephemeral ?? true) {
+    args.push('--ephemeral')
+  }
+  if (codex?.ignoreUserConfig) {
+    args.push('--ignore-user-config')
+  }
+  if (codex?.ignoreRules) {
+    args.push('--ignore-rules')
+  }
+  if (codex?.reasoningEffort) {
+    args.push('-c', `model_reasoning_effort="${codex.reasoningEffort}"`)
+  }
+  for (const dir of codex?.addDirs ?? []) {
+    args.push('--add-dir', dir)
+  }
+  for (const [key, value] of Object.entries(codex?.config ?? {})) {
+    args.push('-c', `${key}=${value}`)
+  }
+  args.push('-')
+
+  const promptPreview = prompt.slice(0, 50).replace(/\n/g, ' ')
+  console.error(
+    `\n>>> Codex [${model.modelID}] [new session]: ${promptPreview}...`,
+  )
+
+  return new Promise((resolve, reject) => {
+    const proc = spawn(cmd, args, {
+      cwd,
+      stdio: ['pipe', 'pipe', 'pipe'],
+    })
+
+    const stderrChunks: string[] = []
+    const stdoutFilter = new CodexLogFilter()
+    const stderrFilter = new CodexLogFilter()
+    let aborted = false
+
+    const cleanup = async () => {
+      await unlink(outputFile).catch(() => {})
+    }
+
+    const abortHandler = () => {
+      if (aborted) return
+      aborted = true
+      console.error('\n[abort] Killing Codex subprocess...')
+      proc.kill('SIGTERM')
+      setTimeout(() => {
+        if (!proc.killed) proc.kill('SIGKILL')
+      }, 1000)
+      void cleanup()
+      reject(new Error('Request aborted'))
+    }
+    signal?.addEventListener('abort', abortHandler, { once: true })
+
+    proc.stdout.on('data', (data: Buffer) => {
+      const text = stdoutFilter.write(data.toString())
+      if (text) {
+        process.stderr.write(text)
+      }
+    })
+    proc.stderr.on('data', (data: Buffer) => {
+      const text = stderrFilter.write(data.toString())
+      stderrChunks.push(text)
+      if (text) {
+        process.stderr.write(text)
+      }
+    })
+
+    const timeout =
+      timeoutSec > 0 ?
+        setTimeout(() => {
+          proc.kill()
+          void cleanup()
+          reject(new Error(`Timeout after ${timeoutSec}s`))
+        }, timeoutSec * 1000)
+      : null
+
+    proc.stdin.end(prompt)
+
+    proc.on('close', async (code) => {
+      if (timeout) clearTimeout(timeout)
+      signal?.removeEventListener('abort', abortHandler)
+      if (aborted) return
+
+      const stdoutTail = stdoutFilter.flush()
+      if (stdoutTail) {
+        process.stderr.write(stdoutTail)
+      }
+      const stderrTail = stderrFilter.flush()
+      if (stderrTail) {
+        stderrChunks.push(stderrTail)
+        process.stderr.write(stderrTail)
+      }
+      const stderr = stderrChunks.join('').trim()
+      if (code !== 0) {
+        await cleanup()
+        const detail =
+          stderr ? `\n${stderr.split('\n').slice(-10).join('\n')}` : ''
+        reject(new Error(`Codex exited with code ${code}${detail}`))
+        return
+      }
+
+      try {
+        const response = (await readFile(outputFile, 'utf8')).trim()
+        await cleanup()
+        if (!response) {
+          reject(new Error('Codex returned an empty response'))
+          return
+        }
+        console.error(`<<< Codex done (${response.length} chars)`)
+        resolve({
+          text: response,
+          sessionId: '',
+        })
+      } catch (err) {
+        await cleanup()
+        reject(err)
+      }
+    })
+
+    proc.on('error', async (err) => {
+      if (timeout) clearTimeout(timeout)
+      signal?.removeEventListener('abort', abortHandler)
+      await cleanup()
+      reject(err)
+    })
+  })
+}

package/src/index.ts

@@ -91,6 +91,7 @@ export type {
   BackendType,
   PermissionMode,
   ClaudeCodeOptions,
+  CodexOptions,
   ModelConfig,
   ExecutionContext,
   StepResult,

package/src/pipeline.ts

@@ -34,6 +34,7 @@ export class Pipeline<S extends BaseState> {
       timeoutSec: config.timeoutSec ?? 3600,
       workdir: config.workdir,
       claudeCode: config.claudeCode,
+      codex: config.codex,
     }
   }
 

package/src/types.ts

@@ -9,7 +9,7 @@ import type { z } from 'zod/v4'
 // ============================================================================
 
 /** Backend type for running agents. */
-export type BackendType = 'opencode' | 'claude-code'
+export type BackendType = 'opencode' | 'claude-code' | 'codex'
 
 /** Permission mode for Claude Code sessions. */
 export type PermissionMode =
@@ -57,6 +57,26 @@ export interface ClaudeCodeOptions {
   allowedTools?: string[]
 }
 
+/** Codex CLI specific session options. */
+export interface CodexOptions {
+  /** Path to Codex executable (default: `codex` from PATH). */
+  pathToCodexExecutable?: string
+  /** Sandbox mode for `codex exec` (default: `read-only`). */
+  sandbox?: 'read-only' | 'workspace-write' | 'danger-full-access'
+  /** Extra config overrides passed as repeated `-c key=value` flags. */
+  config?: Record<string, string>
+  /** Reasoning effort passed to Codex (for example: `low`, `medium`, `high`, `xhigh`). */
+  reasoningEffort?: string
+  /** Run without persisting Codex session files (default: true). */
+  ephemeral?: boolean
+  /** Ignore user config for deterministic automation (default: false). */
+  ignoreUserConfig?: boolean
+  /** Ignore user and project execpolicy rules (default: false). */
+  ignoreRules?: boolean
+  /** Additional directories Codex may access alongside the working directory. */
+  addDirs?: string[]
+}
+
 /** Model configuration for LLM backends. */
 export interface ModelConfig {
   /** Backend to use (default: 'opencode'). */
@@ -88,6 +108,8 @@ export interface ExecutionContext {
   workdir?: string
   /** Claude Code specific options. */
   claudeCode?: ClaudeCodeOptions
+  /** Codex CLI specific options. */
+  codex?: CodexOptions
   /** AbortSignal for cancelling requests. When aborted, kills subprocesses. */
   signal?: AbortSignal
 }
@@ -306,6 +328,8 @@ export interface PipelineConfig {
   workdir?: string
   /** Claude Code specific options. */
   claudeCode?: ClaudeCodeOptions
+  /** Codex CLI specific options. */
+  codex?: CodexOptions
 }
 
 /** Options for running a pipeline step. */
@@ -340,6 +364,8 @@ export interface RunAgentOptions {
   workdir?: string
   /** Claude Code specific options. */
   claudeCode?: ClaudeCodeOptions
+  /** Codex CLI specific options. */
+  codex?: CodexOptions
   /** AbortSignal for cancelling the request. When aborted, kills the subprocess. */
   signal?: AbortSignal
 }