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

package/src/lib/ca-fetch.ts

@@ -1,133 +0,0 @@
-import type { IncomingHttpHeaders, request as httpRequest } from 'node:http'
-
-import { Buffer } from 'node:buffer'
-import { readFileSync } from 'node:fs'
-import { request as httpsRequest } from 'node:https'
-import { rootCertificates } from 'node:tls'
-
-/** Create a Fetch capability whose HTTPS requests trust one CLI-selected CA file. */
-export function fetchWithCaFile(
-  caFile: string,
-  fallback: (input: RequestInfo | URL, init?: RequestInit) => Promise<Response> = globalThis.fetch,
-): (input: RequestInfo | URL, init?: RequestInit) => Promise<Response> {
-  const ca = readFileSync(caFile)
-  const fallbackFetch = fallback.bind(globalThis)
-
-  return async (input: RequestInfo | URL, init?: RequestInit): Promise<Response> => {
-    const url = requestUrl(input)
-    if (url.protocol !== 'https:') return fallbackFetch(input, init)
-    return fetchWithNode(url, init, ca)
-  }
-}
-
-function requestUrl(input: RequestInfo | URL): URL {
-  if (input instanceof URL) return input
-  if (typeof input === 'string') return new URL(input)
-  return new URL(input.url)
-}
-
-function fetchWithNode(url: URL, init: RequestInit | undefined, ca: Buffer): Promise<Response> {
-  return new Promise((resolve, reject) => {
-    const request = httpsRequest(
-      url,
-      {
-        method: init?.method ?? 'GET',
-        headers: headersInitToRecord(init?.headers),
-        // `ca` replaces Node's default trust set. Retain public roots because one
-        // Client Session may reach both a private Kernel and a public Domain issuer.
-        ca: [...rootCertificates, ca],
-      },
-      (response) => {
-        const chunks: Buffer[] = []
-        response.on('data', (chunk) =>
-          chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)),
-        )
-        response.on('end', () => {
-          const status = response.statusCode ?? 0
-          const body =
-            status === 204 || status === 205 || status === 304 ? null : Buffer.concat(chunks)
-          const result = new Response(body, {
-            status,
-            statusText: response.statusMessage,
-            headers: responseHeaders(response.headers),
-          })
-          // Synthetic Responses have no URL list. This transport does not follow
-          // redirects, so the exact request URL is also the final response URL.
-          Object.defineProperty(result, 'url', { value: url.toString() })
-          resolve(result)
-        })
-      },
-    )
-
-    request.on('error', reject)
-    if (init?.signal) {
-      if (init.signal.aborted) {
-        request.destroy(abortError(init.signal.reason))
-      } else {
-        init.signal.addEventListener(
-          'abort',
-          () => request.destroy(abortError(init.signal?.reason)),
-          {
-            once: true,
-          },
-        )
-      }
-    }
-
-    writeBody(request, init?.body)
-      .then(() => request.end())
-      .catch((error) => request.destroy(error))
-  })
-}
-
-function abortError(reason: unknown): Error {
-  return reason instanceof Error
-    ? reason
-    : new DOMException('The operation was aborted.', 'AbortError')
-}
-
-async function writeBody(
-  request: ReturnType<typeof httpRequest>,
-  body: BodyInit | null | undefined,
-): Promise<void> {
-  if (body === undefined || body === null) return
-  if (typeof body === 'string' || body instanceof Uint8Array) {
-    request.write(body)
-    return
-  }
-  if (body instanceof ArrayBuffer) {
-    request.write(Buffer.from(body))
-    return
-  }
-  if (body instanceof Blob) {
-    request.write(Buffer.from(await body.arrayBuffer()))
-    return
-  }
-  throw new Error('Unsupported request body type for CA-backed fetch')
-}
-
-function headersInitToRecord(headers: HeadersInit | undefined): Record<string, string> {
-  if (!headers) return {}
-  if (headers instanceof Headers) {
-    const out: Record<string, string> = {}
-    headers.forEach((value, key) => {
-      out[key] = value
-    })
-    return out
-  }
-  if (Array.isArray(headers)) return Object.fromEntries(headers)
-  return Object.fromEntries(Object.entries(headers).map(([key, value]) => [key, String(value)]))
-}
-
-function responseHeaders(headers: IncomingHttpHeaders): Headers {
-  const out = new Headers()
-  for (const [key, value] of Object.entries(headers)) {
-    if (value === undefined) continue
-    if (Array.isArray(value)) {
-      for (const entry of value) out.append(key, entry)
-    } else {
-      out.set(key, value)
-    }
-  }
-  return out
-}

