@astrale-os/cli 1.0.0-beta.1 → 1.0.0-beta.2

package/studio/server/state/catalog.ts

@@ -1,117 +0,0 @@
-/**
- * catalog.ts — the domain catalog for the canvas "Import a domain" picker. It merges:
- *   - the kernel (always present + required),
- *   - the LOCAL domains detected in this workspace,
- *   - a curated set of FAKED external service domains (placeholders until a real
- *     registry exists).
- * Each entry carries a lucide-style SVG icon + a one-line description.
- */
-import type { DomainCatalogEntry } from '../../shared/types'
-
-const icon = (inner: string) =>
-  `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">${inner}</svg>`
-
-const HEXAGON = icon(
-  '<path d="M21 16V8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l7-4A2 2 0 0 0 21 16z"/><path d="m7.5 4.27 9 5.15"/><path d="m3.3 7 8.7 5 8.7-5"/><path d="M12 22V12"/>',
-)
-const BOXES = icon(
-  '<path d="M2.97 12.92A2 2 0 0 0 2 14.63v3.24a2 2 0 0 0 .97 1.71l3 1.8a2 2 0 0 0 2.06 0L12 19v-5.5l-5-3-4.03 2.42Z"/><path d="m7 16.5-4.74-2.85"/><path d="m7 16.5 5-3"/><path d="M7 16.5v5.17"/><path d="M12 13.5V19l3.97 2.38a2 2 0 0 0 2.06 0l3-1.8a2 2 0 0 0 .97-1.71v-3.24a2 2 0 0 0-.97-1.71L17 10.5l-5 3Z"/><path d="m17 16.5-5-3"/><path d="m17 16.5 4.74-2.85"/><path d="M17 16.5v5.17"/><path d="M7.97 4.42A2 2 0 0 0 7 6.13v4.37l5 3 5-3V6.13a2 2 0 0 0-.97-1.71l-3-1.8a2 2 0 0 0-2.06 0l-3 1.8Z"/><path d="M12 8 7.26 5.15"/><path d="m12 8 4.74-2.85"/><path d="M12 13.5V8"/>',
-)
-const BELL = icon(
-  '<path d="M10.268 21a2 2 0 0 0 3.464 0"/><path d="M3.262 15.326A1 1 0 0 0 4 17h16a1 1 0 0 0 .74-1.673C19.41 13.956 18 12.499 18 8A6 6 0 0 0 6 8c0 4.499-1.411 5.956-2.738 7.326"/>',
-)
-const CARD = icon(
-  '<rect width="20" height="14" x="2" y="5" rx="2"/><line x1="2" x2="22" y1="10" y2="10"/>',
-)
-const USERS = icon(
-  '<path d="M16 21v-2a4 4 0 0 0-4-4H6a4 4 0 0 0-4 4v2"/><circle cx="9" cy="7" r="4"/><path d="M22 21v-2a4 4 0 0 0-3-3.87"/><path d="M16 3.13a4 4 0 0 1 0 7.75"/>',
-)
-const CHART = icon(
-  '<line x1="12" x2="12" y1="20" y2="10"/><line x1="18" x2="18" y1="20" y2="4"/><line x1="6" x2="6" y1="20" y2="16"/>',
-)
-const SEARCH = icon('<circle cx="11" cy="11" r="8"/><path d="m21 21-4.3-4.3"/>')
-const DRIVE = icon(
-  '<line x1="22" x2="2" y1="12" y2="12"/><path d="M5.45 5.11 2 12v6a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2v-6l-3.45-6.89A2 2 0 0 0 16.76 4H7.24a2 2 0 0 0-1.79 1.11z"/><line x1="6" x2="6.01" y1="16" y2="16"/><line x1="10" x2="10.01" y1="16" y2="16"/>',
-)
-const SPARKLES = icon(
-  '<path d="M9.937 15.5A2 2 0 0 0 8.5 14.063l-6.135-1.582a.5.5 0 0 1 0-.962L8.5 9.936A2 2 0 0 0 9.937 8.5l1.582-6.135a.5.5 0 0 1 .963 0L14.063 8.5A2 2 0 0 0 15.5 9.937l6.135 1.581a.5.5 0 0 1 0 .964L15.5 14.063a2 2 0 0 0-1.437 1.437l-1.582 6.135a.5.5 0 0 1-.963 0z"/>',
-)
-
-const KERNEL: DomainCatalogEntry = {
-  origin: 'kernel.astrale.ai',
-  name: 'Kernel',
-  kind: 'kernel',
-  description: 'The typed graph every domain is built on.',
-  icon: HEXAGON,
-  required: true,
-}
-
-const EXTERNAL: DomainCatalogEntry[] = [
-  {
-    origin: 'notifications.astrale.ai',
-    name: 'Notifications',
-    kind: 'external',
-    description: 'Email, push & SMS delivery.',
-    icon: BELL,
-  },
-  {
-    origin: 'payments.astrale.ai',
-    name: 'Payments',
-    kind: 'external',
-    description: 'Charges, subscriptions & invoices.',
-    icon: CARD,
-  },
-  {
-    origin: 'identity.astrale.ai',
-    name: 'Identity',
-    kind: 'external',
-    description: 'SSO, directory sync & users.',
-    icon: USERS,
-  },
-  {
-    origin: 'analytics.astrale.ai',
-    name: 'Analytics',
-    kind: 'external',
-    description: 'Events, funnels & dashboards.',
-    icon: CHART,
-  },
-  {
-    origin: 'search.astrale.ai',
-    name: 'Search',
-    kind: 'external',
-    description: 'Full-text & vector search.',
-    icon: SEARCH,
-  },
-  {
-    origin: 'storage.astrale.ai',
-    name: 'Storage',
-    kind: 'external',
-    description: 'Files, blobs & a CDN.',
-    icon: DRIVE,
-  },
-  {
-    origin: 'ai.astrale.ai',
-    name: 'AI Gateway',
-    kind: 'external',
-    description: 'LLM routing & embeddings.',
-    icon: SPARKLES,
-  },
-]
-
-function humanize(slug: string): string {
-  return slug
-    .replace(/[-_]+/g, ' ')
-    .replace(/\b\w/g, (c) => c.toUpperCase())
-    .trim()
-}
-
-export function buildCatalog(locals: { origin: string; id: string }[]): DomainCatalogEntry[] {
-  const localEntries: DomainCatalogEntry[] = locals.map((d) => ({
-    origin: d.origin,
-    name: humanize(d.id),
-    kind: 'local',
-    description: 'A domain in this workspace.',
-    icon: BOXES,
-  }))
-  return [KERNEL, ...localEntries, ...EXTERNAL]
-}

