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

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

@@ -1,280 +0,0 @@
-import type { IntentMessage, MountedWindow, ResolvedView, Shell } from '@astrale-os/shell'
-
-import { NO_HOST_CAPABILITIES } from '@astrale-os/shell'
-import { describe, expect, test } from 'bun:test'
-
-import {
-  handleOpenIntent,
-  installOpenIntentHandler,
-  type OpenIntentHost,
-} from '../view/open-intent'
-
-const digest = (character: string) => `sha256:${character.repeat(64)}` as const
-const target = (value: string) => value as ResolvedView['target']
-const issuer = (value: string) => value as ResolvedView['route']['issuer']
-const revision = (character: string) => digest(character) as ResolvedView['route']['revision']
-
-const profile: ResolvedView = {
-  target: target('@person-1'),
-  route: {
-    key: 'shell.test:view.profile',
-    declaration: {
-      target: {
-        kind: 'definition',
-        definitions: [{ origin: 'shell.test', kind: 'class', name: 'Person' }],
-      },
-    },
-    href: 'https://shell.test/profile',
-    handshake: 'shell',
-    issuer: issuer('https://shell.test'),
-    etag: digest('a'),
-    revision: revision('b'),
-  },
-}
-const card: ResolvedView = {
-  target: target('@person-1'),
-  route: {
-    key: 'shell.test:view.card',
-    declaration: {
-      target: {
-        kind: 'definition',
-        definitions: [{ origin: 'shell.test', kind: 'class', name: 'Person' }],
-      },
-    },
-    href: 'https://shell.test/card',
-    handshake: 'none',
-    issuer: issuer('https://shell.test'),
-    etag: digest('c'),
-    revision: revision('d'),
-  },
-}
-
-function openMessage(viewId?: string, correlationId?: string): IntentMessage<'open'> {
-  return {
-    type: 'intent',
-    version: 1,
-    envelope: {
-      name: 'open',
-      payload: { nodeId: 'person-1', ...(viewId ? { viewId } : {}) },
-      sender: { windowId: 'old-window' },
-      ...(correlationId ? { correlationId } : {}),
-    },
-  }
-}
-
-function mounted(windowId: string, onClose?: () => void): MountedWindow {
-  return {
-    windowId,
-    window: {
-      windowId,
-      functionId: 'shell.test:view.profile',
-      targetNodeId: '@person-1',
-      children: [],
-      view: profile,
-      location: { target: '@person-1', params: {} },
-      presentation: { kind: 'inline', constrained: false },
-      isolation: 'shared',
-      state: 'ready',
-      credential: { state: 'none' },
-      capabilities: NO_HOST_CAPABILITIES,
-    },
-    handle: { element: {} as HTMLElement },
-    credential: { state: 'none' },
-    presentation: { kind: 'inline', constrained: false },
-    focus() {},
-    close: async () => {
-      onClose?.()
-      return { kind: 'closed' }
-    },
-  }
-}
-
-function harness(views: readonly ResolvedView[] = [profile, card]) {
-  const events: string[] = []
-  const sent: { windowId: string; message: IntentMessage }[] = []
-  const old = mounted('old-window', () => events.push('close:old-window'))
-  let current: MountedWindow | null = old
-  const shell = {
-    views: {
-      resolve: async (node: string) => {
-        events.push(`resolve:${node}`)
-        return views
-      },
-    },
-  } as unknown as Pick<Shell, 'views'>
-  const host: OpenIntentHost = {
-    current: () => current,
-    setCurrent: (next) => {
-      events.push(`current:${next.windowId}`)
-      current = next
-    },
-    mount: async (view) => {
-      events.push(`mount:${view.route.key}:${view.target}`)
-      return mounted('new-window')
-    },
-    opened: (view) => events.push(`opened:${view.route.key}:${view.target}`),
-    failed: (error) => events.push(`failed:${error instanceof Error ? error.message : error}`),
-    reply: (message, windowId) => {
-      if (!message.envelope.correlationId) return
-      events.push(`reply:${message.envelope.sender.windowId}`)
-      sent.push({
-        windowId: message.envelope.sender.windowId,
-        message: {
-          type: 'intent',
-          version: 1,
-          envelope: {
-            name: 'intentReply',
-            payload: {
-              correlationId: message.envelope.correlationId,
-              result: { windowId },
-            },
-            sender: { windowId: 'root' },
-          },
-        },
-      })
-    },
-    reject: (message, error) => {
-      if (!message.envelope.correlationId) return
-      events.push(`reply:${message.envelope.sender.windowId}`)
-      sent.push({
-        windowId: message.envelope.sender.windowId,
-        message: {
-          type: 'intent',
-          version: 1,
-          envelope: {
-            name: 'intentReply',
-            payload: {
-              correlationId: message.envelope.correlationId,
-              error: { message: error instanceof Error ? error.message : String(error) },
-            },
-            sender: { windowId: 'root' },
-          },
-        },
-      })
-    },
-  }
-  return { events, sent, shell, host, current: () => current }
-}
-
-describe('open intent host', () => {
-  /** @evidence TEST-CLI-VIEW-OPEN-PRESERVES-RESOLVED-SELECTION */
-  test('uses the complete resolved placement and replies before retiring the requester', async () => {
-    const h = harness()
-    await handleOpenIntent(h.shell, h.host, openMessage(undefined, 'corr-1'))
-
-    expect(h.events).toEqual([
-      'resolve:person-1',
-      'mount:shell.test:view.profile:@person-1',
-      'current:new-window',
-      'opened:shell.test:view.profile:@person-1',
-      'reply:old-window',
-      'close:old-window',
-    ])
-    expect(h.current()?.windowId).toBe('new-window')
-    expect(h.sent[0]).toMatchObject({
-      windowId: 'old-window',
-      message: {
-        envelope: {
-          payload: { correlationId: 'corr-1', result: { windowId: 'new-window' } },
-        },
-      },
-    })
-  })
-
-  test('selects an explicit canonical View key without flattening its placement', async () => {
-    const h = harness()
-    await handleOpenIntent(h.shell, h.host, openMessage('shell.test:view.card'))
-
-    expect(h.events).toContain('mount:shell.test:view.card:@person-1')
-    expect(h.sent).toEqual([])
-  })
-
-  test('keeps the current view and rejects a correlated resolution failure', async () => {
-    const h = harness([])
-    await handleOpenIntent(h.shell, h.host, openMessage(undefined, 'corr-fail'))
-
-    expect(h.current()?.windowId).toBe('old-window')
-    expect(h.events).toEqual([
-      'resolve:person-1',
-      'reply:old-window',
-      'failed:No view resolves for this node',
-    ])
-  })
-
-  /** @evidence TEST-CLI-VIEW-HANDSHAKE-FAILS-CLOSED */
-  test('makes one replacement mount attempt and never retries as a different placement mode', async () => {
-    const h = harness([profile])
-    let attempts = 0
-    h.host.mount = async (view) => {
-      attempts++
-      h.events.push(`mount:${view.route.handshake}:failed`)
-      throw new Error('handshake failed')
-    }
-
-    await handleOpenIntent(h.shell, h.host, openMessage(undefined, 'corr-mount'))
-
-    expect(attempts).toBe(1)
-    expect(h.current()?.windowId).toBe('old-window')
-    expect(h.events).toEqual([
-      'resolve:person-1',
-      'mount:shell:failed',
-      'reply:old-window',
-      'failed:handshake failed',
-    ])
-  })
-
-  test('serializes overlapping opens', async () => {
-    let handler: ((message: IntentMessage<'open'>) => Promise<void>) | undefined
-    let releaseFirst!: () => void
-    const firstGate = new Promise<void>((resolve) => {
-      releaseFirst = resolve
-    })
-    let resolveCount = 0
-    const base = harness([profile])
-    const events = base.events
-    const shell = {
-      ...base.shell,
-      views: {
-        resolve: async () => {
-          resolveCount += 1
-          events.push(`resolve:${resolveCount}`)
-          if (resolveCount === 1) await firstGate
-          return [profile]
-        },
-      },
-      onIntent: (_name: 'open', next: typeof handler) => {
-        handler = next
-        return () => {}
-      },
-    } as unknown as Shell
-    const host = {
-      ...base.host,
-      mount: async () => {
-        const id = `new-${resolveCount}`
-        events.push(`mount:${id}`)
-        return mounted(id, () => events.push(`close:${id}`))
-      },
-    }
-    installOpenIntentHandler(shell, host)
-
-    const first = handler!(openMessage())
-    const second = handler!(openMessage())
-    await Promise.resolve()
-    expect(events).toEqual(['resolve:1'])
-    releaseFirst()
-    await Promise.all([first, second])
-    expect(events).toEqual([
-      'resolve:1',
-      'mount:new-1',
-      'current:new-1',
-      'opened:shell.test:view.profile:@person-1',
-      'close:old-window',
-      'resolve:2',
-      'mount:new-2',
-      'current:new-2',
-      'opened:shell.test:view.profile:@person-1',
-      'close:new-1',
-    ])
-    expect(base.current()?.windowId).toBe('new-2')
-  })
-})

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

