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

package/src/lib/admin-instance.ts

@@ -1,56 +0,0 @@
-import type { AdminConnectionOptions, ConnectionContext } from '../connection'
-
-import { connectAdminInstances } from '../admin/instance'
-import { withAdminClientSession } from '../connection'
-
-export {
-  AdminInstanceNotFoundError,
-  findOwnedInstance,
-  formatInstanceState,
-  type InstanceInfo,
-  type InstanceState,
-  type OwnedInstanceInfo,
-} from '../admin/instance'
-
-/** Resolve the Admin target and read only the caller-visible Instance inventory. */
-export function listOwnedInstances(options: AdminConnectionOptions) {
-  return withAdminClientSession(options, async (context) =>
-    (await connectAdminInstances(context)).list(),
-  )
-}
-
-/** Read caller-visible inventory together with the exact local identity used for the Admin call. */
-export function listOwnedInstancesWithIdentity(options: AdminConnectionOptions) {
-  return withAdminClientSession(options, async (context) =>
-    Object.freeze({
-      instances: await (await connectAdminInstances(context)).list(),
-      ...(context.identity === undefined ? {} : { identity: context.identity }),
-    }),
-  )
-}
-
-/** Reuse an already-open Admin session for a caller-visible Instance inventory. */
-export async function listOwnedInstancesInContext(context: ConnectionContext) {
-  return (await connectAdminInstances(context)).list()
-}
-
-/** Request one managed Instance; Admin owns infrastructure placement. */
-export function createOwnedInstance(options: AdminConnectionOptions, slug: string) {
-  return withAdminClientSession(options, async (context) =>
-    (await connectAdminInstances(context)).create(slug),
-  )
-}
-
-/** Refresh one exact caller-visible Instance through its V2 receiver Method. */
-export function statusOwnedInstance(options: AdminConnectionOptions, identifier: string) {
-  return withAdminClientSession(options, async (context) =>
-    (await connectAdminInstances(context)).status(identifier),
-  )
-}
-
-/** Delete one exact caller-visible Instance through its V2 receiver Method. */
-export function deleteOwnedInstance(options: AdminConnectionOptions, identifier: string) {
-  return withAdminClientSession(options, async (context) =>
-    (await connectAdminInstances(context)).delete(identifier),
-  )
-}

package/src/lib/admin-target.ts