package/studio/server/state/instance.ts

@@ -1,280 +0,0 @@
-/**
- * state/instance.ts — the deploy/install bridge to Astrale.
- *
- * The ACTIVE instance is GLOBAL (not per-domain) and the `astrale` CLI owns it —
- * we never keep our own copy: `listInstances` reads `astrale instance list`,
- * `setActiveInstance` runs `astrale instance use`. Install + drift are GROUND
- * TRUTH, queried from the target instance (`astrale introspect <origin>`) — NOT
- * a local record — so a deploy done outside the studio (CLI/terminal) is still
- * seen.
- *
- * Deploy (`pnpm prod`) = the managed astrale adapter: deploy + auto-install on
- * the configured instance; we capture the printed service URL.
- */
-import { readFileSync } from 'node:fs'
-import { join } from 'node:path'
-
-import type {
-  DeployRecord,
-  DeployResult,
-  InstanceInfo,
-  InstanceStatus,
-  InstancesState,
-} from '../../shared/types'
-import type { DomainHandle } from '../domain'
-
-import { schemaHashOf } from '../introspect/hash'
-import { readJson, writeJson } from './store'
-
-const DEPLOY_REC = 'deploy.json'
-
-function hasProdScript(root: string): boolean {
-  try {
-    const pkg = JSON.parse(readFileSync(join(root, 'package.json'), 'utf8'))
-    return typeof pkg?.scripts?.prod === 'string'
-  } catch {
-    return false
-  }
-}
-
-async function astraleJson(args: string[]): Promise<any | null> {
-  try {
-    const proc = Bun.spawn(['astrale', ...args], { stdout: 'pipe', stderr: 'ignore' })
-    const out = await new Response(proc.stdout).text()
-    await proc.exited
-    return JSON.parse(out)
-  } catch {
-    return null
-  }
-}
-
-// ── global: the CLI's instances (source of truth = `astrale instance ...`) ──
-
-/** The active instance name — from `astrale instance active` (local, reliable). */
-async function activeName(): Promise<string | null> {
-  const a = await astraleJson(['instance', 'active', '--json'])
-  return a?.name ?? null
-}
-
-/** Public wrapper — the create-domain endpoint stamps this as `--instance` on the scaffold. */
-export const activeInstanceName = activeName
-
-export async function listInstances(): Promise<InstancesState> {
-  // The plain `instance list` fetches signing keys for EVERY bookmark, so one
-  // unreachable bookmark (e.g. a stopped localhost kernel) errors out the whole
-  // command. `--bookmarked` is local-only (reliable); `--admin-only` adds the
-  // managed instances best-effort (skipped if the admin call is unavailable).
-  const local = await astraleJson(['instance', 'list', '--bookmarked', '--json'])
-  const active: string | null = local?.active ?? (await activeName())
-  const instances: InstanceInfo[] = []
-  for (const b of local?.bookmarks ?? []) {
-    instances.push({
-      name: b.name,
-      url: b.url ?? '',
-      active: !!b.active || b.name === active,
-      kind: 'bookmark',
-    })
-  }
-  const managed = await astraleJson(['instance', 'list', '--admin-only', '--json'])
-  for (const m of managed?.instances ?? []) {
-    if (!m.slug || instances.some((i) => i.name === m.slug)) continue
-    instances.push({ name: m.slug, url: m.url ?? '', active: m.slug === active, kind: 'managed' })
-  }
-  if (active && !instances.some((i) => i.name === active)) {
-    instances.unshift({ name: active, url: '', active: true, kind: 'bookmark' })
-  }
-  return { active, instances }
-}
-
-export async function setActiveInstance(
-  name: string,
-): Promise<{ ok: boolean; active: string | null; output: string }> {
-  try {
-    // --adopt-default: never block on an interactive identity prompt;
-    // --skip-jwks-check: don't do a network /meta↔JWKS check (which fails for an
-    // unreachable bookmark like a stopped localhost kernel). Switching is then a
-    // deterministic local write to instances.json.
-    const proc = Bun.spawn(
-      ['astrale', 'instance', 'use', name, '--adopt-default', '--skip-jwks-check'],
-      { stdout: 'pipe', stderr: 'pipe' },
-    )
-    const [out, err] = await Promise.all([
-      new Response(proc.stdout).text(),
-      new Response(proc.stderr).text(),
-    ])
-    const code = await proc.exited
-    const combined = `${out}\n${err}`.trim()
-    if (code !== 0) return { ok: false, active: await activeName(), output: combined.slice(-1000) }
-    return { ok: true, active: await activeName(), output: combined.slice(-1000) }
-  } catch (e: any) {
-    return { ok: false, active: null, output: String(e?.message ?? e) }
-  }
-}
-
-// ── per-domain: deploy target + GROUND-TRUTH install/drift (queried from the instance) ──
-
-export function lastDeploy(root: string): DeployRecord | null {
-  return readJson<DeployRecord | null>(root, DEPLOY_REC, null)
-}
-
-/**
- * Ask the target instance for its public installation introspection. Installed
- * ⇒ the Kernel returns the admitted Bundle, whose root is the exact schema value
- * hashed locally; `DOMAIN_NOT_INSTALLED` ⇒ not installed; anything else
- * (offline / not authed / unknown instance) ⇒ unknown (never falsely
- * "not installed").
- */
-export function installedDomainCommand(origin: string, instance: string): string[] {
-  return ['astrale', 'introspect', origin, '--bundle', '--json', '-i', instance]
-}
-
-type InstalledDomainProbe =
-  | { state: 'installed'; root: unknown }
-  | { state: 'not-installed' | 'unknown'; root: null }
-
-function jsonObject(text: string): Record<string, unknown> | null {
-  try {
-    const value = JSON.parse(text)
-    return value !== null && typeof value === 'object' && !Array.isArray(value) ? value : null
-  } catch {
-    return null
-  }
-}
-
-export function installedDomainProbeResult(
-  stdout: string,
-  stderr: string,
-  exitCode: number,
-): InstalledDomainProbe {
-  const output = jsonObject(stdout)
-  const diagnostic = jsonObject(stderr)
-  const error = output?.error ?? diagnostic?.error
-  if (
-    error === 'DOMAIN_NOT_INSTALLED' ||
-    error === 'NOT_FOUND' ||
-    /\b(?:DOMAIN_NOT_INSTALLED|NOT_FOUND)\b/.test(`${stdout}\n${stderr}`)
-  ) {
-    return { state: 'not-installed', root: null }
-  }
-
-  if (exitCode === 0) {
-    const bundle = output?.bundle
-    if (
-      bundle !== null &&
-      typeof bundle === 'object' &&
-      !Array.isArray(bundle) &&
-      Object.prototype.hasOwnProperty.call(bundle, 'root')
-    ) {
-      return { state: 'installed', root: (bundle as { root: unknown }).root }
-    }
-  }
-  return { state: 'unknown', root: null }
-}
-
-export function installedBundleRootHash(probe: InstalledDomainProbe): string | null {
-  return probe.state === 'installed' ? schemaHashOf(probe.root) : null
-}
-
-async function getInstalledDomain(
-  origin: string,
-  instance: string,
-  timeoutMs = 8000,
-): Promise<InstalledDomainProbe> {
-  try {
-    const proc = Bun.spawn(installedDomainCommand(origin, instance), {
-      stdout: 'pipe',
-      stderr: 'pipe',
-    })
-    const timer = setTimeout(() => {
-      try {
-        proc.kill()
-      } catch {
-        /* already exited */
-      }
-    }, timeoutMs)
-    try {
-      const [out, err] = await Promise.all([
-        new Response(proc.stdout).text(),
-        new Response(proc.stderr).text(),
-      ])
-      const code = await proc.exited
-      return installedDomainProbeResult(out, err, code)
-    } finally {
-      clearTimeout(timer)
-    }
-  } catch {
-    return { state: 'unknown', root: null }
-  }
-}
-
-export async function instanceStatus(
-  handle: DomainHandle,
-  deployTarget: string | null,
-  origin: string | null,
-  localHash: string | null,
-): Promise<InstanceStatus> {
-  const deployable = hasProdScript(handle.root)
-  const last = lastDeploy(handle.root)
-  let install: InstanceStatus['install'] = 'unknown'
-  let installedHash: string | null = null
-  let drift: InstanceStatus['drift'] = 'unknown'
-
-  if (origin && deployTarget) {
-    const probe = await getInstalledDomain(origin, deployTarget)
-    if (probe.state === 'installed') {
-      install = 'installed'
-      installedHash = installedBundleRootHash(probe)
-      drift =
-        installedHash && localHash
-          ? installedHash === localHash
-            ? 'in-sync'
-            : 'drifted'
-          : 'unknown'
-    } else if (probe.state === 'not-installed') {
-      install = 'not-installed'
-    }
-  }
-
-  return { deployTarget, deployable, install, drift, localHash, installedHash, lastDeploy: last }
-}
-
-const SVC_URL = /https:\/\/[\w-]+\.svc\.[\w.-]+\.astrale\.ai\b/
-
-/** Run `pnpm prod` (deploy + managed auto-install). Outward-facing — only call on an explicit request. */
-export async function runDeploy(
-  handle: DomainHandle,
-  localHash: string | null,
-): Promise<DeployResult> {
-  if (!hasProdScript(handle.root)) {
-    return {
-      ok: false,
-      url: null,
-      output:
-        'This domain has no "prod" script in package.json — it is not deployable via `pnpm prod`.',
-    }
-  }
-  let out = ''
-  let err = ''
-  let code = 1
-  try {
-    const proc = Bun.spawn(['pnpm', 'prod'], { cwd: handle.root, stdout: 'pipe', stderr: 'pipe' })
-    ;[out, err] = await Promise.all([
-      new Response(proc.stdout).text(),
-      new Response(proc.stderr).text(),
-    ])
-    code = await proc.exited
-  } catch (e: any) {
-    return { ok: false, url: null, output: `failed to start pnpm: ${e?.message ?? e}` }
-  }
-  const combined = `${out}\n${err}`.trim()
-  const url = combined.match(SVC_URL)?.[0] ?? null
-  const ok = code === 0
-  if (ok)
-    writeJson(handle.root, DEPLOY_REC, {
-      at: new Date().toISOString(),
-      schemaHash: localHash ?? '',
-      ok: true,
-      url: url ?? undefined,
-    } satisfies DeployRecord)
-  return { ok, url, output: combined.slice(-6000) }
-}

