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

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

@@ -1,81 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-
-import { DEFAULT_ADMIN_DOMAIN_ISSUER, DEFAULT_ADMIN_TARGET_URL } from '../admin-target'
-import { AstraleConfigSchema } from '../config'
-
-describe('AstraleConfigSchema', () => {
-  test('parses valid config', () => {
-    const result = AstraleConfigSchema.parse({
-      issuer: 'https://test.astrale.ai',
-    })
-    expect(result.issuer).toBe('https://test.astrale.ai')
-    expect(result.admin.url).toBe(DEFAULT_ADMIN_TARGET_URL)
-  })
-
-  test('applies defaults for empty object', () => {
-    const result = AstraleConfigSchema.parse({})
-    expect(result.issuer).toBe('https://unregistered.invalid')
-    expect(result.admin).toEqual({
-      name: 'admin',
-      url: DEFAULT_ADMIN_TARGET_URL,
-      kernelIssuer: DEFAULT_ADMIN_TARGET_URL,
-      domainIssuer: DEFAULT_ADMIN_DOMAIN_ISSUER,
-    })
-  })
-
-  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()
-  })
-
-  test('strips removed local-runtime config keys', () => {
-    const result = AstraleConfigSchema.parse({
-      issuer: 'https://test.astrale.ai',
-      managerPort: 9000,
-      removedRuntimeKey: true,
-    })
-    expect('managerPort' in result).toBe(false)
-    expect('removedRuntimeKey' in result).toBe(false)
-  })
-
-  test('accepts configured admin bookmark', () => {
-    const result = AstraleConfigSchema.parse({
-      admin: { instance: 'staging-admin' },
-    })
-    expect(result.admin).toEqual({ instance: 'staging-admin' })
-  })
-
-  test('rejects admin config with url and instance together', () => {
-    expect(() =>
-      AstraleConfigSchema.parse({
-        admin: { url: DEFAULT_ADMIN_TARGET_URL, instance: 'admin' },
-      }),
-    ).toThrow()
-  })
-})

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

@@ -1,99 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-
-import { IdentifierCollisionError, ReservedSlugError } from '../../errors'
-import { InstanceStoreSchema, assertNoCollision, resolveInstanceKey } from '../instance'
-import { validateSlug } from '../validation'
-
-const baseStore = InstanceStoreSchema.parse({
-  active: 'staging',
-  instances: {
-    staging: {
-      url: 'https://staging.example.com',
-      createdAt: '2024-02-01T00:00:00Z',
-      slug: 'staging',
-      name: 'Staging Cluster',
-      kind: 'bookmark',
-      mode: 'remote',
-    },
-    localdev: {
-      url: 'https://localdev.example.com',
-      createdAt: '2024-02-02T00:00:00Z',
-      slug: 'localdev',
-      kind: 'bookmark',
-      mode: 'remote',
-    },
-  },
-})
-
-describe('DESIGN — §4.7 slug + namespace', () => {
-  test('validateSlug accepts URL-safe slugs', () => {
-    expect(() => validateSlug('foo')).not.toThrow()
-    expect(() => validateSlug('foo-bar')).not.toThrow()
-    expect(() => validateSlug('f00-bar-1')).not.toThrow()
-  })
-
-  test('validateSlug rejects invalid slugs', () => {
-    expect(() => validateSlug('Foo')).toThrow(/Invalid slug/)
-    expect(() => validateSlug('-foo')).toThrow(/Invalid slug/)
-    expect(() => validateSlug('foo_bar')).toThrow(/Invalid slug/)
-    expect(() => validateSlug('foo.bar')).toThrow(/Invalid slug/)
-    expect(() => validateSlug('')).toThrow(/Invalid slug/)
-  })
-
-  test('validateSlug rejects reserved "manager"', () => {
-    expect(() => validateSlug('manager')).toThrow(ReservedSlugError)
-  })
-
-  test('assertNoCollision rejects existing key', () => {
-    expect(() => assertNoCollision(baseStore, ['staging'])).toThrow(IdentifierCollisionError)
-  })
-
-  test('assertNoCollision rejects existing slug', () => {
-    expect(() => assertNoCollision(baseStore, ['localdev'])).toThrow(IdentifierCollisionError)
-  })
-
-  test('assertNoCollision rejects existing name', () => {
-    expect(() => assertNoCollision(baseStore, ['Staging Cluster'])).toThrow(
-      IdentifierCollisionError,
-    )
-  })
-
-  test('assertNoCollision accepts new identifier', () => {
-    expect(() => assertNoCollision(baseStore, ['newname'])).not.toThrow()
-  })
-
-  test('assertNoCollision ignoreKey skips that entry', () => {
-    expect(() =>
-      assertNoCollision(baseStore, ['staging', 'Staging Cluster'], 'staging'),
-    ).not.toThrow()
-  })
-})
-
-describe('DESIGN — §7 resolver', () => {
-  test('resolveInstanceKey matches by key', () => {
-    expect(resolveInstanceKey(baseStore, 'staging')).toBe('staging')
-  })
-
-  test('resolveInstanceKey matches by slug', () => {
-    expect(resolveInstanceKey(baseStore, 'localdev')).toBe('localdev')
-  })
-
-  test('resolveInstanceKey matches by name', () => {
-    expect(resolveInstanceKey(baseStore, 'Staging Cluster')).toBe('staging')
-  })
-
-  test('resolveInstanceKey returns null on miss', () => {
-    expect(resolveInstanceKey(baseStore, 'nope')).toBeNull()
-  })
-})
-
-describe('DESIGN — backward compat registry', () => {
-  test('legacy store without kind/slug/mode parses', () => {
-    const legacy = InstanceStoreSchema.parse({
-      active: 'old',
-      instances: { old: { url: 'http://x', createdAt: '2023-01-01' } },
-    })
-    expect(legacy.instances.old.kind).toBeUndefined()
-    expect(legacy.instances.old.mode).toBeUndefined()
-  })
-})

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

