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

package/src/lib/provision-instance.ts

@@ -1,162 +0,0 @@
-import chalk from 'chalk'
-
-import type { KernelCommandOpts } from '../connection'
-import type { AdminTargetCommandOpts } from './admin-target'
-
-import { AuthError } from '../errors'
-import { readIdentities, type IdentityStore } from '../identity/index'
-import { createOwnedInstance } from './admin-instance'
-import { setActive, upsertManagedBookmark } from './instance'
-import { withSpinner } from './log'
-import { isMachine } from './output'
-import { promptSelect } from './prompt'
-import { validateSlug } from './validation'
-
-export type ProvisionOpts = KernelCommandOpts &
-  AdminTargetCommandOpts & {
-    hostId?: string
-    // Global flags (program.ts) that force non-interactive — mirrors `instance use`.
-    ci?: boolean
-    noPrompt?: boolean
-  }
-
-/** The created instance plus the local-bookmark side effects of provisioning. */
-export type ProvisionResult = {
-  /** The raw admin-kernel response — the stable machine surface for `--json`. */
-  created: { url: string; organizationId?: string }
-  slug: string
-  /** Set when an existing bookmark of the same name was repointed to a new kernel. */
-  repointedFrom?: string
-  /** Set when bookmarking/activating the new instance failed (non-fatal). */
-  selectionError?: unknown
-}
-
-/** Provisioning a child instance runs a multi-step saga (1-3 min). */
-const SAGA_TIMEOUT_MS = '240000'
-
-/**
- * Provision an alpha instance through the admin kernel, then bookmark it and
- * make it the active target. Extracted from `instance create` so `astrale
- * setup` provisions through the exact same saga (auth assertion → alphaCreate →
- * bookmark → set-active), including the interactive multi-host picker.
- *
- * Presentation is deliberately minimal here (a spinner + a one-line success);
- * the caller renders anything richer — `setup` follows this with a hero panel.
- */
-export async function provisionInstance(
-  slug: string,
-  opts: ProvisionOpts,
-): Promise<ProvisionResult> {
-  validateSlug(slug)
-  await assertAlphaCreateAuth(opts)
-  // The created instance must belong to the LOGGED-IN identity — never to an
-  // identity pinned on the admin bookmark (that mismatch silently made a fresh
-  // user's instance unusable). `--as` still wins.
-  if (!opts.as) opts = { ...opts, as: (await readIdentities()).default }
-
-  const machine = isMachine(opts)
-  const interactive = !!process.stdin.isTTY && !(opts.ci || opts.noPrompt || process.env.CI)
-
-  let repointedFrom: string | undefined
-  let selectionError: unknown = null
-  // The global 30s default doesn't just fail the CLIENT: the disconnect kills
-  // the worker's request mid-saga and leaves TORN state (slug taken, routing
-  // live, no instance node — unrecoverable by retry). Default to a saga-sized
-  // timeout; an explicit --timeout still wins.
-  const createOpts = { ...opts, timeout: opts.timeout ?? SAGA_TIMEOUT_MS }
-
-  const runProvision = (hostId: string | undefined) =>
-    withSpinner(
-      `Provisioning instance ${slug}`,
-      !machine,
-      async () => {
-        const created = await createOwnedInstance(createOpts, slug, hostId)
-        try {
-          // Org id from the create response — authoritative for token scoping
-          // (the router's /auth/org is eventually consistent).
-          const bookmarked = await upsertManagedBookmark(
-            slug,
-            slug,
-            created.url,
-            created.organizationId,
-          )
-          repointedFrom = bookmarked.repointedFrom
-          await setActive(slug)
-        } catch (e) {
-          selectionError = e
-        }
-        return created
-      },
-      {
-        success: (created) =>
-          `Instance provisioned: ${slug} ${chalk.dim(`(${created.url})${selectionError ? '' : ' · active'}`)}`,
-      },
-    )
-
-  // Host placement is chosen SERVER-side (the caller's ready + USE-granted
-  // hosts). We recover ONLY from its multi-host ambiguity: pop a picker and
-  // retry with the chosen host_id — the ambiguity error throws before any
-  // provisioning side effect, so the retry is clean. No host / permission /
-  // capacity / a non-interactive run all reject through to the caller's `fatal`,
-  // surfacing the server's own message plus the listed ids. An explicit
-  // `--host-id` skips all of this.
-  const created = await runProvision(opts.hostId).catch(async (e: unknown) => {
-    const hostIds = !opts.hostId && interactive ? parseEligibleHostIds(e) : null
-    if (!hostIds) throw e
-    const chosen = await promptSelect(
-      `${hostIds.length} hosts available — pick one to provision on`,
-      hostIds.map((hid) => ({ name: hid, value: hid })),
-    )
-    if (!chosen) throw e
-    return runProvision(chosen)
-  })
-
-  // Warnings go to stderr so machine-readable stdout stays clean.
-  const warn = (msg: string) => console.error(chalk.yellow('⚠'), msg)
-  if (selectionError) {
-    const message =
-      selectionError instanceof Error ? selectionError.message : String(selectionError)
-    warn(`Could not select the new instance: ${message}`)
-  } else if (repointedFrom) {
-    warn(`Bookmark "${slug}" repointed: ${repointedFrom} → ${created.url}`)
-  }
-
-  return { created, slug, repointedFrom, ...(selectionError ? { selectionError } : {}) }
-}
-
-/**
- * Recover the eligible host ids from alphaCreate's multi-host error
- * ("N ready hosts are assigned (id1, id2). Specify host_id…") — only when
- * there's a real choice (>1). Returns null for any other error (no host,
- * permission, capacity). Deliberately coupled to that message wording (Option
- * B: no admin-side change); if it ever drifts we simply stop offering the
- * picker and the raw error is shown instead — no worse than before.
- */
-export function parseEligibleHostIds(error: unknown): string[] | null {
-  const text = error instanceof Error ? error.message : String(error)
-  const match = /ready hosts are assigned \(([^)]+)\)/.exec(text)
-  if (!match) return null
-  const ids = match[1]!
-    .split(',')
-    .map((s) => s.trim())
-    .filter(Boolean)
-  return ids.length > 1 ? ids : null
-}
-
-async function assertAlphaCreateAuth(opts: Pick<ProvisionOpts, 'as' | 'creds'>): Promise<void> {
-  if (opts.creds) return
-  assertAlphaCreateIdentity(await readIdentities(), opts)
-}
-
-export function assertAlphaCreateIdentity(
-  store: IdentityStore,
-  opts: Pick<ProvisionOpts, 'as'> = {},
-): void {
-  const name = opts.as ?? store.default
-  const identity = store.identities[name]
-  if (identity && identity.source === 'idp') return
-  throw new AuthError(
-    'WorkOS login required for `astrale instance create`',
-    'Run: astrale auth login',
-  )
-}