package/src/lib/command-dx.ts

@@ -1,188 +0,0 @@
-import type { Command, CommanderError } from 'commander'
-
-import chalk from 'chalk'
-
-import { isMachine } from './output'
-
-export type CommandCatalogEntry = {
-  path: string[]
-  usage: string
-}
-
-export function collectCommandCatalog(program: Command): CommandCatalogEntry[] {
-  const out: CommandCatalogEntry[] = []
-
-  function walk(command: Command, path: string[]): void {
-    for (const child of command.commands) {
-      const childPath = [...path, child.name()]
-      if (child.commands.length === 0) {
-        out.push({ path: childPath, usage: usageFor(childPath, child) })
-      }
-      walk(child, childPath)
-    }
-  }
-
-  walk(program, [])
-  return out
-}
-
-export function renderCommanderError(
-  program: Command,
-  error: CommanderError,
-  argv = process.argv.slice(2),
-): string {
-  const tokens = stripOptions(argv)
-  const catalog = collectCommandCatalog(program)
-  const matched = matchRegisteredPrefix(program, tokens)
-
-  if (matched.path.length === 0 && tokens.length > 0) {
-    return maybeMachine(renderUnknownCommand(tokens, catalog))
-  }
-
-  if (error.code === 'commander.missingArgument') {
-    const usage = usageFor(matched.path, matched.command)
-    return maybeMachine(
-      [
-        `Missing required argument for ${chalk.bold(`astrale ${matched.path.join(' ')}`)}`,
-        '',
-        'Usage:',
-        `  astrale ${usage}`,
-      ].join('\n'),
-    )
-  }
-
-  if (error.code === 'commander.excessArguments') {
-    const usage = usageFor(matched.path, matched.command)
-    const extra = tokens.slice(matched.path.length).join(' ')
-    return maybeMachine(
-      [
-        `Unexpected argument${extra.includes(' ') ? 's' : ''} for ${chalk.bold(
-          `astrale ${matched.path.join(' ')}`,
-        )}${extra ? `: ${extra}` : ''}`,
-        '',
-        'Usage:',
-        `  astrale ${usage}`,
-      ].join('\n'),
-    )
-  }
-
-  const suggestions = nearestCommands(tokens.join(' '), catalog)
-  return maybeMachine(
-    [
-      error.message,
-      ...(suggestions.length > 0
-        ? ['', 'Did you mean:', ...suggestions.map((s) => `  astrale ${s}`)]
-        : []),
-    ].join('\n'),
-  )
-}
-
-const RETIRED_COMMANDS: Record<string, string> = {
-  ls: 'astrale query <source> --edge <class>',
-  describe: 'astrale get <target>',
-}
-
-function renderUnknownCommand(tokens: string[], catalog: CommandCatalogEntry[]): string {
-  const command = tokens.join(' ')
-  const first = tokens[0]
-  const retired = first === undefined ? undefined : RETIRED_COMMANDS[first]
-  if (retired !== undefined) {
-    return [
-      `Unknown command: ${chalk.bold(`astrale ${command}`)}`,
-      '',
-      `\`astrale ${first}\` was removed. Use ${chalk.bold(retired)} instead.`,
-    ].join('\n')
-  }
-  const namespaceMatches = catalog.filter((entry) => entry.path.at(-1) === first)
-  if (namespaceMatches.length > 0) {
-    return [
-      `Unknown command: ${chalk.bold(`astrale ${command}`)}`,
-      '',
-      `"${first}" is available under:`,
-      ...namespaceMatches.map((entry) => `  astrale ${entry.usage}`),
-    ].join('\n')
-  }
-
-  const suggestions = nearestCommands(command, catalog)
-  return [
-    `Unknown command: ${chalk.bold(`astrale ${command}`)}`,
-    ...(suggestions.length > 0
-      ? ['', 'Did you mean:', ...suggestions.map((s) => `  astrale ${s}`)]
-      : []),
-  ].join('\n')
-}
-
-function matchRegisteredPrefix(
-  program: Command,
-  tokens: string[],
-): { command: Command; path: string[] } {
-  let current = program
-  const path: string[] = []
-  for (const token of tokens) {
-    const next = current.commands.find(
-      (cmd) => cmd.name() === token || cmd.aliases().includes(token),
-    )
-    if (!next) break
-    current = next
-    path.push(current.name())
-  }
-  return { command: current, path }
-}
-
-function usageFor(path: string[], command: Command): string {
-  const suffix = command
-    .usage()
-    .replace(/\[options\]\s*/g, '')
-    .replace(/\s+/g, ' ')
-    .trim()
-  return [path.join(' '), suffix].filter(Boolean).join(' ')
-}
-
-const ANSI_RE = new RegExp(String.fromCharCode(27) + '\\[[0-9;]*m', 'g')
-
-function maybeMachine(text: string): string {
-  if (!isMachine()) return text
-  const plain = text.replace(ANSI_RE, '')
-  const first = plain.split('\n').find((line) => line.trim().length > 0) ?? plain
-  return JSON.stringify({ error: 'USAGE_ERROR', message: first, detail: plain })
-}
-
-function stripOptions(argv: string[]): string[] {
-  const out: string[] = []
-  for (const token of argv) {
-    if (token === '--') break
-    if (token.startsWith('-')) continue
-    out.push(token)
-  }
-  return out
-}
-
-function nearestCommands(input: string, catalog: CommandCatalogEntry[]): string[] {
-  if (!input) return []
-  return catalog
-    .map((entry) => ({ usage: entry.usage, score: similarity(input, entry.path.join(' ')) }))
-    .filter((entry) => entry.score >= 0.45)
-    .sort((a, b) => b.score - a.score || a.usage.localeCompare(b.usage))
-    .slice(0, 3)
-    .map((entry) => entry.usage)
-}
-
-function similarity(a: string, b: string): number {
-  const max = Math.max(a.length, b.length)
-  if (max === 0) return 1
-  return 1 - levenshtein(a, b) / max
-}
-
-function levenshtein(a: string, b: string): number {
-  const prev = Array.from({ length: b.length + 1 }, (_, i) => i)
-  const curr = Array.from({ length: b.length + 1 }, () => 0)
-  for (let i = 1; i <= a.length; i += 1) {
-    curr[0] = i
-    for (let j = 1; j <= b.length; j += 1) {
-      const cost = a[i - 1] === b[j - 1] ? 0 : 1
-      curr[j] = Math.min(curr[j - 1] + 1, prev[j] + 1, prev[j - 1] + cost)
-    }
-    prev.splice(0, prev.length, ...curr)
-  }
-  return prev[b.length] ?? 0
-}