@@ -1,290 +0,0 @@
-import { z } from 'zod'
-
-import type { AstraleConfig } from './config'
-import type { InstanceStore } from './instance'
-
-import { AstraleError } from '../errors'
-import { readInstances, resolveInstanceKey } from './instance'
-import { DEFAULT_UPDATE_CHANNEL } from './update'
-import { isHttpUrl } from './validation'
-
-export const DEFAULT_ADMIN_TARGET_NAME = 'admin'
-
-export function defaultAdminTargetForChannel(channel: string): {
-  readonly url: string
-  readonly domainIssuer: string
-} {
-  return channel === 'stable'
-    ? {
-        url: 'https://admin.eu.astrale.ai/api',
-        domainIssuer: 'https://admin.astrale.ai',
-      }
-    : {
-        url: 'https://admin.eu.beta.astrale.ai/api',
-        domainIssuer: 'https://admin.beta.astrale.ai',
-      }
-}
-
-const DEFAULT_ADMIN_TARGET = defaultAdminTargetForChannel(DEFAULT_UPDATE_CHANNEL)
-
-export const DEFAULT_ADMIN_TARGET_URL = DEFAULT_ADMIN_TARGET.url
-export const DEFAULT_ADMIN_DOMAIN_ISSUER = DEFAULT_ADMIN_TARGET.domainIssuer
-
-export const DEFAULT_ADMIN_TARGET_CONFIG = {
-  name: DEFAULT_ADMIN_TARGET_NAME,
-  url: DEFAULT_ADMIN_TARGET_URL,
-  kernelIssuer: DEFAULT_ADMIN_TARGET_URL,
-  domainIssuer: DEFAULT_ADMIN_DOMAIN_ISSUER,
-} satisfies AdminTargetConfig
-
-const HttpUrlSchema = z.string().refine(isHttpUrl, {
-  message: 'expected a valid http:// or https:// URL',
-})
-
-export const AdminTargetConfigSchema = z
-  .object({
-    /** Friendly name / auth registration slug for direct URL admin targets. */
-    name: z.string().min(1).optional(),
-    /** Direct admin kernel URL. */
-    url: HttpUrlSchema.optional(),
-    /** Kernel issuer / JWT audience when different from url. */
-    kernelIssuer: HttpUrlSchema.optional(),
-    /** Exact native Admin Domain issuer used by the standard token exchange. */
-    domainIssuer: HttpUrlSchema.optional(),
-    /** Bookmark name for the admin kernel. */
-    instance: z.string().min(1).optional(),
-  })
-  .superRefine((value, ctx) => {
-    if (value.url && value.instance) {
-      ctx.addIssue({
-        code: 'custom',
-        path: ['instance'],
-        message: 'admin target must use either url or instance, not both',
-      })
-    }
-    if (!value.url && !value.instance) {
-      ctx.addIssue({
-        code: 'custom',
-        message: 'admin target requires url or instance',
-      })
-    }
-    if (value.kernelIssuer && !value.url) {
-      ctx.addIssue({
-        code: 'custom',
-        path: ['kernelIssuer'],
-        message: 'admin kernel issuer is only valid with a direct url target',
-      })
-    }
-    if (value.domainIssuer && !value.url) {
-      ctx.addIssue({
-        code: 'custom',
-        path: ['domainIssuer'],
-        message: 'admin domain issuer is only valid with a direct url target',
-      })
-    }
-  })
-
-export type AdminTargetConfig = z.infer<typeof AdminTargetConfigSchema>
-
-export type AdminTargetCommandOpts = {
-  admin?: string
-  adminUrl?: string
-  domainIssuer?: string
-  instance?: string
-  url?: string
-}
-
-export type AdminTargetSource = 'admin-url' | 'admin' | 'config-instance' | 'config-url' | 'default'
-
-export type ResolvedAdminTarget = {
-  name: string
-  url: string
-  kernelIssuer: string
-  domainIssuer: string
-  defaultIdentity?: string
-  caFile?: string
-  source: AdminTargetSource
-  configured: boolean
-  registrationSlug: string
-}
-
-export const ADMIN_TARGET_OPTIONS = [
-  {
-    flags: '--admin <name>',
-    description: 'Admin kernel bookmark to use for this admin operation',
-  },
-  {
-    flags: '--admin-url <url>',
-    description: 'Admin kernel URL to use for this admin operation',
-  },
-  {
-    flags: '--domain-issuer <url>',
-    description: 'Admin Domain issuer used for token exchange with an explicit URL',
-  },
-]
-
-export async function resolveAdminTarget(
-  opts: AdminTargetCommandOpts,
-  config: AstraleConfig,
-  store?: InstanceStore,
-): Promise<ResolvedAdminTarget> {
-  return resolveAdminTargetFromStore(opts, config, store ?? (await readInstances()))
-}
-
-export function resolveAdminTargetFromStore(
-  opts: AdminTargetCommandOpts,
-  config: AstraleConfig,
-  store: InstanceStore,
-): ResolvedAdminTarget {
-  const override = readOverride(opts)
-  if (override) {
-    if (override.kind === 'instance' && opts.domainIssuer !== undefined) {
-      throw new AstraleError(
-        'INVALID_FLAG',
-        '--domain-issuer is only valid with --admin-url or --url.',
-      )
-    }
-    return override.kind === 'url'
-      ? directTarget({
-          url: override.url,
-          name: DEFAULT_ADMIN_TARGET_NAME,
-          source: override.source,
-          configured: false,
-          domainIssuer: opts.domainIssuer ?? config.admin.domainIssuer,
-        })
-      : bookmarkTarget(
-          store,
-          override.instance,
-          override.source,
-          false,
-          config.admin.domainIssuer ?? DEFAULT_ADMIN_DOMAIN_ISSUER,
-        )
-  }
-
-  const admin = config.admin
-  if (admin.instance) {
-    return bookmarkTarget(
-      store,
-      admin.instance,
-      'config-instance',
-      true,
-      admin.domainIssuer ?? DEFAULT_ADMIN_DOMAIN_ISSUER,
-    )
-  }
-
-  const isDefaultDirectTarget =
-    admin.url === DEFAULT_ADMIN_TARGET_URL &&
-    admin.kernelIssuer === DEFAULT_ADMIN_TARGET_URL &&
-    (admin.domainIssuer ?? DEFAULT_ADMIN_DOMAIN_ISSUER) === DEFAULT_ADMIN_DOMAIN_ISSUER &&
-    admin.name === DEFAULT_ADMIN_TARGET_NAME
-
-  return directTarget({
-    url: admin.url ?? DEFAULT_ADMIN_TARGET_URL,
-    kernelIssuer: admin.kernelIssuer,
-    domainIssuer: admin.domainIssuer ?? DEFAULT_ADMIN_DOMAIN_ISSUER,
-    name: admin.name ?? DEFAULT_ADMIN_TARGET_NAME,
-    source: isDefaultDirectTarget ? 'default' : 'config-url',
-    configured: !isDefaultDirectTarget,
-  })
-}
-
-function readOverride(opts: AdminTargetCommandOpts):
-  | { kind: 'url'; url: string; source: AdminTargetSource }
-  | {
-      kind: 'instance'
-      instance: string
-      source: AdminTargetSource
-    }
-  | null {
-  const selected = [
-    opts.adminUrl ? { label: '--admin-url', kind: 'url' as const, value: opts.adminUrl } : null,
-    opts.admin ? { label: '--admin', kind: 'instance' as const, value: opts.admin } : null,
-    opts.url ? { label: '--url', kind: 'url' as const, value: opts.url } : null,
-    opts.instance
-      ? { label: '-i/--instance', kind: 'instance' as const, value: opts.instance }
-      : null,
-  ].filter((entry): entry is NonNullable<typeof entry> => entry !== null)
-
-  if (selected.length > 1) {
-    throw new AstraleError(
-      'INVALID_FLAG',
-      `Choose one admin target override, not ${selected.map((entry) => entry.label).join(', ')}`,
-      'Use --admin <bookmark> or --admin-url <url> for admin operations.',
-    )
-  }
-
-  const first = selected[0]
-  if (!first) return null
-  if (first.kind === 'url') {
-    return {
-      kind: 'url',
-      url: first.value,
-      source: 'admin-url',
-    }
-  }
-  return {
-    kind: 'instance',
-    instance: first.value,
-    source: 'admin',
-  }
-}
-
-function bookmarkTarget(
-  store: InstanceStore,
-  identifier: string,
-  source: AdminTargetSource,
-  configured: boolean,
-  domainIssuer: string,
-): ResolvedAdminTarget {
-  const key = resolveInstanceKey(store, identifier)
-  const entry = key ? store.instances[key] : undefined
-  if (!key || !entry?.url) {
-    throw new AstraleError(
-      'ADMIN_TARGET_NOT_FOUND',
-      `Admin target "${identifier}" is not bookmarked.`,
-      `Bookmark it first: astrale instance bookmark ${identifier} --url <admin-url>`,
-    )
-  }
-  return {
-    name: key,
-    registrationSlug: key,
-    url: entry.url,
-    kernelIssuer: entry.issuer ?? entry.url,
-    domainIssuer: requireDomainIssuer(
-      entry.domainIssuer ?? (configured ? domainIssuer : undefined),
-      `Admin bookmark "${key}"`,
-    ),
-    defaultIdentity: entry.defaultIdentity,
-    ...(entry.caFile ? { caFile: entry.caFile } : {}),
-    source,
-    configured,
-  }
-}
-
-function directTarget(input: {
-  url: string
-  kernelIssuer?: string
-  domainIssuer?: string
-  name: string
-  source: AdminTargetSource
-  configured: boolean
-}): ResolvedAdminTarget {
-  return {
-    name: input.name,
-    registrationSlug: input.name,
-    url: input.url,
-    kernelIssuer: input.kernelIssuer ?? input.url,
-    domainIssuer: requireDomainIssuer(input.domainIssuer, 'Direct Admin target'),
-    source: input.source,
-    configured: input.configured,
-  }
-}
-
-function requireDomainIssuer(value: string | undefined, label: string): string {
-  if (value !== undefined) return value
-  throw new AstraleError(
-    'ADMIN_DOMAIN_ISSUER_MISSING',
-    `${label} has no Domain issuer for token exchange.`,
-    'Configure domainIssuer or pass --domain-issuer <url>; there is no legacy token fallback.',
-  )
-}