package/studio/server/state/updates.ts

@@ -1,63 +0,0 @@
-/**
- * state/updates.ts — the "is anything stale?" 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
- * `astrale` on PATH, bad output) collapses to "nothing stale" so the badge stays
- * hidden rather than nagging on a hiccup.
- */
-import type { StaleReport } from '../../shared/types'
-
-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> {
-  try {
-    const proc = Bun.spawn(['astrale', 'update', '--check', '--json'], {
-      cwd: root,
-      stdout: 'pipe',
-      stderr: 'ignore',
-    })
-    const out = await new Response(proc.stdout).text()
-    await proc.exited // exit 10 = "stale" (expected); we already have stdout
-    const parsed = JSON.parse(out) as StaleReport
-    return typeof parsed?.stale === 'boolean' ? parsed : NOT_STALE
-  } catch {
-    return NOT_STALE
-  }
-}
-
-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> {
-  try {
-    const proc = Bun.spawn(['astrale', 'update', '--yes'], {
-      cwd: root,
-      stdout: 'pipe',
-      stderr: 'pipe',
-    })
-    const [out, err] = await Promise.all([
-      new Response(proc.stdout).text(),
-      new Response(proc.stderr).text(),
-    ])
-    const code = await proc.exited
-    return { ok: code === 0, output: (out + err).trim() }
-  } catch (e) {
-    return { ok: false, output: String(e) }
-  }
-}