@@ -1,82 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test } from 'bun:test'
-import { mkdtemp, rm } from 'node:fs/promises'
-import net from 'node:net'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-
-import { findFreePort } from '../port'
-import { withViewPortAllocationLock } from '../view/port-allocation'
-
-let tmp: string
-
-beforeEach(async () => {
-  tmp = await mkdtemp(join(tmpdir(), 'astrale-view-port-'))
-})
-
-afterEach(async () => {
-  await rm(tmp, { recursive: true, force: true })
-})
-
-function listen(port: number): Promise<net.Server> {
-  return new Promise((resolve, reject) => {
-    const server = net.createServer()
-    server.once('error', reject)
-    server.listen({ port, host: '127.0.0.1', exclusive: true }, () => resolve(server))
-  })
-}
-
-function close(server: net.Server): Promise<void> {
-  return new Promise((resolve, reject) => {
-    server.close((error) => (error ? reject(error) : resolve()))
-  })
-}
-
-describe('view port allocation', () => {
-  test('never overlaps concurrent allocation critical sections', async () => {
-    const lockPath = join(tmp, 'ports.lock')
-    let active = 0
-    let maxActive = 0
-
-    const contender = () =>
-      withViewPortAllocationLock(async () => {
-        active++
-        maxActive = Math.max(maxActive, active)
-        await Bun.sleep(40)
-        active--
-      }, lockPath)
-
-    await Promise.all([contender(), contender()])
-
-    // Without the view-specific lock both contenders enter before either
-    // delay completes, making this 2 and recreating the probe/bind window.
-    expect(maxActive).toBe(1)
-  })
-
-  test('serializes concurrent probe-then-listen allocations', async () => {
-    const base = await findFreePort(48000, 200)
-    expect(base).not.toBeNull()
-    if (base === null) throw new Error('test port window exhausted')
-    const lockPath = join(tmp, 'ports.lock')
-
-    const allocate = () =>
-      withViewPortAllocationLock(async () => {
-        const port = await findFreePort(base, 4)
-        if (port === null) throw new Error('test port window exhausted')
-
-        // Widen the exact pre-fix race: both callers would finish the advisory
-        // probe before either one binds, then one would fail with EADDRINUSE.
-        await Bun.sleep(40)
-        const server = await listen(port)
-        return { port, server }
-      }, lockPath)
-
-    const allocations = await Promise.all([allocate(), allocate()])
-    try {
-      const ports = allocations.map(({ port }) => port).sort((a, b) => a - b)
-      expect(ports[0]).toBe(base)
-      expect(ports[1]).toBeGreaterThan(base)
-    } finally {
-      await Promise.all(allocations.map(({ server }) => close(server)))
-    }
-  })
-})

