@astrale-os/cli 1.0.0-beta.32 → 1.0.0-beta.43

package/src/setup/engine.ts

@@ -1,83 +0,0 @@
-import chalk from 'chalk'
-
-import type { SetupContext, SetupOpts } from './types'
-
-import { readLocalStatus } from '../lib/local-status'
-import { isMachine } from '../lib/output'
-import { promptMultiSelect } from '../lib/prompt'
-import { type Detected, phaseHeader, renderFinale, renderIntro, renderPlan } from './render'
-import { ALL_STEPS, CONNECT_STEPS, EQUIP_STEPS } from './steps'
-
-export type { SetupOpts } from './types'
-
-/**
- * Run the setup reconciler. Two modes, one set of steps:
- *  - interactive (TTY): hand-hold each Connect step, then offer the unsatisfied
- *    Equip steps as a pre-checked multi-select.
- *  - --plan / non-interactive: detect everything and report (machine JSON or a
- *    human checklist), mutating nothing. This is the agent-facing contract.
- */
-export async function runSetup(opts: SetupOpts, slug?: string): Promise<void> {
-  const machine = isMachine(opts)
-  const interactive = !!process.stdin.isTTY && !(opts.ci || opts.noPrompt || process.env.CI)
-  const ctx: SetupContext = { interactive, machine, opts, slug }
-
-  if (opts.plan || !interactive) {
-    renderPlan(await detectAll(ctx), ctx)
-    return
-  }
-
-  renderIntro()
-
-  // Connect: required prerequisites, walked in order. Each ensure() re-detects
-  // and is a no-op (a ✔ line) when already satisfied, so this resumes cleanly.
-  phaseHeader(1, 'Connect to Astrale')
-  for (const step of CONNECT_STEPS) {
-    await step.ensure(ctx)
-  }
-
-  // Equip: optional. Offer only the unsatisfied ones, pre-checked.
-  const equipGaps: Detected[] = []
-  for (const step of EQUIP_STEPS) {
-    const detection = await step.detect(ctx)
-    if (detection.state !== 'satisfied') equipGaps.push({ step, detection })
-  }
-  if (equipGaps.length > 0) {
-    phaseHeader(2, 'Equip your workspace & agents')
-    const chosen =
-      (await promptMultiSelect(
-        'Select what to set up — space toggles, enter confirms:',
-        equipGaps.map(({ step, detection }) => ({
-          name: `${step.title} ${chalk.dim(`— ${detection.summary}`)}`,
-          value: step.id,
-          checked: true,
-        })),
-      )) ?? []
-    for (const { step } of equipGaps) {
-      if (chosen.includes(step.id)) await step.ensure(ctx)
-    }
-  }
-
-  await renderFinale()
-}
-
-async function detectAll(ctx: SetupContext): Promise<Detected[]> {
-  const detected: Detected[] = []
-  for (const step of ALL_STEPS) {
-    detected.push({ step, detection: await step.detect(ctx) })
-  }
-  return detected
-}
-
-/**
- * Should a bare `astrale` (no args, interactive terminal) launch setup instead
- * of printing help? Yes only when the user has no active instance — i.e. not
- * yet set up. A configured user gets help.
- */
-export async function shouldAutostartSetup(): Promise<boolean> {
-  try {
-    return (await readLocalStatus()).instance === null
-  } catch {
-    return false
-  }
-}

package/src/setup/render.ts

