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

package/studio/client/dist/index.html

@@ -1,13 +0,0 @@
-<!doctype html>
-<html lang="en" class="dark">
-  <head>
-    <meta charset="UTF-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>Domain Studio</title>
-    <script type="module" crossorigin src="/assets/index-N8J8EKlB.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-BiGR8Oo9.css">
-  </head>
-  <body>
-    <div id="root"></div>
-  </body>
-</html>

package/studio/package.json

@@ -1,65 +0,0 @@
-{
-  "name": "@astrale-os/studio",
-  "version": "0.1.0",
-  "private": true,
-  "description": "Astrale Domain Studio — local GUI for authoring/inspecting a domain (launched by `astrale studio`)",
-  "bin": {
-    "astrale-studio": "./server/index.ts"
-  },
-  "files": [
-    "server",
-    "shared",
-    "client/dist"
-  ],
-  "type": "module",
-  "scripts": {
-    "build": "vite build",
-    "start": "bun server/index.ts",
-    "dev:client": "vite",
-    "test": "bun test client/src server shared",
-    "test:e2e": "pnpm build && playwright test",
-    "typecheck": "tsgo --noEmit"
-  },
-  "dependencies": {
-    "@astrale-os/sdk": ">=0.5.0-beta.17 <1.0.0",
-    "@astrale-os/shell": ">=0.4.0 <1.0.0",
-    "@dagrejs/dagre": "^3.0.0",
-    "@radix-ui/react-collapsible": "^1.1.0",
-    "@radix-ui/react-dialog": "^1.1.6",
-    "@radix-ui/react-dropdown-menu": "^2.1.6",
-    "@radix-ui/react-hover-card": "^1.1.0",
-    "@radix-ui/react-popover": "^1.1.0",
-    "@radix-ui/react-scroll-area": "^1.2.3",
-    "@radix-ui/react-separator": "^1.1.2",
-    "@radix-ui/react-slot": "^1.1.2",
-    "@radix-ui/react-tooltip": "^1.1.8",
-    "@tanstack/react-query": "^5.66.0",
-    "@xyflow/react": "^12.4.4",
-    "chokidar": "^4.0.3",
-    "class-variance-authority": "^0.7.1",
-    "clsx": "^2.1.1",
-    "cmdk": "^1.1.1",
-    "elkjs": "^0.11.1",
-    "lucide-react": "^0.475.0",
-    "react": "^19.2.0",
-    "react-dom": "^19.2.0",
-    "react-markdown": "^10.1.0",
-    "remark-gfm": "^4.0.1",
-    "sonner": "^2.0.1",
-    "tailwind-merge": "^3.0.1",
-    "ts-morph": "^25.0.1",
-    "zustand": "^5.0.3"
-  },
-  "devDependencies": {
-    "@playwright/test": "^1.62.1",
-    "@tailwindcss/vite": "^4.0.6",
-    "@types/node": "^20.19.43",
-    "@types/react": "^19.2.0",
-    "@types/react-dom": "^19.2.0",
-    "@vitejs/plugin-react": "^5.0.0",
-    "bun-types": "^1.4.0",
-    "tailwindcss": "^4.0.6",
-    "typescript": "^5.7.3",
-    "vite": "^7.0.0"
-  }
-}

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

