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

package/studio/server/workspace/create.ts

@@ -1,162 +0,0 @@
-/**
- * Scaffold a brand-new domain into the workspace and bring it
- * online. This is the studio's ONE write that ADDS a domain (every other state
- * module operates on an existing one).
- *
- * Flow: validate the slug → `create-astrale-domain <slug> --yes` in the
- * workspace root (the managed `astrale` adapter is its default; we stamp the
- * active instance so prod targets it) → `pnpm install` in the new dir so the
- * domain is fully introspectable + deployable → register + (re)boot it (the live
- * watcher may have already booted a deps-less static fallback while we were
- * installing; we stop that and boot fresh) → warm its bundle. The caller
- * broadcasts the `workspace` event so every client refetches the domain list.
- */
-import { existsSync, readFileSync, writeFileSync } from 'node:fs'
-import { join } from 'node:path'
-
-import { getBundle } from '../cache'
-import { isDomainDir, registerDomain } from '../domain'
-import { findSchemaDefinition } from '../introspect/anatomy-extras'
-import { bootDomain } from '../lifecycle'
-import { stoppers, workspaceRoot, workspaceSchemaDirName } from '../workspace-state'
-
-/** Mirrors create-astrale-domain's `isValidSlug`: lowercase letters, digits, dots, dashes;
- *  must start/end alphanumeric. Also guards the filesystem target (no `/`, no `..`, no leading dot). */
-const SLUG = /^[a-z0-9](?:[a-z0-9.-]*[a-z0-9])?$/
-
-export interface CreateDomainResult {
-  ok: boolean
-  id?: string
-  origin?: string
-  error?: string
-  output: string
-}
-
-async function run(
-  cmd: string,
-  args: string[],
-  cwd: string,
-): Promise<{ code: number; output: string }> {
-  try {
-    const proc = Bun.spawn([cmd, ...args], {
-      cwd,
-      stdout: 'pipe',
-      stderr: 'pipe',
-      env: process.env,
-    })
-    const [out, err] = await Promise.all([
-      new Response(proc.stdout).text(),
-      new Response(proc.stderr).text(),
-    ])
-    const code = await proc.exited
-    return { code, output: `${out}\n${err}`.trim() }
-  } catch (e) {
-    return { code: 1, output: `failed to spawn ${cmd}: ${(e as Error)?.message ?? e}` }
-  }
-}
-
-export async function createDomain(
-  rawName: string,
-  instance: string | null,
-): Promise<CreateDomainResult> {
-  const name = rawName.trim().toLowerCase()
-  if (!name || name.length > 64 || !SLUG.test(name)) {
-    return {
-      ok: false,
-      error: 'Use lowercase letters, digits, dots and dashes (e.g. “crm” or “crm.acme.dev”).',
-      output: '',
-    }
-  }
-  const root = workspaceRoot()
-  if (!root) return { ok: false, error: 'No workspace root is configured.', output: '' }
-  const dir = join(root, name)
-  if (existsSync(dir)) {
-    return {
-      ok: false,
-      error: `A folder named “${name}” already exists in the workspace.`,
-      output: '',
-    }
-  }
-
-  // 1. Scaffold (non-interactive). `--yes` accepts defaults (astrale adapter, template);
-  //    `--instance` stamps the active instance into the managed prod target.
-  const scaffoldArgs = [
-    '--yes',
-    'create-astrale-domain@latest',
-    name,
-    '--yes',
-    ...(instance ? ['--instance', instance] : []),
-  ]
-  const scaffold = await run('npx', scaffoldArgs, root)
-  const schemaDirName = workspaceSchemaDirName()
-  if (!isDomainDir(dir, schemaDirName)) {
-    return {
-      ok: false,
-      error: 'Scaffolding did not produce a domain. See the log.',
-      output: scaffold.output.slice(-6000),
-    }
-  }
-
-  // 1b. Flag the placeholder origin for the agent (we ask for the name only, so the
-  //     origin is `<name>.example.dev` until someone — or the agent — sets the real one).
-  annotateOrigin(dir, schemaDirName)
-
-  // 2. Install deps so the domain is fully introspectable + deployable. Best-effort:
-  //    a scaffolded-but-uninstalled domain still loads (static fallback), so a failed
-  //    install is a soft warning, not a hard failure.
-  const install = await run('pnpm', ['install'], dir)
-
-  // 3. Register + boot with deps present. The live watcher may have already booted a
-  //    deps-less fallback for this dir mid-install — stop it and boot fresh.
-  const handle = registerDomain(dir, schemaDirName)
-  if (!handle) {
-    return {
-      ok: false,
-      error: 'Scaffold incomplete — config, composition entry, or schema index is missing.',
-      output: combine(scaffold, install),
-    }
-  }
-  stoppers.get(handle.id)?.()
-  const { origin } = await bootDomain(handle).then((b) => {
-    stoppers.set(handle.id, b.stop)
-    return b
-  })
-  await getBundle(handle.id, true) // refresh the cache now that deps are installed
-
-  return { ok: true, id: handle.id, origin, output: combine(scaffold, install) }
-}
-
-function combine(a: { output: string }, b: { output: string }): string {
-  return `$ create-astrale-domain\n${a.output}\n\n$ pnpm install\n${b.output}`.trim().slice(-6000)
-}
-
-/**
- * Drop an agent-actionable marker on the origin line of the scaffolded schema.
- * The public schema/index.ts is now commonly a barrel, so the definition is
- * located statically below it. We only ask for the NAME, so the origin starts as the
- * `<name>.example.dev` placeholder — this comment tells a human (or the studio's
- * agent) it's a placeholder to change, and that the studio re-parses the literal
- * as the source of truth so the rename takes effect on save. Best-effort: the
- * template already explains the origin, so a parse miss is harmless.
- */
-export function annotateOrigin(dir: string, schemaDirName = 'schema'): void {
-  const definition = findSchemaDefinition(dir, schemaDirName)
-  if (!definition) return
-  const file = definition.file
-  try {
-    const src = readFileSync(file, 'utf8')
-    if (src.includes('ORIGIN —')) return // already annotated (idempotent)
-    const lines = src.split('\n')
-    const index = Math.max(0, definition.line - 1)
-    const pad = lines[index]?.match(/^[ \t]*/)?.[0] ?? ''
-    const note =
-      `${pad}// ORIGIN — the domain's permanent identity in the graph. It was set from the name as a\n` +
-      `${pad}// PLACEHOLDER; change the literal or constant used here (e.g. to "crm.acme.dev"), ideally BEFORE\n` +
-      `${pad}// the first deploy (the origin is hard to change once installed). The studio parses this\n` +
-      `${pad}// schema statically as the source of truth, so the rename refreshes on save.\n`
-    lines.splice(index, 0, note.trimEnd())
-    writeFileSync(file, lines.join('\n'))
-  } catch {
-    /* best-effort */
-  }
-}