package/src/lib/__tests__/view-server.test.ts

@@ -1,91 +0,0 @@
-import type { AuthApi } from '@astrale-os/sdk/auth'
-
-import { describe, expect, mock, test } from 'bun:test'
-import { once } from 'node:events'
-
-import type { ViewServeConfig } from '../view/session'
-
-import { findFreePort } from '../port'
-import { mintViewCredential, startViewServer } from '../view/server'
-
-const digest = (character: string) => `sha256:${character.repeat(64)}` as const
-const target = (value: string) => value as ViewServeConfig['session']['view']['target']
-const issuer = (value: string) => value as ViewServeConfig['session']['view']['route']['issuer']
-const revision = (character: string) =>
-  digest(character) as ViewServeConfig['session']['view']['route']['revision']
-
-describe('view session server credentials', () => {
-  test('mints a proof-bounded credential for the Kernel audience', async () => {
-    const mint = mock(async () => 'minted-credential')
-    const auth = { mint } as unknown as Pick<AuthApi, 'mint'>
-
-    await expect(mintViewCredential(auth, issuer('https://kernel.test'))).resolves.toBe(
-      'minted-credential',
-    )
-    expect(mint).toHaveBeenCalledWith({
-      audience: 'https://kernel.test',
-      ttlSeconds: 240,
-    })
-  })
-
-  /** @evidence TEST-CLI-PLAIN-VIEW-RECEIVES-NO-CREDENTIAL */
-  test('refuses to mint a token for a handshake-none View', async () => {
-    const nonce = 'plain-view'
-    const port = await findFreePort(48_000, 200)
-    if (port === null) throw new Error('test port window exhausted')
-    const config = {
-      session: {
-        id: 'v-plain',
-        pid: 0,
-        port,
-        nonce,
-        pageUrl: `http://127.0.0.1:${port}/`,
-        view: {
-          target: target('/:example.test'),
-          route: {
-            key: 'example.test:view.public',
-            declaration: { target: { kind: 'domain' } },
-            href: 'https://example.test/ui/public',
-            handshake: 'none',
-            issuer: issuer('https://example.test'),
-            etag: digest('a'),
-            revision: revision('b'),
-          },
-        },
-        createdAt: '2026-08-20T00:00:00.000Z',
-      },
-      kernel: { creds: 'must-not-be-used' },
-      proxy: {
-        kernelUrl: 'https://kernel.test',
-        issuer: 'https://kernel.test',
-        direct: true,
-      },
-      externalOrigins: ['https://connect.nango.dev'],
-      idleMs: 60_000,
-    } satisfies ViewServeConfig
-    const server = startViewServer(config)
-    await once(server, 'listening')
-
-    try {
-      const configResponse = await fetch(`http://127.0.0.1:${port}/s/${nonce}/config.json`)
-      expect(configResponse.status).toBe(200)
-      expect(await configResponse.json()).toMatchObject({
-        sessionId: 'v-plain',
-        externalOrigins: ['https://connect.nango.dev'],
-      })
-
-      const response = await fetch(`http://127.0.0.1:${port}/s/${nonce}/token`, {
-        method: 'POST',
-      })
-
-      expect(response.status).toBe(403)
-      expect(await response.json()).toEqual({
-        error: 'plain views have no Astrale credential privilege',
-      })
-    } finally {
-      await new Promise<void>((resolve, reject) => {
-        server.close((error) => (error ? reject(error) : resolve()))
-      })
-    }
-  })
-})