package/src/lib/sdk-deps.ts

@@ -1,104 +0,0 @@
-import { existsSync } from 'node:fs'
-import { join } from 'node:path'
-
-import { run } from './proc'
-
-/**
- * `astrale update`, Axis C — keep a domain project's first-party `@astrale-os/*`
- * dependencies current. We DELEGATE to pnpm rather than reimplement a package
- * manager: `pnpm outdated` to detect, `pnpm update --latest` to apply. pnpm owns
- * the hard, easy-to-get-wrong parts — registry/`.npmrc`/auth resolution, the
- * `minimumReleaseAge` supply-chain gate, workspace members, semver, and the
- * lockfile — so this stays a thin, robust shim (mirrors how the CLI delegates
- * skills to `npx skills`). Every call is best-effort: pnpm missing or any error
- * means "nothing to do", never a failed update.
- */
-
-/** The dependency pattern pnpm matches both subcommands against. */
-const ASTRALE_DEP_PATTERN = '@astrale-os/*'
-
-export type SdkOutdated = { pkg: string; current: string; latest: string }
-
-/** Is the CLI running at the root of a scaffolded domain project? */
-export function inDomainProject(cwd: string = process.cwd()): boolean {
-  return existsSync(join(cwd, 'astrale.config.ts'))
-}
-
-/**
- * A non-pnpm lockfile means another package manager owns this project; we won't
- * run pnpm against it (that would write a stray `pnpm-lock.yaml`). Returns the
- * foreign PM name, or null when it's pnpm / fresh (Astrale projects are pnpm-first).
- */
-export function foreignPackageManager(cwd: string = process.cwd()): 'npm' | 'yarn' | 'bun' | null {
-  if (existsSync(join(cwd, 'pnpm-lock.yaml'))) return null
-  if (existsSync(join(cwd, 'package-lock.json'))) return 'npm'
-  if (existsSync(join(cwd, 'yarn.lock'))) return 'yarn'
-  if (existsSync(join(cwd, 'bun.lockb')) || existsSync(join(cwd, 'bun.lock'))) return 'bun'
-  return null
-}
-
-type PnpmOutdatedEntry = { current?: string; wanted?: string; latest?: string }
-
-/**
- * Parse `pnpm outdated --format json` into the deps that actually have a newer
- * release. pnpm only lists outdated packages and never proposes a downgrade, so
- * we just drop entries with no `latest` or where `latest` equals the current
- * version (it lists `wanted` when nothing is installed yet — use that as the
- * "current" we display). Pure (no I/O) so it's unit-testable without spawning.
- */
-export function parseSdkOutdated(stdout: string): SdkOutdated[] {
-  let parsed: Record<string, PnpmOutdatedEntry>
-  try {
-    parsed = JSON.parse(stdout || '{}') as Record<string, PnpmOutdatedEntry>
-  } catch {
-    return []
-  }
-  const out: SdkOutdated[] = []
-  for (const [pkg, entry] of Object.entries(parsed)) {
-    const current = entry.current ?? entry.wanted
-    if (entry.latest && current && entry.latest !== current) {
-      out.push({ pkg, current, latest: entry.latest })
-    }
-  }
-  return out
-}
-
-/**
- * Ask pnpm which `@astrale-os/*` deps have a newer release. `pnpm outdated`
- * exits 1 when outdated deps exist — that's not an error, so we parse stdout
- * regardless of exit code. Returns [] when none, pnpm is absent, or anything fails.
- */
-export async function findSdkOutdated(cwd: string = process.cwd()): Promise<SdkOutdated[]> {
-  try {
-    const { stdout } = await run('pnpm', ['outdated', '--format', 'json', ASTRALE_DEP_PATTERN], {
-      cwd,
-    })
-    return parseSdkOutdated(stdout)
-  } catch {
-    return [] // pnpm not on PATH, etc.
-  }
-}
-
-/**
- * Apply via `pnpm update --latest --lockfile-only` — pnpm rewrites package.json
- * (preserving exact pins, the scaffold style) and the lockfile, honoring the
- * registry + supply-chain age policy. `--lockfile-only` is deliberate: it updates
- * the manifest + lockfile WITHOUT running install/build scripts, so an `astrale
- * update` never executes a dependency's postinstall (pnpm would otherwise exit
- * non-zero on `ERR_PNPM_IGNORED_BUILDS`) or churns node_modules — the user runs
- * `pnpm install` to materialize, honoring their own build approvals. Surfaces
- * pnpm's output only on failure. Returns true on success.
- */
-export async function applySdkUpdate(cwd: string = process.cwd()): Promise<boolean> {
-  try {
-    const { code, stdout, stderr } = await run(
-      'pnpm',
-      ['update', '--latest', '--lockfile-only', ASTRALE_DEP_PATTERN],
-      { cwd },
-    )
-    if (code !== 0) process.stderr.write(stdout + stderr)
-    return code === 0
-  } catch {
-    return false
-  }
-}