@@ -1,107 +0,0 @@
-import chalk from 'chalk'
-
-import type { SetupContext, SetupStep, StepDetection, StepState } from './types'
-
-import { readLocalStatus } from '../lib/local-status'
-import { output } from '../lib/output'
-import { panel } from '../lib/panel'
-import { guiOrigin } from './util'
-
-export type Detected = { step: SetupStep; detection: StepDetection }
-
-const MARK: Record<StepState, () => string> = {
-  satisfied: () => chalk.green('✔'),
-  gap: () => chalk.yellow('○'),
-  broken: () => chalk.red('✖'),
-}
-
-export function renderIntro(): void {
-  console.log('')
-  console.log(`${chalk.bold.cyan('astrale setup')} ${chalk.dim('· get connected and equipped')}`)
-}
-
-export function phaseHeader(n: number, title: string): void {
-  console.log('')
-  console.log(chalk.bold(`${n} · ${title}`))
-}
-
-/**
- * The read-only report for `--plan` and non-interactive runs: machine-readable
- * JSON (the agent's contract — each gap carries the command to fix it) or a
- * human checklist mirroring `astrale status`.
- */
-export function renderPlan(detected: Detected[], ctx: SetupContext): void {
-  const connected = detected
-    .filter((d) => d.step.group === 'connect')
-    .every((d) => d.detection.state === 'satisfied')
-
-  if (ctx.machine) {
-    output(
-      {
-        connected,
-        steps: detected.map(({ step, detection }) => ({
-          id: step.id,
-          title: step.title,
-          group: step.group,
-          state: detection.state,
-          summary: detection.summary,
-          ...(detection.fixHint ? { fix: detection.fixHint } : {}),
-        })),
-      },
-      ctx.opts,
-    )
-    return
-  }
-
-  console.log('')
-  console.log(chalk.bold('Astrale setup — status'))
-  for (const group of ['connect', 'equip'] as const) {
-    const rows = detected.filter((d) => d.step.group === group)
-    if (rows.length === 0) continue
-    console.log('')
-    console.log(chalk.bold(group === 'connect' ? 'Connect' : 'Equip'))
-    for (const { detection } of rows) {
-      const hint =
-        detection.state === 'satisfied' || !detection.fixHint
-          ? ''
-          : `  ${chalk.dim(`→ ${detection.fixHint}`)}`
-      console.log(`  ${MARK[detection.state]()} ${detection.summary}${hint}`)
-    }
-  }
-  console.log('')
-  console.log(
-    chalk.dim(
-      connected
-        ? 'Connected. Run `astrale setup` to equip your workspace.'
-        : 'Run `astrale setup` in a terminal to fix these interactively.',
-    ),
-  )
-}
-
-/** Closing recap: the active-instance hero (again) plus the obvious next moves. */
-export async function renderFinale(): Promise<void> {
-  const { instance } = await readLocalStatus()
-  console.log('')
-  if (instance) {
-    console.log(
-      panel(
-        [
-          `${chalk.green('✔')}  ${chalk.bold("You're all set")}`,
-          '',
-          `   ${chalk.cyan('Instance')}  ${chalk.bold(guiOrigin(instance.url))}`,
-        ],
-        { borderColor: chalk.green },
-      ),
-    )
-  } else {
-    console.log(
-      chalk.yellow('⚠'),
-      'Setup finished without an active instance — run `astrale setup` again when ready.',
-    )
-  }
-  console.log('')
-  console.log(chalk.bold('Next'))
-  console.log(`  ${chalk.cyan('astrale get @self --json')}  ${chalk.dim('— smoke test')}`)
-  console.log(`  ${chalk.cyan('astrale browser')}  ${chalk.dim('— drive the GUI as your agent')}`)
-  console.log(`  ${chalk.cyan('astrale --help')}  ${chalk.dim('— everything else')}`)
-}

package/src/setup/steps/admin.ts