@@ -1,138 +0,0 @@
-import { publication } from '@astrale-os/sdk/publication'
-import { defineSchema } from '@astrale-os/sdk/schema'
-import { describe, expect, test } from 'bun:test'
-
-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 deployed = releaseFor(schema, ROOT).publication
-
-describe('Domain Publication reader', () => {
-  test('fetches only the canonical path with redirects disabled', async () => {
-    const requests: Array<{ readonly url: string; readonly redirect?: RequestRedirect }> = []
-    const fetch = async (input: RequestInfo | URL, init?: RequestInit): Promise<Response> => {
-      requests.push({ url: String(input), redirect: init?.redirect })
-      return Response.json(deployed)
-    }
-
-    await expect(fetchDomainPublication(`${ROOT}/`, undefined, fetch)).resolves.toEqual(deployed)
-    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')
-      throw new TypeError('redirect rejected')
-    }
-
-    await expect(fetchDomainPublication(ROOT, undefined, fetch)).rejects.toThrow(
-      'redirect rejected',
-    )
-  })
-
-  test('stops at one MiB and cancels an over-limit response stream', async () => {
-    let pulls = 0
-    let cancelled = false
-    const body = new ReadableStream<Uint8Array>(
-      {
-        pull(controller) {
-          pulls += 1
-          if (pulls === 1) {
-            controller.enqueue(new Uint8Array(MAXIMUM_PUBLICATION_BYTES))
-            return
-          }
-          if (pulls === 2) {
-            controller.enqueue(Uint8Array.of(0))
-            return
-          }
-          controller.error(new Error('reader consumed beyond its byte limit'))
-        },
-        cancel() {
-          cancelled = true
-        },
-      },
-      { highWaterMark: 0 },
-    )
-    const fetch = async (): Promise<Response> => new Response(body)
-
-    await expect(fetchDomainPublication(ROOT, undefined, fetch)).rejects.toThrow(
-      `exceeded ${MAXIMUM_PUBLICATION_BYTES} bytes`,
-    )
-    expect(pulls).toBe(2)
-    expect(cancelled).toBe(true)
-  })
-
-  test('rejects an oversized Content-Length before pulling and cancels the body', async () => {
-    let pulls = 0
-    let cancelled = false
-    const body = new ReadableStream<Uint8Array>(
-      {
-        pull() {
-          pulls += 1
-        },
-        cancel() {
-          cancelled = true
-        },
-      },
-      { highWaterMark: 0 },
-    )
-    const fetch = async (): Promise<Response> =>
-      new Response(body, {
-        headers: { 'content-length': String(MAXIMUM_PUBLICATION_BYTES + 1) },
-      })
-
-    await expect(fetchDomainPublication(ROOT, undefined, fetch)).rejects.toThrow(
-      `exceeded ${MAXIMUM_PUBLICATION_BYTES} bytes`,
-    )
-    expect(pulls).toBe(0)
-    expect(cancelled).toBe(true)
-  })
-
-  test.each([
-    ['invalid UTF-8', Uint8Array.of(0xc3, 0x28), TypeError],
-    ['invalid JSON', new TextEncoder().encode('{'), SyntaxError],
-    ['invalid Publication', new TextEncoder().encode('{}'), publication.PublicationError],
-  ] as const)('rejects %s before returning a Publication', async (_label, bytes, Cause) => {
-    const fetch = async (): Promise<Response> => new Response(bytes)
-    const error = await rejection(fetchDomainPublication(ROOT, undefined, fetch))
-
-    expect(error.message).toBe(`GET ${PUBLICATION_URL} returned an invalid Domain Publication`)
-    expect(error.cause).toBeInstanceOf(Cause)
-  })
-
-  test.each([
-    `${ROOT}/nested`,
-    `${ROOT}?deployment=current`,
-    `${ROOT}#fragment`,
-    'https://user:secret@publication-reader.example.dev',
-    'ftp://publication-reader.example.dev',
-  ])('rejects a non-origin deployment URL before fetch: %s', async (input) => {
-    let called = false
-    const fetch = async (): Promise<Response> => {
-      called = true
-      return Response.json(deployed)
-    }
-
-    await expect(fetchDomainPublication(input, undefined, fetch)).rejects.toBeInstanceOf(TypeError)
-    expect(called).toBe(false)
-  })
-})
-
-async function rejection(input: Promise<unknown>): Promise<Error> {
-  try {
-    await input
-  } catch (cause) {
-    if (cause instanceof Error) return cause
-    throw new Error('Expected an Error rejection.', { cause })
-  }
-  throw new Error('Expected the promise to reject.')
-}

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

