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

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

@@ -0,0 +1,338 @@
+import { afterEach, 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 { ClaudeCodeHarness } from './adapter'
+
+const roots: string[] = []
+
+afterEach(() => {
+  while (roots.length) rmSync(roots.pop()!, { recursive: true, force: true })
+})
+
+function fakeClaude(root: string): string {
+  const file = join(root, 'fake-claude')
+  writeFileSync(
+    file,
+    `#!/usr/bin/env bun
+const fs = require('node:fs')
+const { spawn } = require('node:child_process')
+const args = process.argv.slice(2)
+if (args[0] === '--version') {
+  console.log('2.1.test')
+  process.exit(0)
+}
+if (process.env.FAKE_CLAUDE_LOG) {
+  fs.appendFileSync(process.env.FAKE_CLAUDE_LOG, JSON.stringify({ args }) + '\\n')
+}
+const modelAt = args.indexOf('--model')
+const model = modelAt >= 0 ? args[modelAt + 1] + '-resolved' : 'native-default'
+const resumedAt = args.indexOf('--resume')
+const session = resumedAt >= 0 ? args[resumedAt + 1] : 'fresh-session'
+const send = (event) => process.stdout.write(JSON.stringify(event) + '\\n')
+send({
+  type: 'system',
+  subtype: 'init',
+  session_id: session,
+  model,
+  permissionMode: 'bypassPermissions',
+  apiKeySource: 'none',
+  cwd: process.cwd(),
+  tools: ['Read', 'Edit'],
+  mcp_servers: [],
+  slash_commands: [],
+  agents: [],
+})
+let prompt = ''
+process.stdin.setEncoding('utf8')
+process.stdin.on('data', (chunk) => { prompt += chunk })
+process.stdin.on('end', () => {
+  if (prompt === '.') return setInterval(() => {}, 1000)
+  if (process.env.FAKE_CLAUDE_MODE === 'no-result') process.exit(0)
+  send({ type: 'assistant', message: { content: [{ type: 'text', text: 'answer' }] } })
+  if (process.env.FAKE_CLAUDE_MODE === 'text-then-crash') {
+    console.error('crashed after text')
+    process.exit(7)
+  }
+  if (process.env.FAKE_CLAUDE_MODE === 'result-error') {
+    send({ type: 'result', subtype: 'error_during_execution', is_error: true, result: 'failed' })
+    return
+  }
+  if (process.env.FAKE_CLAUDE_MODE === 'hang-ignore-term') {
+    process.on('SIGTERM', () => {})
+    const child = spawn(process.execPath, ['-e', "process.on('SIGTERM',()=>{});setInterval(()=>{},1000)"], {
+      stdio: 'ignore',
+    })
+    fs.writeFileSync(
+      process.env.FAKE_CLAUDE_PID_LOG,
+      JSON.stringify({ parent: process.pid, child: child.pid }),
+    )
+    return setInterval(() => {}, 1000)
+  }
+  send({
+    type: 'result',
+    subtype: 'success',
+    result: 'done',
+    session_id: session,
+    num_turns: 1,
+    usage: { input_tokens: 2, output_tokens: 3 },
+  })
+})
+`,
+  )
+  chmodSync(file, 0o755)
+  return file
+}
+
+function invocations(log: string): { args: string[] }[] {
+  return readFileSync(log, 'utf8')
+    .trim()
+    .split('\n')
+    .map((line) => JSON.parse(line))
+}
+
+async function waitFor(predicate: () => boolean, timeoutMs = 3_000): Promise<void> {
+  const deadline = Date.now() + timeoutMs
+  while (!predicate()) {
+    if (Date.now() >= deadline) throw new Error('condition did not become true before timeout')
+    await Bun.sleep(20)
+  }
+}
+
+function processExists(pid: number): boolean {
+  try {
+    process.kill(pid, 0)
+    return true
+  } catch {
+    return false
+  }
+}
+
+test('Claude loadout probing reports and passes the Studio model override', async () => {
+  const root = mkdtempSync(join(tmpdir(), 'studio-claude-model-probe-'))
+  roots.push(root)
+  const log = join(root, 'claude.jsonl')
+  const harness = new ClaudeCodeHarness(fakeClaude(root))
+
+  const loadout = await harness.loadout(root, {
+    model: 'sonnet',
+    env: { FAKE_CLAUDE_LOG: log },
+  })
+
+  expect(loadout).toMatchObject({
+    ok: true,
+    model: 'sonnet-resolved',
+    modelSource: 'studio',
+  })
+  const args = invocations(log)[0].args
+  const modelAt = args.indexOf('--model')
+  expect(args.slice(modelAt, modelAt + 2)).toEqual(['--model', 'sonnet'])
+
+  await harness.loadout(root, {
+    model: 'sonnet',
+    env: { FAKE_CLAUDE_LOG: log },
+  })
+  expect(invocations(log)).toHaveLength(1)
+  await harness.loadout(root, {
+    model: 'sonnet',
+    env: { FAKE_CLAUDE_LOG: log },
+    refresh: true,
+  })
+  expect(invocations(log)).toHaveLength(2)
+})
+
+test('Claude turns and Ask calls carry selected models and native effort modes', async () => {
+  const root = mkdtempSync(join(tmpdir(), 'studio-claude-model-turns-'))
+  roots.push(root)
+  const log = join(root, 'claude.jsonl')
+  const harness = new ClaudeCodeHarness(fakeClaude(root))
+  const signal = new AbortController().signal
+
+  const normal = await harness.run({
+    root,
+    prompt: 'normal turn',
+    model: 'sonnet',
+    effort: 'ultracode',
+    access: 'full',
+    env: { FAKE_CLAUDE_LOG: log },
+    signal,
+    onEvent: () => {},
+  })
+  expect(normal).toMatchObject({
+    sessionId: 'fresh-session',
+    finalText: 'done',
+    isError: false,
+  })
+
+  const resumed = await harness.run({
+    root,
+    prompt: 'resumed turn',
+    sessionId: 'parent-session',
+    model: 'opus',
+    effort: 'max',
+    access: 'full',
+    env: { FAKE_CLAUDE_LOG: log },
+    signal,
+    onEvent: () => {},
+  })
+  expect(resumed).toMatchObject({
+    sessionId: 'parent-session',
+    finalText: 'done',
+    isError: false,
+  })
+
+  const fresh = await harness.ask({
+    root,
+    prompt: 'fresh ask',
+    model: 'fable',
+    effort: 'max',
+    access: 'workspace',
+    env: { FAKE_CLAUDE_LOG: log },
+    signal,
+    onDelta: () => {},
+  })
+  const forked = await harness.ask({
+    root,
+    prompt: 'forked ask',
+    sessionId: 'parent-session',
+    model: 'sonnet',
+    effort: 'max',
+    access: 'workspace',
+    env: { FAKE_CLAUDE_LOG: log },
+    signal,
+    onDelta: () => {},
+  })
+  expect(fresh).toEqual({ text: 'done', isError: false })
+  expect(forked).toEqual({ text: 'done', isError: false })
+
+  const [normalArgs, resumedArgs, freshArgs, forkArgs] = invocations(log).map((entry) => entry.args)
+  expect(normalArgs).not.toContain('--resume')
+  expect(
+    normalArgs.slice(normalArgs.indexOf('--model'), normalArgs.indexOf('--model') + 2),
+  ).toEqual(['--model', 'sonnet'])
+  expect(
+    resumedArgs.slice(resumedArgs.indexOf('--resume'), resumedArgs.indexOf('--resume') + 2),
+  ).toEqual(['--resume', 'parent-session'])
+  expect(
+    resumedArgs.slice(resumedArgs.indexOf('--model'), resumedArgs.indexOf('--model') + 2),
+  ).toEqual(['--model', 'opus'])
+  expect(freshArgs.slice(freshArgs.indexOf('--model'), freshArgs.indexOf('--model') + 2)).toEqual([
+    '--model',
+    'fable',
+  ])
+  expect(freshArgs).not.toContain('--resume')
+  expect(forkArgs.slice(forkArgs.indexOf('--model'), forkArgs.indexOf('--model') + 2)).toEqual([
+    '--model',
+    'sonnet',
+  ])
+  expect(forkArgs.slice(forkArgs.indexOf('--resume'), forkArgs.indexOf('--resume') + 3)).toEqual([
+    '--resume',
+    'parent-session',
+    '--fork-session',
+  ])
+  const normalEffortAt = normalArgs.indexOf('--effort')
+  expect(normalArgs.slice(normalEffortAt, normalEffortAt + 2)).toEqual(['--effort', 'xhigh'])
+  const settingsAt = normalArgs.indexOf('--settings')
+  expect(normalArgs.slice(settingsAt, settingsAt + 2)).toEqual(['--settings', '{"ultracode":true}'])
+  expect(normalArgs).not.toContain('ultracode')
+
+  for (const args of [resumedArgs, freshArgs, forkArgs]) {
+    const effortAt = args.indexOf('--effort')
+    expect(args.slice(effortAt, effortAt + 2)).toEqual(['--effort', 'max'])
+  }
+})
+
+test('Claude turns and Ask reject incomplete terminal protocols', async () => {
+  const root = mkdtempSync(join(tmpdir(), 'studio-claude-terminal-'))
+  roots.push(root)
+  const harness = new ClaudeCodeHarness(fakeClaude(root))
+  const input = {
+    root,
+    prompt: 'work',
+    signal: new AbortController().signal,
+    onEvent: () => {},
+  }
+
+  const noResult = await harness.run({
+    ...input,
+    env: { FAKE_CLAUDE_MODE: 'no-result' },
+  })
+  expect(noResult).toMatchObject({
+    isError: true,
+    errorMessage: 'claude exited without a result event',
+  })
+
+  const crashed = await harness.run({
+    ...input,
+    env: { FAKE_CLAUDE_MODE: 'text-then-crash' },
+  })
+  expect(crashed).toMatchObject({
+    isError: true,
+    errorMessage: expect.stringContaining('claude exited 7'),
+  })
+
+  const askInput = {
+    root,
+    prompt: 'question',
+    signal: new AbortController().signal,
+    onDelta: () => {},
+  }
+  const askNoResult = await harness.ask({
+    ...askInput,
+    env: { FAKE_CLAUDE_MODE: 'no-result' },
+  })
+  expect(askNoResult).toMatchObject({
+    isError: true,
+    errorMessage: 'claude exited without a result event',
+  })
+
+  const askCrashed = await harness.ask({
+    ...askInput,
+    env: { FAKE_CLAUDE_MODE: 'text-then-crash' },
+  })
+  expect(askCrashed).toMatchObject({
+    isError: true,
+    errorMessage: expect.stringContaining('claude exited 7'),
+  })
+
+  const askTerminalError = await harness.ask({
+    ...askInput,
+    env: { FAKE_CLAUDE_MODE: 'result-error' },
+  })
+  expect(askTerminalError).toEqual({
+    text: 'failed',
+    isError: true,
+    errorMessage: 'error_during_execution',
+  })
+})
+
+test('Claude Ask cancellation kills the entire stubborn subprocess group', async () => {
+  const root = mkdtempSync(join(tmpdir(), 'studio-claude-ask-cancel-'))
+  roots.push(root)
+  const pidLog = join(root, 'pids.json')
+  const controller = new AbortController()
+  const resultPromise = new ClaudeCodeHarness(fakeClaude(root)).ask({
+    root,
+    prompt: 'question',
+    env: {
+      FAKE_CLAUDE_MODE: 'hang-ignore-term',
+      FAKE_CLAUDE_PID_LOG: pidLog,
+    },
+    signal: controller.signal,
+    onDelta: () => {},
+  })
+
+  await waitFor(() => existsSync(pidLog))
+  const pids = JSON.parse(readFileSync(pidLog, 'utf8')) as { parent: number; child: number }
+  expect(processExists(pids.parent)).toBe(true)
+  expect(processExists(pids.child)).toBe(true)
+  controller.abort()
+
+  expect(await resultPromise).toEqual({
+    text: '',
+    isError: true,
+    errorMessage: 'canceled',
+  })
+  await waitFor(() => !processExists(pids.parent) && !processExists(pids.child))
+})

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

@@ -0,0 +1,71 @@
+import type { HarnessLoadout } from '../../../../shared/types'
+import type {
+  AgentHarness,
+  AgentTurnInput,
+  AgentTurnResult,
+  AskInput,
+  HarnessHealth,
+  HarnessLoadoutOptions,
+} from '../adapter'
+
+import { readSkillContent } from '../skills'
+import { runClaudeAsk } from './ask'
+import { CLAUDE_CAPABILITIES } from './capabilities'
+import { runClaudeTurn } from './events'
+import { loadClaudeConfiguration, probeClaudeHealth } from './loadout'
+import { scanClaudeSkills } from './skills'
+
+const DEFAULT_BIN = process.env.DOMAIN_STUDIO_CLAUDE_BIN || 'claude'
+
+export class ClaudeCodeHarness implements AgentHarness {
+  id = 'claude'
+  label = 'Claude Code (local)'
+  capabilities = CLAUDE_CAPABILITIES
+
+  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 health = await probeClaudeHealth(this.bin, signal)
+    if (!signal?.aborted) this.availCache = { at: now, health }
+    return health
+  }
+
+  async isAvailable(signal?: AbortSignal): Promise<boolean> {
+    return (await this.health(signal)).ok
+  }
+
+  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 loadClaudeConfiguration(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> {
+    return readSkillContent(scanClaudeSkills(root), command)
+  }
+
+  run(input: AgentTurnInput): Promise<AgentTurnResult> {
+    return runClaudeTurn(this.bin, input)
+  }
+
+  ask(input: AskInput) {
+    return runClaudeAsk(this.bin, input)
+  }
+}

package/studio/server/agent/harness/claude/ask.ts

@@ -0,0 +1,114 @@
+import { spawn } from 'node:child_process'
+
+import type { AskInput, AskResult } from '../adapter'
+
+import { childEnvironment, terminateProcessTree } from '../process'
+import { buildClaudeAskArgs } from './command'
+
+/** Execute one ephemeral Claude side-question stream. */
+export function runClaudeAsk(bin: string, input: AskInput): Promise<AskResult> {
+  return new Promise((resolve) => {
+    let finalText = ''
+    let stderr = ''
+    let isError = false
+    let errorMessage: string | undefined
+    let sawResult = false
+    let settled = false
+    let forceKillTimer: ReturnType<typeof setTimeout> | undefined
+    let onAbort = () => {}
+    const finish = (result: AskResult) => {
+      if (settled) return
+      settled = true
+      if (forceKillTimer) clearTimeout(forceKillTimer)
+      input.signal.removeEventListener('abort', onAbort)
+      resolve(result)
+    }
+
+    let child: ReturnType<typeof spawn>
+    try {
+      child = spawn(bin, buildClaudeAskArgs(input), {
+        cwd: input.root,
+        stdio: ['pipe', 'pipe', 'pipe'],
+        env: childEnvironment(input.env),
+        detached: process.platform !== 'win32',
+      })
+    } catch (error) {
+      finish({
+        text: finalText,
+        isError: true,
+        errorMessage: `failed to spawn ${bin}: ${String(error)}`,
+      })
+      return
+    }
+    onAbort = () => {
+      terminateProcessTree(child)
+      forceKillTimer = setTimeout(() => terminateProcessTree(child, 'SIGKILL'), 2_000)
+      forceKillTimer.unref?.()
+    }
+    if (input.signal.aborted) onAbort()
+    else input.signal.addEventListener('abort', onAbort, { once: true })
+    child.stdin?.write(input.prompt)
+    child.stdin?.end()
+
+    const handleLine = (line: string) => {
+      let event: any
+      try {
+        event = JSON.parse(line)
+      } catch {
+        return
+      }
+      if (event.type === 'assistant' && Array.isArray(event.message?.content)) {
+        for (const block of event.message.content)
+          if (block.type === 'text' && block.text) input.onDelta(block.text)
+      } else if (event.type === 'result') {
+        sawResult = true
+        if (typeof event.result === 'string') finalText = event.result
+        if (
+          event.is_error ||
+          event.subtype === 'error_during_execution' ||
+          event.subtype === 'error_max_turns'
+        ) {
+          isError = true
+          errorMessage = event.subtype || 'ask error'
+        }
+      }
+    }
+    let buffer = ''
+    child.stdout?.setEncoding('utf8')
+    child.stdout?.on('data', (chunk: string) => {
+      buffer += chunk
+      let newline: number
+      while ((newline = buffer.indexOf('\n')) >= 0) {
+        const line = buffer.slice(0, newline).trim()
+        buffer = buffer.slice(newline + 1)
+        if (line) handleLine(line)
+      }
+    })
+    child.stderr?.setEncoding('utf8')
+    child.stderr?.on('data', (chunk: string) => {
+      stderr += chunk
+    })
+    child.on('error', (error) =>
+      finish({
+        text: finalText,
+        isError: true,
+        errorMessage: `failed to spawn ${bin}: ${error.message}`,
+      }),
+    )
+    child.on('close', (code) => {
+      const trailing = buffer.trim()
+      if (trailing) handleLine(trailing)
+      if (input.signal.aborted)
+        return finish({ text: finalText, isError: true, errorMessage: 'canceled' })
+      if (code !== 0) {
+        isError = true
+        errorMessage =
+          errorMessage || `claude exited ${code}${stderr ? `: ${stderr.slice(-300)}` : ''}`
+      } else if (!sawResult) {
+        isError = true
+        errorMessage = 'claude exited without a result event'
+      }
+      finish({ text: finalText, isError, errorMessage })
+    })
+  })
+}

package/studio/server/agent/harness/claude/capabilities.ts

@@ -0,0 +1,27 @@
+import type { HarnessCapabilities } from '../../../../shared/types'
+
+/** Stable model aliases plus the effort modes supported by current Claude Code. */
+export const CLAUDE_CAPABILITIES = {
+  effortLevels: ['low', 'medium', 'high', 'xhigh', 'max', 'ultracode'],
+  accessLevels: ['workspace', 'full'],
+  modelOptions: [
+    {
+      id: 'fable',
+      label: 'Fable',
+      description: 'Claude Code alias for the latest available Fable model.',
+    },
+    {
+      id: 'sonnet',
+      label: 'Sonnet',
+      description: 'Claude Code alias for the latest available Sonnet model.',
+    },
+    {
+      id: 'opus',
+      label: 'Opus',
+      description: 'Claude Code alias for the latest available Opus model.',
+    },
+  ],
+  ask: true,
+  loadout: true,
+  gateway: 'anthropic',
+} as const satisfies HarnessCapabilities

package/studio/server/agent/harness/claude/command.ts

@@ -0,0 +1,63 @@
+import type { AgentTurnInput, AskInput } from '../adapter'
+
+const PERMISSION_MODE = process.env.DOMAIN_STUDIO_AGENT_PERMISSION || 'bypassPermissions'
+const EXTRA_ARGS = (process.env.DOMAIN_STUDIO_CLAUDE_ARGS || '').split(' ').filter(Boolean)
+const ULTRACODE_SETTINGS = JSON.stringify({ ultracode: true })
+
+function permissionMode(access?: AgentTurnInput['access']): string {
+  return (
+    process.env.DOMAIN_STUDIO_AGENT_PERMISSION ||
+    (access === 'workspace' ? 'acceptEdits' : PERMISSION_MODE)
+  )
+}
+
+function appendEffort(args: string[], effort?: AgentTurnInput['effort']): void {
+  if (!effort) return
+  if (effort === 'ultracode') {
+    args.push('--effort', 'xhigh', '--settings', ULTRACODE_SETTINGS)
+    return
+  }
+  args.push('--effort', effort)
+}
+
+export function buildClaudeProbeArgs(model?: string): string[] {
+  const args = ['-p', '--output-format', 'stream-json', '--verbose', ...EXTRA_ARGS]
+  if (model) args.push('--model', model)
+  return args
+}
+
+export function buildClaudeTurnArgs(input: AgentTurnInput, mcpPath?: string): string[] {
+  const args = [
+    '-p',
+    '--output-format',
+    'stream-json',
+    '--verbose',
+    '--permission-mode',
+    permissionMode(input.access),
+  ]
+  if (input.sessionId) args.push('--resume', input.sessionId)
+  if (input.model) args.push('--model', input.model)
+  appendEffort(args, input.effort)
+  if (mcpPath) args.push('--mcp-config', mcpPath)
+  if (input.appendSystemPrompt) args.push('--append-system-prompt', input.appendSystemPrompt)
+  args.push(...EXTRA_ARGS)
+  return args
+}
+
+export function buildClaudeAskArgs(input: AskInput): string[] {
+  const args = [
+    '-p',
+    '--output-format',
+    'stream-json',
+    '--verbose',
+    '--permission-mode',
+    permissionMode(input.access),
+  ]
+  if (input.model) args.push('--model', input.model)
+  appendEffort(args, input.effort)
+  if (input.sessionId) args.push('--resume', input.sessionId, '--fork-session')
+  args.push('--no-session-persistence')
+  if (input.appendSystemPrompt) args.push('--append-system-prompt', input.appendSystemPrompt)
+  args.push(...EXTRA_ARGS)
+  return args
+}