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

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

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

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

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

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

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

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

package/studio/server/{state/harness-gateway.ts → agent/harness/gateway/config.ts}

@@ -1,5 +1,5 @@
 /**
- * harness-gateway.ts — point the agent harness at a custom Anthropic-compatible
+ * gateway/config.ts — point the selected harness at an Anthropic-compatible
  * model gateway (e.g. an Astrale `ai-gateway` model node) instead of Claude
  * Code's built-in auth. Two scopes, layered:
  *   - per-domain : `<domain>/.domain-studio/harness-gateway.json` — AUTHORITATIVE
@@ -12,7 +12,7 @@
  * subprocess env ONLY — never the studio's own process env, the user's shell, or
  * a `claude` they run themselves outside the studio.
  */
-import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
+import { chmodSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
 import { homedir } from 'node:os'
 import { dirname, join } from 'node:path'
 
@@ -20,10 +20,10 @@ import type {
   HarnessGatewayAuth,
   HarnessGatewayConfig,
   HarnessGatewayState,
-} from '../../shared/types'
+} from '../../../../shared/types'
 
-import { acquireGatewayToken } from './harness-token'
-import { readJson, removeState, writeJson } from './store'
+import { readJson, removeState, statePath, writeJson } from '../../../state/store'
+import { acquireGatewayToken } from './token'
 
 /** Per-domain file (lives under the domain's `.domain-studio/`, gitignored). */
 const LOCAL_FILE = 'harness-gateway.json'
@@ -55,6 +55,21 @@ function normalize(input: any): HarnessGatewayConfig {
   }
 }
 
+function validateEnabledConfig(config: HarnessGatewayConfig): void {
+  if (!config.enabled) return
+  if (!config.baseUrl) throw new Error('gateway base URL is required while enabled')
+  let url: URL
+  try {
+    url = new URL(config.baseUrl)
+  } catch {
+    throw new Error(`invalid gateway base URL: ${config.baseUrl}`)
+  }
+  if (url.protocol !== 'http:' && url.protocol !== 'https:')
+    throw new Error('gateway base URL must use http:// or https://')
+  if (config.auth.mode === 'token' && !config.auth.token)
+    throw new Error('gateway static token is required in token mode')
+}
+
 function readLocal(root: string): HarnessGatewayConfig | null {
   const raw = readJson<HarnessGatewayConfig | null>(root, LOCAL_FILE, null)
   return raw ? normalize(raw) : null
@@ -77,7 +92,8 @@ function writeGlobal(cfg: HarnessGatewayConfig | null): void {
     return
   }
   mkdirSync(dirname(GLOBAL_FILE), { recursive: true })
-  writeFileSync(GLOBAL_FILE, JSON.stringify(cfg, null, 2))
+  writeFileSync(GLOBAL_FILE, JSON.stringify(cfg, null, 2), { mode: 0o600 })
+  chmodSync(GLOBAL_FILE, 0o600)
 }
 
 /** Resolve the layered state. A PRESENT local override wins outright — even when
@@ -115,11 +131,13 @@ export function setHarnessGateway(
   input: SetHarnessGatewayInput,
 ): HarnessGatewayState {
   const cfg = normalize(input.config)
+  validateEnabledConfig(cfg)
   if (input.scope === 'global') {
     writeGlobal(cfg)
     removeState(root, LOCAL_FILE)
   } else {
     writeJson(root, LOCAL_FILE, cfg)
+    chmodSync(statePath(root, LOCAL_FILE), 0o600)
   }
   return getHarnessGatewayState(root)
 }
@@ -165,10 +183,14 @@ export type HarnessEnvResult =
  */
 export async function resolveHarnessEnv(root: string): Promise<HarnessEnvResult> {
   const cfg = resolveHarnessGateway(root)
-  if (!cfg || !cfg.enabled || !cfg.baseUrl) return { ok: true, env: {} }
+  if (!cfg || !cfg.enabled) return { ok: true, env: {} }
+  if (!cfg.baseUrl) return { ok: false, error: 'gateway base URL is required while enabled' }
   let audience: string
   try {
-    audience = new URL(cfg.baseUrl).origin
+    const url = new URL(cfg.baseUrl)
+    if (url.protocol !== 'http:' && url.protocol !== 'https:')
+      return { ok: false, error: 'gateway base URL must use http:// or https://' }
+    audience = url.origin
   } catch {
     return { ok: false, error: `invalid gateway base URL: ${cfg.baseUrl}` }
   }