package/src/lib/self.ts

@@ -1,22 +0,0 @@
-/**
- * Lexical `@self` helpers. Effective-principal resolution is deliberately not
- * local: connection/self.ts asks the authenticated target Kernel through
- * Identity.whoami before replacing any reference.
- */
-
-// Anchors:
-//   left:  start-of-string OR right after `=` (param-value head)
-//   right: end-of-string OR `::` (instance method) OR `/` (path navigation)
-const SELF_RE = /(?:^|(?<=[=]))@self(?=$|::|\/)/g
-
-/** Cheap pre-check before invoking authenticated principal resolution. */
-export function containsSelfRef(input: string): boolean {
-  SELF_RE.lastIndex = 0
-  return SELF_RE.test(input)
-}
-
-/** Replace every admitted `@self` token with one authenticated NodeId. */
-export function expandSelfReferences(input: string, selfId: string): string {
-  const replacement = `@${selfId}`
-  return input.replace(SELF_RE, () => replacement)
-}

package/src/lib/skills.ts

@@ -1,171 +0,0 @@
-import { existsSync, lstatSync, mkdirSync, readlinkSync, symlinkSync } from 'node:fs'
-import { homedir } from 'node:os'
-import { dirname, join } from 'node:path'
-
-import { findAgentBrowser } from './browser'
-import { run } from './proc'
-
-/**
- * Agent skills and the agent-browser tool are owned by the coding-agent harness
- * (Claude Code et al.) and by npm — not by this CLI. `astrale setup` and
- * `astrale update` only *detect* them and delegate installation to their real
- * installers (`npx skills add`, `npm i -g agent-browser`). This module is that
- * detection + delegation layer.
- */
-
-/** The skill name the agent harness looks up under `<dir>/<name>/SKILL.md`. */
-export const ASTRALE_CLI_SKILL = 'astrale-cli'
-export const ASTRALE_DOMAIN_SKILL = 'astrale-domain'
-export const AGENT_BROWSER_SKILL = 'agent-browser'
-
-/**
- * Published skill source consumed by `npx skills add`. The public `astrale-os/cli`
- * repo hosts BOTH the astrale-cli and astrale-domain skills (under `skills/`), so
- * one `npx skills add astrale-os/cli` installs both; address one with
- * `astrale-os/cli@astrale-cli` or `astrale-os/cli@astrale-domain`.
- */
-export const ASTRALE_CLI_SKILL_SOURCE = 'astrale-os/cli'
-
-/** Human-facing command that installs (or refreshes) both astrale skills, globally. */
-export const SKILL_INSTALL_HINT = `npx skills add ${ASTRALE_CLI_SKILL_SOURCE} -g`
-
-/**
- * Install or refresh the astrale agent skills by delegating to the skill package
- * manager (`npx skills add`). We install GLOBALLY (`-g`, user-level): one run
- * equips every project on the machine — the harness resolves the skills from the
- * user Claude dir (see {@link detectSkill}) regardless of cwd, and installs land
- * in `~/.agents/skills` rather than clobbering any project's own `.agents/skills`
- * (notably this repo's symlinked source). We don't reimplement skill installation
- * — re-running the real installer is also how an existing install updates to the
- * latest published SKILL.md, so this doubles as the update path.
- *
- * We CAPTURE the installer's output rather than stream it, and surface it only on
- * failure. A global install reports a benign per-agent note for any agent format
- * that can't go user-level (e.g. PromptScript: "does not support global skill
- * installation") as a "Failed to install N" banner — even though `npx skills`
- * still exits 0 and the skills land for every other agent. Streaming that made a
- * successful refresh look broken; suppressing it on success lets the caller print
- * a clean line. Resolves true on exit 0. Requires Node/`npx` on PATH + network.
- */
-export async function installSkills(): Promise<boolean> {
-  const { code, stdout, stderr } = await run('npx', [
-    'skills',
-    'add',
-    ASTRALE_CLI_SKILL_SOURCE,
-    '-g',
-    '-y',
-  ])
-  if (code !== 0) process.stderr.write(stdout + stderr)
-  return code === 0
-}
-
-/**
- * The directories the agent harness ACTUALLY loads skills from, in resolution
- * order: a project `.claude/skills` found by walking UP from cwd (the harness
- * walks up to the project root), then the user-global Claude dir.
- *
- * Deliberately NOT `.agents/skills`: the harness never reads it, so a skill
- * present only there is on disk but NOT loaded — the false "installed" this
- * used to report, which let `astrale setup` mark a skill satisfied while the
- * agent couldn't see it. `.agents/skills` is a SOURCE convention; it only loads
- * once bridged into `.claude/skills` (e.g. `.claude/skills` symlinked to
- * `.agents/skills`, as this monorepo wires itself — see {@link ensureSkillsBridge}).
- * We probe for `SKILL.md` (not the directory) so a symlinked skill still resolves.
- */
-function skillSearchDirs(): string[] {
-  const dirs: string[] = []
-  let cur = process.cwd()
-  for (;;) {
-    dirs.push(join(cur, '.claude', 'skills'))
-    const parent = dirname(cur)
-    if (parent === cur) break
-    cur = parent
-  }
-  dirs.push(join(homedir(), '.claude', 'skills'))
-  return dirs
-}
-
-export type SkillPresence = { installed: boolean; location: string | null }
-
-/** Is `<name>/SKILL.md` present in a directory the harness actually loads from? */
-export function detectSkill(name: string): SkillPresence {
-  for (const dir of skillSearchDirs()) {
-    const file = join(dir, name, 'SKILL.md')
-    if (existsSync(file)) return { installed: true, location: file }
-  }
-  return { installed: false, location: null }
-}
-
-/** Is the `agent-browser` binary resolvable on PATH? */
-export async function detectAgentBrowser(): Promise<boolean> {
-  return (await findAgentBrowser()) !== null
-}
-
-/* ───────────────────────────── skills bridge ─────────────────────────────
- * Agent tooling stages skills under `.agents/skills`, but the harness only loads
- * `.claude/skills` (walking up). A single `.claude/skills -> ../.agents/skills`
- * symlink bridges EVERY staged skill — present and future — for a workspace and
- * every project nested under it. This is exactly how this monorepo wires itself.
- * It complements the global `-g` installs above: those equip machine-wide skills
- * the CLI owns; this makes a workspace's own staged skills loadable. */
-
-/** The relative target every bridge points at, from `<root>/.claude/skills`. */
-const BRIDGE_TARGET = join('..', '.agents', 'skills')
-
-function isSymlink(p: string): boolean {
-  try {
-    return lstatSync(p).isSymbolicLink()
-  } catch {
-    return false
-  }
-}
-
-/** Nearest ancestor of `fromDir` (inclusive) that stages skills under
- *  `.agents/skills` — the "skills workspace root". null if none up the tree. */
-function findAgentsSkillsRoot(fromDir: string): string | null {
-  let cur = fromDir
-  for (;;) {
-    if (existsSync(join(cur, '.agents', 'skills'))) return cur
-    const parent = dirname(cur)
-    if (parent === cur) return null
-    cur = parent
-  }
-}
-
-export type BridgeStatus =
-  /** no `.agents/skills` up the tree → nothing to bridge */
-  | { kind: 'none' }
-  /** `.claude/skills` already symlinks to `.agents/skills` → harness loads them */
-  | { kind: 'bridged'; root: string }
-  /** `.claude/skills` exists but isn't our bridge (a real dir / foreign link) → leave it */
-  | { kind: 'foreign'; root: string }
-  /** `.agents/skills` present, no `.claude/skills` → we can create the bridge */
-  | { kind: 'unbridged'; root: string; link: string }
-
-/** Read-only: is the workspace's `.agents/skills` visible to the harness? */
-export function skillsBridgeStatus(fromDir: string = process.cwd()): BridgeStatus {
-  const root = findAgentsSkillsRoot(fromDir)
-  if (!root) return { kind: 'none' }
-  const link = join(root, '.claude', 'skills')
-  if (isSymlink(link)) {
-    try {
-      if (readlinkSync(link) === BRIDGE_TARGET) return { kind: 'bridged', root }
-    } catch {
-      /* unreadable link → treat as foreign, don't touch it */
-    }
-    return { kind: 'foreign', root }
-  }
-  if (existsSync(link)) return { kind: 'foreign', root }
-  return { kind: 'unbridged', root, link }
-}
-
-/** Create the `.claude/skills -> ../.agents/skills` bridge if it's missing.
- *  Idempotent and NON-destructive: a correct bridge is left as-is; a pre-existing
- *  real `.claude/skills` (or a foreign symlink) is never clobbered. */
-export function ensureSkillsBridge(fromDir: string = process.cwd()): BridgeStatus {
-  const status = skillsBridgeStatus(fromDir)
-  if (status.kind !== 'unbridged') return status
-  mkdirSync(dirname(status.link), { recursive: true })
-  symlinkSync(BRIDGE_TARGET, status.link)
-  return { kind: 'bridged', root: status.root }
-}

