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

package/src/state/files.ts

@@ -1,170 +0,0 @@
-import { randomUUID } from 'node:crypto'
-import {
-  closeSync,
-  fsyncSync,
-  mkdirSync,
-  openSync,
-  renameSync,
-  unlinkSync,
-  writeFileSync,
-} from 'node:fs'
-import { mkdir, open, readFile, rename, stat, unlink } from 'node:fs/promises'
-import { dirname } from 'node:path'
-
-/** Atomically publish one complete private state file through a same-directory temporary file. */
-export async function atomicWrite(path: string, data: string): Promise<void> {
-  const directory = dirname(path)
-  const temporary = `${path}.${randomUUID()}.tmp`
-  await mkdir(directory, { recursive: true })
-
-  let handle: Awaited<ReturnType<typeof open>> | undefined
-  try {
-    handle = await open(temporary, 'wx', 0o600)
-    await handle.writeFile(data)
-    await handle.sync()
-    await handle.close()
-    handle = undefined
-    await rename(temporary, path)
-
-    const directoryHandle = await open(directory, 'r')
-    try {
-      await directoryHandle.sync()
-    } finally {
-      await directoryHandle.close()
-    }
-  } catch (error) {
-    await handle?.close().catch(() => undefined)
-    await unlink(temporary).catch(() => undefined)
-    throw error
-  }
-}
-
-/** Atomically publish one complete private state file for synchronous consumer capabilities. */
-export function atomicWriteSync(path: string, data: string): void {
-  const directory = dirname(path)
-  const temporary = `${path}.${randomUUID()}.tmp`
-  mkdirSync(directory, { recursive: true })
-
-  let descriptor: number | undefined
-  try {
-    descriptor = openSync(temporary, 'wx', 0o600)
-    writeFileSync(descriptor, data)
-    fsyncSync(descriptor)
-    closeSync(descriptor)
-    descriptor = undefined
-    renameSync(temporary, path)
-
-    const directoryDescriptor = openSync(directory, 'r')
-    try {
-      fsyncSync(directoryDescriptor)
-    } finally {
-      closeSync(directoryDescriptor)
-    }
-  } catch (error) {
-    if (descriptor !== undefined) closeSync(descriptor)
-    try {
-      unlinkSync(temporary)
-    } catch {
-      // The temporary file was either never created or was already renamed.
-    }
-    throw error
-  }
-}
-
-export interface FileLockOptions {
-  readonly pollIntervalMs?: number
-  readonly staleAfterMs?: number
-  readonly timeoutMs?: number
-}
-
-/** Run one transition under a bounded cross-process create-exclusive lock. */
-export async function withFileLock<Value>(
-  lockPath: string,
-  transition: () => Promise<Value>,
-  options: FileLockOptions = {},
-): Promise<Value> {
-  const pollIntervalMs = options.pollIntervalMs ?? 100
-  const staleAfterMs = options.staleAfterMs ?? 30_000
-  const timeoutMs = options.timeoutMs ?? 60_000
-  const deadline = Date.now() + timeoutMs
-
-  for (;;) {
-    if (await tryAcquire(lockPath)) {
-      try {
-        return await transition()
-      } finally {
-        await unlink(lockPath).catch(() => undefined)
-      }
-    }
-    if (await takeoverIfAbandoned(lockPath, staleAfterMs)) continue
-    if (Date.now() >= deadline) {
-      throw new Error(`Timed out after ${timeoutMs}ms waiting for lock ${lockPath}`)
-    }
-    await sleep(pollIntervalMs)
-  }
-}
-
-async function tryAcquire(lockPath: string): Promise<boolean> {
-  try {
-    const handle = await open(lockPath, 'wx', 0o600)
-    try {
-      await handle.writeFile(
-        JSON.stringify({ pid: process.pid, createdAt: new Date().toISOString() }),
-      )
-      await handle.sync()
-    } finally {
-      await handle.close()
-    }
-    return true
-  } catch (error) {
-    const code = (error as { code?: string }).code
-    if (code === 'EEXIST') return false
-    if (code === 'ENOENT') {
-      await mkdir(dirname(lockPath), { recursive: true })
-      return tryAcquire(lockPath)
-    }
-    throw error
-  }
-}
-
-async function takeoverIfAbandoned(lockPath: string, staleAfterMs: number): Promise<boolean> {
-  try {
-    const info = await stat(lockPath)
-    if (Date.now() - info.mtimeMs > staleAfterMs) {
-      await unlink(lockPath).catch(() => undefined)
-      return true
-    }
-  } catch (error) {
-    if ((error as { code?: string }).code === 'ENOENT') return true
-    throw error
-  }
-
-  const pid = await readLockPid(lockPath)
-  if (pid !== undefined && pid !== process.pid && !isPidAlive(pid)) {
-    await unlink(lockPath).catch(() => undefined)
-    return true
-  }
-  return false
-}
-
-async function readLockPid(lockPath: string): Promise<number | undefined> {
-  try {
-    const value = (JSON.parse(await readFile(lockPath, 'utf-8')) as { pid?: unknown }).pid
-    return typeof value === 'number' ? value : undefined
-  } catch {
-    return undefined
-  }
-}
-
-function isPidAlive(pid: number): boolean {
-  try {
-    process.kill(pid, 0)
-    return true
-  } catch (error) {
-    return (error as { code?: string }).code === 'EPERM'
-  }
-}
-
-function sleep(milliseconds: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, milliseconds))
-}