package/studio/server/workspace/git.ts

@@ -1,75 +0,0 @@
-/**
- * Best-effort workspace Git enrichment for change tracking. The fixtures are not
- * git repos, so EVERY function here degrades gracefully and NEVER throws. The
- * baseline (baseline.ts) is the primary tracker; git only enriches when present.
- */
-import { execFileSync } from 'node:child_process'
-import { existsSync } from 'node:fs'
-import { dirname, relative, resolve } from 'node:path'
-
-import type { FileChange } from '../../shared/types'
-
-/** Walk parent dirs looking for a `.git` entry (dir or file, to support worktrees/submodules). */
-export function detectGit(root: string): { hasGit: boolean; gitRoot?: string } {
-  let dir = resolve(root)
-  while (true) {
-    if (existsSync(resolve(dir, '.git'))) return { hasGit: true, gitRoot: dir }
-    const parent = dirname(dir)
-    if (parent === dir) return { hasGit: false }
-    dir = parent
-  }
-}
-
-function git(gitRoot: string, args: string[]): string | null {
-  try {
-    return execFileSync('git', ['-C', gitRoot, ...args], {
-      encoding: 'utf8',
-      stdio: ['ignore', 'pipe', 'ignore'],
-      maxBuffer: 64 * 1024 * 1024,
-    })
-  } catch {
-    return null
-  }
-}
-
-/** `git diff` scoped to the schema dir. Returns stdout (possibly '') or null when there is no git. */
-export function gitDiff(root: string, schemaDirName: string): string | null {
-  const { hasGit, gitRoot } = detectGit(root)
-  if (!hasGit || !gitRoot) return null
-  // Path to the schema dir relative to the git root (forward-slashed for git).
-  const rel = relative(gitRoot, resolve(root, schemaDirName)).split('\\').join('/')
-  const out = git(gitRoot, ['diff', '--', rel || '.'])
-  return out
-}
-
-/** XY porcelain code → our FileChange status. Returns null for codes we don't surface. */
-function mapStatus(xy: string): FileChange['status'] | null {
-  const x = xy[0] ?? ' '
-  const y = xy[1] ?? ' '
-  if (x === '?' || y === '?') return 'added' // untracked
-  if (x === 'A' || y === 'A') return 'added'
-  if (x === 'D' || y === 'D') return 'removed'
-  if (x === 'R' || y === 'R') return 'modified' // rename → surface destination as modified
-  if (x === 'M' || y === 'M' || x === 'C' || y === 'C' || x === 'U' || y === 'U') return 'modified'
-  return null
-}
-
-/** Parse `git status --porcelain` into FileChange[]. Empty array when there is no git. */
-export function gitStatus(root: string): FileChange[] {
-  const { hasGit, gitRoot } = detectGit(root)
-  if (!hasGit || !gitRoot) return []
-  const out = git(gitRoot, ['status', '--porcelain'])
-  if (out == null) return []
-  const changes: FileChange[] = []
-  for (const line of out.split('\n')) {
-    if (!line.trim()) continue
-    const xy = line.slice(0, 2)
-    let path = line.slice(3)
-    // Renames/copies render as "old -> new"; keep the destination path.
-    const arrow = path.indexOf(' -> ')
-    if (arrow !== -1) path = path.slice(arrow + 4)
-    const status = mapStatus(xy)
-    if (status) changes.push({ file: path, status })
-  }
-  return changes
-}