package/src/lib/concurrency.ts

@@ -1,31 +0,0 @@
-/**
- * Minimal bounded-concurrency map. No external dependency (the repo
- * hand-rolls with `Promise.all`); a tiny worker pool is enough for the
- * `domain dev up` fan-out.
- */
-
-/**
- * Run `fn` over `items` with at most `limit` in flight at once. Results
- * are returned in input order regardless of completion order. The first
- * rejection rejects the returned promise (in-flight work still settles).
- */
-export async function mapBounded<T, R>(
-  items: readonly T[],
-  limit: number,
-  fn: (item: T, index: number) => Promise<R>,
-): Promise<R[]> {
-  const results: R[] = []
-  const bound = Math.max(1, Math.min(limit, items.length))
-  let next = 0
-
-  async function worker(): Promise<void> {
-    while (true) {
-      const i = next++
-      if (i >= items.length) return
-      results[i] = await fn(items[i] as T, i)
-    }
-  }
-
-  await Promise.all(Array.from({ length: bound }, () => worker()))
-  return results
-}

package/src/lib/config.ts

@@ -1,46 +0,0 @@
-import { readFile, writeFile, mkdir } from 'node:fs/promises'
-import { dirname } from 'node:path'
-import { z } from 'zod'
-
-import { CONFIG_PATH } from '../state/index'
-import { AdminTargetConfigSchema, DEFAULT_ADMIN_TARGET_CONFIG } from './admin-target'
-import { log } from './log'
-
-export const AstraleConfigSchema = z.object({
-  issuer: z.string().url().default('https://unregistered.invalid'),
-  admin: AdminTargetConfigSchema.default(DEFAULT_ADMIN_TARGET_CONFIG),
-  telemetry: z.object({ enabled: z.boolean().default(true) }).default({ enabled: true }),
-})
-
-export type AstraleConfig = z.infer<typeof AstraleConfigSchema>
-
-export const DEFAULT_CONFIG: AstraleConfig = AstraleConfigSchema.parse({})
-
-export async function readConfig(): Promise<AstraleConfig> {
-  try {
-    const raw = await readFile(CONFIG_PATH, 'utf-8')
-    return AstraleConfigSchema.parse(JSON.parse(raw))
-  } catch (e) {
-    // A present-but-broken config (invalid JSON or failed validation) should
-    // surface; a missing file (readFile ENOENT) stays silent — that's the
-    // normal first-run case and defaults are expected.
-    if (e instanceof z.ZodError || e instanceof SyntaxError) {
-      log.warn(`Invalid config at ${CONFIG_PATH} — using defaults`)
-    }
-    return DEFAULT_CONFIG
-  }
-}
-
-export async function writeConfig(config: AstraleConfig): Promise<void> {
-  await mkdir(dirname(CONFIG_PATH), { recursive: true })
-  await writeFile(CONFIG_PATH, JSON.stringify(config, null, 2) + '\n')
-}
-
-export async function configExists(): Promise<boolean> {
-  try {
-    await readFile(CONFIG_PATH)
-    return true
-  } catch {
-    return false
-  }
-}