package/src/lib/binary.ts

@@ -1,127 +0,0 @@
-import chalk from 'chalk'
-import { writeFile } from 'node:fs/promises'
-
-import type { OutputOpts } from './output'
-
-import { output } from './output'
-
-/** A binary kernel result: bytes (or a stream of them) plus its content-type. */
-export type BinaryLike = {
-  readonly body: Uint8Array | AsyncIterable<Uint8Array>
-  readonly mediaType: string
-  readonly status?: number
-  readonly headers?: Readonly<Record<string, string>>
-}
-
-/** Collapse a (possibly streamed) binary body into a single byte array. */
-export async function readBinaryBody(
-  body: Uint8Array | AsyncIterable<Uint8Array>,
-): Promise<Uint8Array> {
-  if (body instanceof Uint8Array) return new Uint8Array(body)
-  const chunks: Uint8Array[] = []
-  let size = 0
-  for await (const chunk of body) {
-    const detached = new Uint8Array(chunk)
-    chunks.push(detached)
-    size += detached.byteLength
-  }
-  const bytes = new Uint8Array(size)
-  let offset = 0
-  for (const chunk of chunks) {
-    bytes.set(chunk, offset)
-    offset += chunk.byteLength
-  }
-  return bytes
-}
-
-function isTextLike(contentType: string): boolean {
-  const ct = contentType.toLowerCase()
-  return (
-    ct.startsWith('text/') ||
-    ct.includes('json') ||
-    ct.includes('xml') ||
-    ct.includes('event-stream')
-  )
-}
-
-function humanSize(bytes: number): string {
-  if (bytes < 1024) return `${bytes} B`
-  const units = ['kB', 'MB', 'GB']
-  let v = bytes / 1024
-  let i = 0
-  while (v >= 1024 && i < units.length - 1) {
-    v /= 1024
-    i++
-  }
-  return `${v.toFixed(1)} ${units[i]}`
-}
-
-/** The `--json` envelope: text-like inlines decoded text, otherwise base64. */
-function jsonEnvelope(resp: BinaryLike, bytes: Uint8Array): Record<string, unknown> {
-  if (isTextLike(resp.mediaType)) {
-    return {
-      status: resp.status ?? 200,
-      contentType: resp.mediaType,
-      body: new TextDecoder().decode(bytes),
-    }
-  }
-  return {
-    status: resp.status ?? 200,
-    contentType: resp.mediaType,
-    bodyBase64: Buffer.from(bytes).toString('base64'),
-  }
-}
-
-/**
- * Present a binary kind result.
- *
- * Precedence:
- *   -o <file>       → write raw bytes to a file (+ a dim summary on stderr)
- *   --raw           → raw bytes to stdout
- *   --json          → base64/text-wrapped JSON object (jq-friendly)
- *   non-TTY (pipe)  → raw bytes to stdout (`astrale call … > out.png`)
- *   TTY, text-like  → decode and print the text
- *   TTY, otherwise  → a one-line summary (don't spew binary at a terminal)
- */
-export async function presentBinary(
-  resp: BinaryLike,
-  opts: OutputOpts,
-  io?: { outFile?: string },
-): Promise<void> {
-  const bytes = await readBinaryBody(resp.body)
-
-  if (io?.outFile) {
-    await writeFile(io.outFile, bytes)
-    process.stderr.write(
-      chalk.dim(`  wrote ${humanSize(bytes.length)} (${resp.mediaType}) → ${io.outFile}\n`),
-    )
-    return
-  }
-
-  if (opts.raw) {
-    process.stdout.write(bytes)
-    return
-  }
-
-  if (opts.json) {
-    output(jsonEnvelope(resp, bytes), opts)
-    return
-  }
-
-  if (!(process.stdout.isTTY ?? false)) {
-    process.stdout.write(bytes)
-    return
-  }
-
-  if (isTextLike(resp.mediaType)) {
-    const text = new TextDecoder().decode(bytes)
-    process.stdout.write(text.endsWith('\n') ? text : text + '\n')
-    return
-  }
-
-  process.stdout.write(
-    chalk.dim(
-      `  <binary · ${resp.mediaType} · ${humanSize(bytes.length)}> — pipe or use -o <file> to save\n`,
-    ),
-  )
-}