@@ -1,93 +0,0 @@
-import type { SetupContext, SetupStep } from '../types'
-
-import {
-  AdminTargetConfigSchema,
-  DEFAULT_ADMIN_DOMAIN_ISSUER,
-  DEFAULT_ADMIN_TARGET_NAME,
-} from '../../lib/admin-target'
-import { readConfig, writeConfig } from '../../lib/config'
-import { readLocalStatus } from '../../lib/local-status'
-import { log } from '../../lib/log'
-import { promptText } from '../../lib/prompt'
-import { urlError } from '../util'
-
-const FIX = 'astrale admin use --url <admin-url>'
-
-async function setAdminUrl(url: string): Promise<void> {
-  const config = await readConfig()
-  await writeConfig({
-    ...config,
-    admin: AdminTargetConfigSchema.parse({
-      name: DEFAULT_ADMIN_TARGET_NAME,
-      url,
-      kernelIssuer: url,
-      domainIssuer: config.admin.domainIssuer ?? DEFAULT_ADMIN_DOMAIN_ISSUER,
-    }),
-  })
-}
-
-async function setAdminBookmark(bookmark: string): Promise<void> {
-  const config = await readConfig()
-  await writeConfig({
-    ...config,
-    admin: AdminTargetConfigSchema.parse({
-      instance: bookmark,
-      domainIssuer: config.admin.domainIssuer ?? DEFAULT_ADMIN_DOMAIN_ISSUER,
-    }),
-  })
-}
-
-/**
- * Step 2 — the admin control plane. There's always a default (admin.eu), so the
- * checklist shows it as satisfied and setup just confirms it with a ✔ line — no
- * prompt, since the default is right for nearly everyone and asking only confused
- * first-run users. Explicit --admin-url / --admin flags still persist immediately,
- * and power users repoint later with `astrale admin use <bookmark>|--url <url>`.
- * The only prompt left is the recovery path when the configured target is broken.
- */
-export const adminStep: SetupStep = {
-  id: 'admin',
-  title: 'Admin control plane',
-  group: 'connect',
-
-  async detect() {
-    const { admin } = await readLocalStatus()
-    if ('error' in admin) {
-      return { state: 'broken', summary: `Admin target invalid: ${admin.error}`, fixHint: FIX }
-    }
-    return {
-      state: 'satisfied',
-      summary: `${admin.name} (${admin.url})`,
-      detail: `source: ${admin.source}`,
-    }
-  },
-
-  async ensure(ctx: SetupContext) {
-    // Explicit overrides win and persist, no prompt.
-    if (ctx.opts.adminUrl) {
-      await setAdminUrl(ctx.opts.adminUrl)
-      log.success(`Admin control plane set: ${ctx.opts.adminUrl}`)
-      return 'fixed'
-    }
-    if (ctx.opts.admin) {
-      await setAdminBookmark(ctx.opts.admin)
-      log.success(`Admin control plane set: bookmark "${ctx.opts.admin}"`)
-      return 'fixed'
-    }
-
-    const { admin } = await readLocalStatus()
-    if ('error' in admin) {
-      log.warn(`Admin target invalid: ${admin.error}`)
-      const url = await promptText('Admin kernel URL', { validate: urlError })
-      if (!url) return 'skipped'
-      await setAdminUrl(url)
-      log.success(`Admin control plane set: ${url}`)
-      return 'fixed'
-    }
-
-    // Configured or baked default: accept it silently — no prompt. Power users
-    // repoint with `astrale admin use` (or the --admin-url / --admin flags above).
-    log.success(`Admin control plane: ${admin.name} (${admin.url})`)
-    return 'unchanged'
-  },
-}

package/src/setup/steps/agent-browser.ts