package/src/state/identities.ts

@@ -1,229 +0,0 @@
-import { readFile } from 'node:fs/promises'
-import { z } from 'zod'
-
-import type { FileLockOptions } from './files'
-
-import { atomicWrite, withFileLock } from './files'
-import { IDENTITIES_PATH } from './paths'
-
-export type IdentitySource = 'key' | 'idp'
-export type IdentityMode = 'local' | 'remote'
-
-export interface Registration {
-  readonly iss: string
-  readonly sub: string
-  readonly registeredAt: string
-}
-
-export interface Identity {
-  readonly subject: string
-  readonly createdAt: string
-  readonly source?: IdentitySource
-  readonly mode?: IdentityMode
-  readonly kid?: string
-  readonly idp?: string
-  readonly issuer?: string
-  readonly audience?: string
-  readonly claims?: Readonly<Record<string, unknown>>
-  readonly registrations?: Readonly<Record<string, Registration>>
-}
-
-export interface IdentityStore {
-  readonly default: string
-  readonly identities: Readonly<Record<string, Identity>>
-}
-
-export const IDENTITY_STORE_VERSION = 1 as const
-
-export type IdentityStateErrorCode =
-  | 'IDENTITY_STATE_INVALID'
-  | 'IDENTITY_STATE_VERSION_UNSUPPORTED'
-  | 'IDENTITY_STATE_UNREADABLE'
-  | 'IDENTITY_STATE_BACKUP_CONFLICT'
-
-export class IdentityStateError extends Error {
-  readonly code: IdentityStateErrorCode
-  readonly path: string
-
-  constructor(code: IdentityStateErrorCode, path: string, message: string, cause?: unknown) {
-    super(message, { cause })
-    this.name = 'IdentityStateError'
-    this.code = code
-    this.path = path
-  }
-}
-
-export interface IdentityStoreOptions {
-  readonly path?: string
-  readonly now?: () => Date
-  readonly lock?: FileLockOptions
-}
-
-export interface IdentityUpdate<Value> {
-  readonly next: IdentityStore
-  readonly value: Value
-}
-
-const RegistrationSchema: z.ZodType<Registration> = z
-  .object({
-    iss: z.string(),
-    sub: z.string(),
-    registeredAt: z.string(),
-  })
-  .strict()
-
-const IdentitySchema: z.ZodType<Identity> = z
-  .object({
-    subject: z.string(),
-    createdAt: z.string(),
-    source: z.enum(['key', 'idp']).optional(),
-    mode: z.enum(['local', 'remote']).optional(),
-    kid: z.string().optional(),
-    idp: z.string().optional(),
-    issuer: z.string().url().optional(),
-    audience: z.string().optional(),
-    claims: z.record(z.string(), z.unknown()).optional(),
-    registrations: z.record(z.string(), RegistrationSchema).optional(),
-  })
-  .strict()
-
-const IdentityStoreFields = {
-  default: z.string(),
-  identities: z.record(z.string(), IdentitySchema),
-}
-
-const IdentityStoreSchema: z.ZodType<IdentityStore> = z.object(IdentityStoreFields).strict()
-
-const IdentityFileV1Schema = z
-  .object({ version: z.literal(IDENTITY_STORE_VERSION), ...IdentityStoreFields })
-  .strict()
-
-interface DecodedIdentityStore {
-  readonly store: IdentityStore
-  readonly legacyBytes?: string
-}
-
-export async function readIdentityStore(
-  options: IdentityStoreOptions = {},
-): Promise<IdentityStore> {
-  return (await readDecoded(options)).store
-}
-
-export async function updateIdentityStore<Value>(
-  transition: (current: IdentityStore) => IdentityUpdate<Value> | Promise<IdentityUpdate<Value>>,
-  options: IdentityStoreOptions = {},
-): Promise<Value> {
-  const path = options.path ?? IDENTITIES_PATH
-  return withFileLock(
-    `${path}.lock`,
-    async () => {
-      const current = await readDecoded(options)
-      const update = await transition(current.store)
-      if (current.legacyBytes !== undefined) {
-        await preserveLegacyBackup(path, current.legacyBytes)
-      }
-      await atomicWrite(path, encodeV1(update.next))
-      return update.value
-    },
-    options.lock,
-  )
-}
-
-async function readDecoded(options: IdentityStoreOptions): Promise<DecodedIdentityStore> {
-  const path = options.path ?? IDENTITIES_PATH
-  let raw: string
-  try {
-    raw = await readFile(path, 'utf-8')
-  } catch (error) {
-    if ((error as { code?: string }).code === 'ENOENT') {
-      return { store: seed(options.now?.() ?? new Date()) }
-    }
-    throw new IdentityStateError(
-      'IDENTITY_STATE_UNREADABLE',
-      path,
-      `Could not read identity state at ${path}`,
-      error,
-    )
-  }
-
-  let input: unknown
-  try {
-    input = JSON.parse(raw)
-  } catch (error) {
-    throw invalidState(path, error)
-  }
-
-  if (hasVersion(input)) {
-    if (typeof input.version !== 'number' || !Number.isInteger(input.version)) {
-      throw invalidState(path)
-    }
-    if (input.version !== IDENTITY_STORE_VERSION) {
-      throw new IdentityStateError(
-        'IDENTITY_STATE_VERSION_UNSUPPORTED',
-        path,
-        `Identity state at ${path} uses unsupported version ${input.version}`,
-      )
-    }
-    try {
-      const { version: _, ...store } = IdentityFileV1Schema.parse(input)
-      return { store }
-    } catch (error) {
-      throw invalidState(path, error)
-    }
-  }
-
-  try {
-    return { store: IdentityStoreSchema.parse(input), legacyBytes: raw }
-  } catch (error) {
-    throw invalidState(path, error)
-  }
-}
-
-function hasVersion(input: unknown): input is { readonly version: unknown } {
-  return typeof input === 'object' && input !== null && Object.hasOwn(input, 'version')
-}
-
-function seed(_now: Date): IdentityStore {
-  return {
-    default: '',
-    identities: {},
-  }
-}
-
-function encodeV1(store: IdentityStore): string {
-  return `${JSON.stringify({ version: IDENTITY_STORE_VERSION, ...store }, null, 2)}\n`
-}
-
-async function preserveLegacyBackup(path: string, legacyBytes: string): Promise<void> {
-  const backupPath = `${path}.v0.bak`
-  try {
-    const existing = await readFile(backupPath, 'utf-8')
-    if (existing !== legacyBytes) {
-      throw new IdentityStateError(
-        'IDENTITY_STATE_BACKUP_CONFLICT',
-        backupPath,
-        `Legacy identity backup at ${backupPath} does not match the file being migrated`,
-      )
-    }
-  } catch (error) {
-    if (error instanceof IdentityStateError) throw error
-    if ((error as { code?: string }).code !== 'ENOENT') {
-      throw new IdentityStateError(
-        'IDENTITY_STATE_UNREADABLE',
-        backupPath,
-        `Could not read legacy identity backup at ${backupPath}`,
-        error,
-      )
-    }
-    await atomicWrite(backupPath, legacyBytes)
-  }
-}
-
-function invalidState(path: string, cause?: unknown): IdentityStateError {
-  return new IdentityStateError(
-    'IDENTITY_STATE_INVALID',
-    path,
-    `Identity state at ${path} is malformed`,
-    cause,
-  )
-}

