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

package/src/program/options.ts

@@ -1,41 +0,0 @@
-import type { CommandDefinition, CommandOption } from './command'
-
-import { RAW_OUTPUT_OPTIONS } from '../lib/output'
-
-const KERNEL_PASSTHROUGH_OPTIONS: readonly CommandOption[] = Object.freeze([
-  {
-    flags: '--url <url>',
-    description: 'Target a kernel URL directly (overrides instance resolution)',
-  },
-  {
-    flags: '-i, --instance <name>',
-    description: 'Target a specific instance (overrides active)',
-  },
-  { flags: '--timeout <ms>', description: 'Request timeout in ms (default: 30000)' },
-  { flags: '--as <identity>', description: 'Call as a specific identity' },
-  { flags: '--creds <token>', description: 'Use a pre-signed credential (e.g. delegation token)' },
-  {
-    flags: '--anonymous',
-    description:
-      'Send no credential (cannot be combined with --as or --creds; --as and --creds are mutually exclusive)',
-  },
-  { flags: '--debug', description: 'Print full error diagnostics on failure' },
-])
-
-const KERNEL_OPTIONS: readonly CommandOption[] = Object.freeze([
-  {
-    flags: '--format <type>',
-    description: 'Output format (default: yaml in TTY, json when piped)',
-    choices: ['yaml', 'json'],
-  },
-  ...RAW_OUTPUT_OPTIONS,
-  ...KERNEL_PASSTHROUGH_OPTIONS,
-])
-
-/** Attach the single canonical option set to one Kernel-touching command. */
-export function withKernelOptions(definition: CommandDefinition): CommandDefinition {
-  return {
-    ...definition,
-    options: [...(definition.options ?? []), ...KERNEL_OPTIONS],
-  }
-}

package/src/program/registry.ts

@@ -1,63 +0,0 @@
-import { type Command, Option } from 'commander'
-
-import type { CommandDefinition, CommandGroup } from './command'
-
-type CommanderAction = Parameters<Command['action']>[0]
-
-/**
- * Register a single command on a Commander program or subcommand.
- */
-export function registerCommand(parent: Command, def: CommandDefinition): void {
-  const cmd = parent.command(def.name, { hidden: def.hidden ?? false }).description(def.description)
-
-  if (def.summary) cmd.summary(def.summary)
-
-  if (def.aliases) {
-    for (const alias of def.aliases) cmd.alias(alias)
-  }
-
-  if (def.arguments) {
-    for (const arg of def.arguments) {
-      const bracket = arg.required !== false ? `<${arg.name}>` : `[${arg.name}]`
-      cmd.argument(bracket, arg.description)
-    }
-  }
-
-  if (def.options) {
-    for (const opt of def.options) {
-      if (opt.choices) {
-        const o = new Option(opt.flags, opt.description)
-        o.choices(opt.choices)
-        if (opt.default !== undefined) o.default(opt.default)
-        cmd.addOption(o)
-      } else if (opt.default !== undefined) {
-        cmd.option(opt.flags, opt.description, opt.default)
-      } else {
-        cmd.option(opt.flags, opt.description)
-      }
-    }
-  }
-
-  // CommandDefinition keeps each callback tuple opaque; Commander materializes
-  // that tuple only after this definition has registered its arguments/options.
-  cmd.action(def.action as CommanderAction)
-
-  if (def.afterHelpText) cmd.addHelpText('after', def.afterHelpText)
-}
-
-/**
- * Register a command group (subcommand with nested commands). Supports
- * one level of nested subgroups via `group.subgroups`.
- */
-export function registerGroup(parent: Command, group: CommandGroup): void {
-  const sub = parent.command(group.name).description(group.description)
-  if (group.summary) sub.summary(group.summary)
-  for (const def of group.commands) {
-    registerCommand(sub, def)
-  }
-  if (group.subgroups) {
-    for (const nested of group.subgroups) {
-      registerGroup(sub, nested)
-    }
-  }
-}

package/src/program/tsconfig.json

@@ -1,6 +0,0 @@
-{
-  "extends": "../../tsconfig.json",
-  "compilerOptions": { "types": ["@types/node"] },
-  "include": ["*.ts"],
-  "exclude": ["__tests__"]
-}

package/src/setup/__tests__/instance-step.test.ts

