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

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

@@ -1,148 +0,0 @@
-import type { StudioEvent } from '../../../shared/types'
-import type { DomainHandle } from '../../domain'
-
-import { addThreadEntry, readComments, setStatus, upsertComment } from '../../state/comments'
-import { emitStudioEvent } from '../notify'
-
-interface RunBridge {
-  domainId: string
-  root: string
-  notify: (event: StudioEvent) => void
-  onReply: (commentId: string, text: string) => void
-  onProgress: (text: string) => void
-}
-
-export interface BridgeSession {
-  token: string
-  onReply(callback: (commentId: string, text: string) => void): void
-  onProgress(callback: (text: string) => void): void
-  invoke(sub: string, body: Record<string, unknown>): Promise<Response>
-  dispose(): void
-}
-
-const bridges = new Map<string, RunBridge>()
-
-function ok(data: unknown): Response {
-  return new Response(JSON.stringify(data), {
-    status: 200,
-    headers: { 'content-type': 'application/json' },
-  })
-}
-
-function error(message: string, status = 400): Response {
-  return new Response(JSON.stringify({ error: message }), {
-    status,
-    headers: { 'content-type': 'application/json' },
-  })
-}
-
-/** Open the authenticated write-back session owned by one agent run. */
-export function openBridgeSession(
-  handle: DomainHandle,
-  token: string,
-  notify: (event: StudioEvent) => void,
-): BridgeSession {
-  const bridge: RunBridge = {
-    domainId: handle.id,
-    root: handle.root,
-    notify,
-    onReply: () => {},
-    onProgress: () => {},
-  }
-  bridges.set(token, bridge)
-  return {
-    token,
-    onReply: (callback) => {
-      bridge.onReply = callback
-    },
-    onProgress: (callback) => {
-      bridge.onProgress = callback
-    },
-    invoke: (sub, body) => applyBridgeCall(handle, sub, { ...body, token }),
-    dispose: () => {
-      bridges.delete(token)
-    },
-  }
-}
-
-/** Handle one token-guarded bridge route. */
-export function handleBridge(
-  handle: DomainHandle,
-  sub: string,
-  _req: Request,
-  body: any,
-): Promise<Response> {
-  return applyBridgeCall(handle, sub, body)
-}
-
-async function applyBridgeCall(handle: DomainHandle, sub: string, body: any): Promise<Response> {
-  const token = String(body?.token ?? '')
-  const bridge = bridges.get(token)
-  if (!bridge || bridge.domainId !== handle.id) return error('invalid or expired bridge token', 401)
-  const root = bridge.root
-
-  switch (sub) {
-    case 'threads': {
-      const open = readComments(root).comments.filter(
-        (comment) => comment.status === 'open' && comment.thread.at(-1)?.role !== 'author',
-      )
-      return ok({
-        threads: open.map((comment) => ({
-          id: comment.id,
-          kind: comment.kind,
-          anchor: comment.anchorRefs?.[0]?.ref ?? null,
-          file: comment.anchorRefs?.[0]?.file ?? null,
-          latest: comment.thread.at(-1)?.text ?? '',
-        })),
-      })
-    }
-    case 'reply': {
-      const commentId = String(body.commentId ?? '')
-      const text = String(body.text ?? '').trim()
-      if (!commentId || !text) return error('commentId and text are required')
-      const comment = addThreadEntry(root, commentId, {
-        role: 'author',
-        type: body.options ? 'choice' : 'text',
-        text,
-        options: body.options,
-        answer: body.answer,
-      })
-      if (!comment) return error('unknown commentId', 404)
-      if (body.resolve) setStatus(root, commentId, 'closed', body.closeNote)
-      bridge.onReply(commentId, text)
-      emitStudioEvent(bridge.notify, { type: 'comments', domainId: handle.id })
-      return ok({ ok: true, resolved: !!body.resolve })
-    }
-    case 'resolve': {
-      const commentId = String(body.commentId ?? '')
-      if (!commentId) return error('commentId is required')
-      const comment = setStatus(root, commentId, 'closed', body.closeNote)
-      if (!comment) return error('unknown commentId', 404)
-      bridge.onReply(commentId, body.closeNote ? `resolved: ${body.closeNote}` : 'resolved')
-      emitStudioEvent(bridge.notify, { type: 'comments', domainId: handle.id })
-      return ok({ ok: true })
-    }
-    case 'progress': {
-      const text = String(body.text ?? '').trim()
-      if (text) bridge.onProgress(text)
-      return ok({ ok: true })
-    }
-    case 'raise_question': {
-      const ref = String(body.ref ?? '')
-      const text = String(body.text ?? '').trim()
-      if (!ref || !text) return error('ref and text are required')
-      const comment = upsertComment(root, {
-        anchors: [body.label ?? ref],
-        anchorRefs: [{ ref, kind: (body.kind ?? 'schema') as any, file: body.file }],
-        text,
-        firstRole: 'author',
-        type: body.options ? 'choice' : 'text',
-        options: body.options,
-      })
-      emitStudioEvent(bridge.notify, { type: 'comments', domainId: handle.id })
-      return ok({ ok: true, id: comment.id })
-    }
-    default:
-      return error('unknown bridge route', 404)
-  }
-}

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

