@astrale-os/cli 1.0.0-beta.3 → 1.0.0-beta.30

package/src/lib/__tests__/browser-retention.test.ts

@@ -0,0 +1,212 @@
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test'
+import {
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  rmSync,
+  symlinkSync,
+  utimesSync,
+  writeFileSync,
+} from 'node:fs'
+import { hostname, tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+import type { BrowserRetentionBudget } from '../browser-retention'
+
+import {
+  DEFAULT_MAX_CACHE_BYTES,
+  DEFAULT_MAX_PROFILE_AGE_DAYS,
+  browserRetentionBudget,
+  heldByLiveBrowser,
+  profileCacheBytes,
+  sweepBrowserProfiles,
+} from '../browser-retention'
+
+const DAY = 24 * 60 * 60 * 1000
+const BUDGET: BrowserRetentionBudget = { maxCacheBytes: 10_000, maxProfileAgeMs: 30 * DAY }
+
+let dir: string
+
+beforeEach(() => {
+  dir = mkdtempSync(join(tmpdir(), 'astrale-browser-ret-'))
+  delete process.env.ASTRALE_BROWSER_MAX_CACHE_BYTES
+  delete process.env.ASTRALE_BROWSER_MAX_PROFILE_AGE_DAYS
+})
+
+afterEach(() => {
+  rmSync(dir, { recursive: true, force: true })
+})
+
+type Seed = { idleMs?: number; cacheBytes?: number; lockPid?: number }
+
+/** A profile shaped like Chromium's: session state at the root and in Default/,
+ *  cache in the subdirectories retention is allowed to delete. */
+function seedProfile(name: string, { idleMs = 0, cacheBytes = 0, lockPid }: Seed): string {
+  const profile = join(dir, name)
+  mkdirSync(join(profile, 'Default'), { recursive: true })
+  writeFileSync(join(profile, 'Local State'), '{"os_crypt":{"encrypted_key":"x"}}')
+  writeFileSync(join(profile, 'Default', 'Cookies'), 'SQLite format 3\0cookie-data')
+  writeFileSync(join(profile, 'Default', 'Preferences'), '{"profile":{}}')
+  mkdirSync(join(profile, 'Default', 'Local Storage', 'leveldb'), { recursive: true })
+  writeFileSync(join(profile, 'Default', 'Local Storage', 'leveldb', '000003.log'), 'state')
+
+  if (cacheBytes > 0) {
+    mkdirSync(join(profile, 'Default', 'Cache', 'Cache_Data'), { recursive: true })
+    writeFileSync(
+      join(profile, 'Default', 'Cache', 'Cache_Data', 'f_000001'),
+      'x'.repeat(cacheBytes),
+    )
+    mkdirSync(join(profile, 'Default', 'Code Cache', 'js'), { recursive: true })
+    writeFileSync(join(profile, 'Default', 'Code Cache', 'js', 'index'), 'y'.repeat(cacheBytes))
+  }
+  if (lockPid !== undefined) {
+    symlinkSync(`${hostname()}-${lockPid}`, join(profile, 'SingletonLock'))
+  }
+  const when = new Date(Date.now() - idleMs)
+  utimesSync(profile, when, when)
+  return profile
+}
+
+const sessionIntact = (name: string): boolean =>
+  existsSync(join(dir, name, 'Default', 'Cookies')) &&
+  existsSync(join(dir, name, 'Local State')) &&
+  existsSync(join(dir, name, 'Default', 'Preferences')) &&
+  existsSync(join(dir, name, 'Default', 'Local Storage', 'leveldb', '000003.log'))
+
+const cacheGone = (name: string): boolean =>
+  !existsSync(join(dir, name, 'Default', 'Cache')) &&
+  !existsSync(join(dir, name, 'Default', 'Code Cache'))
+
+describe('age rule', () => {
+  test('a dormant profile is removed outright', async () => {
+    seedProfile('dormant', { idleMs: 40 * DAY, cacheBytes: 100 })
+    const r = await sweepBrowserProfiles({ dir, budget: BUDGET })
+    expect(r.removed).toEqual(['dormant'])
+    expect(existsSync(join(dir, 'dormant'))).toBe(false)
+    expect(r.bytesFreed).toBeGreaterThan(0)
+  })
+
+  test('a recently used profile is kept', async () => {
+    seedProfile('fresh', { idleMs: 2 * DAY, cacheBytes: 100 })
+    const r = await sweepBrowserProfiles({ dir, budget: BUDGET })
+    expect(r.removed).toEqual([])
+    expect(sessionIntact('fresh')).toBe(true)
+  })
+
+  test('the age bound is configurable', async () => {
+    seedProfile('two-days', { idleMs: 2 * DAY })
+    const strict = { ...BUDGET, maxProfileAgeMs: DAY }
+    expect((await sweepBrowserProfiles({ dir, budget: strict })).removed).toEqual(['two-days'])
+  })
+})
+
+describe('size rule', () => {
+  test('a profile under budget is left completely alone', async () => {
+    seedProfile('small', { idleMs: DAY, cacheBytes: 1_000 })
+    const r = await sweepBrowserProfiles({ dir, budget: BUDGET })
+    expect(r.purged).toEqual([])
+    expect(cacheGone('small')).toBe(false)
+  })
+
+  test('a profile over budget loses its cache but keeps its session', async () => {
+    seedProfile('bloated', { idleMs: DAY, cacheBytes: 20_000 })
+    const r = await sweepBrowserProfiles({ dir, budget: BUDGET })
+    expect(r.purged).toEqual(['bloated'])
+    expect(cacheGone('bloated')).toBe(true)
+    // The entire point: the cookie survives, so the user stays signed in.
+    expect(sessionIntact('bloated')).toBe(true)
+    expect(existsSync(join(dir, 'bloated'))).toBe(true)
+    expect(r.bytesFreed).toBeGreaterThanOrEqual(40_000)
+  })
+
+  test('the size bound counts only cache directories, not the whole profile', async () => {
+    const profile = seedProfile('measured', { idleMs: DAY, cacheBytes: 3_000 })
+    writeFileSync(join(profile, 'Default', 'History'), 'z'.repeat(50_000))
+    // 2 cache files of 3 KB each; History is not cache and must not count.
+    expect(await profileCacheBytes(profile)).toBe(6_000)
+    expect((await sweepBrowserProfiles({ dir, budget: BUDGET })).purged).toEqual([])
+  })
+})
+
+describe('live-browser guard', () => {
+  test('a profile locked by a live process is never touched', async () => {
+    // Our own pid is unambiguously alive.
+    seedProfile('in-use', { idleMs: 40 * DAY, cacheBytes: 20_000, lockPid: process.pid })
+    const r = await sweepBrowserProfiles({ dir, budget: BUDGET })
+    expect(r.skipped).toEqual(['in-use'])
+    expect(r.removed).toEqual([])
+    expect(r.purged).toEqual([])
+    expect(existsSync(join(dir, 'in-use'))).toBe(true)
+    expect(cacheGone('in-use')).toBe(false)
+  })
+
+  test('a stale lock from a dead process does not protect anything', async () => {
+    // Chromium leaves these behind after a crash; they must not pin disk forever.
+    seedProfile('crashed', { idleMs: 40 * DAY, lockPid: 999_999 })
+    const r = await sweepBrowserProfiles({ dir, budget: BUDGET })
+    expect(r.removed).toEqual(['crashed'])
+  })
+
+  test('heldByLiveBrowser reads the symlink without resolving it', () => {
+    // The target names a file that does not exist — statting it would throw.
+    const live = seedProfile('live', { lockPid: process.pid })
+    const dead = seedProfile('dead', { lockPid: 999_999 })
+    const none = seedProfile('none', {})
+    expect(heldByLiveBrowser(live)).toBe(true)
+    expect(heldByLiveBrowser(dead)).toBe(false)
+    expect(heldByLiveBrowser(none)).toBe(false)
+  })
+})
+
+describe('sweep resilience', () => {
+  test('a missing browser directory is a no-op, not an error', async () => {
+    const gone = join(dir, 'does-not-exist')
+    const r = await sweepBrowserProfiles({ dir: gone, budget: BUDGET })
+    expect(r).toEqual({ removed: [], purged: [], skipped: [], bytesFreed: 0 })
+  })
+
+  test('stray files beside the profiles are ignored', async () => {
+    writeFileSync(join(dir, 'browser.json'), '{}')
+    seedProfile('real', { idleMs: 40 * DAY })
+    expect((await sweepBrowserProfiles({ dir, budget: BUDGET })).removed).toEqual(['real'])
+  })
+
+  test('several profiles are handled independently in one pass', async () => {
+    seedProfile('a-dormant', { idleMs: 40 * DAY })
+    seedProfile('b-bloated', { idleMs: DAY, cacheBytes: 20_000 })
+    seedProfile('c-fine', { idleMs: DAY, cacheBytes: 100 })
+    seedProfile('d-locked', { idleMs: 40 * DAY, lockPid: process.pid })
+    const r = await sweepBrowserProfiles({ dir, budget: BUDGET })
+    expect(r.removed).toEqual(['a-dormant'])
+    expect(r.purged).toEqual(['b-bloated'])
+    expect(r.skipped).toEqual(['d-locked'])
+    expect(sessionIntact('c-fine')).toBe(true)
+  })
+})
+
+describe('browserRetentionBudget', () => {
+  test('defaults when nothing is configured', async () => {
+    expect(await browserRetentionBudget()).toEqual({
+      maxCacheBytes: DEFAULT_MAX_CACHE_BYTES,
+      maxProfileAgeMs: DEFAULT_MAX_PROFILE_AGE_DAYS * DAY,
+    })
+  })
+
+  test('env overrides both bounds', async () => {
+    process.env.ASTRALE_BROWSER_MAX_CACHE_BYTES = '4096'
+    process.env.ASTRALE_BROWSER_MAX_PROFILE_AGE_DAYS = '3'
+    expect(await browserRetentionBudget()).toEqual({
+      maxCacheBytes: 4096,
+      maxProfileAgeMs: 3 * DAY,
+    })
+  })
+
+  test.each([
+    ['zero', '0'],
+    ['negative', '-1'],
+    ['not a number', 'lots'],
+  ])('a %s env value falls back to the default rather than removing the cap', async (_l, value) => {
+    process.env.ASTRALE_BROWSER_MAX_CACHE_BYTES = value
+    expect((await browserRetentionBudget()).maxCacheBytes).toBe(DEFAULT_MAX_CACHE_BYTES)
+  })
+})

package/src/lib/__tests__/command-dx.test.ts

@@ -16,7 +16,7 @@ function dx(
   error: CommanderError,
   argv: string[],
 ) {
-  const rendered = JSON.parse(stripAnsi(renderCommanderError(program, error, argv))) as {
+  const rendered = JSON.parse(stripAnsi(renderCommanderError(program, error, argv, true))) as {
     error: string
     message: string
     detail: string

package/src/lib/__tests__/config.test.ts

@@ -23,6 +23,33 @@ describe('AstraleConfigSchema', () => {
     })
   })
 
+  test('retention bounds survive a parse — a read/write cycle must not drop them', () => {
+    // zod strips unknown keys, so a bound declared only in its reader would be
+    // silently erased by any command that rewrites the config.
+    const result = AstraleConfigSchema.parse({
+      telemetry: { enabled: true, maxAgeDays: 7, maxBytes: 1_048_576 },
+      browser: { maxCacheBytes: 52_428_800, maxProfileAgeDays: 14 },
+    })
+    expect(result.telemetry).toEqual({ enabled: true, maxAgeDays: 7, maxBytes: 1_048_576 })
+    expect(result.browser).toEqual({ maxCacheBytes: 52_428_800, maxProfileAgeDays: 14 })
+  })
+
+  test.each([
+    ['zero', 0],
+    ['negative', -5],
+    ['not a number', 'lots'],
+    ['infinite', Number.POSITIVE_INFINITY],
+  ])('a %s bound is dropped, and does not take the rest of the config with it', (_l, value) => {
+    const result = AstraleConfigSchema.parse({
+      issuer: 'https://test.astrale.ai',
+      telemetry: { enabled: true, maxAgeDays: value },
+      browser: { maxCacheBytes: value },
+    })
+    expect(result.telemetry.maxAgeDays).toBeUndefined()
+    expect(result.browser.maxCacheBytes).toBeUndefined()
+    expect(result.issuer).toBe('https://test.astrale.ai')
+  })
+
   test('rejects non-url issuer', () => {
     expect(() => AstraleConfigSchema.parse({ issuer: 'not-a-url' })).toThrow()
   })

package/src/lib/__tests__/domain-publication.test.ts

@@ -1,26 +1,15 @@
-import { publication } from '@astrale-os/kernel-protocol'
-import { defineDomain } from '@astrale-os/sdk'
-import { issuer } from '@astrale-os/sdk/auth'
-import { createDeployment } from '@astrale-os/sdk/deployment'
-import { defineSchema } from '@astrale-os/sdk/schema/v1'
+import { publication } from '@astrale-os/sdk/publication'
+import { defineSchema } from '@astrale-os/sdk/schema'
 import { describe, expect, test } from 'bun:test'
 
-import { fetchDomainPublication } from '../domain-publication'
+import { releaseFor } from '../../__tests__/fixtures/publication'
+import { domainPublicationUrl, fetchDomainPublication } from '../domain-publication'
 
 const ROOT = 'https://publication-reader.example.dev'
 const PUBLICATION_URL = `${ROOT}/.well-known/astrale/domain.json`
 const MAXIMUM_PUBLICATION_BYTES = 1024 * 1024
 const schema = defineSchema('publication-reader.example.dev', {})
-const definition = defineDomain({
-  schema,
-  handlers: { functions: {}, classes: {}, interfaces: {} },
-})
-const deployed = createDeployment({
-  definition,
-  issuer: issuer.accept(ROOT),
-  bundleHref: `${ROOT}/domain.bundle.json`,
-  bindings: { callables: [] },
-}).publication
+const deployed = releaseFor(schema, ROOT).publication
 
 describe('Domain Publication reader', () => {
   test('fetches only the canonical path with redirects disabled', async () => {
@@ -34,6 +23,11 @@ describe('Domain Publication reader', () => {
     expect(requests).toEqual([{ url: PUBLICATION_URL, redirect: 'error' }])
   })
 
+  test('normalizes an origin and admits the exact canonical Publication URL', () => {
+    expect(domainPublicationUrl(ROOT).href).toBe(PUBLICATION_URL)
+    expect(domainPublicationUrl(PUBLICATION_URL).href).toBe(PUBLICATION_URL)
+  })
+
   test('propagates redirect rejection instead of accepting another target', async () => {
     const fetch = async (_input: RequestInfo | URL, init?: RequestInit): Promise<Response> => {
       expect(init?.redirect).toBe('error')

package/src/lib/__tests__/idp.test.ts

@@ -9,6 +9,7 @@ import {
   IdpSessionSchema,
   isSessionExpired,
   issuerFromToken,
+  legacyBuiltinWorkosReplacement,
   normalizeTokenResponse,
   OAuthTokenError,
   OidcMetadataSchema,
@@ -63,8 +64,11 @@ describe('IdP schemas and token helpers', () => {
     expect(config?.client.token_request_format).toBe('json')
   })
 
-  test('does not invent a WorkOS environment when no client id is configured', () => {
-    expect(builtinIdpConfig('workos', undefined, {})).toBeNull()
+  test('builds the built-in WorkOS IdP with the public client id by default', () => {
+    const config = builtinIdpConfig('workos', undefined, {})
+
+    expect(config?.entry.builtIn).toBe(true)
+    expect(config?.client.client_id).toBe('client_01KC29HET5F3QAQ8GNTPZ7F320')
   })
 
   test('reads WorkOS client id from WORKOS_CLIENT_ID before VITE_WORKOS_CLIENT_ID', () => {
@@ -75,8 +79,34 @@ describe('IdP schemas and token helpers', () => {
       }),
     ).toBe('client_primary')
     expect(workosClientIdFromEnv({ VITE_WORKOS_CLIENT_ID: 'client_vite' })).toBe('client_vite')
-    expect(workosClientIdFromEnv({})).toBeUndefined()
-    expect(workosClientIdFromEnv({ WORKOS_CLIENT_ID: '   ' })).toBeUndefined()
+    expect(workosClientIdFromEnv({})).toBe('client_01KC29HET5F3QAQ8GNTPZ7F320')
+    expect(workosClientIdFromEnv({ WORKOS_CLIENT_ID: '   ' })).toBe(
+      'client_01KC29HET5F3QAQ8GNTPZ7F320',
+    )
+  })
+
+  test('replaces only the legacy persisted built-in WorkOS client', () => {
+    const legacy = builtinIdpConfig('workos', 'client_01KC29HEGD7B40TV2C4QZ436BG', {})!
+    const replacement = legacyBuiltinWorkosReplacement(legacy, undefined, {})
+
+    expect(replacement?.client.client_id).toBe('client_01KC29HET5F3QAQ8GNTPZ7F320')
+    expect(replacement?.metadata.jwks_uri).toBe(
+      'https://api.workos.com/sso/jwks/client_01KC29HET5F3QAQ8GNTPZ7F320',
+    )
+    expect(
+      legacyBuiltinWorkosReplacement(
+        { ...legacy, entry: { ...legacy.entry, builtIn: false } },
+        undefined,
+        {},
+      ),
+    ).toBeUndefined()
+    expect(
+      legacyBuiltinWorkosReplacement(
+        { ...legacy, client: { ...legacy.client, client_id: 'client_custom' } },
+        undefined,
+        {},
+      ),
+    ).toBeUndefined()
   })
 
   test('stores client secret env names, not secret material', () => {

package/src/lib/__tests__/instance-candidates.test.ts

@@ -18,7 +18,6 @@ const managedDemo: OwnedInstanceInfo = {
   slug: 'demo',
   url: 'https://demo.eu.astrale.ai',
   state: 'ready',
-  region: 'eu',
 }
 
 describe('collectInstanceCandidates', () => {
@@ -138,11 +137,10 @@ describe('describeInstanceCandidate', () => {
         slug: 'twin',
         url: 'https://twin.eu.astrale.ai',
         state: 'ready',
-        region: 'eu',
       },
     ])
     expect(describeInstanceCandidate(managed!)).toBe(
-      'twin (managed) https://twin.eu.astrale.ai/api — eu',
+      'twin (managed) https://twin.eu.astrale.ai/api',
     )
   })
 })

package/src/lib/__tests__/instance-target.test.ts

@@ -3,6 +3,7 @@ import { describe, expect, test } from 'bun:test'
 import type { AstraleConfig } from '../config'
 import type { InstanceStore } from '../instance'
 
+import { AdminInstanceNotFoundError } from '../../admin/instance/model'
 import { AstraleError } from '../../errors'
 import { DEFAULT_CONFIG } from '../config'
 import {
@@ -112,6 +113,7 @@ describe('resolveInstanceTarget', () => {
             id: 'node-1',
             slug,
             url: `https://${slug}.eu.astrale.ai`,
+            state: 'ready',
           }),
         },
       ),
@@ -124,9 +126,6 @@ describe('resolveInstanceTarget', () => {
   })
 
   test('unknown slugs surface the original instance-not-found error', async () => {
-    const notFound = new Error('Path not found: "/admin/instances/missing"')
-    notFound.name = 'NotFoundError'
-
     await expect(
       resolveInstanceTarget(
         { source: 'name', name: 'missing' },
@@ -134,7 +133,7 @@ describe('resolveInstanceTarget', () => {
           config: DEFAULT_CONFIG,
           instances: emptyStore,
           managed: async () => {
-            throw notFound
+            throw new AdminInstanceNotFoundError('missing')
           },
         },
       ),
@@ -168,14 +167,8 @@ describe('instance target helpers', () => {
     expect(couldBeConfiguredAdminInstance('bryan', directAdminConfig)).toBe(false)
   })
 
-  test('treats wrapped remote Instance.info misses as managed lookup not-found', () => {
-    const wrapped = new Error('Path not found: "/admin/instances/admin"') as Error & {
-      data?: unknown
-    }
-    wrapped.name = 'KernelError'
-    wrapped.data = { type: 'NotFoundError' }
-
-    expect(isManagedInstanceNotFound(wrapped)).toBe(true)
+  test('treats the owner-scoped Admin error as managed lookup not-found', () => {
+    expect(isManagedInstanceNotFound(new AdminInstanceNotFoundError('admin'))).toBe(true)
   })
 
   test('does not hide non-not-found managed lookup failures', () => {
@@ -194,37 +187,12 @@ describe('instance target helpers', () => {
   })
 })
 
-describe('isManagedInstanceNotFound: kernel InternalKernelError wrap', () => {
-  test('NOT_FOUND-prefixed InternalKernelError is an instance miss', () => {
-    const e = new Error('NOT_FOUND: no instance node for "knowledge"')
-    e.name = 'InternalKernelError'
-    expect(isManagedInstanceNotFound(e)).toBe(true)
-  })
-  test('other InternalKernelError messages are not swallowed', () => {
+describe('isManagedInstanceNotFound: unknown errors', () => {
+  test('does not infer a miss from an InternalKernelError message', () => {
     const e = new Error('DISPATCH_FAILED: handler crashed')
     e.name = 'InternalKernelError'
     expect(isManagedInstanceNotFound(e)).toBe(false)
   })
-  test('resolveNamedInstanceTarget maps the wrap to typed INSTANCE_NOT_FOUND', async () => {
-    const managed = async () => {
-      const e = new Error('NOT_FOUND: no instance node for "ghost"')
-      e.name = 'InternalKernelError'
-      throw e
-    }
-    const opts = {
-      config: DEFAULT_CONFIG,
-      instances: { instances: {} },
-      managed,
-    } as unknown as Parameters<typeof resolveInstanceTarget>[1]
-    let caught: unknown
-    try {
-      await resolveInstanceTarget({ source: 'name', name: 'ghost' }, opts)
-    } catch (e) {
-      caught = e
-    }
-    expect(caught).toBeInstanceOf(AstraleError)
-    expect((caught as AstraleError).code).toBe('INSTANCE_NOT_FOUND')
-  })
 
   test('maps Admin token-exchange failure to INSTANCE_NOT_FOUND', async () => {
     const managed = async () => {

package/src/lib/__tests__/log-errors.test.ts

@@ -0,0 +1,64 @@
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test'
+
+import { AstraleError } from '../../errors'
+import { failInput, fatal } from '../log'
+
+class ExitError extends Error {}
+
+let stderr = ''
+let exit: typeof process.exit
+let write: typeof process.stderr.write
+
+beforeEach(() => {
+  stderr = ''
+  exit = process.exit
+  write = process.stderr.write
+  process.exit = (() => {
+    throw new ExitError()
+  }) as typeof process.exit
+  process.stderr.write = ((chunk: string | Uint8Array) => {
+    stderr += String(chunk)
+    return true
+  }) as typeof process.stderr.write
+})
+
+afterEach(() => {
+  process.exit = exit
+  process.stderr.write = write
+})
+
+describe('terminal error safety', () => {
+  test('renders an empty aggregate as an honest non-blank unexpected failure', () => {
+    expect(() => fatal(new AggregateError([], ''), { json: true })).toThrow(ExitError)
+    expect(JSON.parse(stderr)).toEqual({
+      error: 'UNEXPECTED_ERROR',
+      message: 'The CLI encountered an unexpected internal failure.',
+    })
+  })
+
+  test('retains unknown failure evidence only under explicit debug output', () => {
+    const failure = new AggregateError([new Error('provider rejected organization scope')], '')
+
+    expect(() => fatal(failure, { json: true, debug: true })).toThrow(ExitError)
+
+    expect(stderr).toContain(
+      '{"error":"UNEXPECTED_ERROR","message":"The CLI encountered an unexpected internal failure."}',
+    )
+    expect(stderr).toContain('aggregate: Error: provider rejected organization scope')
+  })
+
+  test('rejects blank admitted CLI diagnostics', () => {
+    expect(() => new AstraleError('INVALID_INPUT', '  ')).toThrow(TypeError)
+  })
+
+  test('labels only expected admission failures as invalid input', () => {
+    expect(() => failInput(new TypeError('Authored value is invalid.'), { json: true })).toThrow(
+      ExitError,
+    )
+    expect(JSON.parse(stderr)).toMatchObject({ error: 'INVALID_INPUT' })
+
+    stderr = ''
+    expect(() => failInput(new AggregateError([], ''), { json: true })).toThrow(ExitError)
+    expect(JSON.parse(stderr)).toMatchObject({ error: 'UNEXPECTED_ERROR' })
+  })
+})