@@ -1,22 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-
-import { formatElapsed } from '../format'
-
-describe('formatElapsed', () => {
-  test('formats milliseconds under 1s', () => {
-    expect(formatElapsed(50)).toBe('50ms')
-    expect(formatElapsed(999)).toBe('999ms')
-    expect(formatElapsed(0)).toBe('0ms')
-  })
-
-  test('rounds fractional ms', () => {
-    expect(formatElapsed(50.7)).toBe('51ms')
-    expect(formatElapsed(0.4)).toBe('0ms')
-  })
-
-  test('formats seconds at 1000ms+', () => {
-    expect(formatElapsed(1000)).toBe('1.00s')
-    expect(formatElapsed(1500)).toBe('1.50s')
-    expect(formatElapsed(12345)).toBe('12.35s')
-  })
-})

package/src/lib/__tests__/idp-session.driver.ts

@@ -1,60 +0,0 @@
-/**
- * Subprocess driver for idp-session.test.ts. `ensureFreshSession` resolves
- * paths through the import-time ASTRALE_HOME singleton, and `bun test` shares
- * one process across files, so session-touching scenarios run here — in a
- * fresh process whose ASTRALE_HOME the test controls.
- *
- * Usage: bun idp-session.driver.ts <ensure|ensure-concurrent>
- * Env: ASTRALE_HOME (required), DRIVER_AUDIENCE, DRIVER_ORG_ID
- * Stdout: one JSON line describing the outcome.
- */
-import { accessTokenForAudience, classifyRefreshFailure } from '../idp'
-import { ensureFreshSession } from '../idp-session'
-
-const scenario = process.argv[2]
-const audience = process.env.DRIVER_AUDIENCE || undefined
-const minimumRemainingSeconds = process.env.DRIVER_MINIMUM_SECONDS
-  ? Number(process.env.DRIVER_MINIMUM_SECONDS)
-  : undefined
-let orgHintCalls = 0
-const resolveOrganizationId = async (): Promise<string | undefined> => {
-  orgHintCalls += 1
-  return process.env.DRIVER_ORG_ID || undefined
-}
-
-function print(result: Record<string, unknown>): void {
-  process.stdout.write(JSON.stringify(result) + '\n')
-}
-
-try {
-  if (scenario === 'ensure') {
-    const session = await ensureFreshSession('alice', {
-      audience,
-      minimumRemainingSeconds,
-      resolveOrganizationId,
-    })
-    print({ ok: true, token: accessTokenForAudience(session, audience), orgHintCalls })
-  } else if (scenario === 'ensure-concurrent') {
-    const [a, b] = await Promise.all([
-      ensureFreshSession('alice', { audience, minimumRemainingSeconds, resolveOrganizationId }),
-      ensureFreshSession('alice', { audience, minimumRemainingSeconds, resolveOrganizationId }),
-    ])
-    print({
-      ok: true,
-      tokens: [accessTokenForAudience(a, audience), accessTokenForAudience(b, audience)],
-      orgHintCalls,
-    })
-  } else {
-    throw new Error(`Unknown scenario: ${scenario}`)
-  }
-} catch (e) {
-  const error = e as Error & { code?: string }
-  print({
-    ok: false,
-    errorName: error.name,
-    errorCode: error.code,
-    classification: classifyRefreshFailure(e),
-    message: error.message,
-    orgHintCalls,
-  })
-}