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

package/src/lib/update.ts

@@ -1,409 +0,0 @@
-import { createHash } from 'node:crypto'
-import {
-  chmod,
-  copyFile,
-  mkdir,
-  mkdtemp,
-  readFile,
-  realpath,
-  rename,
-  rm,
-  writeFile,
-} from 'node:fs/promises'
-import { tmpdir } from 'node:os'
-import { dirname, join } from 'node:path'
-import { z } from 'zod'
-
-import { AstraleError } from '../errors'
-import { INSTALL_PATH } from '../state/index'
-import { run } from './proc'
-
-const DEFAULT_REPO = 'astrale-os/cli'
-export const DEFAULT_UPDATE_CHANNEL = 'beta'
-
-export const InstallMetadataSchema = z.object({
-  method: z.literal('script'),
-  channel: z.string().min(1).default(DEFAULT_UPDATE_CHANNEL),
-  version: z.string().min(1).optional(),
-  repo: z.string().min(1).default(DEFAULT_REPO),
-  bin: z.string().min(1),
-  installedAt: z.string().optional(),
-})
-
-export type InstallMetadata = z.infer<typeof InstallMetadataSchema>
-
-const ManifestAssetSchema = z.object({
-  name: z.string().min(1),
-  sha256: z
-    .string()
-    .regex(/^[a-fA-F0-9]{64}$/)
-    .optional(),
-})
-
-export const UpdateManifestSchema = z.object({
-  version: z.string().min(1),
-  binaryVersion: z.string().min(1).optional(),
-  channel: z.string().min(1),
-  repo: z.string().min(1).optional(),
-  assets: z.record(
-    z.string(),
-    z.union([
-      ManifestAssetSchema,
-      z
-        .string()
-        .min(1)
-        .transform((name) => ({ name })),
-    ]),
-  ),
-})
-
-export type UpdateManifest = z.infer<typeof UpdateManifestSchema>
-
-export type Platform = {
-  os: 'darwin' | 'linux'
-  arch: 'arm64' | 'x64'
-}
-
-export type UpdateRequest = {
-  check?: boolean
-  channel?: string
-  version?: string
-  currentVersion: string
-  platform?: Platform
-  installPath?: string
-  execution?: UpdateExecution
-}
-
-export type UpdateExecution =
-  | { kind: 'standalone'; executable: string }
-  | { kind: 'package-managed'; executable: string }
-
-const admittedScriptInstall = Symbol('admittedScriptInstall')
-export type AdmittedScriptInstall = Readonly<{
-  metadata: InstallMetadata
-  executable: string
-  [admittedScriptInstall]: true
-}>
-
-export type UpdateResult =
-  | {
-      status: 'managed'
-      currentVersion: string
-      executable: string
-    }
-  | {
-      status: 'up-to-date'
-      currentVersion: string
-      latestVersion: string
-      channel: string
-    }
-  | {
-      status: 'available'
-      currentVersion: string
-      latestVersion: string
-      channel: string
-    }
-  | {
-      status: 'updated'
-      previousVersion: string
-      currentVersion: string
-      channel: string
-      bin: string
-    }
-
-export function detectPlatform(): Platform {
-  const os = process.platform
-  const arch = process.arch
-  if (os !== 'darwin' && os !== 'linux') {
-    throw new AstraleError(
-      'UNSUPPORTED_PLATFORM',
-      `Unsupported OS "${os}" — Astrale update supports macOS and Linux.`,
-    )
-  }
-  if (arch !== 'arm64' && arch !== 'x64') {
-    throw new AstraleError(
-      'UNSUPPORTED_PLATFORM',
-      `Unsupported CPU architecture "${arch}" — Astrale update supports arm64 and x64.`,
-    )
-  }
-  return { os, arch }
-}
-
-export function platformKey(platform: Platform): string {
-  return `${platform.os}-${platform.arch}`
-}
-
-export function classifyUpdateExecution(input: {
-  bunVersion?: string
-  executable: string
-  entry?: string
-}): UpdateExecution {
-  return input.bunVersion && input.entry?.startsWith('/$bunfs/')
-    ? { kind: 'standalone', executable: input.executable }
-    : { kind: 'package-managed', executable: input.executable }
-}
-
-export function detectUpdateExecution(): UpdateExecution {
-  return classifyUpdateExecution({
-    bunVersion: (process.versions as { bun?: string }).bun,
-    executable: process.execPath,
-    entry: process.argv[1],
-  })
-}
-
-export function packageManagedUpdateError(executable: string): AstraleError {
-  return new AstraleError(
-    'UPDATE_PACKAGE_MANAGED',
-    'This Astrale build is managed by your package manager.',
-    `Active binary: ${executable}. Update it with npm, pnpm, or bun; or put the official script installation first on PATH.`,
-  )
-}
-
-export async function readInstallMetadata(path = INSTALL_PATH): Promise<InstallMetadata> {
-  let raw: string
-  try {
-    raw = await readFile(path, 'utf8')
-  } catch (error) {
-    if (!isMissingFile(error)) throw error
-    throw new AstraleError(
-      'UPDATE_NOT_SCRIPT_INSTALLED',
-      'Astrale was not installed by the official install script.',
-      'Reinstall with: curl -fsSL https://raw.githubusercontent.com/astrale-os/cli/main/install.sh | sh',
-    )
-  }
-
-  let decoded: unknown
-  try {
-    decoded = JSON.parse(raw)
-  } catch {
-    throw badInstallMetadata(path)
-  }
-  const parsed = InstallMetadataSchema.safeParse(decoded)
-  if (!parsed.success) {
-    throw badInstallMetadata(path)
-  }
-  return parsed.data
-}
-
-function isMissingFile(error: unknown): error is NodeJS.ErrnoException {
-  return error instanceof Error && 'code' in error && error.code === 'ENOENT'
-}
-
-function badInstallMetadata(path: string): AstraleError {
-  return new AstraleError(
-    'UPDATE_BAD_INSTALL_METADATA',
-    `Invalid install metadata at ${path}.`,
-    'Reinstall with: curl -fsSL https://raw.githubusercontent.com/astrale-os/cli/main/install.sh | sh',
-  )
-}
-
-export async function admitScriptInstall(
-  meta: InstallMetadata,
-  execution: Extract<UpdateExecution, { kind: 'standalone' }>,
-): Promise<AdmittedScriptInstall> {
-  const [running, recorded] = await Promise.all([
-    realpathIfExists(execution.executable),
-    realpathIfExists(meta.bin),
-  ])
-  if (running === undefined || recorded === undefined || running !== recorded) {
-    throw new AstraleError(
-      'UPDATE_INSTALL_MISMATCH',
-      'The running Astrale binary does not own the recorded script installation.',
-      `Running binary: ${execution.executable}; recorded binary: ${meta.bin}. Refusing to replace a different installation.`,
-    )
-  }
-  return Object.freeze({
-    metadata: meta,
-    executable: running,
-    [admittedScriptInstall]: true as const,
-  })
-}
-
-async function realpathIfExists(path: string): Promise<string | undefined> {
-  try {
-    return await realpath(path)
-  } catch (error) {
-    if (isMissingFile(error)) return undefined
-    throw error
-  }
-}
-
-export async function writeInstallMetadata(
-  meta: InstallMetadata,
-  path = INSTALL_PATH,
-): Promise<void> {
-  await mkdir(dirname(path), { recursive: true })
-  await writeFile(path, JSON.stringify(meta, null, 2) + '\n')
-}
-
-export function releaseBase(
-  meta: InstallMetadata,
-  req: Pick<UpdateRequest, 'channel' | 'version'>,
-): string {
-  if (process.env.ASTRALE_UPDATE_BASE) return process.env.ASTRALE_UPDATE_BASE.replace(/\/+$/, '')
-  const repo = meta.repo || DEFAULT_REPO
-  if (req.version) {
-    const version = req.version.replace(/^cli\/v/, '').replace(/^v/, '')
-    return `https://github.com/${repo}/releases/download/cli/v${version}`
-  }
-  return `https://github.com/${repo}/releases/download/${req.channel ?? meta.channel ?? DEFAULT_UPDATE_CHANNEL}`
-}
-
-export async function fetchManifest(base: string): Promise<UpdateManifest> {
-  const raw = await readUrlText(`${base}/manifest.json`)
-  return UpdateManifestSchema.parse(JSON.parse(raw))
-}
-
-export function shouldUpdate(currentVersion: string, manifestVersion: string): boolean {
-  return currentVersion !== manifestVersion
-}
-
-export async function updateAstrale(req: UpdateRequest): Promise<UpdateResult> {
-  const execution = req.execution ?? detectUpdateExecution()
-  if (execution.kind === 'package-managed') {
-    return {
-      status: 'managed',
-      currentVersion: req.currentVersion,
-      executable: execution.executable,
-    }
-  }
-
-  const install = await admitScriptInstall(await readInstallMetadata(req.installPath), execution)
-  const meta = install.metadata
-  const currentVersion = meta.version ?? req.currentVersion
-  const channel = req.channel ?? meta.channel ?? DEFAULT_UPDATE_CHANNEL
-  const platform = req.platform ?? detectPlatform()
-  const key = platformKey(platform)
-  const base = releaseBase(meta, { channel, version: req.version })
-  const manifest = await fetchManifest(base)
-  const asset = manifest.assets[key]
-  if (!asset) {
-    throw new AstraleError(
-      'UPDATE_ASSET_NOT_FOUND',
-      `No Astrale CLI release asset for ${key}.`,
-      `Available platforms: ${Object.keys(manifest.assets).join(', ')}`,
-    )
-  }
-
-  if (!shouldUpdate(currentVersion, manifest.version)) {
-    return {
-      status: 'up-to-date',
-      currentVersion,
-      latestVersion: manifest.version,
-      channel: manifest.channel,
-    }
-  }
-
-  if (req.check) {
-    return {
-      status: 'available',
-      currentVersion,
-      latestVersion: manifest.version,
-      channel: manifest.channel,
-    }
-  }
-
-  const tmp = await mkdtemp(join(tmpdir(), 'astrale-update-'))
-  try {
-    const archive = join(tmp, asset.name)
-    await downloadToFile(`${base}/${asset.name}`, archive)
-    const manifestChecksum = 'sha256' in asset ? asset.sha256 : undefined
-    const expected = manifestChecksum ?? (await fetchChecksum(base, asset.name))
-    const actual = await sha256File(archive)
-    if (actual !== expected.toLowerCase()) {
-      throw new AstraleError(
-        'UPDATE_CHECKSUM_MISMATCH',
-        `Checksum mismatch for ${asset.name}.`,
-        `Expected ${expected}; got ${actual}.`,
-      )
-    }
-
-    await extractTarGz(archive, tmp)
-    const nextBin = join(tmp, 'astrale')
-    await chmod(nextBin, 0o755)
-    await smokeVersion(nextBin, manifest.binaryVersion ?? manifest.version)
-
-    const previous = `${meta.bin}.previous`
-    const staged = `${meta.bin}.next`
-    await copyFile(meta.bin, previous).catch(() => undefined)
-    await copyFile(nextBin, staged)
-    await chmod(staged, 0o755)
-    await rename(staged, meta.bin)
-
-    await writeInstallMetadata(
-      {
-        ...meta,
-        channel: manifest.channel,
-        version: manifest.version,
-        installedAt: new Date().toISOString(),
-      },
-      req.installPath,
-    )
-
-    return {
-      status: 'updated',
-      previousVersion: currentVersion,
-      currentVersion: manifest.version,
-      channel: manifest.channel,
-      bin: meta.bin,
-    }
-  } finally {
-    await rm(tmp, { recursive: true, force: true })
-  }
-}
-
-async function readUrlText(url: string): Promise<string> {
-  if (url.startsWith('file://')) {
-    return readFile(new URL(url), 'utf8')
-  }
-  const res = await fetch(url)
-  if (!res.ok) throw new Error(`GET ${url} failed: HTTP ${res.status}`)
-  return res.text()
-}
-
-async function downloadToFile(url: string, path: string): Promise<void> {
-  if (url.startsWith('file://')) {
-    await copyFile(new URL(url), path)
-    return
-  }
-  const res = await fetch(url)
-  if (!res.ok) throw new Error(`GET ${url} failed: HTTP ${res.status}`)
-  const bytes = new Uint8Array(await res.arrayBuffer())
-  await writeFile(path, bytes)
-}
-
-async function fetchChecksum(base: string, assetName: string): Promise<string> {
-  const raw = await readUrlText(`${base}/sha256sums.txt`)
-  for (const line of raw.split(/\r?\n/)) {
-    const [sha, file] = line.trim().split(/\s+/, 2)
-    if (!sha || !file) continue
-    if (file.replace(/^\*/, '') === assetName && /^[a-fA-F0-9]{64}$/.test(sha)) return sha
-  }
-  throw new AstraleError(
-    'UPDATE_CHECKSUM_NOT_FOUND',
-    `Checksum entry not found for ${assetName}.`,
-    `Release base: ${base}`,
-  )
-}
-
-async function sha256File(path: string): Promise<string> {
-  const hash = createHash('sha256')
-  hash.update(await readFile(path))
-  return hash.digest('hex')
-}
-
-async function extractTarGz(archive: string, cwd: string): Promise<void> {
-  const { code, stderr } = await run('tar', ['-xzf', archive, '-C', cwd])
-  if (code !== 0) {
-    throw new Error(`Could not extract update archive: ${stderr.trim()}`)
-  }
-}
-
-async function smokeVersion(bin: string, expectedVersion: string): Promise<void> {
-  const { code, stdout, stderr } = await run(bin, ['--version'])
-  if (code !== 0) throw new Error(`Updated binary failed --version: ${stderr.trim()}`)
-  const actual = stdout.trim()
-  if (actual !== expectedVersion) {
-    throw new Error(`Updated binary reported version ${actual}, expected ${expectedVersion}`)
-  }
-}

