@astrale-os/cli 1.0.0-beta.8 → 1.0.0-npm-deprecated.0

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

@@ -1,269 +0,0 @@
-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

@@ -1,116 +0,0 @@
-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

@@ -1,176 +0,0 @@
-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',
-  })
-})