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

package/src/lib/provision-instance.ts

@@ -1,139 +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 { validateSlug } from './validation'
-
-export type ProvisionOpts = KernelCommandOpts &
-  AdminTargetCommandOpts & {
-    // 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 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 → create →
- * bookmark → set-active).
- *
- * 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)
-  const authentication = await instanceCreateAuthentication(opts)
-  opts = authentication.opts
-
-  const machine = isMachine(opts)
-  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 = () =>
-    withSpinner(
-      `Provisioning instance ${slug}`,
-      !machine,
-      async () => {
-        const created = await createOwnedInstance(createOpts, slug)
-        try {
-          // Org id from the create response — authoritative for token scoping
-          // (the router's /auth/org is eventually consistent).
-          const bookmarked = await upsertManagedBookmark({
-            key: slug,
-            slug,
-            url: created.url,
-            ...(created.organizationId ? { organizationId: created.organizationId } : {}),
-            ...(authentication.defaultIdentity
-              ? { defaultIdentity: authentication.defaultIdentity }
-              : {}),
-          })
-          repointedFrom = bookmarked.repointedFrom
-          await setActive(slug)
-        } catch (e) {
-          selectionError = e
-        }
-        return created
-      },
-      {
-        success: (created) =>
-          `Instance provisioned: ${slug} ${chalk.dim(`(${created.url})${selectionError ? '' : ' · active'}`)}`,
-      },
-    )
-
-  const created = await runProvision()
-
-  // 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 } : {}) }
-}
-
-async function instanceCreateAuthentication(opts: ProvisionOpts): Promise<{
-  readonly opts: ProvisionOpts
-  readonly defaultIdentity?: string
-}> {
-  if (opts.creds) return { opts }
-  const store = await readIdentities()
-  const defaultIdentity = selectInstanceCreateIdentity(store, opts)
-  return {
-    opts: opts.as ? opts : { ...opts, as: defaultIdentity },
-    defaultIdentity,
-  }
-}
-
-export function selectInstanceCreateIdentity(
-  store: IdentityStore,
-  opts: Pick<ProvisionOpts, 'as'> = {},
-): string {
-  assertInstanceCreateIdentity(store, opts)
-  return opts.as ?? store.default
-}
-
-export function assertInstanceCreateIdentity(
-  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/lock.ts

@@ -1,117 +0,0 @@
-import { randomUUID } from 'node:crypto'
-import { lstat, mkdir, readFile, readdir, rm, stat, unlink, writeFile } from 'node:fs/promises'
-import { dirname, join } from 'node:path'
-
-export type FileLockOptions = {
-  pollIntervalMs?: number
-  staleAfterMs?: number
-  timeoutMs?: number
-}
-
-type Claim = { directory: string; pid: number; ticket: number | null; choosing: boolean }
-
-/**
- * Serialize a cross-process transition with a filesystem bakery lock.
- *
- * Every contender owns a UUID directory for its entire lifetime. Dead claims are
- * removed only by that unrepeatable name, so recovery never deletes a pathname a
- * new live owner could have replaced between an ownership check and an unlink.
- */
-export async function withFileLock<T>(
-  lockPath: string,
-  fn: () => Promise<T>,
-  opts: FileLockOptions = {},
-): Promise<T> {
-  const pollIntervalMs = opts.pollIntervalMs ?? 100
-  const staleAfterMs = opts.staleAfterMs ?? 30_000
-  const timeoutMs = opts.timeoutMs ?? 60_000
-  const deadline = Date.now() + timeoutMs
-  const claimsRoot = `${lockPath}.claims`
-  const token = randomUUID()
-  const claimDirectory = join(claimsRoot, token)
-
-  await mkdir(dirname(lockPath), { recursive: true })
-  await mkdir(claimsRoot, { recursive: true })
-  await mkdir(claimDirectory)
-  await writeFile(join(claimDirectory, 'owner.json'), JSON.stringify({ pid: process.pid }), {
-    mode: 0o600,
-  })
-  await writeFile(join(claimDirectory, 'choosing'), '', { mode: 0o600 })
-
-  try {
-    const claims = await liveClaims(claimsRoot, staleAfterMs)
-    const ticket = Math.max(0, ...claims.flatMap((claim) => claim.ticket ?? [])) + 1
-    await writeFile(join(claimDirectory, 'ticket'), String(ticket), { mode: 0o600 })
-    await unlink(join(claimDirectory, 'choosing'))
-
-    for (;;) {
-      const contenders = await liveClaims(claimsRoot, staleAfterMs)
-      const blocked = contenders.some(
-        (claim) =>
-          claim.directory !== claimDirectory &&
-          (claim.choosing ||
-            claim.ticket === null ||
-            claim.ticket < ticket ||
-            (claim.ticket === ticket && claim.directory < claimDirectory)),
-      )
-      if (!blocked) return await fn()
-      if (Date.now() >= deadline) throw new Error('Timed out waiting for another skill update')
-      await new Promise((resolve) => setTimeout(resolve, pollIntervalMs))
-    }
-  } finally {
-    await rm(claimDirectory, { recursive: true, force: true })
-  }
-}
-
-async function liveClaims(root: string, staleAfterMs: number): Promise<Claim[]> {
-  const directories = (await readdir(root, { withFileTypes: true }).catch(() => []))
-    .filter((entry) => entry.isDirectory())
-    .map((entry) => join(root, entry.name))
-  const claims = await Promise.all(
-    directories.map(async (directory): Promise<Claim | null> => {
-      try {
-        const owner = JSON.parse(await readFile(join(directory, 'owner.json'), 'utf8')) as {
-          pid?: unknown
-        }
-        if (typeof owner.pid !== 'number') return await discardIfStale(directory, staleAfterMs)
-        if (!isPidAlive(owner.pid)) {
-          await rm(directory, { recursive: true, force: true })
-          return null
-        }
-        const choosing = await lstat(join(directory, 'choosing'))
-          .then(() => true)
-          .catch(() => false)
-        const ticket = await readFile(join(directory, 'ticket'), 'utf8')
-          .then((value) => {
-            const parsed = Number(value)
-            return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : null
-          })
-          .catch(() => null)
-        return { directory, pid: owner.pid, ticket, choosing }
-      } catch {
-        return await discardIfStale(directory, staleAfterMs)
-      }
-    }),
-  )
-  return claims.filter((claim): claim is Claim => claim !== null)
-}
-
-async function discardIfStale(directory: string, staleAfterMs: number): Promise<null> {
-  try {
-    if (Date.now() - (await stat(directory)).mtimeMs > staleAfterMs) {
-      await rm(directory, { recursive: true, force: true })
-    }
-  } catch {
-    // A concurrently released unique claim is already gone.
-  }
-  return null
-}
-
-function isPidAlive(pid: number): boolean {
-  try {
-    process.kill(pid, 0)
-    return true
-  } catch (error) {
-    return (error as { code?: string }).code === 'EPERM'
-  }
-}