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

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,110 +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
-  readonly mediaType: string
-  readonly headers?: Readonly<Record<string, string>>
-}
-
-/** Collapse a (possibly streamed) binary body into a single byte array. */
-export async function readBinaryBody(body: Uint8Array): Promise<Uint8Array> {
-  return body
-}
-
-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: 200,
-      contentType: resp.mediaType,
-      body: new TextDecoder().decode(bytes),
-    }
-  }
-  return {
-    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.ts

@@ -1,150 +0,0 @@
-import { mkdir, readFile, writeFile } from 'node:fs/promises'
-import { join } from 'node:path'
-
-import { paths } from '../state/index'
-import { run } from './proc'
-
-/**
- * `astrale browser` is a thin orchestrator over `agent-browser`
- * (https://github.com/vercel-labs/agent-browser) — the Rust browser-automation
- * CLI that AI agents drive. We own only the *session*: resolve the active
- * instance's GUI origin, pin a persistent per-instance profile so the WorkOS
- * login cookie survives across runs, and verify auth. Driving (snapshot/click/
- * eval/…) is agent-browser's job, invoked directly by the agent afterward.
- *
- * Why a profile and not an injected token: the GUI session is an httpOnly
- * sealed cookie (`astrale_router_session`) with no token-injection path, so the
- * only way to "use my session" is to drive a browser whose profile already
- * holds the cookie — minted once via interactive login, reused thereafter.
- */
-
-export const BROWSER_DIR = join(paths.home, 'browser')
-export const BROWSER_SESSION_PATH = join(paths.home, 'browser.json')
-export const AGENT_BROWSER_REPO = 'vercel-labs/agent-browser'
-
-/** Per-instance persistent profile dir handed to `agent-browser --profile`. */
-export function profileDirFor(host: string): string {
-  return join(BROWSER_DIR, host)
-}
-
-/** The last-connected browser session, read by agents to know how to drive. */
-export type BrowserSession = {
-  /** GUI origin, e.g. `https://alpha1.eu.astrale.ai`. */
-  url: string
-  host: string
-  /** Profile dir, or null when attached to an external Chrome over CDP. */
-  profile: string | null
-  /** CDP endpoint (`9222` or a ws URL) when in attach mode. */
-  cdp: string | null
-  email?: string
-  updatedAt: string
-}
-
-export async function readSession(): Promise<BrowserSession | null> {
-  try {
-    return JSON.parse(await readFile(BROWSER_SESSION_PATH, 'utf8')) as BrowserSession
-  } catch {
-    return null
-  }
-}
-
-export async function saveSession(session: BrowserSession): Promise<void> {
-  await mkdir(paths.home, { recursive: true })
-  await writeFile(BROWSER_SESSION_PATH, `${JSON.stringify(session, null, 2)}\n`)
-}
-
-/** Resolve `agent-browser` on PATH; null when not installed. */
-export async function findAgentBrowser(): Promise<string | null> {
-  // `command -v` is a POSIX shell builtin (no `command` executable exists on
-  // Windows), so resolve via `where` on Windows and a shell on Unix.
-  const lookup =
-    process.platform === 'win32'
-      ? run('where', ['agent-browser'])
-      : run('sh', ['-c', 'command -v agent-browser'])
-  const res = await lookup.catch(() => null)
-  if (!res || res.code !== 0) return null
-  const path = res.stdout.split(/\r?\n/)[0]?.trim()
-  return path || null
-}
-
-export type AbResult = {
-  ok: boolean
-  data: unknown
-  error: string | null
-}
-
-/**
- * Connection target for an agent-browser invocation: either a persistent
- * profile dir or a CDP endpoint (mutually exclusive).
- */
-export type AbTarget = { profile?: string; cdp?: string }
-
-/**
- * Run an `agent-browser` command with `--json` and parse its envelope
- * (`{success, data, error}`). Global flags (`--profile`/`--cdp`/`--headed`)
- * precede the subcommand; `--json` trails the args, matching the CLI's parser.
- */
-export async function ab(
-  args: string[],
-  opts: AbTarget & { headed?: boolean } = {},
-): Promise<AbResult> {
-  const argv = ['agent-browser']
-  if (opts.profile) argv.push('--profile', opts.profile)
-  if (opts.cdp) argv.push('--cdp', opts.cdp)
-  if (opts.headed) argv.push('--headed')
-  argv.push(...args, '--json')
-
-  const { code, stdout, stderr } = await run(argv[0], argv.slice(1))
-
-  try {
-    const parsed = JSON.parse(stdout) as { success?: boolean; data?: unknown; error?: string }
-    if (parsed && typeof parsed === 'object' && 'success' in parsed) {
-      return { ok: !!parsed.success, data: parsed.data ?? null, error: parsed.error ?? null }
-    }
-  } catch {
-    // fall through to exit-code interpretation
-  }
-  return { ok: code === 0, data: null, error: stderr.trim() || null }
-}
-
-// Reads the GUI session from whatever origin the page currently sits on. During
-// an interactive login the page is on the IdP origin, where `/auth/me` 404s and
-// the fetch rejects → {authed:false}; once the router redirects back to the GUI
-// it resolves to the authenticated user. Returned as a value (not top-level
-// await — agent-browser's `eval` forbids it) so page.evaluate auto-resolves it.
-const AUTH_EVAL =
-  "fetch('/auth/me',{credentials:'include'})" +
-  '.then(r=>r.json())' +
-  '.then(j=>({authed:!!j.authenticated,email:j.user&&j.user.email}))' +
-  '.catch(()=>({authed:false}))'
-
-export type AuthState = { authed: boolean; email?: string }
-
-function readAuthResult(res: AbResult): AuthState {
-  const result = (res.data as { result?: unknown } | null)?.result
-  if (result && typeof result === 'object') {
-    const r = result as { authed?: boolean; email?: string }
-    return { authed: !!r.authed, email: r.email }
-  }
-  return { authed: false }
-}
-
-/**
- * Poll auth on the current page (no navigation — safe during login redirects).
- * Pass `headed:true` while a sign-in window is open: agent-browser defaults to
- * headless, so an unflagged command flips the live window back to headless and
- * closes it.
- */
-export async function pollAuth(target: AbTarget & { headed?: boolean }): Promise<AuthState> {
-  return readAuthResult(await ab(['eval', AUTH_EVAL], target))
-}
-
-/** Navigate to the GUI, then read auth (used for the silent reuse check). */
-export async function navigateAndCheck(
-  url: string,
-  target: AbTarget & { headed?: boolean },
-): Promise<AuthState> {
-  const opened = await ab(['open', url], target)
-  if (!opened.ok) return { authed: false }
-  return pollAuth(target)
-}