package/src/lib/table.ts

@@ -1,62 +0,0 @@
-import chalk from 'chalk'
-
-/** A display column: which row key to read, its header, and an optional cell color. */
-export type Column = { key: string; header: string; color?: (s: string) => string }
-
-const GUTTER = '  '
-// ESC[…m — built without a control char in the source so no lint disable is needed.
-const ANSI = new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*m`, 'g')
-
-/** Printable width of a string, ignoring ANSI color codes. */
-function visibleWidth(s: string): number {
-  return s.replace(ANSI, '').length
-}
-
-/** Pad to a target *visible* width (color codes don't count toward length). */
-function pad(s: string, width: number): string {
-  const diff = width - visibleWidth(s)
-  return diff > 0 ? s + ' '.repeat(diff) : s
-}
-
-/**
- * Render an aligned, optionally-colored table.
- *
- * Cells may carry ANSI (e.g. a per-row status color) — widths are computed on
- * visible length so alignment stays correct. `Column.color` colors a whole
- * column of otherwise-plain cells. Columns empty across every row are dropped;
- * the last column is left unpadded so there's no trailing whitespace.
- */
-export function renderTable(
-  rows: Array<Record<string, string>>,
-  opts: { columns: Column[]; showHeader?: boolean },
-): string {
-  if (rows.length === 0) return chalk.dim('  (empty)')
-
-  const cols = opts.columns.filter((c) => rows.some((r) => (r[c.key] ?? '') !== ''))
-  if (cols.length === 0) return chalk.dim('  (empty)')
-
-  const widths = cols.map((c) =>
-    Math.max(
-      opts.showHeader ? c.header.length : 0,
-      ...rows.map((r) => visibleWidth(r[c.key] ?? '')),
-    ),
-  )
-
-  const line = (cell: (col: Column, i: number) => string): string =>
-    '  ' + cols.map(cell).join(GUTTER).replace(/\s+$/, '')
-
-  const lines: string[] = []
-  if (opts.showHeader) {
-    lines.push(line((c, i) => chalk.dim(pad(c.header, widths[i]))))
-  }
-  for (const r of rows) {
-    lines.push(
-      line((c, i) => {
-        const raw = r[c.key] ?? ''
-        const text = i === cols.length - 1 ? raw : pad(raw, widths[i])
-        return c.color ? c.color(text) : text
-      }),
-    )
-  }
-  return lines.join('\n')
-}