@astrale-os/cli 0.7.0-alpha.0 → 0.8.0-alpha.0

package/studio/server/agent/harness/codex/adapter.test.ts

@@ -0,0 +1,269 @@
+import { afterEach, describe, expect, test } from 'bun:test'
+import { chmodSync, existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+import { CodexHarness } from './adapter'
+
+const roots: string[] = []
+
+afterEach(() => {
+  while (roots.length) rmSync(roots.pop()!, { recursive: true, force: true })
+})
+
+function fakeCodex(root: string): string {
+  const file = join(root, 'fake-codex')
+  writeFileSync(
+    file,
+    `#!/usr/bin/env bun
+const args = process.argv.slice(2)
+if (args[0] === '--version') {
+  console.log('codex-cli 0.test')
+  process.exit(0)
+}
+if (args[0] === 'app-server') {
+  if (process.env.FAKE_APP_MODE !== 'partial-fail') process.exit(2)
+  let buffer = ''
+  const send = (message) => process.stdout.write(JSON.stringify(message) + '\\n')
+  process.stdin.setEncoding('utf8')
+  process.stdin.on('data', (chunk) => {
+    buffer += chunk
+    let newline
+    while ((newline = buffer.indexOf('\\n')) >= 0) {
+      const line = buffer.slice(0, newline).trim()
+      buffer = buffer.slice(newline + 1)
+      if (!line) continue
+      const message = JSON.parse(line)
+      if (message.method === 'initialize') send({ id: message.id, result: { userAgent: 'fake' } })
+      if (message.method === 'thread/fork') send({ id: message.id, result: { thread: { id: 'fork-thread' } } })
+      if (message.method === 'turn/start') {
+        send({ id: message.id, result: { turn: { id: 'turn-1' } } })
+        send({ method: 'item/agentMessage/delta', params: { delta: 'partial' } })
+        send({ method: 'turn/completed', params: { turn: { status: 'failed', error: { message: 'late failure' } } } })
+      }
+    }
+  })
+  await new Promise(() => {})
+}
+if (args[0] !== 'exec') process.exit(2)
+
+let prompt = ''
+process.stdin.setEncoding('utf8')
+process.stdin.on('data', (chunk) => { prompt += chunk })
+process.stdin.on('end', () => {
+  if (process.env.FAKE_CODEX_LOG) {
+    require('node:fs').writeFileSync(
+      process.env.FAKE_CODEX_LOG,
+      JSON.stringify({ args, prompt }),
+    )
+  }
+  const thread = args[1] === 'resume' ? args[2] : 'new-thread'
+  if (thread === 'rejected-thread') {
+    console.error('Error: thread/resume: thread/resume failed: no rollout found for thread id rejected-thread')
+    process.exit(1)
+  }
+  if (thread === 'transient-thread') {
+    console.error('network unavailable')
+    process.exit(1)
+  }
+  const send = (event) => process.stdout.write(JSON.stringify(event) + '\\n')
+  if (prompt === 'hang') {
+    const descendant = require('node:child_process').spawn(
+      process.execPath,
+      ['-e', 'setInterval(() => {}, 1000)'],
+      { stdio: 'ignore' },
+    )
+    if (process.env.FAKE_DESCENDANT_PID) {
+      require('node:fs').writeFileSync(process.env.FAKE_DESCENDANT_PID, String(descendant.pid))
+    }
+    process.on('SIGTERM', () => process.exit(143))
+    send({ type: 'thread.started', thread_id: thread })
+    setInterval(() => {}, 1000)
+    return
+  }
+  send({ type: 'thread.started', thread_id: thread })
+  send({ type: 'turn.started' })
+  send({ type: 'item.completed', item: { id: 'answer', type: 'agent_message', text: 'done' } })
+  if (process.env.FAKE_CODEX_MODE === 'no-terminal') return
+  send({ type: 'turn.completed', usage: { input_tokens: 7, cached_input_tokens: 2, output_tokens: 3 } })
+})
+`,
+  )
+  chmodSync(file, 0o755)
+  return file
+}
+
+function turnInput(
+  root: string,
+  overrides: Partial<Parameters<CodexHarness['run']>[0]> = {},
+): Parameters<CodexHarness['run']>[0] {
+  return {
+    root,
+    prompt: 'work',
+    signal: new AbortController().signal,
+    onEvent: () => {},
+    ...overrides,
+  }
+}
+
+async function waitForExit(pid: number): Promise<boolean> {
+  for (let i = 0; i < 40; i++) {
+    try {
+      process.kill(pid, 0)
+    } catch {
+      return true
+    }
+    await Bun.sleep(25)
+  }
+  return false
+}
+
+describe('Codex process runner', () => {
+  test('streams a real JSONL subprocess turn and pipes the prompt over stdin', async () => {
+    const root = mkdtempSync(join(tmpdir(), 'studio-codex-run-'))
+    roots.push(root)
+    const bin = fakeCodex(root)
+    const log = join(root, 'invocation.json')
+    const events: string[] = []
+
+    const result = await new CodexHarness(bin).run(
+      turnInput(root, {
+        prompt: 'inspect this domain',
+        env: { FAKE_CODEX_LOG: log },
+        onEvent: (event) => events.push(`${event.kind}:${event.text}`),
+      }),
+    )
+
+    expect(result).toMatchObject({
+      sessionId: 'new-thread',
+      finalText: 'done',
+      tokens: 10,
+      isError: false,
+    })
+    expect(events).toContain('status:session started')
+    expect(events).toContain('message:done')
+    const invocation = JSON.parse(readFileSync(log, 'utf8'))
+    expect(invocation.prompt).toBe('inspect this domain')
+    expect(invocation.args).toContain('--json')
+  })
+
+  test('marks an invalid stored thread but not a transient resumed-turn failure as rejected', async () => {
+    const root = mkdtempSync(join(tmpdir(), 'studio-codex-resume-'))
+    roots.push(root)
+    const harness = new CodexHarness(fakeCodex(root))
+    const rejected = await harness.run(turnInput(root, { sessionId: 'rejected-thread' }))
+    const transient = await harness.run(turnInput(root, { sessionId: 'transient-thread' }))
+
+    expect(rejected).toMatchObject({
+      isError: true,
+      resumeRejected: true,
+    })
+    expect(rejected.errorMessage).toContain('no rollout found')
+    expect(transient).toMatchObject({
+      isError: true,
+      resumeRejected: false,
+    })
+    expect(transient.errorMessage).toContain('network unavailable')
+  })
+
+  test('terminates a running process group when the turn is canceled', async () => {
+    const root = mkdtempSync(join(tmpdir(), 'studio-codex-cancel-'))
+    roots.push(root)
+    const controller = new AbortController()
+    const descendantPidFile = join(root, 'descendant.pid')
+    let aborted = false
+    const result = await new CodexHarness(fakeCodex(root)).run(
+      turnInput(root, {
+        prompt: 'hang',
+        env: { FAKE_DESCENDANT_PID: descendantPidFile },
+        signal: controller.signal,
+        onEvent: (event) => {
+          if (!aborted && event.kind === 'status') {
+            aborted = true
+            controller.abort()
+          }
+        },
+      }),
+    )
+
+    expect(result).toMatchObject({
+      isError: true,
+      errorMessage: 'canceled',
+    })
+    const descendantPid = Number(readFileSync(descendantPidFile, 'utf8'))
+    const exited = await waitForExit(descendantPid)
+    if (!exited) {
+      try {
+        process.kill(descendantPid, 'SIGKILL')
+      } catch {
+        /* already gone */
+      }
+    }
+    expect(exited).toBe(true)
+  })
+
+  test('falls back to a fresh ephemeral exec without resuming the parent Ask thread', async () => {
+    const root = mkdtempSync(join(tmpdir(), 'studio-codex-ask-fallback-'))
+    roots.push(root)
+    const log = join(root, 'invocation.json')
+    const deltas: string[] = []
+    const result = await new CodexHarness(fakeCodex(root)).ask({
+      root,
+      prompt: 'side question',
+      appendSystemPrompt: 'ask protocol',
+      sessionId: 'parent-thread',
+      model: 'gpt-studio',
+      effort: 'high',
+      access: 'workspace',
+      env: { FAKE_CODEX_LOG: log },
+      signal: new AbortController().signal,
+      onDelta: (delta) => deltas.push(delta),
+    })
+
+    expect(result).toEqual({ text: 'done', isError: false, errorMessage: undefined })
+    expect(deltas).toEqual(['done'])
+    const invocation = JSON.parse(readFileSync(log, 'utf8'))
+    expect(invocation.args.slice(0, 2)).toEqual(['exec', '--json'])
+    expect(invocation.args).not.toContain('resume')
+    expect(invocation.args).toContain('--ephemeral')
+    const modelAt = invocation.args.indexOf('--model')
+    expect(invocation.args.slice(modelAt, modelAt + 2)).toEqual(['--model', 'gpt-studio'])
+  })
+
+  test('does not retry after a failed Ask attempt has already streamed partial text', async () => {
+    const root = mkdtempSync(join(tmpdir(), 'studio-codex-ask-partial-'))
+    roots.push(root)
+    const execLog = join(root, 'exec.json')
+    const deltas: string[] = []
+    const result = await new CodexHarness(fakeCodex(root)).ask({
+      root,
+      prompt: 'side question',
+      sessionId: 'parent-thread',
+      env: { FAKE_APP_MODE: 'partial-fail', FAKE_CODEX_LOG: execLog },
+      signal: new AbortController().signal,
+      onDelta: (delta) => deltas.push(delta),
+    })
+
+    expect(result).toEqual({
+      text: 'partial',
+      isError: true,
+      errorMessage: 'late failure',
+    })
+    expect(deltas).toEqual(['partial'])
+    expect(existsSync(execLog)).toBe(false)
+  })
+
+  test('rejects a zero-exit JSONL stream without a terminal turn event', async () => {
+    const root = mkdtempSync(join(tmpdir(), 'studio-codex-terminal-'))
+    roots.push(root)
+    const result = await new CodexHarness(fakeCodex(root)).run(
+      turnInput(root, { env: { FAKE_CODEX_MODE: 'no-terminal' } }),
+    )
+
+    expect(result).toMatchObject({
+      finalText: 'done',
+      isError: true,
+      errorMessage: 'codex exited without a terminal turn event',
+    })
+  })
+})

package/studio/server/agent/harness/codex/adapter.ts

@@ -0,0 +1,116 @@
+import type { HarnessLoadout } from '../../../../shared/types'
+import type {
+  AgentHarness,
+  AgentTurnInput,
+  AgentTurnResult,
+  AskInput,
+  AskResult,
+  HarnessHealth,
+  HarnessLoadoutOptions,
+} from '../adapter'
+
+import { captureCommand } from '../process'
+import { readSkillContent } from '../skills'
+import { runCodexForkAsk } from './ask'
+import { runCodexExec } from './exec'
+import { loadCodexConfiguration } from './loadout'
+import { scanCodexSkills } from './skills'
+
+const DEFAULT_BIN = process.env.DOMAIN_STUDIO_CODEX_BIN || 'codex'
+
+export class CodexHarness implements AgentHarness {
+  id = 'codex'
+  label = 'Codex (local)'
+  capabilities = {
+    effortLevels: ['minimal', 'low', 'medium', 'high', 'xhigh'],
+    accessLevels: ['workspace', 'full'],
+    ask: true,
+    loadout: true,
+    gateway: 'none',
+  } as const
+
+  private availCache?: { at: number; health: HarnessHealth }
+  private loadoutCache?: { at: number; key: string; data: HarnessLoadout }
+
+  constructor(private readonly bin = DEFAULT_BIN) {}
+
+  async health(signal?: AbortSignal): Promise<HarnessHealth> {
+    const now = Date.now()
+    if (this.availCache && now - this.availCache.at < 30_000) return this.availCache.health
+    const result = await captureCommand(this.bin, ['--version'], process.cwd(), { signal })
+    const health: HarnessHealth = {
+      ok: result.code === 0,
+      version: result.code === 0 ? result.stdout.trim() || undefined : undefined,
+      bin: this.bin,
+      detail:
+        result.code === 0
+          ? undefined
+          : result.stderr.trim() ||
+            `\`${this.bin}\` was not found on PATH; install it and run \`codex login\``,
+    }
+    if (!signal?.aborted) this.availCache = { at: now, health }
+    return health
+  }
+
+  async isAvailable(signal?: AbortSignal): Promise<boolean> {
+    return (await this.health(signal)).ok
+  }
+
+  run(input: AgentTurnInput): Promise<AgentTurnResult> {
+    return runCodexExec(this.bin, input)
+  }
+
+  async ask(input: AskInput): Promise<AskResult> {
+    let result = await runCodexForkAsk(this.bin, input)
+    if (result.isError && result.text) return result
+    if (result.isError && result.errorMessage !== 'canceled' && input.sessionId)
+      result = await runCodexForkAsk(this.bin, { ...input, sessionId: undefined })
+    if (!result.isError || result.errorMessage === 'canceled') return result
+    if (result.text) return result
+
+    let streamed = ''
+    const fallback = await runCodexExec(
+      this.bin,
+      {
+        ...input,
+        sessionId: undefined,
+        mcpServers: [],
+        onEvent: (event) => {
+          if (event.kind === 'message') {
+            streamed = event.text
+            input.onDelta(event.text)
+          }
+        },
+      },
+      true,
+    )
+    return {
+      text: fallback.finalText || streamed,
+      isError: fallback.isError,
+      errorMessage: fallback.errorMessage,
+    }
+  }
+
+  async loadout(root: string, options?: HarnessLoadoutOptions): Promise<HarnessLoadout> {
+    const now = Date.now()
+    const key = `${root}\u0000${options?.model ?? ''}\u0000${JSON.stringify(options?.env ?? {})}`
+    if (
+      !options?.refresh &&
+      this.loadoutCache &&
+      this.loadoutCache.key === key &&
+      now - this.loadoutCache.at < 60_000
+    )
+      return this.loadoutCache.data
+    const data = await loadCodexConfiguration(this.bin, root, options)
+    this.loadoutCache = { at: now, key, data }
+    return data
+  }
+
+  async skillContent(
+    root: string,
+    command: string,
+  ): Promise<{ command: string; content: string; path: string } | null> {
+    const loadout = await this.loadout(root)
+    return readSkillContent(loadout.skills, command)
+  }
+}

package/studio/server/agent/harness/codex/ask.test.ts

@@ -0,0 +1,176 @@
+import { afterEach, expect, test } from 'bun:test'
+import { chmodSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+import { runCodexForkAsk } from './ask'
+
+const roots: string[] = []
+
+afterEach(() => {
+  while (roots.length) rmSync(roots.pop()!, { recursive: true, force: true })
+})
+
+function fakeCodex(root: string): string {
+  const file = join(root, 'fake-codex')
+  writeFileSync(
+    file,
+    `#!/usr/bin/env bun
+let buffer = ''
+const fs = require('node:fs')
+const send = (message) => process.stdout.write(JSON.stringify(message) + '\\n')
+const record = (message) => {
+  if (process.env.FAKE_APP_LOG) fs.appendFileSync(process.env.FAKE_APP_LOG, JSON.stringify(message) + '\\n')
+}
+process.stdin.setEncoding('utf8')
+process.stdin.on('data', (chunk) => {
+  buffer += chunk
+  let newline
+  while ((newline = buffer.indexOf('\\n')) >= 0) {
+    const line = buffer.slice(0, newline).trim()
+    buffer = buffer.slice(newline + 1)
+    if (!line) continue
+    const message = JSON.parse(line)
+    record(message)
+    const fresh = process.env.FAKE_APP_EXPECT_FRESH === '1'
+    if (message.method === 'initialize') send({ id: message.id, result: { userAgent: 'fake' } })
+    if (message.method === 'thread/fork') {
+      if (fresh) {
+        send({ id: message.id, error: { message: 'unexpected fork' } })
+      } else if (message.params.threadId !== 'parent-thread') {
+        send({ id: message.id, error: { message: 'wrong parent' } })
+      } else {
+        send({ id: message.id, result: { thread: { id: 'fork-thread' } } })
+      }
+    }
+    if (message.method === 'thread/start') {
+      if (fresh) send({ id: message.id, result: { thread: { id: 'fresh-thread' } } })
+      else send({ id: message.id, error: { message: 'unexpected fresh thread' } })
+    }
+    if (message.method === 'turn/start') {
+      const expectedThread = fresh ? 'fresh-thread' : 'fork-thread'
+      if (message.params.threadId !== expectedThread) {
+        send({ id: message.id, error: { message: 'turn did not target fork' } })
+      } else {
+        send({ id: message.id, result: { turn: { id: 'turn-1' } } })
+        send({ method: 'item/agentMessage/delta', params: { delta: 'hello ' } })
+        send({ method: 'item/agentMessage/delta', params: { delta: 'studio' } })
+        send({ method: 'item/completed', params: { item: { type: 'agentMessage', text: 'hello studio' } } })
+        send({
+          method: 'turn/completed',
+          params: { turn: { status: process.env.FAKE_APP_TERMINAL || 'completed' } },
+        })
+      }
+    }
+  }
+})
+`,
+  )
+  chmodSync(file, 0o755)
+  return file
+}
+
+test('forks the parent thread and streams the side answer without mutating it', async () => {
+  const root = mkdtempSync(join(tmpdir(), 'studio-codex-app-server-'))
+  roots.push(root)
+  const bin = fakeCodex(root)
+  const log = join(root, 'app-server.jsonl')
+  const deltas: string[] = []
+  const result = await runCodexForkAsk(bin, {
+    root,
+    prompt: 'question',
+    appendSystemPrompt: 'ask protocol',
+    sessionId: 'parent-thread',
+    model: 'gpt-studio',
+    effort: 'high',
+    access: 'workspace',
+    env: { FAKE_APP_LOG: log },
+    signal: new AbortController().signal,
+    onDelta: (delta) => deltas.push(delta),
+  })
+
+  expect(result).toEqual({ text: 'hello studio', isError: false })
+  expect(deltas).toEqual(['hello ', 'studio'])
+  const requests = readFileSync(log, 'utf8')
+    .trim()
+    .split('\n')
+    .map((line) => JSON.parse(line))
+  expect(requests.map((request) => request.method)).toEqual([
+    'initialize',
+    'initialized',
+    'thread/fork',
+    'turn/start',
+  ])
+  expect(requests[2].params).toMatchObject({
+    threadId: 'parent-thread',
+    cwd: root,
+    approvalPolicy: 'never',
+    sandbox: 'workspace-write',
+    ephemeral: true,
+    model: 'gpt-studio',
+    config: { 'mcp_servers.domain-studio.enabled': false },
+  })
+  expect(requests[3].params).toMatchObject({
+    threadId: 'fork-thread',
+    model: 'gpt-studio',
+    effort: 'high',
+  })
+})
+
+test('starts a fresh Ask thread and normalizes Claude-only effort modes', async () => {
+  const root = mkdtempSync(join(tmpdir(), 'studio-codex-app-server-fresh-'))
+  roots.push(root)
+  const log = join(root, 'app-server-fresh.jsonl')
+  const result = await runCodexForkAsk(fakeCodex(root), {
+    root,
+    prompt: 'first question',
+    model: 'gpt-fresh',
+    effort: 'ultracode',
+    access: 'full',
+    env: { FAKE_APP_LOG: log, FAKE_APP_EXPECT_FRESH: '1' },
+    signal: new AbortController().signal,
+    onDelta: () => {},
+  })
+
+  expect(result).toEqual({ text: 'hello studio', isError: false })
+  const requests = readFileSync(log, 'utf8')
+    .trim()
+    .split('\n')
+    .map((line) => JSON.parse(line))
+  expect(requests.map((request) => request.method)).toEqual([
+    'initialize',
+    'initialized',
+    'thread/start',
+    'turn/start',
+  ])
+  expect(requests[2].params).toMatchObject({
+    cwd: root,
+    sandbox: 'danger-full-access',
+    ephemeral: true,
+    model: 'gpt-fresh',
+  })
+  expect(requests[3].params).toMatchObject({
+    threadId: 'fresh-thread',
+    model: 'gpt-fresh',
+    effort: 'xhigh',
+  })
+})
+
+test('does not report canceled app-server turns as successful answers', async () => {
+  const root = mkdtempSync(join(tmpdir(), 'studio-codex-app-server-canceled-'))
+  roots.push(root)
+  const result = await runCodexForkAsk(fakeCodex(root), {
+    root,
+    prompt: 'question',
+    sessionId: 'parent-thread',
+    env: { FAKE_APP_TERMINAL: 'canceled' },
+    signal: new AbortController().signal,
+    onDelta: () => {},
+  })
+
+  expect(result).toEqual({
+    text: 'hello studio',
+    isError: true,
+    errorMessage: 'Codex side question ended with status canceled',
+  })
+})