package/src/lib/use-target.ts

@@ -1,24 +0,0 @@
-import type { IdentityStore } from '../identity/index'
-import type { InstanceStore } from './instance'
-
-import { resolveInstanceKey } from './instance'
-
-export type UseTarget =
-  | { kind: 'identity'; name: string }
-  | { kind: 'instance'; name: string }
-  | { kind: 'ambiguous'; name: string }
-  | { kind: 'missing'; name: string }
-
-export function resolveUseTarget(
-  name: string,
-  instances: InstanceStore,
-  identities: IdentityStore,
-): UseTarget {
-  const identityExists = !!identities.identities[name]
-  const instanceKey = resolveInstanceKey(instances, name)
-
-  if (identityExists && instanceKey) return { kind: 'ambiguous', name }
-  if (identityExists) return { kind: 'identity', name }
-  if (instanceKey) return { kind: 'instance', name: instanceKey }
-  return { kind: 'missing', name }
-}

package/src/lib/validation.ts

@@ -1,59 +0,0 @@
-import { isDnsLabel } from '@astrale-os/sdk/value'
-import { z } from 'zod'
-
-import { ReservedSlugError } from '../errors'
-
-// Shared validators + schema fragments used by both instance and identity
-// registries — kept in a leaf module to avoid circular imports.
-
-const NAME_RE = /^[a-zA-Z0-9_.-]+$/
-// `host` is the reserved slug of the host/manager kernel (SPEC §5.2); `manager` is the legacy name.
-const RESERVED_SLUGS = new Set(['manager', 'host'])
-
-export { RESERVED_SLUGS }
-
-export function validateName(name: string, entity: string): void {
-  if (!name || !NAME_RE.test(name)) {
-    throw new Error(
-      `Invalid ${entity.toLowerCase()} name "${name}" — must be non-empty and contain only letters, digits, hyphens, underscores, and dots`,
-    )
-  }
-}
-
-export function validateSlug(slug: string): void {
-  // Canonical Core DNS-label rule: a slug becomes a
-  // hostname label, so reject anything not DNS-safe (§4.7).
-  if (!slug || !isDnsLabel(slug)) {
-    throw new Error(
-      `Invalid slug "${slug}" — must be a lowercase DNS label [a-z0-9-], ≤63 chars, no leading/trailing hyphen (§4.7)`,
-    )
-  }
-  if (RESERVED_SLUGS.has(slug)) {
-    throw new ReservedSlugError(slug)
-  }
-}
-
-export function validateUrl(url: string): void {
-  try {
-    const parsed = new URL(url)
-    if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
-      throw new Error('not http(s)')
-    }
-  } catch {
-    throw new Error(`Invalid URL "${url}" — expected a valid http:// or https:// URL`)
-  }
-}
-
-/** Non-throwing predicate form of `validateUrl`. */
-export function isHttpUrl(url: string): boolean {
-  try {
-    validateUrl(url)
-    return true
-  } catch {
-    return false
-  }
-}
-
-/** `local` = only this machine. `remote` = mirrored via astrale cloud (§2.7). */
-export const RegistryModeSchema = z.enum(['local', 'remote'])
-export type RegistryMode = z.infer<typeof RegistryModeSchema>