@@ -1,81 +0,0 @@
-import type { SetupStep } from '../types'
-
-import { AGENT_BROWSER_REPO } from '../../lib/browser'
-import { log } from '../../lib/log'
-import { runInherit } from '../../lib/proc'
-import { confirmDefaultYes } from '../../lib/prompt'
-import { AGENT_BROWSER_SKILL, detectAgentBrowser, detectSkill } from '../../lib/skills'
-
-const FIX = 'npm install -g agent-browser && agent-browser install'
-const SKILL_FIX = `npx skills add ${AGENT_BROWSER_REPO} -g`
-
-/**
- * Equip — agent-browser, the tool `astrale browser` drives. Two halves: the
- * third-party binary (a global npm install + one-time engine download, so opt-in
- * and confirmed) and its agent skill (so the harness knows the commands). We
- * track BOTH: a skill that the harness can't load is as broken as a missing
- * binary, so detection requires both, and `ensure` wires a missing skill even
- * when the binary is already present (the "installed but not loaded" gap).
- */
-export const agentBrowserStep: SetupStep = {
-  id: 'agent-browser',
-  title: 'agent-browser',
-  group: 'equip',
-
-  async detect() {
-    const haveBin = await detectAgentBrowser()
-    const haveSkill = detectSkill(AGENT_BROWSER_SKILL).installed
-    if (haveBin && haveSkill)
-      return { state: 'satisfied', summary: 'agent-browser + skill installed' }
-    if (haveBin && !haveSkill) {
-      return {
-        state: 'gap',
-        summary: 'agent-browser installed, but its skill is not loaded by the harness',
-        fixHint: SKILL_FIX,
-      }
-    }
-    return { state: 'gap', summary: 'agent-browser not installed', fixHint: FIX }
-  },
-
-  async ensure() {
-    const haveSkill = () => detectSkill(AGENT_BROWSER_SKILL).installed
-    if ((await detectAgentBrowser()) && haveSkill()) {
-      log.success('agent-browser already installed')
-      return 'unchanged'
-    }
-
-    // 1) The binary — third-party global npm + engine download, so confirm it.
-    if (!(await detectAgentBrowser())) {
-      log.warn(`agent-browser is a third-party global npm package (${AGENT_BROWSER_REPO}).`)
-      if (!(await confirmDefaultYes('Install agent-browser globally now?'))) {
-        log.dim(`  Skipped — install later: ${FIX} && ${SKILL_FIX}`)
-        return 'skipped'
-      }
-
-      log.step('npm install -g agent-browser')
-      if ((await runInherit('npm', ['install', '-g', 'agent-browser'])) !== 0) {
-        log.warn('npm install failed — see the output above.')
-        return 'failed'
-      }
-
-      log.step('agent-browser install  (downloading the browser engine)')
-      if ((await runInherit('agent-browser', ['install'])) !== 0) {
-        log.warn('`agent-browser install` failed — re-run it manually.')
-        return 'failed'
-      }
-    }
-
-    // 2) The skill — wire it into the harness so the agent can load it. Runs even
-    //    when the binary was already present (the installed-but-not-loaded gap).
-    if (!haveSkill()) {
-      log.step(`${SKILL_FIX}  (teaches your agent its commands)`)
-      if ((await runInherit('npx', ['skills', 'add', AGENT_BROWSER_REPO, '-g', '-y'])) !== 0) {
-        log.warn(`Skill install did not complete — run it later: ${SKILL_FIX}`)
-        return 'failed'
-      }
-    }
-
-    log.success('agent-browser ready — drive the GUI with `astrale browser`')
-    return 'fixed'
-  },
-}

package/src/setup/steps/auth.ts

@@ -1,54 +0,0 @@
-import type { SetupContext, SetupStep } from '../types'
-
-import { readLocalStatus } from '../../lib/local-status'
-import { log } from '../../lib/log'
-import { loginViaIdp } from '../../lib/login-flow'
-
-const FIX = 'astrale auth login'
-
-/**
- * Step 1 — a WorkOS-backed identity with a cached session. Provisioning an
- * instance requires an `idp` identity (not the local seed key), and stale
- * access tokens refresh on the first command when a refresh token is cached.
- */
-export const authStep: SetupStep = {
-  id: 'auth',
-  title: 'Sign in',
-  group: 'connect',
-
-  async detect() {
-    const { identity } = await readLocalStatus()
-    if (!identity || identity.source !== 'idp') {
-      return { state: 'gap', summary: 'Not signed in', fixHint: FIX }
-    }
-    const session = identity.session
-    if (!session || !session.cached) {
-      return { state: 'gap', summary: `No cached token for "${identity.name}"`, fixHint: FIX }
-    }
-    if (session.requiresLogin) {
-      return {
-        state: 'gap',
-        summary: `Session for "${identity.name}" requires login`,
-        fixHint: FIX,
-      }
-    }
-    return {
-      state: 'satisfied',
-      summary: `Signed in as ${identity.name}`,
-      detail: identity.subject,
-    }
-  },
-
-  async ensure(ctx: SetupContext) {
-    const detection = await authStep.detect(ctx)
-    if (detection.state === 'satisfied') {
-      log.success(detection.summary)
-      return 'unchanged'
-    }
-
-    log.step('Sign in with your Astrale account (a URL + code will appear) …')
-    const { identityName } = await loginViaIdp({ use: true })
-    log.success(`Signed in as "${identityName}"`)
-    return 'fixed'
-  },
-}