package/src/lib/domain-publication.ts

@@ -1,102 +0,0 @@
-import { publication } from '@astrale-os/sdk/publication'
-
-const MAXIMUM_PUBLICATION_BYTES = 1024 * 1024
-type FetchLike = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>
-
-/** Fetch and admit one canonical Domain Publication without following its bundle. */
-export async function fetchDomainPublication(
-  input: string,
-  signal?: AbortSignal,
-  fetchImpl: FetchLike = globalThis.fetch,
-): Promise<publication.Publication> {
-  const root = deploymentRoot(input)
-  const url = new URL(publication.PATH, root)
-  const response = await fetchImpl(url, {
-    redirect: 'error',
-    ...(signal === undefined ? {} : { signal }),
-  })
-  if (!response.ok) {
-    await cancel(response.body)
-    throw new Error(`GET ${url.href} → ${response.status}`)
-  }
-  const bytes = await readBounded(response, url)
-  try {
-    const source = new TextDecoder('utf-8', { fatal: true }).decode(bytes)
-    return publication.accept(JSON.parse(source) as unknown)
-  } catch (cause) {
-    throw new Error(`GET ${url.href} returned an invalid Domain Publication`, { cause })
-  }
-}
-
-async function readBounded(response: Response, url: URL): Promise<Uint8Array> {
-  const declared = response.headers.get('content-length')
-  if (
-    declared !== null &&
-    (!/^\d+$/u.test(declared) ||
-      !Number.isSafeInteger(Number(declared)) ||
-      Number(declared) > MAXIMUM_PUBLICATION_BYTES)
-  ) {
-    await cancel(response.body)
-    throw sizeError(url)
-  }
-  if (response.body === null) return new Uint8Array()
-
-  const reader = response.body.getReader()
-  const chunks: Uint8Array[] = []
-  let size = 0
-  let complete = false
-  try {
-    for (;;) {
-      const next = await reader.read()
-      if (next.done) {
-        complete = true
-        break
-      }
-      if (next.value.byteLength === 0) continue
-      if (next.value.byteLength > MAXIMUM_PUBLICATION_BYTES - size) {
-        throw sizeError(url)
-      }
-      chunks.push(next.value)
-      size += next.value.byteLength
-    }
-  } finally {
-    if (!complete) await reader.cancel().catch(() => undefined)
-    reader.releaseLock()
-  }
-
-  const bytes = new Uint8Array(size)
-  let offset = 0
-  for (const chunk of chunks) {
-    bytes.set(chunk, offset)
-    offset += chunk.byteLength
-  }
-  return bytes
-}
-
-function sizeError(url: URL): Error {
-  return new Error(`GET ${url.href} exceeded ${MAXIMUM_PUBLICATION_BYTES} bytes`)
-}
-
-async function cancel(body: ReadableStream<Uint8Array> | null): Promise<void> {
-  if (body !== null) await body.cancel().catch(() => undefined)
-}
-
-function deploymentRoot(input: string): URL {
-  let url: URL
-  try {
-    url = new URL(input)
-  } catch {
-    throw new TypeError(`Domain deployment URL is invalid: ${input}`)
-  }
-  if (
-    !['http:', 'https:'].includes(url.protocol) ||
-    url.username !== '' ||
-    url.password !== '' ||
-    url.search !== '' ||
-    url.hash !== '' ||
-    !['', '/'].includes(url.pathname)
-  ) {
-    throw new TypeError(`Domain deployment URL must be an HTTP(S) origin: ${input}`)
-  }
-  return new URL(url.origin)
-}