package/src/lib/view/assets.ts

@@ -1,78 +0,0 @@
-import { existsSync, statSync } from 'node:fs'
-import { copyFile } from 'node:fs/promises'
-import { dirname, join } from 'node:path'
-import { fileURLToPath } from 'node:url'
-
-/**
- * The prebuilt host-page bundle, shipped next to the CLI module
- * (`<pkg>/viewer/dist`). The module URL is authoritative because npm global
- * installs expose the CLI through a bin symlink outside the package root.
- */
-export function viewerDistDir(moduleUrl = import.meta.url, entry = process.argv[1] ?? '.'): string {
-  const override = process.env.ASTRALE_VIEWER_DIR
-  if (override) return override
-
-  const moduleDirectory = dirname(fileURLToPath(moduleUrl))
-  const published = join(moduleDirectory, '..', 'viewer', 'dist')
-  const source = join(moduleDirectory, '..', '..', '..', 'viewer', 'dist')
-  const legacy = join(dirname(entry), '..', 'viewer', 'dist')
-  const complete = [published, source, legacy].find(hasViewerBundle)
-  if (complete) return complete
-
-  // A source checkout may intentionally omit generated dist assets. Keep the
-  // source-derived destination so ensureViewerAssets can build it on demand.
-  if (hasViewerSource(join(source, '..'))) return source
-
-  // Published installs cannot rebuild: preserve the package-relative path in
-  // the diagnostic instead of pointing at the npm prefix beside the bin link.
-  return published
-}
-
-/** Ensure the host bundle exists; on a dev checkout, build it with Bun. */
-export async function ensureViewerAssets(
-  moduleUrl = import.meta.url,
-  entry = process.argv[1] ?? '.',
-): Promise<string> {
-  const dist = viewerDistDir(moduleUrl, entry)
-  const srcDir = join(dist, '..')
-  if (hasViewerBundle(dist) && !viewerSourceIsNewer(srcDir, dist)) return dist
-  const bun = (
-    globalThis as { Bun?: { build: (o: object) => Promise<{ success: boolean; logs: unknown[] }> } }
-  ).Bun
-  if (bun && hasViewerSource(srcDir)) {
-    const result = await bun.build({
-      entrypoints: [join(srcDir, 'main.ts')],
-      outdir: dist,
-      target: 'browser',
-      minify: false,
-    })
-    if (!result.success) throw new Error(`viewer build failed: ${result.logs.join('\n')}`)
-    await copyFile(join(srcDir, 'index.html'), join(dist, 'index.html'))
-    return dist
-  }
-  throw new Error(
-    `viewer bundle missing at ${dist} — reinstall the CLI (or run \`bun scripts/build.ts\` in a dev checkout)`,
-  )
-}
-
-function hasViewerBundle(directory: string): boolean {
-  return existsSync(join(directory, 'main.js')) && existsSync(join(directory, 'index.html'))
-}
-
-function hasViewerSource(directory: string): boolean {
-  return existsSync(join(directory, 'main.ts')) && existsSync(join(directory, 'index.html'))
-}
-
-function viewerSourceIsNewer(source: string, dist: string): boolean {
-  if (!hasViewerSource(source)) return false
-  if (!hasViewerBundle(dist)) return true
-  const newestSource = Math.max(
-    statSync(join(source, 'main.ts')).mtimeMs,
-    statSync(join(source, 'index.html')).mtimeMs,
-  )
-  const oldestOutput = Math.min(
-    statSync(join(dist, 'main.js')).mtimeMs,
-    statSync(join(dist, 'index.html')).mtimeMs,
-  )
-  return newestSource > oldestOutput
-}