package/src/setup/steps/domain.ts

@@ -1,68 +0,0 @@
-import { existsSync } from 'node:fs'
-import { join } from 'node:path'
-
-import type { SetupStep } from '../types'
-
-import { readLocalStatus } from '../../lib/local-status'
-import { log } from '../../lib/log'
-import { runInherit } from '../../lib/proc'
-import { confirmDefaultYes, promptText } from '../../lib/prompt'
-
-/** A scaffolded domain project carries this config at its root. */
-function hasDomainProject(): boolean {
-  return existsSync(join(process.cwd(), 'astrale.config.ts'))
-}
-
-const FIX = 'npx create-astrale-domain <name> --instance <slug>'
-
-/**
- * Equip — scaffold a first domain in the current directory via
- * `create-astrale-domain`, pre-wired to the active instance. The scaffold also
- * ships the astrale-domain authoring skill, so this covers that skill too.
- */
-export const domainStep: SetupStep = {
-  id: 'domain',
-  title: 'Scaffold a domain',
-  group: 'equip',
-
-  async detect() {
-    if (hasDomainProject()) {
-      return { state: 'satisfied', summary: 'domain project detected in this directory' }
-    }
-    return { state: 'gap', summary: 'no domain project here', fixHint: FIX }
-  },
-
-  async ensure() {
-    if (hasDomainProject()) {
-      log.success('Domain project already in this directory')
-      return 'unchanged'
-    }
-
-    if (!(await confirmDefaultYes('Scaffold a new domain project here?'))) {
-      log.dim(`  Skipped — scaffold later: ${FIX}`)
-      return 'skipped'
-    }
-
-    const name = await promptText('Domain project name', {
-      default: 'my-domain',
-      validate: (v) =>
-        /^[a-z0-9][a-z0-9-]*$/.test(v) ? true : 'Use a lowercase name like my-domain',
-    })
-    if (!name) {
-      log.dim('  Skipped — no name given.')
-      return 'skipped'
-    }
-
-    const slug = (await readLocalStatus()).instance?.active
-    const args = ['create-astrale-domain', name, ...(slug ? ['--instance', slug] : [])]
-    log.step(`npx ${args.join(' ')}`)
-    if ((await runInherit('npx', args)) !== 0) {
-      log.warn('Scaffold failed — see the output above.')
-      return 'failed'
-    }
-
-    log.success(`Domain scaffolded → ./${name}`)
-    log.dim(`  Next: cd ${name} && pnpm install && pnpm prod`)
-    return 'fixed'
-  },
-}

package/src/setup/steps/index.ts

@@ -1,18 +0,0 @@
-import type { SetupStep } from '../types'
-
-import { adminStep } from './admin'
-import { agentBrowserStep } from './agent-browser'
-import { authStep } from './auth'
-import { domainStep } from './domain'
-import { instanceStep } from './instance'
-import { skillsStep } from './skills'
-import { skillsBridgeStep } from './skills-bridge'
-
-/** Required prerequisites, walked in order — each is a precondition for the next. */
-export const CONNECT_STEPS: SetupStep[] = [authStep, adminStep, instanceStep]
-
-/** Optional extras, offered together as a pre-checked multi-select. The skills
- *  bridge runs first so the per-skill steps below detect against the bridged state. */
-export const EQUIP_STEPS: SetupStep[] = [skillsBridgeStep, skillsStep, agentBrowserStep, domainStep]
-
-export const ALL_STEPS: SetupStep[] = [...CONNECT_STEPS, ...EQUIP_STEPS]