@astrale-os/cli 0.8.0-alpha.0 → 0.8.1-alpha.2

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

@@ -1,272 +1,50 @@
 import { describe, expect, test } from 'bun:test'
-import { SignJWT } from 'jose'
-import { webcrypto } from 'node:crypto'
 
-import {
-  containsSelfRef,
-  expandSelfReferences,
-  resolveSelfNodeId,
-  selfRefusalError,
-  type SelfResolverContext,
-  type SelfResolution,
-} from '../self'
-
-// ── Regex behavior ───────────────────────────────────────────
+import { containsSelfRef, expandSelfReferences } from '../self'
 
 describe('containsSelfRef / expandSelfReferences', () => {
   const ID = 'node-abc-123'
 
-  // Cases that MUST match — documented positions only.
   test.each([
     ['@self', `@${ID}`],
     ['@self::deployFunction', `@${ID}::deployFunction`],
-    ['@self/functions', `@${ID}/functions`], // path navigation
+    ['@self/functions', `@${ID}/functions`],
     ['@self/functions/foo', `@${ID}/functions/foo`],
     ['node=@self', `node=@${ID}`],
     ['target=@self::method', `target=@${ID}::method`],
     ['target=@self/sub', `target=@${ID}/sub`],
-    ['x=@self::m  y=@self', `x=@${ID}::m  y=@${ID}`], // double match
-  ])('expands %p → %p', (input, expected) => {
+    ['x=@self::m  y=@self', `x=@${ID}::m  y=@${ID}`],
+  ])('expands %p -> %p', (input, expected) => {
     expect(containsSelfRef(input)).toBe(true)
     expect(expandSelfReferences(input, ID)).toBe(expected)
   })
 
-  // selfId carrying `String.replace` substitution metacharacters must not
-  // be re-interpreted (function-form replacement guards this).
   test.each([
     ['@self', 'x$&y', '@x$&y'],
     ['@self', 'x$$y', '@x$$y'],
     ['@self', 'x$1y', '@x$1y'],
     ['@self', 'x$`y', '@x$`y'],
     ['@self::m', 'x$&y', '@x$&y::m'],
-  ])('selfId with `$` metachars is treated literally: %p × %p → %p', (input, id, expected) => {
+  ])('treats replacement metacharacters literally: %p x %p -> %p', (input, id, expected) => {
     expect(expandSelfReferences(input, id)).toBe(expected)
   })
 
-  // Cases that MUST NOT match — substrings, JSON-like, comma-lists.
   test.each([
     'prefix@self',
     '@selfsuffix',
     '@self.example',
     '@self,@other',
     'node=before@self',
-    '{"ref":"@self"}', // inside quoted JSON — lookbehind requires `=` or `^`
+    '{"ref":"@self"}',
     'no-self-here',
-  ])('does NOT expand %p', (input) => {
+  ])('does not expand %p', (input) => {
     expect(containsSelfRef(input)).toBe(false)
     expect(expandSelfReferences(input, ID)).toBe(input)
   })
 
-  test('containsSelfRef is stateless across calls (regex.lastIndex reset)', () => {
-    // Both calls should return true even though the underlying global regex
-    // tracks lastIndex internally. The implementation must reset it.
+  test('is stateless across calls', () => {
     expect(containsSelfRef('@self')).toBe(true)
     expect(containsSelfRef('@self')).toBe(true)
     expect(containsSelfRef('@self')).toBe(true)
   })
 })
-
-// ── Resolver — refusal paths ─────────────────────────────────
-
-describe('resolveSelfNodeId refusals', () => {
-  test('bootstrap manager identity → manager', () => {
-    const ctx: SelfResolverContext = {
-      identity: { name: 'manager', subject: 'manager', createdAt: 'x' },
-      instanceSlug: 'manager',
-      instanceSigned: false,
-    }
-    const r = resolveSelfNodeId(ctx)
-    expect(r).toEqual({ reason: 'manager' })
-  })
-
-  test('identity without registration on slug → no-registration', () => {
-    const ctx: SelfResolverContext = {
-      identity: { name: 'alice', subject: 'alice', createdAt: 'x' },
-      instanceSlug: 'kernel-aidev',
-      instanceSigned: false,
-    }
-    const r = resolveSelfNodeId(ctx)
-    expect(r).toEqual({
-      reason: 'no-registration',
-      identityName: 'alice',
-      instanceSlug: 'kernel-aidev',
-    })
-  })
-
-  test('instance-signed path → instance-signed', () => {
-    const ctx: SelfResolverContext = {
-      identity: { name: 'manager', subject: 'manager', createdAt: 'x' },
-      instanceSlug: 'child-with-keypair',
-      instanceSigned: true,
-    }
-    const r = resolveSelfNodeId(ctx)
-    expect(r).toEqual({ reason: 'instance-signed', instanceSlug: 'child-with-keypair' })
-  })
-
-  test('no slug (--url without -i) → url-no-slug', () => {
-    const ctx: SelfResolverContext = {
-      identity: { name: 'alice', subject: 'alice', createdAt: 'x' },
-      instanceSlug: undefined,
-      instanceSigned: false,
-    }
-    const r = resolveSelfNodeId(ctx)
-    expect(r).toEqual({ reason: 'url-no-slug' })
-  })
-
-  test('--creds with malformed JWT → creds-no-sub', () => {
-    const ctx: SelfResolverContext = {
-      credsJwt: 'not-a-jwt',
-      instanceSigned: false,
-    }
-    const r = resolveSelfNodeId(ctx)
-    expect(r).toEqual({ reason: 'creds-no-sub' })
-  })
-
-  test('--creds with valid JWT but empty sub → creds-no-sub', async () => {
-    const key = await generateEs256()
-    const jwt = await new SignJWT({})
-      .setProtectedHeader({ alg: 'ES256' })
-      .setIssuer('test')
-      .setAudience('test')
-      .sign(key)
-    const ctx: SelfResolverContext = { credsJwt: jwt, instanceSigned: false }
-    const r = resolveSelfNodeId(ctx)
-    expect(r).toEqual({ reason: 'creds-no-sub' })
-  })
-
-  test('--creds with whitespace-only sub → creds-no-sub', async () => {
-    const key = await generateEs256()
-    const jwt = await new SignJWT({})
-      .setProtectedHeader({ alg: 'ES256' })
-      .setSubject('   ')
-      .setIssuer('test')
-      .setAudience('test')
-      .sign(key)
-    const ctx: SelfResolverContext = { credsJwt: jwt, instanceSigned: false }
-    const r = resolveSelfNodeId(ctx)
-    expect(r).toEqual({ reason: 'creds-no-sub' })
-  })
-})
-
-// ── Resolver — happy paths ───────────────────────────────────
-
-describe('resolveSelfNodeId happy paths', () => {
-  test('--as identity with registration → registration sub', () => {
-    const ctx: SelfResolverContext = {
-      identity: {
-        name: 'alice',
-        subject: 'alice',
-        createdAt: 'x',
-        registrations: {
-          'kernel-aidev': { iss: 'https://aidev/', sub: 'node-id-aidev', registeredAt: 'x' },
-        },
-      },
-      instanceSlug: 'kernel-aidev',
-      instanceSigned: false,
-    }
-    const r = resolveSelfNodeId(ctx)
-    expect(r).toEqual({ id: 'node-id-aidev' })
-  })
-
-  test('default identity with registration → registration sub', () => {
-    const ctx: SelfResolverContext = {
-      identity: {
-        name: 'computer',
-        subject: 'kernel-node-id',
-        createdAt: 'x',
-        registrations: {
-          kernel: { iss: 'https://k/', sub: 'kernel-node-id', registeredAt: 'x' },
-        },
-      },
-      instanceSlug: 'kernel',
-      instanceSigned: false,
-    }
-    const r: SelfResolution = resolveSelfNodeId(ctx)
-    expect(r).toEqual({ id: 'kernel-node-id' })
-  })
-
-  test('--creds with valid sub → sub wins over identity', async () => {
-    const key = await generateEs256()
-    const jwt = await new SignJWT({ sub: 'creds-derived-id' })
-      .setProtectedHeader({ alg: 'ES256' })
-      .setIssuer('test')
-      .setSubject('creds-derived-id')
-      .setAudience('test')
-      .sign(key)
-    const ctx: SelfResolverContext = {
-      identity: { name: 'alice', subject: 'alice', createdAt: 'x' },
-      instanceSlug: 'kernel',
-      credsJwt: jwt,
-      instanceSigned: false,
-    }
-    const r = resolveSelfNodeId(ctx)
-    expect(r).toEqual({ id: 'creds-derived-id' })
-  })
-
-  test('manager identity WITH registrations → uses registration sub (not refused)', () => {
-    const ctx: SelfResolverContext = {
-      identity: {
-        name: 'manager',
-        subject: 'manager',
-        createdAt: 'x',
-        registrations: {
-          'some-child': { iss: 'x', sub: 'mgr-node-id-on-child', registeredAt: 'x' },
-        },
-      },
-      instanceSlug: 'some-child',
-      instanceSigned: false,
-    }
-    const r = resolveSelfNodeId(ctx)
-    expect(r).toEqual({ id: 'mgr-node-id-on-child' })
-  })
-})
-
-// ── Error builder ────────────────────────────────────────────
-
-describe('selfRefusalError', () => {
-  test('manager refusal carries metadata + actionable message', () => {
-    const e = selfRefusalError({ reason: 'manager' })
-    expect(e).toBeInstanceOf(Error)
-    expect(e.name).toBe('SelfRefusalError')
-    expect(e.message).toContain('bootstrap `manager` identity')
-    expect(e.message).toContain('astrale identity create')
-    expect((e as Error & { selfRefusal?: { reason: string } }).selfRefusal?.reason).toBe('manager')
-  })
-
-  test('no-registration message references the specific identity + slug', () => {
-    const e = selfRefusalError({
-      reason: 'no-registration',
-      identityName: 'alice',
-      instanceSlug: 'kernel-aidev',
-    })
-    expect(e.message).toContain('alice')
-    expect(e.message).toContain('kernel-aidev')
-    expect(e.message).toContain('astrale identity register alice -i kernel-aidev')
-  })
-
-  test('instance-signed message hints at --as', () => {
-    const e = selfRefusalError({ reason: 'instance-signed', instanceSlug: 'child' })
-    expect(e.message).toContain('--as')
-    expect(e.message).toContain('child')
-  })
-
-  test('url-no-slug message hints at -i', () => {
-    const e = selfRefusalError({ reason: 'url-no-slug' })
-    expect(e.message).toContain('-i')
-  })
-
-  test('creds-no-sub message hints at literal @<nodeId>', () => {
-    const e = selfRefusalError({ reason: 'creds-no-sub' })
-    expect(e.message).toContain('@<nodeId>')
-  })
-})
-
-// ── Helpers ──────────────────────────────────────────────────
-
-async function generateEs256(): Promise<CryptoKey> {
-  const pair = await webcrypto.subtle.generateKey({ name: 'ECDSA', namedCurve: 'P-256' }, true, [
-    'sign',
-    'verify',
-  ])
-  return pair.privateKey
-}

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

@@ -1,6 +1,6 @@
 import { describe, expect, test } from 'bun:test'
 
-import type { IdentityStore } from '../identity'
+import type { IdentityStore } from '../../identity/index'
 import type { InstanceStore } from '../instance'
 
 import { resolveUseTarget } from '../use-target'

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

@@ -1,26 +1,54 @@
 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,
-  mountWithHandshakeFallback,
   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 = {
-  id: 'profile-view',
-  path: '/shell/views/profile',
-  url: 'https://shell.test/profile',
-  origin: 'class',
+  target: target('@person-1'),
+  route: {
+    key: 'shell.test:view.profile',
+    declaration: {
+      target: {
+        kind: 'definition',
+        definitions: [{ origin: 'shell.test', kind: 'class', name: 'Person' }],
+      },
+      auth: 'required',
+    },
+    href: 'https://shell.test/profile',
+    handshake: 'shell',
+    issuer: issuer('https://shell.test'),
+    etag: digest('a'),
+    revision: revision('b'),
+  },
 }
 const card: ResolvedView = {
-  id: 'card-view',
-  path: '/shell/views/card',
-  url: 'https://shell.test/card',
-  handshake: 'none',
-  origin: 'class',
+  target: target('@person-1'),
+  route: {
+    key: 'shell.test:view.card',
+    declaration: {
+      target: {
+        kind: 'definition',
+        definitions: [{ origin: 'shell.test', kind: 'class', name: 'Person' }],
+      },
+      auth: 'public',
+    },
+    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'> {
@@ -41,13 +69,21 @@ function mounted(windowId: string, onClose?: () => void): MountedWindow {
     windowId,
     window: {
       windowId,
-      functionId: 'view',
+      functionId: 'shell.test:view.profile',
+      targetNodeId: '@person-1',
+      children: [],
+      view: profile,
+      location: { target: '@person-1', params: {} },
+      presentation: { kind: 'inline', constrained: false },
       isolation: 'shared',
-      state: 'active',
-      delegationToken: null,
-      capabilities: { intents: [] },
+      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' }
@@ -74,11 +110,11 @@ function harness(views: readonly ResolvedView[] = [profile, card]) {
       events.push(`current:${next.windowId}`)
       current = next
     },
-    mount: async (view, nodeId) => {
-      events.push(`mount:${view.id}:${nodeId}`)
+    mount: async (view) => {
+      events.push(`mount:${view.route.key}:${view.target}`)
       return mounted('new-window')
     },
-    opened: (view, nodeId) => events.push(`opened:${view.path}:${nodeId}`),
+    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
@@ -123,40 +159,35 @@ function harness(views: readonly ResolvedView[] = [profile, card]) {
 }
 
 describe('open intent host', () => {
-  test('uses kernel preference and replies before retiring the requesting child', async () => {
+  /** @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:profile-view:person-1',
+      'mount:shell.test:view.profile:@person-1',
       'current:new-window',
-      'opened:/shell/views/profile:person-1',
+      'opened:shell.test:view.profile:@person-1',
       'reply:old-window',
       'close:old-window',
     ])
     expect(h.current()?.windowId).toBe('new-window')
-    expect(h.sent).toEqual([
-      {
-        windowId: 'old-window',
-        message: {
-          type: 'intent',
-          version: 1,
-          envelope: {
-            name: 'intentReply',
-            payload: { correlationId: 'corr-1', result: { windowId: 'new-window' } },
-            sender: { windowId: 'root' },
-          },
+    expect(h.sent[0]).toMatchObject({
+      windowId: 'old-window',
+      message: {
+        envelope: {
+          payload: { correlationId: 'corr-1', result: { windowId: 'new-window' } },
         },
       },
-    ])
+    })
   })
 
-  test('honors an explicit view and keeps fire-and-forget navigation reply-free', async () => {
+  test('selects an explicit canonical View key without flattening its placement', async () => {
     const h = harness()
-    await handleOpenIntent(h.shell, h.host, openMessage('card-view'))
+    await handleOpenIntent(h.shell, h.host, openMessage('shell.test:view.card'))
 
-    expect(h.events).toContain('mount:card-view:person-1')
+    expect(h.events).toContain('mount:shell.test:view.card:@person-1')
     expect(h.sent).toEqual([])
   })
 
@@ -170,36 +201,28 @@ describe('open intent host', () => {
       'reply:old-window',
       'failed:No view resolves for this node',
     ])
-    expect(h.sent[0]!.message.envelope).toEqual({
-      name: 'intentReply',
-      payload: {
-        correlationId: 'corr-fail',
-        error: { message: 'No view resolves for this node' },
-      },
-      sender: { windowId: 'root' },
-    })
   })
 
-  test('keeps the current view when the replacement mount fails', async () => {
+  /** @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])
-    h.host.mount = async () => {
-      h.events.push('mount:failed')
-      throw new Error('replacement failed')
+    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:failed',
+      'mount:shell:failed',
       'reply:old-window',
-      'failed:replacement failed',
+      'failed:handshake failed',
     ])
-    expect(h.sent[0]!.message.envelope.payload).toEqual({
-      correlationId: 'corr-mount',
-      error: { message: 'replacement failed' },
-    })
   })
 
   test('serializes overlapping opens', async () => {
@@ -246,63 +269,14 @@ describe('open intent host', () => {
       'resolve:1',
       'mount:new-1',
       'current:new-1',
-      'opened:/shell/views/profile:person-1',
+      'opened:shell.test:view.profile:@person-1',
       'close:old-window',
       'resolve:2',
       'mount:new-2',
       'current:new-2',
-      'opened:/shell/views/profile:person-1',
+      'opened:shell.test:view.profile:@person-1',
       'close:new-1',
     ])
     expect(base.current()?.windowId).toBe('new-2')
   })
 })
-
-describe('mountWithHandshakeFallback', () => {
-  test('mounts a plain view once', async () => {
-    const attempts: string[] = []
-    const result = await mountWithHandshakeFallback({
-      handshake: 'none',
-      attempts: 2,
-      mount: async (handshake) => {
-        attempts.push(handshake)
-        return 'plain-window'
-      },
-      cleanupFailedAttempt: () => attempts.push('cleanup'),
-    })
-    expect(result).toEqual({ mounted: 'plain-window', handshake: 'none' })
-    expect(attempts).toEqual(['none'])
-  })
-
-  test('retries shell mounts, cleans each failure, then falls back to plain', async () => {
-    const attempts: string[] = []
-    const result = await mountWithHandshakeFallback({
-      handshake: 'shell',
-      attempts: 2,
-      mount: async (handshake) => {
-        attempts.push(handshake)
-        if (handshake === 'shell') throw new Error('handshake failed')
-        return 'plain-window'
-      },
-      cleanupFailedAttempt: () => attempts.push('cleanup'),
-    })
-    expect(result).toEqual({ mounted: 'plain-window', handshake: 'none' })
-    expect(attempts).toEqual(['shell', 'cleanup', 'shell', 'cleanup', 'none'])
-  })
-
-  test('cleans and surfaces the decisive plain fallback failure', async () => {
-    const attempts: string[] = []
-    const run = mountWithHandshakeFallback({
-      handshake: 'shell',
-      attempts: 2,
-      mount: async (handshake) => {
-        attempts.push(handshake)
-        throw new Error(handshake === 'shell' ? 'handshake failed' : 'plain failed')
-      },
-      cleanupFailedAttempt: () => attempts.push('cleanup'),
-    })
-
-    await expect(run).rejects.toThrow('plain failed')
-    expect(attempts).toEqual(['shell', 'cleanup', 'shell', 'cleanup', 'none', 'cleanup'])
-  })
-})

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

@@ -0,0 +1,99 @@
+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' }, auth: 'required' },
+          },
+        },
+        createdAt: '2026-08-12T00:00:00.000Z',
+      },
+      kernel: { creds: 'raw-secret-carrier' },
+      proxy: {
+        kernelUrl: 'https://kernel.test',
+        issuer: 'https://kernel.test',
+        direct: true,
+      },
+      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',
+    })
+  })
+})