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

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

@@ -1,32 +0,0 @@
-import { expect, test } from 'bun:test'
-
-import { codexMcpConfigArgs } from './mcp'
-
-test('serializes a structured MCP grant into Codex overrides', () => {
-  expect(
-    codexMcpConfigArgs([
-      {
-        name: 'domain-studio',
-        command: '/opt/bun',
-        args: ['/studio/bridge/stdio.ts', '--config', '/domain/bridge.json'],
-        env: { MODE: 'test value' },
-        required: true,
-        approvalMode: 'approve',
-        enabledTools: ['reply_to_thread', 'resolve_thread'],
-      },
-    ]),
-  ).toEqual([
-    '-c',
-    'mcp_servers.domain-studio.command="/opt/bun"',
-    '-c',
-    'mcp_servers.domain-studio.args=["/studio/bridge/stdio.ts","--config","/domain/bridge.json"]',
-    '-c',
-    'mcp_servers.domain-studio.env={MODE="test value"}',
-    '-c',
-    'mcp_servers.domain-studio.required=true',
-    '-c',
-    'mcp_servers.domain-studio.default_tools_approval_mode="approve"',
-    '-c',
-    'mcp_servers.domain-studio.enabled_tools=["reply_to_thread","resolve_thread"]',
-  ])
-})

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

@@ -1,27 +0,0 @@
-import type { HarnessMcpServer } from '../adapter'
-
-export function tomlString(value: string): string {
-  return JSON.stringify(value)
-}
-
-function tomlStringMap(values: Record<string, string>): string {
-  return `{${Object.entries(values)
-    .map(([key, value]) => `${key}=${tomlString(value)}`)
-    .join(',')}}`
-}
-
-/** Serialize Studio MCP grants into Codex CLI config overrides. */
-export function codexMcpConfigArgs(servers: HarnessMcpServer[] | undefined): string[] {
-  const args: string[] = []
-  for (const server of servers ?? []) {
-    const prefix = `mcp_servers.${server.name}`
-    const add = (key: string, value: string) => args.push('-c', `${prefix}.${key}=${value}`)
-    add('command', tomlString(server.command))
-    if (server.args?.length) add('args', JSON.stringify(server.args))
-    if (server.env && Object.keys(server.env).length) add('env', tomlStringMap(server.env))
-    if (server.required !== undefined) add('required', String(server.required))
-    if (server.approvalMode) add('default_tools_approval_mode', tomlString(server.approvalMode))
-    if (server.enabledTools?.length) add('enabled_tools', JSON.stringify(server.enabledTools))
-  }
-  return args
-}

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