@@ -1,74 +0,0 @@
-import { afterEach, expect, test } from 'bun:test'
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-
-import { registerDomain, unregisterDomain } from '../domain'
-import { updateSettings } from '../state/settings'
-import { runAsk } from './ask'
-import { saveConversation } from './conversation'
-
-const roots: string[] = []
-const domainIds: string[] = []
-const envBefore = {
-  harness: process.env.DOMAIN_STUDIO_HARNESS,
-  model: process.env.DOMAIN_STUDIO_MOCK_EXPECT_MODEL,
-  session: process.env.DOMAIN_STUDIO_MOCK_EXPECT_SESSION,
-}
-
-function restore(name: keyof typeof envBefore, variable: string): void {
-  const value = envBefore[name]
-  if (value === undefined) delete process.env[variable]
-  else process.env[variable] = value
-}
-
-afterEach(() => {
-  restore('harness', 'DOMAIN_STUDIO_HARNESS')
-  restore('model', 'DOMAIN_STUDIO_MOCK_EXPECT_MODEL')
-  restore('session', 'DOMAIN_STUDIO_MOCK_EXPECT_SESSION')
-  while (domainIds.length) unregisterDomain(domainIds.pop()!)
-  while (roots.length) rmSync(roots.pop()!, { recursive: true, force: true })
-})
-
-test('Ask uses the active harness model and matching per-harness conversation', async () => {
-  const root = mkdtempSync(join(tmpdir(), 'studio-ask-model-'))
-  roots.push(root)
-  mkdirSync(join(root, 'schema'))
-  writeFileSync(join(root, 'astrale.config.ts'), 'export default {}\n')
-  writeFileSync(join(root, 'application.ts'), 'export default {}\n')
-  writeFileSync(join(root, 'schema/index.ts'), 'export const Test = {}\n')
-  const handle = registerDomain(root)!
-  domainIds.push(handle.id)
-
-  process.env.DOMAIN_STUDIO_HARNESS = 'mock'
-  process.env.DOMAIN_STUDIO_MOCK_EXPECT_MODEL = 'mock-selected-model'
-  process.env.DOMAIN_STUDIO_MOCK_EXPECT_SESSION = 'mock-parent-session'
-  updateSettings(root, {
-    agentModels: {
-      mock: 'mock-selected-model',
-      claude: 'claude-other-model',
-    },
-  })
-  saveConversation(root, 'mock', {
-    sessionId: 'mock-parent-session',
-    turns: 2,
-    updatedAt: 'now',
-  })
-  saveConversation(root, 'claude', {
-    sessionId: 'claude-other-session',
-    turns: 4,
-    updatedAt: 'now',
-  })
-
-  const deltas: string[] = []
-  const result = await runAsk(
-    handle,
-    { question: 'Which context is active?' },
-    new AbortController().signal,
-    (delta) => deltas.push(delta),
-  )
-
-  expect(result.isError).toBe(false)
-  expect(result.text).toStartWith('(forked from mock-par…)')
-  expect(deltas.join('')).toBe(result.text)
-})

package/studio/server/agent/ask.ts

@@ -1,71 +0,0 @@
-/**
- * agent/ask.ts — the "side question" channel. A quick, EPHEMERAL aside about one
- * element: it FORKS the domain's live conversation (so it inherits the full context
- * the main loop built up) but writes nothing back to the parent transcript — the
- * main thread, its session, and comments.json are all untouched. Streams the
- * answer; nothing is persisted.
- *
- * It deliberately bypasses the single-run-per-domain lock (the fork is isolated
- * from the parent conversation) so you can ask while a main agent turn is running.
- */
-import type { AnchorRef } from '../../shared/types'
-import type { DomainHandle } from '../domain'
-import type { AskResult } from './harness/adapter'
-
-import { getBundle } from '../cache'
-import { readConversation } from './conversation'
-import { resolveHarnessConfiguration } from './harness/selection'
-import { buildAskPrompt, buildAskSystemPrompt } from './prompts/ask'
-import { studioSessionId } from './telemetry'
-
-export interface AskRequest {
-  anchor?: AnchorRef
-  excerpt?: string
-  question: string
-}
-
-export async function runAsk(
-  handle: DomainHandle,
-  body: AskRequest,
-  signal: AbortSignal,
-  onDelta: (text: string) => void,
-): Promise<AskResult> {
-  const question = String(body?.question ?? '').trim()
-  if (!question) return { text: '', isError: true, errorMessage: 'question is required' }
-  const resolved = await resolveHarnessConfiguration(handle.root)
-  if (!resolved.ok)
-    return {
-      text: '',
-      isError: true,
-      errorMessage: `model gateway auth failed — ${resolved.error}`,
-    }
-  const { harness, model, effort, env } = resolved.configuration
-  if (!harness.ask)
-    return {
-      text: '',
-      isError: true,
-      errorMessage: `${harness.label} does not support side questions`,
-    }
-
-  const ref = body.anchor?.ref ?? '(no target)'
-  const bundle = await getBundle(handle.id)
-  const prompt = buildAskPrompt({
-    anchorRef: ref,
-    excerpt: body.excerpt || ref,
-    question,
-    ir: bundle?.ir ?? null,
-    overlay: bundle?.overlay,
-  })
-  return harness.ask({
-    root: handle.root,
-    prompt,
-    appendSystemPrompt: buildAskSystemPrompt(),
-    sessionId: readConversation(handle.root, harness.id).sessionId,
-    model,
-    effort,
-    access: resolved.configuration.settings.agentAccess,
-    env: { ...env, ASTRALE_SESSION: studioSessionId(handle.id) },
-    signal,
-    onDelta,
-  })
-}

package/studio/server/agent/bridge/client.test.ts