package/src/state/index.ts

@@ -1,31 +0,0 @@
-export { atomicWrite, atomicWriteSync, withFileLock } from './files'
-export type { FileLockOptions } from './files'
-export { ExchangeCredentialCache } from './exchange-credentials'
-export type { exchange } from './exchange-credentials'
-export { IDENTITY_STORE_VERSION, readIdentityStore, updateIdentityStore } from './identities'
-export type {
-  Identity,
-  IdentityMode,
-  IdentitySource,
-  IdentityStore,
-  IdentityStoreOptions,
-  IdentityUpdate,
-  Registration,
-} from './identities'
-export {
-  ASTRALE_HOME,
-  CONFIG_PATH,
-  DATA_DIR,
-  IDENTITIES_PATH,
-  IDPS_PATH,
-  IDP_SESSIONS_DIR,
-  EXCHANGE_CREDENTIALS_PATH,
-  INSTALL_PATH,
-  INSTANCES_PATH,
-  KEYS_DIR,
-  SESSION_ROUTES_PATH,
-  createPaths,
-  paths,
-} from './paths'
-export type { PathEnvironment, Paths } from './paths'
-export { FileSessionRouteStore, SESSION_ROUTE_STORE } from './session-routes'

package/src/state/paths.ts

@@ -1,64 +0,0 @@
-import { homedir } from 'node:os'
-import { join } from 'node:path'
-
-export interface PathEnvironment {
-  readonly ASTRALE_HOME?: string
-  readonly ASTRALE_KEYS_DIR?: string
-  readonly ASTRALE_DATA_DIR?: string
-}
-
-export interface Paths {
-  readonly home: string
-  readonly keys: string
-  readonly data: string
-  readonly config: string
-  readonly install: string
-  readonly identities: string
-  readonly instances: string
-  readonly idps: string
-  readonly idpSessionsDir: string
-  readonly exchangeCredentials: string
-  readonly sessionRoutes: string
-  idpDir(name: string): string
-  idpSession(identityName: string): string
-}
-
-/** Resolve every CLI state path once from explicit input and the captured environment. */
-export function createPaths(home?: string, environment?: PathEnvironment): Paths {
-  const captured = environment ?? {
-    ASTRALE_HOME: process.env.ASTRALE_HOME,
-    ASTRALE_KEYS_DIR: process.env.ASTRALE_KEYS_DIR,
-    ASTRALE_DATA_DIR: process.env.ASTRALE_DATA_DIR,
-  }
-  const base = home ?? captured.ASTRALE_HOME ?? join(homedir(), '.astrale')
-  const idpsDir = join(base, 'idps')
-  const idpSessionsDir = join(base, 'idp-sessions')
-  return Object.freeze({
-    home: base,
-    keys: captured.ASTRALE_KEYS_DIR ?? join(base, 'keys'),
-    data: captured.ASTRALE_DATA_DIR ?? join(base, 'data'),
-    config: join(base, 'config.json'),
-    install: join(base, 'install.json'),
-    identities: join(base, 'identities.json'),
-    instances: join(base, 'instances.json'),
-    idps: join(idpsDir, 'index.json'),
-    idpSessionsDir,
-    exchangeCredentials: join(base, 'exchange', 'credentials.json'),
-    sessionRoutes: join(base, 'session', 'routes.json'),
-    idpDir: (name: string) => join(idpsDir, name),
-    idpSession: (identityName: string) => join(idpSessionsDir, `${identityName}.json`),
-  })
-}
-
-export const paths: Paths = createPaths()
-export const ASTRALE_HOME = paths.home
-export const KEYS_DIR = paths.keys
-export const DATA_DIR = paths.data
-export const CONFIG_PATH = paths.config
-export const INSTALL_PATH = paths.install
-export const IDENTITIES_PATH = paths.identities
-export const INSTANCES_PATH = paths.instances
-export const IDPS_PATH = paths.idps
-export const IDP_SESSIONS_DIR = paths.idpSessionsDir
-export const EXCHANGE_CREDENTIALS_PATH = paths.exchangeCredentials
-export const SESSION_ROUTES_PATH = paths.sessionRoutes