package/studio/server/workspace/updates.ts

@@ -1,83 +0,0 @@
-/**
- * Workspace update bridge for the header Update badge.
- *
- * We don't reimplement staleness: the `astrale` CLI owns it. `astrale update
- * --check --json`, run in the DOMAIN ROOT (so its @astrale-os/* SDK-dep axis sees
- * THIS project), emits a unified `{ stale, cli, sdk }` report. We run it with
- * stdout piped and read it regardless of exit code — a stale result exits 10 by
- * design, which is not an error here. Best-effort: anything unexpected (no
- * bad output) collapses to "nothing stale" so the badge stays
- * hidden rather than nagging on a hiccup.
- */
-import type { StaleReport } from '../../shared/types'
-
-import { decodeJsonObject, runStudioCliJson, runStudioCliText } from '../cli'
-
-const NOT_STALE: StaleReport = {
-  stale: false,
-  cli: { stale: false, managed: true },
-  sdk: { stale: false, inProject: false, outdated: [] },
-}
-
-export async function getUpdates(root: string): Promise<StaleReport> {
-  const result = await runStudioCliJson(['update', '--check', '--json'], decodeStaleReport, {
-    cwd: root,
-    acceptedExitCodes: [0, 10],
-  })
-  return result.ok && result.data ? result.data : NOT_STALE
-}
-
-function decodeStaleReport(value: unknown): StaleReport | null {
-  const report = decodeJsonObject(value)
-  const cli = decodeJsonObject(report?.cli)
-  const sdk = decodeJsonObject(report?.sdk)
-  if (
-    typeof report?.stale !== 'boolean' ||
-    typeof cli?.stale !== 'boolean' ||
-    typeof cli.managed !== 'boolean' ||
-    typeof sdk?.stale !== 'boolean' ||
-    typeof sdk.inProject !== 'boolean' ||
-    !Array.isArray(sdk.outdated)
-  ) {
-    return null
-  }
-  const outdated = sdk.outdated.flatMap((value) => {
-    const item = decodeJsonObject(value)
-    return typeof item?.pkg === 'string' &&
-      typeof item.current === 'string' &&
-      typeof item.latest === 'string'
-      ? [{ pkg: item.pkg, current: item.current, latest: item.latest }]
-      : []
-  })
-  if (outdated.length !== sdk.outdated.length) return null
-  return {
-    stale: report.stale,
-    cli: {
-      stale: cli.stale,
-      managed: cli.managed,
-      ...(typeof cli.current === 'string' ? { current: cli.current } : {}),
-      ...(typeof cli.latest === 'string' ? { latest: cli.latest } : {}),
-      ...(typeof cli.channel === 'string' ? { channel: cli.channel } : {}),
-    },
-    sdk: { stale: sdk.stale, inProject: sdk.inProject, outdated },
-  }
-}
-
-export interface UpdateApplyResult {
-  ok: boolean
-  output: string
-}
-
-/**
- * Apply the update for the header "Update now" button — `astrale update --yes`,
- * run in the domain root. The CLI does the work non-interactively and resiliently
- * (binary + skills + SDK deps; a binary that can't self-update warns but doesn't
- * block the others), so we just spawn it and capture the combined output to show.
- */
-export async function applyUpdates(root: string): Promise<UpdateApplyResult> {
-  const result = await runStudioCliText(['update', '--yes'], { cwd: root })
-  return {
-    ok: result.ok,
-    output: `${result.stdout}${result.stderr}`.trim() || result.detail,
-  }
-}