package/src/lib/failure-debug.ts

@@ -1,26 +0,0 @@
-import chalk from 'chalk'
-
-const MAXIMUM_DEBUG_FAILURES = 32
-
-export function printFailureDebug(error: unknown, url: string): void {
-  process.stderr.write(`\n${chalk.dim('── debug ─────────────────')}\n`)
-  if (url) process.stderr.write(`${chalk.dim(`url:   ${url}`)}\n`)
-  const seen = new Set<unknown>()
-  const pending: Array<{ value: unknown; relation: string }> = [{ value: error, relation: 'error' }]
-  while (pending.length > 0 && seen.size < MAXIMUM_DEBUG_FAILURES) {
-    const { value, relation } = pending.shift()!
-    if (seen.has(value)) continue
-    seen.add(value)
-    if (!(value instanceof Error)) {
-      process.stderr.write(`${chalk.dim(`${relation}: ${String(value)}`)}\n`)
-      continue
-    }
-    process.stderr.write(
-      `${chalk.dim(`${relation}: ${value.constructor.name}: ${value.message}`)}\n`,
-    )
-    if (value.stack) process.stderr.write(`${chalk.dim(value.stack)}\n`)
-    if (value.cause !== undefined) pending.push({ value: value.cause, relation: 'caused by' })
-    if (value instanceof AggregateError)
-      for (const child of value.errors) pending.push({ value: child, relation: 'aggregate' })
-  }
-}

package/src/lib/format.ts

@@ -1,4 +0,0 @@
-export function formatElapsed(ms: number): string {
-  if (ms < 1000) return `${Math.round(ms)}ms`
-  return `${(ms / 1000).toFixed(2)}s`
-}

package/src/lib/idp-session.ts