@@ -1,195 +0,0 @@
-#!/usr/bin/env bun
-/**
- * bridge/stdio.ts — the stdio MCP server spawned by local harnesses. It exposes
- * the Domain Studio write-back tools from the generated MCP configuration and
- * forwards each call to the token-guarded HTTP bridge (api → agent/bridge/*),
- * so an agent can reply to comment threads and post progress AS IT WORKS.
- *
- * Transport: newline-delimited JSON-RPC 2.0 on stdin/stdout. Nothing but
- * protocol messages may touch stdout; diagnostics go to stderr.
- */
-import { readFileSync } from 'node:fs'
-
-import { asJsonRecord, asString, parseJson } from '../../json'
-import { forwardBridgeTool } from './client'
-
-function configFromArgv(): { base?: string; token?: string } {
-  const i = process.argv.indexOf('--config')
-  const path = i >= 0 ? process.argv[i + 1] : undefined
-  if (!path) return {}
-  try {
-    const record = asJsonRecord(parseJson(readFileSync(path, 'utf8')))
-    const base = asString(record?.base)
-    const token = asString(record?.token)
-    return {
-      ...(base === undefined ? {} : { base }),
-      ...(token === undefined ? {} : { token }),
-    }
-  } catch {
-    return {}
-  }
-}
-
-const config = configFromArgv()
-const BASE = config.base || process.env.DOMAIN_STUDIO_BRIDGE_URL || ''
-const TOKEN = config.token || process.env.DOMAIN_STUDIO_BRIDGE_TOKEN || ''
-
-const TOOLS = [
-  {
-    name: 'list_open_threads',
-    description:
-      'List the open comment threads that are awaiting your reply (id, anchor, file, latest message). Call this first to see what to address.',
-    inputSchema: { type: 'object', properties: {}, additionalProperties: false },
-    route: 'threads',
-  },
-  {
-    name: 'reply_to_thread',
-    description:
-      'Post a reply to one comment thread so the user sees it live. Say what you changed, answer a question, or ask one back. Pass `options` (a short list of concrete choices) to turn the reply into a multiple-choice question the user can pick from (or answer freely). Set resolve=true with a short closeNote ONLY when fully handled — never resolve a question you just asked.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        commentId: { type: 'string', description: 'the thread id from list_open_threads' },
-        text: {
-          type: 'string',
-          description: 'your reply (concise — a framing line when offering options)',
-        },
-        options: {
-          type: 'array',
-          items: { type: 'string' },
-          description: '2–5 short choices for the user to pick from; they may also answer freely',
-        },
-        resolve: { type: 'boolean', description: 'close the thread when done (not when asking)' },
-        closeNote: { type: 'string', description: 'one-line summary when resolving' },
-      },
-      required: ['commentId', 'text'],
-      additionalProperties: false,
-    },
-    route: 'reply',
-  },
-  {
-    name: 'resolve_thread',
-    description: 'Mark a comment thread resolved (closed) with an optional closeNote.',
-    inputSchema: {
-      type: 'object',
-      properties: { commentId: { type: 'string' }, closeNote: { type: 'string' } },
-      required: ['commentId'],
-      additionalProperties: false,
-    },
-    route: 'resolve',
-  },
-  {
-    name: 'post_progress',
-    description:
-      'Post a short progress note shown in the studio activity panel (not tied to a thread).',
-    inputSchema: {
-      type: 'object',
-      properties: { text: { type: 'string' } },
-      required: ['text'],
-      additionalProperties: false,
-    },
-    route: 'progress',
-  },
-  {
-    name: 'raise_question',
-    description:
-      'Open a NEW question thread anchored to a schema element (ref like "class.Monitor.property.url") when you need the user to decide something. Pass `options` for a multiple-choice question — the user picks one or answers freely.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        ref: {
-          type: 'string',
-          description: 'anchor ref, e.g. "class.Order" or "module.inventory/inventory"',
-        },
-        text: {
-          type: 'string',
-          description: 'the question (one framing line when offering options)',
-        },
-        file: { type: 'string' },
-        options: {
-          type: 'array',
-          items: { type: 'string' },
-          description: '2–5 short choices the user can pick from',
-        },
-      },
-      required: ['ref', 'text'],
-      additionalProperties: false,
-    },
-    route: 'raise_question',
-  },
-] as const
-
-function send(msg: unknown): void {
-  process.stdout.write(`${JSON.stringify(msg)}\n`)
-}
-function reply(id: unknown, result: unknown): void {
-  send({ jsonrpc: '2.0', id, result })
-}
-function replyError(id: unknown, code: number, message: string): void {
-  send({ jsonrpc: '2.0', id, error: { code, message } })
-}
-
-async function handle(req: any): Promise<void> {
-  const { id, method, params } = req
-  switch (method) {
-    case 'initialize':
-      reply(id, {
-        protocolVersion: params?.protocolVersion || '2025-06-18',
-        capabilities: { tools: {} },
-        serverInfo: { name: 'domain-studio', version: '0.1.0' },
-      })
-      return
-    case 'notifications/initialized':
-    case 'initialized':
-      return // notification, no response
-    case 'ping':
-      reply(id, {})
-      return
-    case 'tools/list':
-      reply(id, {
-        tools: TOOLS.map(({ name, description, inputSchema }) => ({
-          name,
-          description,
-          inputSchema,
-        })),
-      })
-      return
-    case 'tools/call': {
-      const tool = TOOLS.find((t) => t.name === params?.name)
-      if (!tool) {
-        replyError(id, -32602, `unknown tool: ${params?.name}`)
-        return
-      }
-      const result = await forwardBridgeTool(
-        BASE,
-        TOKEN,
-        tool.route,
-        (params?.arguments ?? {}) as Record<string, unknown>,
-      )
-      reply(id, result)
-      return
-    }
-    default:
-      if (id !== undefined) replyError(id, -32601, `method not found: ${method}`)
-  }
-}
-
-let buf = ''
-process.stdin.setEncoding('utf8')
-process.stdin.on('data', (chunk: string) => {
-  buf += chunk
-  let nl: number
-  while ((nl = buf.indexOf('\n')) >= 0) {
-    const line = buf.slice(0, nl).trim()
-    buf = buf.slice(nl + 1)
-    if (!line) continue
-    let req: any
-    try {
-      req = JSON.parse(line)
-    } catch {
-      continue
-    }
-    void handle(req)
-  }
-})
-process.stdin.on('end', () => process.exit(0))

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