package/studio/server/workspace-state.ts

@@ -1,26 +0,0 @@
-/**
- * workspace-state.ts — process-global workspace context shared by the entrypoint
- * (index.ts), the live watcher (workspace-watch.ts), and the create-domain
- * endpoint (workspace/create.ts): the scanned ROOT (where new domains are
- * scaffolded), the schema-dir name, and the `domainId → file-watcher stop` map.
- *
- * It exists so the create endpoint can scaffold into the same root the studio
- * watches — and re-boot the freshly-created domain — without index.ts having to
- * thread those values through the API signature.
- */
-
-const state = { root: '', schemaDirName: 'schema' }
-
-/** domainId → stop its file watcher. The startup scan + the live watcher + the
- *  create endpoint all share this one map so "what domains are live" stays single-sourced. */
-export const stoppers = new Map<string, () => void>()
-
-/** Called once at boot with the resolved workspace root + schema-dir name. */
-export function initWorkspaceState(root: string, schemaDirName: string): void {
-  state.root = root
-  state.schemaDirName = schemaDirName
-}
-
-/** The directory the studio scans for domains — where `create new` scaffolds a sibling. */
-export const workspaceRoot = (): string => state.root
-export const workspaceSchemaDirName = (): string => state.schemaDirName

package/studio/server/workspace-watch.ts

@@ -1,106 +0,0 @@
-/**
- * workspace-watch.ts — keeps the domain registry in sync with the workspace while
- * the studio is running. A domain dropped in (or one whose astrale.config.ts +
- * composition entry + schema/index.ts triple just completed) is registered, booted, and
- * announced over SSE; one whose triple vanished is unregistered. It reuses
- * `scanWorkspace` (detection) + `bootDomain` (lifecycle), so there is no second
- * source of truth for "what is a domain" or "how a domain comes online".
- */
-import chokidar from 'chokidar'
-import { basename } from 'node:path'
-
-import { scanWorkspace } from './detect'
-import { allDomains, isDomainDir, unregisterDomain } from './domain'
-import { bootDomain } from './lifecycle'
-import { broadcast } from './sse'
-
-const IGNORED =
-  /(^|[/\\])(node_modules|\.git|\.astrale|\.domain-studio|dist|\.dist|\.next|\.cache|\.turbo|\.vercel|coverage)([/\\]|$)/
-// only these file changes can change the domain SET (vs. ordinary in-domain edits)
-export const DOMAIN_SET_TRIGGER_FILES = new Set([
-  'astrale.config.ts',
-  'application.ts',
-  'schema.ts',
-  'index.ts',
-])
-
-/**
- * Watch `root` for domains appearing/disappearing.
- * @param stoppers shared `domainId → file-watcher stop` map. The startup scan seeds
- *   it (via bootDomain); this watcher keeps it in sync as domains come and go.
- */
-export function watchWorkspace(
-  root: string,
-  schemaDirName: string,
-  stoppers: Map<string, () => void>,
-): () => void {
-  let timer: ReturnType<typeof setTimeout> | undefined
-  let running = false
-  let queued = false
-
-  const reconcile = async () => {
-    const before = new Set(allDomains().map((d) => d.id))
-
-    // 1. drop domains whose triple vanished (dir deleted, or a trigger file removed)
-    for (const h of allDomains()) {
-      if (isDomainDir(h.root, h.schemaDirName)) continue
-      stoppers.get(h.id)?.()
-      stoppers.delete(h.id)
-      unregisterDomain(h.id)
-      console.log(`  Domain Studio — domain removed: ${h.id}`)
-    }
-
-    // 2. register + boot any new ones (scanWorkspace registers; bootDomain initializes + watches)
-    for (const h of scanWorkspace(root, schemaDirName)) {
-      if (stoppers.has(h.id)) continue
-      const { origin, stop } = await bootDomain(h)
-      stoppers.set(h.id, stop)
-      console.log(`  Domain Studio — domain added: ${origin} (${h.id})`)
-    }
-
-    // 3. announce if the set changed → clients refetch /api/workspace
-    const after = new Set(allDomains().map((d) => d.id))
-    if (before.size !== after.size || [...after].some((id) => !before.has(id))) {
-      broadcast({ type: 'workspace', domains: [...after] })
-    }
-  }
-
-  // serialize reconciles — bootDomain is async; coalesce event bursts
-  const run = async () => {
-    if (running) {
-      queued = true
-      return
-    }
-    running = true
-    try {
-      await reconcile()
-    } catch (e) {
-      console.error('  Domain Studio — workspace reconcile failed:', e)
-    } finally {
-      running = false
-      if (queued) {
-        queued = false
-        void run()
-      }
-    }
-  }
-  const schedule = () => {
-    clearTimeout(timer)
-    timer = setTimeout(() => void run(), 400)
-  }
-  const onFile = (p: string) => {
-    if (DOMAIN_SET_TRIGGER_FILES.has(basename(p))) schedule()
-  }
-
-  const watcher = chokidar.watch(root, {
-    ignoreInitial: true,
-    depth: 4,
-    ignored: (p: string) => IGNORED.test(p),
-  })
-  watcher.on('addDir', schedule).on('unlinkDir', schedule).on('add', onFile).on('unlink', onFile)
-
-  return () => {
-    clearTimeout(timer)
-    void watcher.close()
-  }
-}