package/src/lib/browser-retention.ts

@@ -1,210 +0,0 @@
-/**
- * Browser-profile retention.
- *
- * `astrale browser` keeps one persistent Chromium profile per host so the
- * WorkOS cookie survives between runs. That cookie is a few kilobytes;
- * everything Chromium accumulates around it is cache, and it accumulates
- * without limit — a real profile here reached 373 MB, 98% of it cache.
- *
- * Chromium will not bound it for us. `--disk-cache-size` is measurably ignored
- * for a profile's HTTP cache — the largest component by far — so deleting is
- * the only lever. Two rules, cheapest first:
- *
- *   1. A profile untouched for longer than the age bound goes entirely. Its
- *      WorkOS cookie has expired anyway, so it holds nothing worth the disk.
- *   2. A surviving profile whose cache exceeds the size bound has its cache
- *      directories removed. Cookies, Local Storage, Preferences and Local State
- *      are never touched — the whole point of the profile is that the session
- *      outlives the sweep.
- *
- * A profile whose SingletonLock names a live process is always left alone:
- * deleting files under a running Chromium is how profiles get corrupted.
- */
-import { readlinkSync } from 'node:fs'
-import { readdir, rm, stat } from 'node:fs/promises'
-import { join } from 'node:path'
-
-import { BROWSER_DIR } from './browser'
-import { readConfig } from './config'
-
-/** Reconstructible directories, relative to a profile root. Everything here can
- *  be deleted with no user-visible consequence beyond a colder first load. */
-const CACHE_PATHS = [
-  'Default/Cache',
-  'Default/Code Cache',
-  'Default/GPUCache',
-  'Default/DawnWebGPUCache',
-  'Default/DawnGraphiteCache',
-  'Default/Service Worker/CacheStorage',
-  'Default/Service Worker/ScriptCache',
-  'GraphiteDawnCache',
-  'GPUPersistentCache',
-  'GrShaderCache',
-  'ShaderCache',
-  'component_crx_cache',
-  'extensions_crx_cache',
-] as const
-
-export const DEFAULT_MAX_CACHE_BYTES = 50 * 1024 * 1024
-export const DEFAULT_MAX_PROFILE_AGE_DAYS = 30
-
-export type BrowserRetentionBudget = {
-  /** Cap on one profile's cache directories, not on the profile as a whole. */
-  maxCacheBytes: number
-  maxProfileAgeMs: number
-}
-
-export type BrowserSweepResult = {
-  /** Profiles deleted outright (dormant past the age bound). */
-  removed: string[]
-  /** Profiles kept, cache emptied (over the size bound). */
-  purged: string[]
-  /** Profiles a live browser was holding — left untouched. */
-  skipped: string[]
-  bytesFreed: number
-}
-
-const EMPTY: BrowserSweepResult = { removed: [], purged: [], skipped: [], bytesFreed: 0 }
-
-/** First finite, strictly positive candidate; anything else falls through to
- *  the next one, and ultimately to the default. A typo must not mean "no cap". */
-function firstPositive(candidates: (number | string | undefined)[]): number | null {
-  for (const candidate of candidates) {
-    if (candidate === undefined) continue
-    const n = typeof candidate === 'string' ? Number(candidate.trim()) : candidate
-    if (Number.isFinite(n) && n > 0) return n
-  }
-  return null
-}
-
-/** Resolved budget: env over config over defaults. */
-export async function browserRetentionBudget(): Promise<BrowserRetentionBudget> {
-  const browser = (await readConfig().catch(() => null))?.browser
-  const bytes =
-    firstPositive([process.env.ASTRALE_BROWSER_MAX_CACHE_BYTES, browser?.maxCacheBytes]) ??
-    DEFAULT_MAX_CACHE_BYTES
-  const days =
-    firstPositive([process.env.ASTRALE_BROWSER_MAX_PROFILE_AGE_DAYS, browser?.maxProfileAgeDays]) ??
-    DEFAULT_MAX_PROFILE_AGE_DAYS
-  return { maxCacheBytes: bytes, maxProfileAgeMs: days * 24 * 60 * 60 * 1000 }
-}
-
-/** True when a process with this pid exists. EPERM means it exists but is not
- *  ours — still alive, and still a reason not to touch the profile. */
-function isLive(pid: number): boolean {
-  try {
-    process.kill(pid, 0)
-    return true
-  } catch (e) {
-    return (e as NodeJS.ErrnoException).code === 'EPERM'
-  }
-}
-
-/**
- * Whether a live browser holds this profile. SingletonLock is a symlink whose
- * target is `<hostname>-<pid>` and which does NOT resolve to a real file, so it
- * must be read with readlink, never stat'ed. A stale lock (dead pid) is not a
- * reason to skip — Chromium leaves those behind after a crash.
- */
-export function heldByLiveBrowser(profileDir: string): boolean {
-  let target: string
-  try {
-    target = readlinkSync(join(profileDir, 'SingletonLock'))
-  } catch {
-    return false
-  }
-  const pid = Number(target.slice(target.lastIndexOf('-') + 1))
-  return Number.isInteger(pid) && pid > 0 && isLive(pid)
-}
-
-/** Bytes under `dir`, or 0 when it is missing or unreadable. */
-async function directoryBytes(dir: string): Promise<number> {
-  let entries
-  try {
-    entries = await readdir(dir, { withFileTypes: true })
-  } catch {
-    return 0
-  }
-  let total = 0
-  for (const entry of entries) {
-    const path = join(dir, entry.name)
-    if (entry.isDirectory()) {
-      total += await directoryBytes(path)
-    } else if (entry.isFile()) {
-      try {
-        total += (await stat(path)).size
-      } catch {
-        /* raced away mid-walk */
-      }
-    }
-  }
-  return total
-}
-
-/** Cumulative size of one profile's cache directories. */
-export async function profileCacheBytes(profileDir: string): Promise<number> {
-  let total = 0
-  for (const relative of CACHE_PATHS) total += await directoryBytes(join(profileDir, relative))
-  return total
-}
-
-/** Delete every cache directory of a profile; returns bytes actually freed. */
-async function purgeCache(profileDir: string): Promise<number> {
-  const before = await profileCacheBytes(profileDir)
-  for (const relative of CACHE_PATHS) {
-    await rm(join(profileDir, relative), { recursive: true, force: true }).catch(() => {
-      /* best effort — retention must never break the browser command */
-    })
-  }
-  return before - (await profileCacheBytes(profileDir))
-}
-
-/**
- * Apply both rules across every profile under `dir`. Never throws: a failed
- * sweep must not stop the user from driving a browser.
- */
-export async function sweepBrowserProfiles(
-  options: { dir?: string; budget?: BrowserRetentionBudget; now?: number } = {},
-): Promise<BrowserSweepResult> {
-  const dir = options.dir ?? BROWSER_DIR
-  let names: string[]
-  try {
-    names = (await readdir(dir, { withFileTypes: true }))
-      .filter((e) => e.isDirectory())
-      .map((e) => e.name)
-  } catch {
-    return EMPTY
-  }
-  if (names.length === 0) return EMPTY
-
-  const budget = options.budget ?? (await browserRetentionBudget())
-  const now = options.now ?? Date.now()
-  const result: BrowserSweepResult = { removed: [], purged: [], skipped: [], bytesFreed: 0 }
-
-  for (const name of names) {
-    const profileDir = join(dir, name)
-    if (heldByLiveBrowser(profileDir)) {
-      result.skipped.push(name)
-      continue
-    }
-    try {
-      // The profile root's mtime tracks USE, not writes: Chromium rewrites
-      // SingletonLock and DevToolsActivePort there on every launch, while cache
-      // writes land in subdirectories and leave the root alone.
-      const idleMs = now - (await stat(profileDir)).mtime.getTime()
-      if (idleMs > budget.maxProfileAgeMs) {
-        result.bytesFreed += await directoryBytes(profileDir)
-        await rm(profileDir, { recursive: true, force: true })
-        result.removed.push(name)
-        continue
-      }
-      if ((await profileCacheBytes(profileDir)) > budget.maxCacheBytes) {
-        result.bytesFreed += await purgeCache(profileDir)
-        result.purged.push(name)
-      }
-    } catch {
-      /* best effort, per profile — one bad profile must not stop the sweep */
-    }
-  }
-  return result
-}