@@ -1,239 +0,0 @@
-import { describe, expect, mock, test } from 'bun:test'
-
-import type { OwnedInstanceInfo } from '../../lib/admin-instance'
-import type { SetupContext } from '../types'
-
-import { AstraleError } from '../../errors'
-import {
-  adoptOwnedInstance,
-  ensureOwnedInstance,
-  type InstanceSetupDependencies,
-} from '../steps/instance'
-
-const ctx: SetupContext = {
-  interactive: true,
-  machine: true,
-  opts: {},
-  slug: 'new-instance',
-}
-
-function instance(slug: string, state: OwnedInstanceInfo['state'] = 'ready'): OwnedInstanceInfo {
-  return {
-    id: `${slug}-id`,
-    slug,
-    url: `https://${slug}.eu.astrale.ai`,
-    state,
-    organizationId: `org_${slug}`,
-  }
-}
-
-function dependencies(
-  overrides: Partial<InstanceSetupDependencies> = {},
-): InstanceSetupDependencies {
-  return {
-    fetchOwned: mock(async () => []),
-    adopt: mock(async () => {}),
-    selectReady: mock(async (instances) => instances[0] ?? null),
-    confirmCreate: mock(async () => true),
-    promptSlug: mock(async () => 'new-instance'),
-    provision: mock(async (slug) => ({
-      created: { url: `https://${slug}.eu.astrale.ai`, organizationId: `org_${slug}` },
-      slug,
-    })),
-    ...overrides,
-  }
-}
-
-describe('setup owned-instance reconciliation', () => {
-  test('silently adopts the sole owned ready instance', async () => {
-    const ready = instance('only')
-    const failed = instance('old-attempt', 'failed')
-    const deps = dependencies({ fetchOwned: mock(async () => [failed, ready]) })
-
-    await expect(ensureOwnedInstance(ctx, deps)).resolves.toBe('fixed')
-
-    expect(deps.adopt).toHaveBeenCalledTimes(1)
-    expect(deps.adopt).toHaveBeenCalledWith(ready)
-    expect(deps.selectReady).not.toHaveBeenCalled()
-    expect(deps.confirmCreate).not.toHaveBeenCalled()
-    expect(deps.provision).not.toHaveBeenCalled()
-  })
-
-  test('asks the user to pick when several owned instances are ready', async () => {
-    const first = instance('first')
-    const second = instance('second')
-    const pending = instance('pending', 'provisioning')
-    const deps = dependencies({
-      fetchOwned: mock(async () => [first, pending, second]),
-      selectReady: mock(async (instances) => instances[1] ?? null),
-    })
-
-    await expect(ensureOwnedInstance(ctx, deps)).resolves.toBe('fixed')
-
-    expect(deps.selectReady).toHaveBeenCalledWith([first, second])
-    expect(deps.adopt).toHaveBeenCalledWith(second)
-    expect(deps.confirmCreate).not.toHaveBeenCalled()
-    expect(deps.provision).not.toHaveBeenCalled()
-  })
-
-  test('leaves setup skipped when the ready-instance picker is cancelled', async () => {
-    const first = instance('first')
-    const second = instance('second')
-    const deps = dependencies({
-      fetchOwned: mock(async () => [first, second]),
-      selectReady: mock(async () => null),
-    })
-
-    await expect(ensureOwnedInstance(ctx, deps)).resolves.toBe('skipped')
-
-    expect(deps.selectReady).toHaveBeenCalledWith([first, second])
-    expect(deps.adopt).not.toHaveBeenCalled()
-    expect(deps.confirmCreate).not.toHaveBeenCalled()
-    expect(deps.provision).not.toHaveBeenCalled()
-  })
-
-  test('offers first-instance creation only after a confirmed empty owner list', async () => {
-    const deps = dependencies()
-    const original = console.log
-    console.log = mock(() => {})
-
-    try {
-      await expect(ensureOwnedInstance(ctx, deps)).resolves.toBe('fixed')
-    } finally {
-      console.log = original
-    }
-
-    expect(deps.confirmCreate).toHaveBeenCalledTimes(1)
-    expect(deps.promptSlug).toHaveBeenCalledTimes(1)
-    expect(deps.provision).toHaveBeenCalledWith('new-instance')
-    expect(deps.adopt).not.toHaveBeenCalled()
-  })
-
-  test('does not provision when first-instance creation is declined', async () => {
-    const deps = dependencies({ confirmCreate: mock(async () => false) })
-
-    await expect(ensureOwnedInstance(ctx, deps)).resolves.toBe('skipped')
-
-    expect(deps.confirmCreate).toHaveBeenCalledTimes(1)
-    expect(deps.promptSlug).not.toHaveBeenCalled()
-    expect(deps.provision).not.toHaveBeenCalled()
-  })
-
-  test('does not provision when the slug prompt is cancelled', async () => {
-    const deps = dependencies({ promptSlug: mock(async () => undefined) })
-
-    await expect(ensureOwnedInstance(ctx, deps)).resolves.toBe('skipped')
-
-    expect(deps.confirmCreate).toHaveBeenCalledTimes(1)
-    expect(deps.promptSlug).toHaveBeenCalledTimes(1)
-    expect(deps.provision).not.toHaveBeenCalled()
-  })
-
-  test('does not report setup fixed when provisioning could not select the instance', async () => {
-    const deps = dependencies({
-      provision: mock(async (slug) => ({
-        created: { url: `https://${slug}.eu.astrale.ai`, organizationId: `org_${slug}` },
-        slug,
-        selectionError: new Error('instances.json is read-only'),
-      })),
-    })
-    const logged: string[] = []
-    const original = console.log
-    console.log = mock((...args: unknown[]) => {
-      logged.push(args.map(String).join(' '))
-    })
-
-    let caught: unknown
-    try {
-      await ensureOwnedInstance(ctx, deps)
-    } catch (error) {
-      caught = error
-    } finally {
-      console.log = original
-    }
-
-    expect(caught).toBeInstanceOf(AstraleError)
-    expect((caught as AstraleError).code).toBe('INSTANCE_SELECTION_FAILED')
-    expect((caught as AstraleError).message).toContain('instances.json is read-only')
-    expect((caught as AstraleError).hint).toContain('astrale instance use new-instance')
-    expect(logged.join('\n')).not.toContain('https://new-instance.eu.astrale.ai')
-  })
-
-  test('does not create a duplicate while an owned instance is provisioning or failed', async () => {
-    const provisioning = {
-      ...instance('pending', 'provisioning'),
-      phase: 'installing:default-domains',
-    }
-    const failed = { ...instance('broken', 'failed'), error: 'postInstall failed' }
-    const deps = dependencies({ fetchOwned: mock(async () => [provisioning, failed]) })
-    const logged: string[] = []
-    const original = console.log
-    console.log = mock((...args: unknown[]) => {
-      logged.push(args.map(String).join(' '))
-    })
-
-    try {
-      await expect(ensureOwnedInstance(ctx, deps)).resolves.toBe('skipped')
-    } finally {
-      console.log = original
-    }
-
-    expect(deps.selectReady).not.toHaveBeenCalled()
-    expect(deps.confirmCreate).not.toHaveBeenCalled()
-    expect(deps.promptSlug).not.toHaveBeenCalled()
-    expect(deps.provision).not.toHaveBeenCalled()
-    expect(logged.join('\n')).toContain('pending: provisioning (installing:default-domains)')
-    expect(logged.join('\n')).toContain('broken: failed')
-    expect(logged.join('\n')).toContain('postInstall failed')
-    expect(logged.join('\n')).toContain('astrale instance status')
-  })
-
-  test('does not treat owner-discovery failure as an empty account', async () => {
-    const deps = dependencies({
-      fetchOwned: mock(async () => {
-        throw new Error('admin unavailable')
-      }),
-    })
-
-    let caught: unknown
-    try {
-      await ensureOwnedInstance(ctx, deps)
-    } catch (error) {
-      caught = error
-    }
-
-    expect(caught).toBeInstanceOf(AstraleError)
-    expect((caught as AstraleError).code).toBe('INSTANCE_DISCOVERY_FAILED')
-    expect((caught as AstraleError).hint).toContain('No instance was created')
-    expect(deps.confirmCreate).not.toHaveBeenCalled()
-    expect(deps.provision).not.toHaveBeenCalled()
-  })
-})
-
-describe('owned-instance adoption', () => {
-  test('persists the owner organization before activating the bookmark', async () => {
-    const owned = instance('existing')
-    const calls: unknown[][] = []
-    const original = console.log
-    console.log = mock(() => {})
-
-    try {
-      await adoptOwnedInstance(owned, {
-        upsert: mock(async (...args) => {
-          calls.push(['upsert', ...args])
-          return {}
-        }),
-        activate: mock(async (...args) => {
-          calls.push(['activate', ...args])
-        }),
-      })
-    } finally {
-      console.log = original
-    }
-
-    expect(calls).toEqual([
-      ['upsert', 'existing', 'existing', 'https://existing.eu.astrale.ai', 'org_existing'],
-      ['activate', 'existing'],
-    ])
-  })
-})

package/src/setup/__tests__/util.test.ts

@@ -1,29 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-
-import { guiOrigin, slugError, urlError } from '../util'
-
-describe('guiOrigin — the clickable instance URL', () => {
-  test('strips the /api path bookmarks carry', () => {
-    expect(guiOrigin('https://my-app.eu.astrale.ai/api')).toBe('https://my-app.eu.astrale.ai')
-  })
-
-  test('leaves a bare origin untouched', () => {
-    expect(guiOrigin('https://my-app.eu.astrale.ai')).toBe('https://my-app.eu.astrale.ai')
-  })
-
-  test('returns the input verbatim when it is not a URL', () => {
-    expect(guiOrigin('not a url')).toBe('not a url')
-  })
-})
-
-describe('inquirer validators', () => {
-  test('slugError accepts a DNS-label slug and rejects junk', () => {
-    expect(slugError('my-app')).toBe(true)
-    expect(typeof slugError('Not A Slug')).toBe('string')
-  })
-
-  test('urlError accepts http(s) and rejects junk', () => {
-    expect(urlError('https://admin.eu.astrale.ai/api')).toBe(true)
-    expect(typeof urlError('ftp://nope')).toBe('string')
-  })
-})

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'
-  },
-}