package/studio/shared/agent-effort.test.ts

@@ -1,12 +0,0 @@
-import { expect, test } from 'bun:test'
-
-import { effectiveAgentEffort } from './agent-effort'
-
-test('normalizes persisted effort when switching harness vocabularies', () => {
-  expect(effectiveAgentEffort(['low', 'medium', 'high', 'xhigh'], 'max')).toBe('xhigh')
-  expect(effectiveAgentEffort(['low', 'medium', 'high', 'xhigh'], 'ultracode')).toBe('xhigh')
-  expect(effectiveAgentEffort(['low', 'medium', 'high'], 'minimal')).toBe('low')
-  expect(effectiveAgentEffort(['medium', 'high'], 'xhigh')).toBe('high')
-  expect(effectiveAgentEffort(['medium'], 'low')).toBe('medium')
-  expect(effectiveAgentEffort(['low'], undefined)).toBeUndefined()
-})

package/studio/shared/agent-effort.ts

@@ -1,15 +0,0 @@
-import type { AgentEffort } from './types'
-
-/** Map a persisted cross-harness effort onto the selected harness's vocabulary. */
-export function effectiveAgentEffort(
-  levels: readonly AgentEffort[],
-  requested?: string,
-): AgentEffort | undefined {
-  if (!requested) return undefined
-  if (levels.includes(requested as AgentEffort)) return requested as AgentEffort
-  if (requested === 'max' && levels.includes('xhigh')) return 'xhigh'
-  if (requested === 'ultracode' && levels.includes('xhigh')) return 'xhigh'
-  if (requested === 'minimal' && levels.includes('low')) return 'low'
-  if (levels.includes('high')) return 'high'
-  return levels[0]
-}

package/studio/shared/agent-models.test.ts

@@ -1,9 +0,0 @@
-import { expect, test } from 'bun:test'
-
-import { updateAgentModel } from './agent-models'
-
-test('switching model overrides preserves independent harness selections', () => {
-  const selected = updateAgentModel({ claude: 'opus' }, 'Codex', ' gpt-5.4-mini ')
-  expect(selected).toEqual({ claude: 'opus', codex: 'gpt-5.4-mini' })
-  expect(updateAgentModel(selected, 'claude', '')).toEqual({ codex: 'gpt-5.4-mini' })
-})

package/studio/shared/agent-models.ts

@@ -1,14 +0,0 @@
-/** Update one harness-specific model override without disturbing sibling harnesses. */
-export function updateAgentModel(
-  current: Record<string, string>,
-  harness: string,
-  model: string,
-): Record<string, string> {
-  const key = harness.trim().toLowerCase()
-  if (!key) return current
-  const next = { ...current }
-  const normalized = model.trim()
-  if (normalized) next[key] = normalized
-  else delete next[key]
-  return next
-}

package/studio/shared/contracts/README.md

@@ -1,16 +0,0 @@
-# Studio shared contract boundaries
-
-`../types.ts` is the compatibility facade used by existing server and client
-imports. Definitions live under one semantic owner:
-
-- `schema.ts` owns the render IR and all schema/anatomy introspection results.
-- `workspace.ts` owns persisted and workspace-facing state, including the sole
-  `LayoutState` and `VisibilityState` definitions.
-- `agent.ts` owns the harness-neutral agent protocol and harness configuration.
-- `runtime.ts` owns Studio runtime configuration, SSE events, and CLI staleness.
-- `../schema/identity.ts` owns pure canonical reference/key identity helpers.
-
-Allowed dependency direction is identity → schema → workspace → agent → runtime.
-Shared contracts never import server or client implementations. New consumers
-may import an owning module directly; `@shared/types` remains supported for
-compatibility.