@@ -1,49 +0,0 @@
-import { expect, test } from 'bun:test'
-
-import { forwardBridgeTool } from './client'
-
-test('marks HTTP and transport failures as MCP tool errors', async () => {
-  const denied = await forwardBridgeTool(
-    'http://studio.test',
-    'token',
-    'reply',
-    {},
-    async () => new Response('denied', { status: 401 }),
-  )
-  expect(denied).toEqual({
-    content: [{ type: 'text', text: 'bridge error 401: denied' }],
-    isError: true,
-  })
-
-  const unavailable = await forwardBridgeTool(
-    'http://studio.test',
-    'token',
-    'reply',
-    {},
-    async () => {
-      throw new Error('offline')
-    },
-  )
-  expect(unavailable).toEqual({
-    content: [{ type: 'text', text: 'bridge call failed: offline' }],
-    isError: true,
-  })
-})
-
-test('keeps the scoped bearer authoritative and returns successful content', async () => {
-  let sent: any
-  const response = await forwardBridgeTool(
-    'http://studio.test',
-    'scoped',
-    'threads',
-    { token: 'forged' },
-    async (_url, init) => {
-      sent = JSON.parse(String(init?.body))
-      return new Response('{"threads":[]}')
-    },
-  )
-  expect(sent).toEqual({ token: 'scoped' })
-  expect(response).toEqual({
-    content: [{ type: 'text', text: '{"threads":[]}' }],
-  })
-})

package/studio/server/agent/bridge/client.ts

@@ -1,37 +0,0 @@
-export interface BridgeToolResult {
-  content: [{ type: 'text'; text: string }]
-  isError?: true
-}
-
-type FetchBridge = (input: string | URL | Request, init?: RequestInit) => Promise<Response>
-
-function result(text: string, isError = false): BridgeToolResult {
-  return {
-    content: [{ type: 'text', text }],
-    ...(isError ? { isError: true as const } : {}),
-  }
-}
-
-/** Forward one stdio MCP tool call to the authenticated Studio bridge. */
-export async function forwardBridgeTool(
-  base: string,
-  token: string,
-  route: string,
-  args: Record<string, unknown>,
-  fetchBridge: FetchBridge = fetch,
-): Promise<BridgeToolResult> {
-  if (!base || !token) return result('bridge not configured', true)
-  try {
-    const response = await fetchBridge(`${base}/${route}`, {
-      method: 'POST',
-      headers: { 'content-type': 'application/json' },
-      body: JSON.stringify({ ...args, token }),
-    })
-    const text = await response.text()
-    return response.ok
-      ? result(text || 'ok')
-      : result(`bridge error ${response.status}: ${text}`, true)
-  } catch (error: any) {
-    return result(`bridge call failed: ${error?.message ?? error}`, true)
-  }
-}

package/studio/server/agent/bridge/grant.test.ts