@@ -1,167 +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 { probeCodexModels } from './models'
-
-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 fs = require('node:fs')
-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)
-    const mode = process.env.FAKE_MODEL_MODE
-    if (process.env.FAKE_MODEL_LOG) fs.appendFileSync(process.env.FAKE_MODEL_LOG, line + '\\n')
-    if (message.method === 'initialize') {
-      if (mode === 'early-close') {
-        console.error('probe crashed before initialization')
-        process.exit(7)
-      }
-      if (mode !== 'timeout') send({ id: message.id, result: { userAgent: 'fake' } })
-    }
-    if (message.method === 'config/read') {
-      if (mode === 'rpc-error') send({ id: message.id, error: { message: 'config denied' } })
-      else if (mode === 'malformed-config') send({ id: message.id, result: { origins: {} } })
-      else send({ id: message.id, result: { config: { model: 'gpt-configured' }, origins: {} } })
-    }
-    if (message.method === 'model/list') {
-      send({
-        id: message.id,
-        result: {
-          data: mode === 'malformed-models' ? {} : [
-            { id: 'default', model: 'gpt-default', displayName: 'Default GPT', description: 'default model', isDefault: true },
-            { id: 'fast', model: 'gpt-fast', displayName: 'Fast GPT', description: 'fast model', isDefault: false },
-          ],
-          nextCursor: null,
-        },
-      })
-    }
-  }
-})
-`,
-  )
-  chmodSync(file, 0o755)
-  return file
-}
-
-test('resolves Codex config and live catalog through the app-server protocol', async () => {
-  const root = mkdtempSync(join(tmpdir(), 'studio-codex-models-'))
-  roots.push(root)
-  const log = join(root, 'requests.jsonl')
-
-  const result = await probeCodexModels(fakeCodex(root), root, undefined, {
-    FAKE_MODEL_LOG: log,
-  })
-
-  expect(result).toEqual({
-    ok: true,
-    nativeModel: 'gpt-configured',
-    model: 'gpt-configured',
-    modelSource: 'config',
-    models: [
-      {
-        id: 'gpt-default',
-        label: 'Default GPT',
-        description: 'default model',
-        isDefault: true,
-      },
-      {
-        id: 'gpt-fast',
-        label: 'Fast GPT',
-        description: 'fast model',
-        isDefault: false,
-      },
-    ],
-    detail: 'Codex resolves gpt-configured from its effective config.',
-  })
-  const requests = readFileSync(log, 'utf8')
-    .trim()
-    .split('\n')
-    .map((line) => JSON.parse(line))
-  expect(requests.map((request) => request.method)).toEqual([
-    'initialize',
-    'initialized',
-    'config/read',
-    'model/list',
-  ])
-  expect(requests[2].params).toEqual({ cwd: root, includeLayers: false })
-  expect(requests[3].params).toEqual({ includeHidden: false, limit: 100 })
-})
-
-test('keeps the native Codex model visible while a Studio override wins', async () => {
-  const root = mkdtempSync(join(tmpdir(), 'studio-codex-model-override-'))
-  roots.push(root)
-
-  const result = await probeCodexModels(fakeCodex(root), root, 'gpt-fast')
-
-  expect(result).toMatchObject({
-    ok: true,
-    nativeModel: 'gpt-configured',
-    model: 'gpt-fast',
-    modelSource: 'studio',
-  })
-  expect(result.detail).toBe('Codex resolves gpt-fast from this Studio domain.')
-})
-
-test.each([
-  ['malformed-config', 'Codex config probe returned an invalid response'],
-  ['malformed-models', 'Codex model catalog returned an invalid response'],
-  ['rpc-error', 'config denied'],
-] as const)('fails closed on %s app-server protocol responses', async (mode, detail) => {
-  const root = mkdtempSync(join(tmpdir(), `studio-codex-model-${mode}-`))
-  roots.push(root)
-
-  const result = await probeCodexModels(fakeCodex(root), root, undefined, {
-    FAKE_MODEL_MODE: mode,
-  })
-
-  expect(result.ok).toBe(false)
-  expect(result.detail).toBe(detail)
-})
-
-test('reports spawn, early-close, and timeout failures without hanging', async () => {
-  const root = mkdtempSync(join(tmpdir(), 'studio-codex-model-failures-'))
-  roots.push(root)
-  const bin = fakeCodex(root)
-
-  const missing = await probeCodexModels(join(root, 'missing-codex'), root)
-  expect(missing).toMatchObject({
-    ok: false,
-    models: [],
-  })
-  expect(missing.detail).toContain('failed to spawn')
-
-  const early = await probeCodexModels(bin, root, undefined, {
-    FAKE_MODEL_MODE: 'early-close',
-  })
-  expect(early.ok).toBe(false)
-  expect(early.detail).toContain('probe crashed before initialization')
-
-  const timedOut = await probeCodexModels(bin, root, undefined, { FAKE_MODEL_MODE: 'timeout' }, 50)
-  expect(timedOut).toEqual({
-    ok: false,
-    nativeModel: undefined,
-    model: undefined,
-    modelSource: undefined,
-    models: [],
-    detail: 'Codex model probe timed out',
-  })
-})

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

@@ -1,211 +0,0 @@
-import { spawn } from 'node:child_process'
-
-import type { HarnessLoadout, HarnessModelOption } from '../../../../shared/types'
-
-import { childEnvironment, terminateProcessTree } from '../process'
-
-const PROBE_TIMEOUT_MS = 15_000
-
-export interface CodexModelProbe {
-  ok: boolean
-  nativeModel?: string
-  model?: string
-  modelSource?: HarnessLoadout['modelSource']
-  models: HarnessModelOption[]
-  detail?: string
-}
-
-/** Read the effective Codex config and the authenticated account's model catalog.
- *
- * `config/read` resolves the same project/profile/user/system layers a real turn
- * sees for this cwd. `model/list` supplies the live picker options and built-in
- * default. An explicit Studio override remains highest precedence, matching
- * Codex's documented `--model` behavior.
- */
-export function probeCodexModels(
-  bin: string,
-  root: string,
-  override?: string,
-  env?: Record<string, string>,
-  timeoutMs = PROBE_TIMEOUT_MS,
-): Promise<CodexModelProbe> {
-  return new Promise((resolve) => {
-    let child: ReturnType<typeof spawn>
-    try {
-      child = spawn(bin, ['app-server', '--stdio'], {
-        cwd: root,
-        stdio: ['pipe', 'pipe', 'pipe'],
-        env: childEnvironment(env),
-        detached: process.platform !== 'win32',
-      })
-    } catch (error) {
-      resolve({
-        ok: false,
-        models: [],
-        detail: `failed to spawn ${bin} app-server: ${String(error)}`,
-      })
-      return
-    }
-
-    let settled = false
-    let configDone = false
-    let modelsDone = false
-    let configModel: string | undefined
-    let catalog: HarnessModelOption[] = []
-    let probeError = ''
-    let stderr = ''
-    let buffer = ''
-
-    const send = (message: unknown) => child.stdin?.write(`${JSON.stringify(message)}\n`)
-    const finish = () => {
-      if (settled) return
-      settled = true
-      clearTimeout(timer)
-      try {
-        terminateProcessTree(child)
-      } catch {
-        /* already gone */
-      }
-      const selected = override?.trim() || undefined
-      const catalogDefault = catalog.find((model) => model.isDefault)?.id
-      const nativeModel = configModel ?? catalogDefault
-      const model = selected ?? nativeModel
-      resolve({
-        ok: configDone && modelsDone && !probeError,
-        nativeModel,
-        model,
-        modelSource: selected
-          ? 'studio'
-          : configModel
-            ? 'config'
-            : catalogDefault
-              ? 'default'
-              : undefined,
-        models: catalog,
-        detail:
-          probeError ||
-          (model
-            ? `Codex resolves ${model} from ${
-                selected
-                  ? 'this Studio domain'
-                  : configModel
-                    ? 'its effective config'
-                    : 'its catalog default'
-              }.`
-            : undefined),
-      })
-    }
-    const maybeFinish = () => {
-      if (configDone && modelsDone) finish()
-    }
-    const timer = setTimeout(() => {
-      probeError = 'Codex model probe timed out'
-      configDone = true
-      modelsDone = true
-      finish()
-    }, timeoutMs)
-
-    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) continue
-        let message: any
-        try {
-          message = JSON.parse(line)
-        } catch {
-          continue
-        }
-        if (message.id === 1) {
-          if (message.error) {
-            probeError = message.error.message ?? 'Codex app-server init failed'
-            configDone = true
-            modelsDone = true
-            return finish()
-          }
-          send({ method: 'initialized', params: {} })
-          send({ method: 'config/read', id: 2, params: { cwd: root, includeLayers: false } })
-          send({ method: 'model/list', id: 3, params: { includeHidden: false, limit: 100 } })
-          continue
-        }
-        if (message.id === 2) {
-          configDone = true
-          if (message.error) {
-            probeError ||= message.error.message ?? 'Codex config probe failed'
-          } else {
-            const config = message.result?.config
-            if (!config || typeof config !== 'object' || Array.isArray(config)) {
-              probeError ||= 'Codex config probe returned an invalid response'
-            } else {
-              const raw = config.model
-              configModel = typeof raw === 'string' && raw.trim() ? raw.trim() : undefined
-            }
-          }
-          maybeFinish()
-          continue
-        }
-        if (message.id === 3) {
-          modelsDone = true
-          if (message.error) {
-            probeError ||= message.error.message ?? 'Codex model catalog probe failed'
-          } else {
-            if (!Array.isArray(message.result?.data)) {
-              probeError ||= 'Codex model catalog returned an invalid response'
-              maybeFinish()
-              continue
-            }
-            catalog = message.result.data
-              .map((entry: any): HarnessModelOption | null => {
-                const id = String(entry?.model ?? entry?.id ?? '').trim()
-                if (!id) return null
-                return {
-                  id,
-                  label: String(entry?.displayName ?? id),
-                  description:
-                    typeof entry?.description === 'string' ? entry.description : undefined,
-                  isDefault: entry?.isDefault === true,
-                }
-              })
-              .filter((entry: HarnessModelOption | null): entry is HarnessModelOption => !!entry)
-          }
-          maybeFinish()
-        }
-      }
-    })
-    child.stderr?.setEncoding('utf8')
-    child.stderr?.on('data', (chunk: string) => {
-      stderr += chunk
-    })
-    child.on('error', (error) => {
-      probeError = `failed to spawn ${bin} app-server: ${error.message}`
-      configDone = true
-      modelsDone = true
-      finish()
-    })
-    child.on('close', (code) => {
-      if (settled) return
-      probeError =
-        probeError ||
-        `Codex app-server exited ${code ?? -1}${stderr ? `: ${stderr.trim().slice(-400)}` : ''}`
-      configDone = true
-      modelsDone = true
-      finish()
-    })
-
-    send({
-      method: 'initialize',
-      id: 1,
-      params: {
-        clientInfo: {
-          name: 'astrale_domain_studio_probe',
-          title: 'Astrale Domain Studio',
-          version: '0.1.0',
-        },
-        capabilities: null,
-      },
-    })
-  })
-}

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

@@ -1,33 +0,0 @@
-import { homedir } from 'node:os'
-import { join } from 'node:path'
-
-import type { LoadoutSkill } from '../../../../shared/types'
-
-import { scanAncestors, scanSkillDir } from '../skills'
-
-export interface CodexPlugin {
-  name: string
-  path: string
-  enabled: boolean
-}
-
-/** Discover project, user, and plugin skills visible to Codex. */
-export function scanCodexSkills(root: string, plugins: CodexPlugin[]): LoadoutSkill[] {
-  const out: LoadoutSkill[] = []
-  const seen = new Set<string>()
-  const home = homedir()
-  scanAncestors(root, ['.agents/skills', '.codex/skills'], out, seen)
-  scanSkillDir(join(home, '.agents', 'skills'), 'user', undefined, '', true, out, seen)
-  scanSkillDir(join(home, '.codex', 'skills'), 'user', undefined, '', true, out, seen)
-  for (const plugin of plugins)
-    scanSkillDir(
-      join(plugin.path, 'skills'),
-      'plugin',
-      plugin.name,
-      `${plugin.name}:`,
-      plugin.enabled,
-      out,
-      seen,
-    )
-  return out
-}

package/studio/server/agent/harness/gateway/config.test.ts

@@ -1,98 +0,0 @@
-import { afterEach, expect, test } from 'bun:test'
-import { mkdtempSync, rmSync, statSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-
-import { statePath, writeJson } from '../../../state/store'
-import {
-  clearHarnessGateway,
-  getHarnessGatewayState,
-  resolveHarnessEnv,
-  setHarnessGateway,
-} from './config'
-
-const roots: string[] = []
-
-afterEach(() => {
-  while (roots.length) rmSync(roots.pop()!, { recursive: true, force: true })
-})
-
-test('owns normalized per-domain gateway configuration and child environment', async () => {
-  const root = mkdtempSync(join(tmpdir(), 'studio-harness-gateway-'))
-  roots.push(root)
-
-  const state = setHarnessGateway(root, {
-    scope: 'domain',
-    config: {
-      enabled: true,
-      baseUrl: ' https://gateway.example/v1/models/demo ',
-      model: ' demo-model ',
-      auth: { mode: 'token', token: ' secret ' },
-    },
-  })
-  expect(state).toMatchObject({
-    source: 'domain',
-    effective: {
-      enabled: true,
-      baseUrl: 'https://gateway.example/v1/models/demo',
-      model: 'demo-model',
-      auth: { mode: 'token', token: 'secret' },
-    },
-  })
-  expect(await resolveHarnessEnv(root)).toEqual({
-    ok: true,
-    env: {
-      ANTHROPIC_BASE_URL: 'https://gateway.example/v1/models/demo',
-      ANTHROPIC_AUTH_TOKEN: 'secret',
-      ANTHROPIC_MODEL: 'demo-model',
-      ANTHROPIC_SMALL_FAST_MODEL: 'demo-model',
-    },
-  })
-  expect(statSync(statePath(root, 'harness-gateway.json')).mode & 0o777).toBe(0o600)
-
-  clearHarnessGateway(root, 'domain')
-  expect(getHarnessGatewayState(root).local).toBeNull()
-})
-
-test('rejects enabled gateway configurations that cannot authenticate safely', () => {
-  const root = mkdtempSync(join(tmpdir(), 'studio-harness-gateway-invalid-'))
-  roots.push(root)
-
-  expect(() =>
-    setHarnessGateway(root, {
-      scope: 'domain',
-      config: { enabled: true, baseUrl: '', auth: { mode: 'mint' } },
-    }),
-  ).toThrow('gateway base URL is required')
-  expect(() =>
-    setHarnessGateway(root, {
-      scope: 'domain',
-      config: { enabled: true, baseUrl: 'file:///tmp/gateway', auth: { mode: 'mint' } },
-    }),
-  ).toThrow('must use http:// or https://')
-  expect(() =>
-    setHarnessGateway(root, {
-      scope: 'domain',
-      config: {
-        enabled: true,
-        baseUrl: 'https://gateway.example',
-        auth: { mode: 'token', token: ' ' },
-      },
-    }),
-  ).toThrow('static token is required')
-})
-
-test('fails closed for invalid enabled configuration already present on disk', async () => {
-  const root = mkdtempSync(join(tmpdir(), 'studio-harness-gateway-legacy-invalid-'))
-  roots.push(root)
-  writeJson(root, 'harness-gateway.json', {
-    enabled: true,
-    baseUrl: '',
-    auth: { mode: 'mint' },
-  })
-
-  expect(await resolveHarnessEnv(root)).toEqual({
-    ok: false,
-    error: 'gateway base URL is required while enabled',
-  })
-})