@@ -1,134 +0,0 @@
-import { withFileLock } from '../state/index'
-import {
-  accessTokenForAudience,
-  classifyRefreshFailure,
-  idpSessionPath,
-  OAuthTokenError,
-  readIdpSession,
-  refreshSession,
-  type IdpSession,
-} from './idp'
-import { orgIdForAudience } from './instance'
-import { fetchOrgHint } from './meta'
-
-/** No cached session file exists for the identity — only a login creates one. */
-export class IdpSessionMissingError extends Error {
-  readonly identityName: string
-
-  constructor(identityName: string) {
-    super(`No cached IdP session for "${identityName}"`)
-    this.name = 'IdpSessionMissingError'
-    this.identityName = identityName
-  }
-}
-
-/** The session needs a refresh but never received a refresh token. */
-export class IdpSessionNoRefreshTokenError extends Error {
-  readonly identityName: string
-
-  constructor(identityName: string) {
-    super(`IdP session for "${identityName}" has no refresh token`)
-    this.name = 'IdpSessionNoRefreshTokenError'
-    this.identityName = identityName
-  }
-}
-
-export type EnsureFreshSessionOptions = {
-  audience?: string
-  organizationId?: string
-  /**
-   * Org-hint resolver, consulted only when a refresh actually happens.
-   * Defaults to `fetchOrgHint`; injectable for tests.
-   */
-  resolveOrganizationId?: (audience: string) => Promise<string | undefined>
-}
-
-export function idpSessionLockPath(identityName: string): string {
-  // Lives next to the session file; listIdpSessions only picks up *.json.
-  return `${idpSessionPath(identityName)}.lock`
-}
-
-/**
- * Return a session holding a fresh access token for `audience`, refreshing it
- * if needed. This is the ONLY correct way to refresh: WorkOS refresh tokens
- * are single-use, so two processes refreshing concurrently burn the same
- * token — the loser's `invalid_grant` can revoke the whole upstream session.
- * All refreshes therefore serialize on a per-identity file lock, and waiters
- * re-read the rotated session instead of re-exchanging.
- *
- * `IdpAudienceMismatchError` propagates verbatim (the session is healthy; the
- * IdP just won't mint that audience).
- */
-export async function ensureFreshSession(
-  identityName: string,
-  opts: EnsureFreshSessionOptions = {},
-): Promise<IdpSession> {
-  const session = await readIdpSession(identityName)
-  if (!session) throw new IdpSessionMissingError(identityName)
-  if (accessTokenForAudience(session, opts.audience)) return session
-  if (!session.refresh_token) throw new IdpSessionNoRefreshTokenError(identityName)
-
-  return withFileLock(idpSessionLockPath(identityName), async () => {
-    // Re-read under the lock: a process that held the lock before us may have
-    // already rotated the session — using its result is the whole point.
-    const current = await readIdpSession(identityName)
-    if (!current) throw new IdpSessionMissingError(identityName)
-    if (accessTokenForAudience(current, opts.audience)) return current
-
-    // Org resolution order: explicit > bookmarked-at-create > router lookup.
-    const bookmarkOrg =
-      opts.organizationId ?? (opts.audience ? await orgIdForAudience(opts.audience) : undefined)
-    const organizationId =
-      bookmarkOrg ??
-      (opts.audience
-        ? await (opts.resolveOrganizationId ?? fetchOrgHint)(opts.audience)
-        : undefined)
-    try {
-      return await refreshSession(identityName, current, {
-        audience: opts.audience,
-        organizationId,
-      })
-    } catch (e) {
-      // A bookmarked org can go stale (instance deleted/recreated elsewhere).
-      // On an org rejection, retry once with the router's view and let the
-      // bookmark heal on the next `instance create`.
-      if (
-        bookmarkOrg &&
-        !opts.organizationId &&
-        opts.audience &&
-        classifyRefreshFailure(e) === 'org-rejected'
-      ) {
-        const routerOrg = await (opts.resolveOrganizationId ?? fetchOrgHint)(opts.audience)
-        if (routerOrg && routerOrg !== bookmarkOrg) {
-          return await refreshSession(identityName, current, {
-            audience: opts.audience,
-            organizationId: routerOrg,
-          })
-        }
-      }
-      const rescued = await rescueAfterInvalidGrant(identityName, current, opts.audience, e)
-      if (rescued) return rescued
-      throw e
-    }
-  })
-}
-
-/**
- * Last-resort race recovery: an `invalid_grant` ("refresh token already
- * exchanged") can mean a non-locking process — an older CLI build, or a
- * stale-lock takeover window — won the exchange and saved the rotated
- * session. If the file changed since we read it and now serves the audience,
- * use it instead of declaring the session dead.
- */
-async function rescueAfterInvalidGrant(
-  identityName: string,
-  seen: IdpSession,
-  audience: string | undefined,
-  error: unknown,
-): Promise<IdpSession | undefined> {
-  if (!(error instanceof OAuthTokenError) || error.code !== 'invalid_grant') return undefined
-  const latest = await readIdpSession(identityName).catch(() => null)
-  if (!latest || latest.updatedAt === seen.updatedAt) return undefined
-  if (!accessTokenForAudience(latest, audience)) return undefined
-  return latest
-}