package/src/lib/view/open-intent.ts

@@ -1,67 +0,0 @@
-import type { IntentMessage, MountedWindow, ResolvedView, Shell } from '@astrale-os/shell'
-
-export interface OpenIntentHost {
-  current(): MountedWindow | null
-  setCurrent(window: MountedWindow): void
-  mount(view: ResolvedView): Promise<MountedWindow>
-  opened(view: ResolvedView): void
-  failed(error: unknown): void
-  reply(message: IntentMessage<'open'>, windowId: string): void
-  reject(message: IntentMessage<'open'>, error: unknown): void
-}
-
-/** Register the root host's serialized node-to-View navigation handler. */
-export function installOpenIntentHandler(shell: Shell, host: OpenIntentHost): () => void {
-  let queue = Promise.resolve()
-  return shell.onIntent('open', (message) => {
-    const run = queue.then(() => handleOpenIntent(shell, host, message))
-    queue = run.catch(() => {})
-    return run
-  })
-}
-
-export async function handleOpenIntent(
-  shell: Pick<Shell, 'views'>,
-  host: OpenIntentHost,
-  message: IntentMessage<'open'>,
-): Promise<void> {
-  const { nodeId, viewId } = message.envelope.payload
-  try {
-    const selected = selectResolvedView(await shell.views.resolve(nodeId), viewId)
-    const previous = host.current()
-    const next = await host.mount(selected)
-
-    host.setCurrent(next)
-    host.opened(selected)
-    // A correlated requester is normally `previous`; answer while its channel
-    // still exists, then retire the old mount.
-    host.reply(message, next.windowId)
-
-    if (previous && previous.windowId !== next.windowId) {
-      try {
-        const closed = await previous.close({ force: true })
-        if (closed.kind === 'refused') {
-          host.failed(new Error(closed.reason ?? `Window ${previous.windowId} refused to close`))
-        }
-      } catch (error) {
-        host.failed(error)
-      }
-    }
-  } catch (error) {
-    host.reject(message, error)
-    host.failed(error)
-  }
-}
-
-export function selectResolvedView(
-  views: readonly ResolvedView[],
-  viewId: string | undefined,
-): ResolvedView {
-  const selected = viewId
-    ? views.find((view) => view.route.key === viewId || `/:${view.route.key}` === viewId)
-    : views[0]
-  if (selected) return selected
-  throw new Error(
-    viewId ? `View ${viewId} does not resolve for this node` : 'No view resolves for this node',
-  )
-}

package/src/lib/view/port-allocation.ts

@@ -1,19 +0,0 @@
-import { join } from 'node:path'
-
-import { withFileLock } from '../../state/index'
-import { VIEW_DIR } from './session'
-
-const VIEW_PORT_LOCK = join(VIEW_DIR, 'ports.lock')
-
-/**
- * Keep the free-port probe and detached server startup in one cross-process
- * critical section. A probe alone is only advisory: without this lock, two
- * concurrent `astrale view` processes can both observe 4419 as free before
- * either child binds it.
- */
-export function withViewPortAllocationLock<T>(
-  fn: () => Promise<T>,
-  lockPath = VIEW_PORT_LOCK,
-): Promise<T> {
-  return withFileLock(lockPath, fn)
-}