@@ -1,89 +0,0 @@
-import { afterEach, describe, expect, test } from 'bun:test'
-import { mkdtempSync, rmSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-
-import { asJsonRecord } from '../json'
-import { readJson, writeJson } from '../state/store'
-import {
-  clearConversation,
-  readConversation,
-  saveConversation,
-  setConversationSession,
-} from './conversation'
-
-const roots: string[] = []
-const root = () => {
-  const value = mkdtempSync(join(tmpdir(), 'studio-conversation-'))
-  roots.push(value)
-  return value
-}
-
-afterEach(() => {
-  while (roots.length) rmSync(roots.pop()!, { recursive: true, force: true })
-})
-
-describe('per-harness conversations', () => {
-  test('preserves independent Claude and Codex sessions', () => {
-    const dir = root()
-    saveConversation(dir, 'claude', {
-      sessionId: 'claude-session',
-      turns: 2,
-      updatedAt: 'now',
-    })
-    saveConversation(dir, 'codex', {
-      sessionId: 'codex-thread',
-      turns: 3,
-      updatedAt: 'later',
-    })
-
-    expect(readConversation(dir, 'claude')).toMatchObject({
-      sessionId: 'claude-session',
-      turns: 2,
-    })
-    expect(readConversation(dir, 'codex')).toMatchObject({
-      sessionId: 'codex-thread',
-      turns: 3,
-    })
-    clearConversation(dir, 'codex')
-    expect(readConversation(dir, 'claude').sessionId).toBe('claude-session')
-    expect(readConversation(dir, 'codex').sessionId).toBeUndefined()
-  })
-
-  test('migrates the legacy single-session shape on first write', () => {
-    const dir = root()
-    writeJson(dir, '.cache/agent/session.json', {
-      harness: 'claude',
-      sessionId: 'legacy-session',
-      turns: 4,
-      updatedAt: 'then',
-    })
-    expect(readConversation(dir, 'claude').turns).toBe(4)
-
-    setConversationSession(dir, 'codex', 'codex-thread')
-    const stored = readJson(dir, '.cache/agent/session.json', asJsonRecord, {})
-    expect(stored).toMatchObject({
-      version: 1,
-      conversations: {
-        claude: { sessionId: 'legacy-session' },
-        codex: { sessionId: 'codex-thread' },
-      },
-    })
-  })
-
-  test('fails closed without rewriting a future conversation-store version', () => {
-    const dir = root()
-    const future = {
-      version: 2,
-      conversations: {
-        codex: { sessionId: 'future-thread', turns: 9 },
-      },
-    }
-    writeJson(dir, '.cache/agent/session.json', future)
-
-    expect(() => setConversationSession(dir, 'claude', 'new-session')).toThrow(
-      'unsupported agent conversation store version: 2',
-    )
-    expect(readJson(dir, '.cache/agent/session.json', asJsonRecord, {})).toEqual(future)
-  })
-})

package/studio/server/agent/conversation.ts

@@ -1,158 +0,0 @@
-import type { AgentSessionInfo, ConversationInfo } from '../../shared/types'
-
-import { asFiniteNumber, asJsonRecord, asString } from '../json'
-import { readJson, removeState, writeJson } from '../state/store'
-
-const SESSION_FILE = '.cache/agent/session.json'
-
-interface HarnessConversation {
-  sessionId?: string
-  turns?: number
-  updatedAt?: string
-}
-
-interface ConversationStore {
-  version: 1
-  conversations: Record<string, HarnessConversation>
-}
-
-interface LegacySessionState extends HarnessConversation {
-  harness?: string
-}
-
-type DecodedConversationWire =
-  | {
-      kind: 'versioned'
-      version: number | undefined
-      conversations: Record<string, HarnessConversation>
-    }
-  | { kind: 'legacy'; state: LegacySessionState }
-
-function decodeHarnessConversation(value: unknown): HarnessConversation | undefined {
-  const record = asJsonRecord(value)
-  if (!record) return undefined
-  const sessionId = asString(record.sessionId)
-  const turnsValue = asFiniteNumber(record.turns)
-  const turns =
-    turnsValue !== undefined && turnsValue >= 0 && Number.isInteger(turnsValue)
-      ? turnsValue
-      : undefined
-  const updatedAt = asString(record.updatedAt)
-  return {
-    ...(sessionId === undefined ? {} : { sessionId }),
-    ...(turns === undefined ? {} : { turns }),
-    ...(updatedAt === undefined ? {} : { updatedAt }),
-  }
-}
-
-function decodeConversationWire(value: unknown): DecodedConversationWire | undefined {
-  const record = asJsonRecord(value)
-  if (!record) return undefined
-  if ('conversations' in record) {
-    const conversations: Record<string, HarnessConversation> = {}
-    for (const [harness, candidate] of Object.entries(asJsonRecord(record.conversations) ?? {})) {
-      const conversation = decodeHarnessConversation(candidate)
-      if (conversation) conversations[harness] = conversation
-    }
-    return {
-      kind: 'versioned',
-      version: asFiniteNumber(record.version),
-      conversations,
-    }
-  }
-  const state = decodeHarnessConversation(record)
-  if (!state) return undefined
-  const harness = asString(record.harness)
-  return { kind: 'legacy', state: { ...state, ...(harness === undefined ? {} : { harness }) } }
-}
-
-function readStore(root: string): ConversationStore {
-  const raw = readJson(root, SESSION_FILE, decodeConversationWire, null)
-  if (!raw) return { version: 1, conversations: {} }
-  if (raw.kind === 'versioned') {
-    if (raw.version !== 1)
-      throw new Error(`unsupported agent conversation store version: ${String(raw.version)}`)
-    return { version: 1, conversations: { ...raw.conversations } }
-  }
-  const legacy = raw.state
-  if (legacy.harness && legacy.sessionId) {
-    return {
-      version: 1,
-      conversations: {
-        [legacy.harness]: {
-          sessionId: legacy.sessionId,
-          turns: legacy.turns ?? 0,
-          updatedAt: legacy.updatedAt,
-        },
-      },
-    }
-  }
-  return { version: 1, conversations: {} }
-}
-
-function writeStore(root: string, store: ConversationStore): void {
-  const entries = Object.entries(store.conversations).filter(([, c]) => !!c.sessionId)
-  if (entries.length === 0) {
-    removeState(root, SESSION_FILE)
-    return
-  }
-  writeJson(root, SESSION_FILE, {
-    version: 1,
-    conversations: Object.fromEntries(entries),
-  } satisfies ConversationStore)
-}
-
-export function readConversation(root: string, harness: string): HarnessConversation {
-  return readStore(root).conversations[harness] ?? {}
-}
-
-export function conversationInfo(root: string, harness: string): ConversationInfo {
-  const conversation = readConversation(root, harness)
-  return {
-    active: !!conversation.sessionId,
-    turns: conversation.turns ?? 0,
-    harness: conversation.sessionId ? harness : undefined,
-  }
-}
-
-export function sessionInfo(root: string, harness: string): AgentSessionInfo {
-  const conversation = readConversation(root, harness)
-  return {
-    sessionId: conversation.sessionId ?? null,
-    turns: conversation.turns ?? 0,
-    harness: conversation.sessionId ? harness : undefined,
-  }
-}
-
-export function saveConversation(
-  root: string,
-  harness: string,
-  conversation: Required<Pick<HarnessConversation, 'sessionId' | 'turns'>> &
-    Pick<HarnessConversation, 'updatedAt'>,
-): void {
-  const store = readStore(root)
-  store.conversations[harness] = conversation
-  writeStore(root, store)
-}
-
-export function setConversationSession(root: string, harness: string, sessionId: string): void {
-  const trimmed = sessionId.trim()
-  if (!trimmed) {
-    clearConversation(root, harness)
-    return
-  }
-  const store = readStore(root)
-  const previous = store.conversations[harness] ?? {}
-  store.conversations[harness] = {
-    sessionId: trimmed,
-    turns: previous.turns ?? 0,
-    updatedAt: new Date().toISOString(),
-  }
-  writeStore(root, store)
-}
-
-export function clearConversation(root: string, harness: string): void {
-  const store = readStore(root)
-  delete store.conversations[harness]
-  writeStore(root, store)
-}