package/src/state/session-routes.ts

@@ -1,34 +0,0 @@
-import type { SessionRouteArtifact, SessionRouteStore } from '@astrale-os/sdk/client/session'
-
-import { chmodSync, mkdirSync, readFileSync, unlinkSync } from 'node:fs'
-import { dirname } from 'node:path'
-
-import { atomicWriteSync } from './files'
-import { SESSION_ROUTES_PATH } from './paths'
-
-/** CLI filesystem representation for Kernel Client's admitted confidential route artifact. */
-export class FileSessionRouteStore implements SessionRouteStore {
-  constructor(private readonly path = SESSION_ROUTES_PATH) {}
-
-  read(): unknown {
-    return JSON.parse(readFileSync(this.path, 'utf8')) as unknown
-  }
-
-  write(artifact: SessionRouteArtifact): void {
-    const directory = dirname(this.path)
-    mkdirSync(directory, { recursive: true, mode: 0o700 })
-    chmodSync(directory, 0o700)
-    atomicWriteSync(this.path, `${JSON.stringify(artifact)}\n`)
-    chmodSync(this.path, 0o600)
-  }
-
-  clear(): void {
-    try {
-      unlinkSync(this.path)
-    } catch (error) {
-      if ((error as { readonly code?: unknown }).code !== 'ENOENT') throw error
-    }
-  }
-}
-
-export const SESSION_ROUTE_STORE = Object.freeze(new FileSessionRouteStore())