package/src/lib/__tests__/view-session.test.ts

@@ -1,100 +0,0 @@
-import { afterEach, describe, expect, test } from 'bun:test'
-import { closeSync } from 'node:fs'
-import { chmod, mkdir, mkdtemp, readFile, rm, stat } from 'node:fs/promises'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-
-import type { ViewServeConfig } from '../view/session'
-
-import {
-  configPath,
-  logPath,
-  openSessionLog,
-  recordPath,
-  removeSessionFiles,
-  saveRecord,
-  saveServeConfig,
-} from '../view/session'
-
-const temporaryDirectories: string[] = []
-
-afterEach(async () => {
-  await Promise.all(
-    temporaryDirectories.splice(0).map((path) => rm(path, { recursive: true, force: true })),
-  )
-})
-
-function mode(value: Awaited<ReturnType<typeof stat>>): number {
-  return Number(value.mode) & 0o777
-}
-
-const target = (value: string) => value as ViewServeConfig['session']['view']['target']
-const issuer = (value: string) => value as ViewServeConfig['session']['view']['route']['issuer']
-const revision = (character: string) =>
-  `sha256:${character.repeat(64)}` as ViewServeConfig['session']['view']['route']['revision']
-
-describe('view session private state', () => {
-  /** @evidence TEST-CLI-VIEW-CREDENTIAL-CONFIG-IS-OWNER-ONLY */
-  test('repairs directory/log modes and atomically stores raw carriers as 0600', async () => {
-    const root = await mkdtemp(join(tmpdir(), 'astrale-view-state-'))
-    temporaryDirectories.push(root)
-    const directory = join(root, 'view')
-    await mkdir(directory, { mode: 0o755 })
-    await chmod(directory, 0o755)
-
-    const config = {
-      session: {
-        id: 'v-a1b2c3',
-        pid: 0,
-        port: 4419,
-        nonce: 'nonce',
-        pageUrl: 'http://127.0.0.1:4419/s/nonce/',
-        view: {
-          target: target('/:example.test'),
-          route: {
-            key: 'example.test:view.main',
-            href: 'https://example.test/ui',
-            handshake: 'shell',
-            issuer: issuer('https://example.test'),
-            etag: `sha256:${'a'.repeat(64)}`,
-            revision: revision('b'),
-            declaration: { target: { kind: 'domain' } },
-          },
-        },
-        createdAt: '2026-08-12T00:00:00.000Z',
-      },
-      kernel: { creds: 'raw-secret-carrier' },
-      proxy: {
-        kernelUrl: 'https://kernel.test',
-        issuer: 'https://kernel.test',
-        direct: true,
-      },
-      externalOrigins: [],
-      idleMs: 60_000,
-    } satisfies ViewServeConfig
-
-    await saveServeConfig(config, directory)
-    await saveRecord(config.session, directory)
-    const descriptor = await openSessionLog(config.session.id, directory)
-    closeSync(descriptor)
-
-    expect(mode(await stat(directory))).toBe(0o700)
-    expect(mode(await stat(configPath(config.session.id, directory)))).toBe(0o600)
-    expect(mode(await stat(recordPath(config.session.id, directory)))).toBe(0o600)
-    expect(mode(await stat(logPath(config.session.id, directory)))).toBe(0o600)
-    expect(await readFile(configPath(config.session.id, directory), 'utf8')).toContain(
-      'raw-secret-carrier',
-    )
-
-    await removeSessionFiles(config.session.id, directory)
-    await expect(stat(configPath(config.session.id, directory))).rejects.toMatchObject({
-      code: 'ENOENT',
-    })
-    await expect(stat(recordPath(config.session.id, directory))).rejects.toMatchObject({
-      code: 'ENOENT',
-    })
-    await expect(stat(logPath(config.session.id, directory))).rejects.toMatchObject({
-      code: 'ENOENT',
-    })
-  })
-})