@@ -1,62 +0,0 @@
-import { afterEach, expect, test } from 'bun:test'
-import { existsSync, mkdtempSync, readFileSync, rmSync, statSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-
-import type { DomainHandle } from '../../domain'
-
-import { startBridge } from './grant'
-
-const roots: string[] = []
-
-afterEach(() => {
-  while (roots.length) rmSync(roots.pop()!, { recursive: true, force: true })
-})
-
-function domain(root: string, id: string): DomainHandle {
-  return {
-    id,
-    root,
-    configFile: join(root, 'astrale.config.ts'),
-    applicationFile: join(root, 'application.ts'),
-    schemaDirName: 'schema',
-    schemaDir: join(root, 'schema'),
-    schemaIndex: join(root, 'schema/index.ts'),
-  }
-}
-
-test('keeps its bearer out of the harness command line', () => {
-  const root = mkdtempSync(join(tmpdir(), 'studio-bridge-'))
-  roots.push(root)
-
-  const bridge = startBridge(domain(root, 'test-domain'), () => {})
-  const server = bridge.mcpServers[0]!
-  const configPath = server.args?.at(-1)
-  expect(server.name).toBe('domain-studio')
-  expect(server.approvalMode).toBe('approve')
-  expect(configPath).toBeTruthy()
-
-  const config = JSON.parse(readFileSync(configPath!, 'utf8')) as {
-    base: string
-    token: string
-  }
-  expect(server.args?.join(' ')).not.toContain(config.token)
-  expect(config.base).toContain('/api/domain/test-domain/agent/bridge')
-  expect(existsSync(configPath!)).toBe(true)
-  expect(statSync(configPath!).mode & 0o777).toBe(0o600)
-
-  bridge.dispose()
-  expect(existsSync(configPath!)).toBe(false)
-})
-
-test('does not let an in-process tool replace its scoped bearer', async () => {
-  const root = mkdtempSync(join(tmpdir(), 'studio-bridge-invoke-'))
-  roots.push(root)
-  const bridge = startBridge(domain(root, 'test-domain'), () => {})
-  const server = bridge.mcpServers[0]!
-
-  await expect(server.invoke?.('list_open_threads', { token: 'forged' })).resolves.toEqual({
-    threads: [],
-  })
-  bridge.dispose()
-})

package/studio/server/agent/bridge/grant.ts

@@ -1,84 +0,0 @@
-import { randomUUID } from 'node:crypto'
-import { chmodSync } from 'node:fs'
-import { join } from 'node:path'
-
-import type { StudioEvent } from '../../../shared/types'
-import type { DomainHandle } from '../../domain'
-import type { HarnessMcpServer } from '../harness/adapter'
-
-import { removeState, statePath, writeJson } from '../../state/store'
-import { openBridgeSession } from './routes'
-
-export interface Bridge {
-  enabled: boolean
-  mcpServers: HarnessMcpServer[]
-  onReply(callback: (commentId: string, text: string) => void): void
-  onProgress(callback: (text: string) => void): void
-  dispose(): void
-}
-
-const TOOL_ROUTES: Record<string, string> = {
-  list_open_threads: 'threads',
-  reply_to_thread: 'reply',
-  resolve_thread: 'resolve',
-  post_progress: 'progress',
-  raise_question: 'raise_question',
-}
-
-let studioPort = Number(process.env.PORT) || 4319
-
-export function setBridgePort(port: number): void {
-  studioPort = port
-}
-
-const MCP_SERVER = join(import.meta.dir, 'stdio.ts')
-const BIN = process.env.DOMAIN_STUDIO_BRIDGE_BUN || process.execPath
-
-/** Mint the run-scoped MCP grant and its secret-bearing configuration file. */
-export function startBridge(handle: DomainHandle, notify: (event: StudioEvent) => void): Bridge {
-  const token = randomUUID()
-  const fileId = randomUUID()
-  const session = openBridgeSession(handle, token, notify)
-  const base = `http://127.0.0.1:${studioPort}/api/domain/${encodeURIComponent(handle.id)}/agent/bridge`
-  const bridgeRel = `.cache/agent/bridge-${fileId}.json`
-  writeJson(handle.root, bridgeRel, { base, token })
-  const bridgeConfigPath = statePath(handle.root, bridgeRel)
-  chmodSync(bridgeConfigPath, 0o600)
-
-  const server: HarnessMcpServer = {
-    name: 'domain-studio',
-    command: BIN,
-    args: [MCP_SERVER, '--config', bridgeConfigPath],
-    required: true,
-    approvalMode: 'approve',
-    enabledTools: Object.keys(TOOL_ROUTES),
-    invoke: async (tool, args) => {
-      const route = TOOL_ROUTES[tool]
-      if (!route) throw new Error(`unknown bridge tool: ${tool}`)
-      const response = await session.invoke(route, args)
-      const result = await response.json()
-      if (!response.ok)
-        throw new Error(
-          typeof result?.error === 'string'
-            ? result.error
-            : `bridge call failed: ${response.status}`,
-        )
-      return result
-    },
-  }
-
-  return {
-    enabled: true,
-    mcpServers: [server],
-    onReply: session.onReply,
-    onProgress: session.onProgress,
-    dispose: () => {
-      session.dispose()
-      try {
-        removeState(handle.root, bridgeRel)
-      } catch {
-        /* best-effort */
-      }
-    },
-  }
-}

package/studio/server/agent/bridge/routes.test.ts

@@ -1,151 +0,0 @@
-import { afterEach, expect, test } from 'bun:test'
-import { mkdtempSync, readFileSync, rmSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-
-import type { DomainHandle } from '../../domain'
-
-import { readComments, upsertComment } from '../../state/comments'
-import { startBridge } from './grant'
-import { handleBridge } from './routes'
-
-const roots: string[] = []
-
-afterEach(() => {
-  while (roots.length) rmSync(roots.pop()!, { recursive: true, force: true })
-})
-
-function domain(root: string, id: string): DomainHandle {
-  return {
-    id,
-    root,
-    configFile: join(root, 'astrale.config.ts'),
-    applicationFile: join(root, 'application.ts'),
-    schemaDirName: 'schema',
-    schemaDir: join(root, 'schema'),
-    schemaIndex: join(root, 'schema/index.ts'),
-  }
-}
-
-test('authorizes one domain and applies live thread mutations', async () => {
-  const rootA = mkdtempSync(join(tmpdir(), 'studio-bridge-a-'))
-  const rootB = mkdtempSync(join(tmpdir(), 'studio-bridge-b-'))
-  roots.push(rootA, rootB)
-  const domainA = domain(rootA, 'domain-a')
-  const domainB = domain(rootB, 'domain-b')
-  const awaiting = upsertComment(rootA, {
-    anchors: ['Test'],
-    anchorRefs: [{ ref: 'class.Test', kind: 'schema' }],
-    text: 'please answer',
-  })
-  upsertComment(rootA, {
-    anchors: ['Agent question'],
-    anchorRefs: [{ ref: 'class.Test', kind: 'schema' }],
-    text: 'already answered by author',
-    firstRole: 'author',
-  })
-
-  const notifications: string[] = []
-  const bridge = startBridge(domainA, (event) =>
-    notifications.push(`${event.type}:${'domainId' in event ? event.domainId : ''}`),
-  )
-  const configPath = bridge.mcpServers[0]!.args!.at(-1)!
-  const { token } = JSON.parse(readFileSync(configPath, 'utf8')) as { token: string }
-  const replies: string[] = []
-  const progress: string[] = []
-  bridge.onReply((id, text) => replies.push(`${id}:${text}`))
-  bridge.onProgress((text) => progress.push(text))
-  const request = new Request('http://studio.test')
-
-  const invalid = await handleBridge(domainA, 'reply', request, {
-    token: 'wrong',
-    commentId: awaiting.id,
-    text: 'forged',
-  })
-  const crossDomain = await handleBridge(domainB, 'reply', request, {
-    token,
-    commentId: awaiting.id,
-    text: 'forged',
-  })
-  expect([invalid.status, crossDomain.status]).toEqual([401, 401])
-  expect(readComments(rootA).comments[0]!.thread).toHaveLength(1)
-
-  const listed = await handleBridge(domainA, 'threads', request, { token })
-  expect(await listed.json()).toEqual({
-    threads: [
-      {
-        id: awaiting.id,
-        kind: 'comment',
-        anchor: 'class.Test',
-        file: null,
-        latest: 'please answer',
-      },
-    ],
-  })
-
-  const replied = await handleBridge(domainA, 'reply', request, {
-    token,
-    commentId: awaiting.id,
-    text: 'done',
-    resolve: true,
-    closeNote: 'complete',
-  })
-  await handleBridge(domainA, 'progress', request, { token, text: 'working' })
-  const raised = await handleBridge(domainA, 'raise_question', request, {
-    token,
-    ref: 'class.Test.property.value',
-    text: 'Which value?',
-    options: ['A', 'B'],
-  })
-
-  expect(await replied.json()).toEqual({ ok: true, resolved: true })
-  expect(await raised.json()).toMatchObject({ ok: true })
-  const comments = readComments(rootA).comments
-  expect(comments[0]).toMatchObject({
-    id: awaiting.id,
-    status: 'closed',
-    closeNote: 'complete',
-  })
-  expect(comments[0]!.thread.at(-1)).toMatchObject({ role: 'author', text: 'done' })
-  expect(comments.at(-1)).toMatchObject({
-    kind: 'question',
-    status: 'open',
-    thread: [{ role: 'author', type: 'choice', text: 'Which value?', options: ['A', 'B'] }],
-  })
-  expect(replies).toEqual([`${awaiting.id}:done`])
-  expect(progress).toEqual(['working'])
-  expect(notifications).toEqual(['comments:domain-a', 'comments:domain-a'])
-
-  bridge.dispose()
-  const expired = await handleBridge(domainA, 'threads', request, { token })
-  expect(expired.status).toBe(401)
-})
-
-test('returns committed success when UI notification delivery fails', async () => {
-  const root = mkdtempSync(join(tmpdir(), 'studio-bridge-notify-'))
-  roots.push(root)
-  const handle = domain(root, 'domain-notify')
-  const comment = upsertComment(root, {
-    anchors: ['Test'],
-    anchorRefs: [{ ref: 'class.Test', kind: 'schema' }],
-    text: 'reply once',
-  })
-  const bridge = startBridge(handle, () => {
-    throw new Error('listener failed')
-  })
-  const configPath = bridge.mcpServers[0]!.args!.at(-1)!
-  const { token } = JSON.parse(readFileSync(configPath, 'utf8')) as { token: string }
-
-  const response = await handleBridge(handle, 'reply', new Request('http://studio.test'), {
-    token,
-    commentId: comment.id,
-    text: 'committed',
-  })
-
-  expect(response.status).toBe(200)
-  expect(readComments(root).comments[0]!.thread.map((entry) => entry.text)).toEqual([
-    'reply once',
-    'committed',
-  ])
-  bridge.dispose()
-})