package/src/state/tsconfig.json

@@ -1,6 +0,0 @@
-{
-  "extends": "../../tsconfig.json",
-  "compilerOptions": { "types": ["@types/node"] },
-  "include": ["*.ts"],
-  "exclude": ["__tests__"]
-}

package/src/telemetry/__tests__/analyze-log.test.ts

@@ -1,38 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-
-import { clampLog } from '../analyze'
-
-describe('clampLog', () => {
-  test('short output is written through untouched', () => {
-    const json = '{"is_error":false,"num_turns":3}'
-    expect(clampLog(json)).toBe(json)
-  })
-
-  test('output at exactly the limit is not clamped', () => {
-    const text = 'x'.repeat(1000)
-    expect(clampLog(text, 1000)).toBe(text)
-  })
-
-  test('oversized output keeps its head and its tail', () => {
-    // The JSON envelope opens at the top; a stack or error message closes at
-    // the bottom. Both must survive; the middle is what nobody reads.
-    const text = `HEAD${'x'.repeat(50_000)}TAIL`
-    const clamped = clampLog(text, 1000)
-    expect(clamped.startsWith('HEAD')).toBe(true)
-    expect(clamped.endsWith('TAIL')).toBe(true)
-    expect(clamped).toContain('bytes elided')
-  })
-
-  test('the result stays within a small constant of the limit', () => {
-    const clamped = clampLog('y'.repeat(10_000_000), 4096)
-    // head + tail + the elision marker, never the input.
-    expect(clamped.length).toBeLessThan(4096 + 128)
-  })
-
-  test('the elision count reports what was actually dropped', () => {
-    const clamped = clampLog('z'.repeat(10_000), 1000)
-    const elided = Number(/… (\d+) bytes elided …/u.exec(clamped)?.[1])
-    const kept = clamped.length - `\n… ${elided} bytes elided …\n`.length
-    expect(elided + kept).toBe(10_000)
-  })
-})

package/src/telemetry/__tests__/gate.test.ts

@@ -1,63 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-
-import type { TelemetryEvent } from '../types'
-
-import { commandHead, extractSignals, hasSignals } from '../gate'
-
-function ev(argv: string[], exitCode: number, errorName?: string): TelemetryEvent {
-  return {
-    v: 1,
-    ts: '2026-07-10T10:00:00.000Z',
-    argv,
-    exitCode,
-    durationMs: 10,
-    errorName,
-    cwd: '/w',
-    root: '/w',
-    surface: 'cli',
-  }
-}
-
-describe('commandHead', () => {
-  test('keeps up to two leading command tokens, stops at flags/values', () => {
-    expect(commandHead(['get', '/path', '-i', 'x'])).toBe('get /path')
-    expect(commandHead(['domain', 'install', './foo'])).toBe('domain install')
-    expect(commandHead(['status'])).toBe('status')
-    expect(commandHead(['--help'])).toBe('(bare)')
-    expect(commandHead(['call', 'k=v'])).toBe('call')
-  })
-})
-
-describe('extractSignals / hasSignals', () => {
-  test('failures grouped by command with error names', () => {
-    const s = extractSignals([
-      ev(['domain', 'install'], 1, 'AUTH_ERROR'),
-      ev(['domain', 'install'], 1, 'AUTH_ERROR'),
-      ev(['status'], 0),
-    ])
-    expect(s.failures).toEqual([
-      { command: 'domain install', count: 2, errorNames: ['AUTH_ERROR'] },
-    ])
-    expect(s.retries).toEqual([])
-    expect(hasSignals(s)).toBe(true)
-  })
-
-  test('3+ runs of one command is a retry smell even when green', () => {
-    const s = extractSignals([ev(['get', '/a'], 0), ev(['get', '/a'], 0), ev(['get', '/a'], 0)])
-    expect(s.retries).toEqual([{ command: 'get /a', count: 3 }])
-    expect(hasSignals(s)).toBe(true)
-  })
-
-  test('quiet session has no signals until a transcript is attached', () => {
-    const s = extractSignals([ev(['status'], 0), ev(['query', '/'], 0)])
-    expect(hasSignals(s)).toBe(false)
-    s.harnessSessions = [
-      {
-        harness: 'claude-code',
-        transcriptPath: '/t.jsonl',
-        sizeBytes: 1,
-      },
-    ]
-    expect(hasSignals(s)).toBe(true)
-  })
-})