package/src/lib/__tests__/view-snapshot.test.ts

@@ -1,77 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-
-import type { AbResult } from '../browser'
-
-import { snapshotText, waitForSettledSnapshot } from '../view/snapshot'
-
-const pending = result('- paragraph\n  - StaticText "Opening integrations…"')
-const settled = result('- heading "Integrations" [level=1]\n- button "Connect Google" [ref=e4]')
-
-function result(snapshot: string): AbResult {
-  return { ok: true, data: { snapshot }, error: null }
-}
-
-function clock() {
-  let elapsed = 0
-  return {
-    now: () => elapsed,
-    sleep: async (ms: number) => {
-      elapsed += ms
-    },
-    elapsed: () => elapsed,
-  }
-}
-
-describe('view snapshot settling', () => {
-  test('waits through a late loading-to-content transition and a quiet window', async () => {
-    const fakeClock = clock()
-    let calls = 0
-    const takeSnapshot = async () => {
-      calls += 1
-      return fakeClock.elapsed() < 1_250 ? pending : settled
-    }
-
-    const snapshot = await waitForSettledSnapshot(takeSnapshot, fakeClock, {
-      timeoutMs: 4_000,
-      quietWindowMs: 750,
-      pollMs: 250,
-    })
-
-    expect(snapshotText(snapshot)).toContain('Connect Google')
-    expect(fakeClock.elapsed()).toBe(2_000)
-    expect(calls).toBe(10)
-  })
-
-  test('returns the latest permanently pending snapshot at the bound', async () => {
-    const fakeClock = clock()
-    let calls = 0
-    const takeSnapshot = async () => {
-      calls += 1
-      return pending
-    }
-
-    const snapshot = await waitForSettledSnapshot(takeSnapshot, fakeClock, {
-      timeoutMs: 1_000,
-      quietWindowMs: 500,
-      pollMs: 250,
-    })
-
-    expect(snapshot).toBe(pending)
-    expect(fakeClock.elapsed()).toBe(1_000)
-    expect(calls).toBe(6)
-  })
-
-  test('ignores changing agent-browser refs when measuring stability', async () => {
-    const fakeClock = clock()
-    let ref = 0
-
-    const snapshot = await waitForSettledSnapshot(
-      async () => result(`- button "Deploy" [ref=e${++ref}]`),
-      fakeClock,
-      { timeoutMs: 2_000, quietWindowMs: 500, pollMs: 250 },
-    )
-
-    expect(snapshotText(snapshot)).toContain('Deploy')
-    expect(fakeClock.elapsed()).toBe(500)
-  })
-})

package/src/lib/admin-domain.ts

@@ -1,43 +0,0 @@
-import type { AdminConnectionOptions, ConnectionContext } from '../connection'
-
-import { connectAdminCatalog, type DomainInfo, type PublishDomainInput } from '../admin/catalog'
-import { connectAdminInstances, type OwnedInstanceInfo } from '../admin/instance'
-import { withAdminClientSession } from '../connection'
-
-export type { DomainInfo, InstallDomainResult, PublishDomainInput } from '../admin/catalog'
-
-/** Read the caller-visible V2 Admin Domain catalog. */
-export function listAdminDomains(options: AdminConnectionOptions): Promise<DomainInfo[]> {
-  return withAdminClientSession(options, async (context) =>
-    (await connectAdminCatalog(context)).list(),
-  )
-}
-
-/** Reuse one open Admin session for catalog reads. */
-export async function listAdminDomainsInContext(context: ConnectionContext): Promise<DomainInfo[]> {
-  return (await connectAdminCatalog(context)).list()
-}
-
-/** Publish and optionally configure default installation through V2 receiver Methods. */
-export function publishAdminDomain(options: AdminConnectionOptions, input: PublishDomainInput) {
-  return withAdminClientSession(options, async (context) =>
-    (await connectAdminCatalog(context)).publish(input),
-  )
-}
-
-/** Install one resolved catalog Domain on one caller-visible Instance. */
-export async function installAdminDomainInContext(
-  context: ConnectionContext,
-  instance: OwnedInstanceInfo,
-  domain: DomainInfo,
-) {
-  const receipt = await (await connectAdminInstances(context)).installDomain(instance.id, domain.id)
-  return Object.freeze({
-    name: domain.name,
-    origin: receipt.origin,
-    instanceId: instance.slug,
-    url: domain.url ?? '',
-    ok: receipt.ok,
-    ...(receipt.error === undefined ? {} : { error: receipt.error }),
-  })
-}