@astrale-os/cli 1.0.0-beta.1 → 1.0.0-beta.10

package/src/commands/__tests__/domain-list.test.ts

@@ -1,8 +1,10 @@
-import { describe, expect, test } from 'bun:test'
+import { defineSchema, schema as schemaApi } from '@astrale-os/sdk/schema'
+import { afterAll, describe, expect, test } from 'bun:test'
 
 import type { DomainInfo } from '../../lib/admin-domain'
 
-import { byDefaultThenName, domainProjection, type DomainRow } from '../domain/list'
+import { releaseFor } from '../../__tests__/fixtures/publication'
+import { byDefaultThenName, domainProjection, probe, type DomainRow } from '../domain/list'
 
 const strip = (s: string): string => s.replace(/\[[0-9;]*m/g, '')
 
@@ -68,7 +70,64 @@ describe('domain list — projection', () => {
     const live: DomainRow = { ...base, reachable: true, checkError: null }
     expect(strip(domainProjection([live]).rows[0].status)).toBe('● live')
 
-    const down: DomainRow = { ...base, reachable: false, checkError: 'meta HTTP 502' }
-    expect(strip(domainProjection([down]).rows[0].status)).toBe('○ meta HTTP 502')
+    const down: DomainRow = { ...base, reachable: false, checkError: 'Publication HTTP 502' }
+    expect(strip(domainProjection([down]).rows[0].status)).toBe('○ Publication HTTP 502')
+  })
+})
+
+describe('domain list — canonical Publication check', () => {
+  const servers: { stop(): void }[] = []
+  afterAll(() => {
+    for (const server of servers) server.stop()
+  })
+
+  test('reports the admitted schema revision in machine data', async () => {
+    const schema = defineSchema('catalog-check.example.dev', {})
+    const deployed = releaseFor(schema, 'https://catalog-check.example.dev').publication
+    const server = Bun.serve({
+      port: 0,
+      fetch(request) {
+        return new URL(request.url).pathname === '/.well-known/astrale/domain.json'
+          ? Response.json(deployed)
+          : new Response('not found', { status: 404 })
+      },
+    })
+    servers.push(server)
+
+    await expect(
+      probe(
+        entry({
+          origin: schema.origin,
+          url: `http://localhost:${server.port}`,
+        }),
+      ),
+    ).resolves.toMatchObject({
+      reachable: true,
+      schemaRevision: schemaApi.revision(schema),
+      checkError: null,
+    })
+  })
+
+  test('rejects a Publication whose origin differs from the catalog entry', async () => {
+    const schema = defineSchema('deployed.example.dev', {})
+    const deployed = releaseFor(schema, 'https://deployed.example.dev').publication
+    const server = Bun.serve({
+      port: 0,
+      fetch: () => Response.json(deployed),
+    })
+    servers.push(server)
+
+    await expect(
+      probe(
+        entry({
+          origin: 'catalog.example.dev',
+          url: `http://localhost:${server.port}`,
+        }),
+      ),
+    ).resolves.toMatchObject({
+      reachable: false,
+      checkError:
+        'Domain origin mismatch: deployed=deployed.example.dev expected=catalog.example.dev',
+    })
   })
 })

package/src/commands/__tests__/install-identity-override.test.ts

@@ -1,5 +1,7 @@
+import { defineSchema } from '@astrale-os/sdk/schema'
 import { afterAll, describe, expect, test } from 'bun:test'
 
+import { releaseFor } from '../../__tests__/fixtures/publication'
 import { domainRefFromTarget, isIdentityOverride, probeDeclaredOrigin } from '../domain/install'
 
 describe('admin-path target classification', () => {
@@ -29,46 +31,44 @@ describe('identity-override detection', () => {
   })
 })
 
-describe('declared-origin probe (/meta)', () => {
+describe('declared-origin Publication probe', () => {
   const servers: { stop(): void }[] = []
   afterAll(() => {
     for (const s of servers) s.stop()
   })
 
-  function serveMeta(handler: (req: Request) => Response): string {
+  function servePublication(handler: (req: Request) => Response): string {
     const server = Bun.serve({ port: 0, fetch: handler })
     servers.push(server)
     return `http://localhost:${server.port}`
   }
 
-  test('reads origin from a well-formed /meta', async () => {
-    // The exact shape SDK workers serve (adapter-cloudflare worker `/meta`).
-    const url = serveMeta((req) =>
-      new URL(req.url).pathname === '/meta'
-        ? Response.json({
-            origin: 'crm.acme.dev',
-            issuer: 'https://crm.acme.dev',
-            schemaRevision: 'sha256:abc',
-            deploymentVersion: 'v1',
-          })
+  test('reads origin from a well-formed canonical Publication', async () => {
+    const schema = defineSchema('crm.acme.dev', {})
+    const deployed = releaseFor(schema, 'https://crm.acme.dev').publication
+    const url = servePublication((req) =>
+      new URL(req.url).pathname === '/.well-known/astrale/domain.json'
+        ? Response.json(deployed)
         : new Response('nope', { status: 404 }),
     )
     expect(await probeDeclaredOrigin(url)).toBe('crm.acme.dev')
   })
 
-  test('falls back to the pre-Kernel-V2 domainName field', async () => {
-    const legacy = serveMeta(() => Response.json({ iss: 'https://x', domainName: 'crm.acme.dev' }))
-    expect(await probeDeclaredOrigin(legacy)).toBe('crm.acme.dev')
+  test('does not accept the removed pre-Kernel-V2 domainName shape', async () => {
+    const legacy = servePublication(() =>
+      Response.json({ iss: 'https://x', domainName: 'crm.acme.dev' }),
+    )
+    expect(await probeDeclaredOrigin(legacy)).toBeUndefined()
   })
 
-  test('degrades to undefined on missing origin, non-200, bad JSON, or dead host', async () => {
-    const noName = serveMeta(() => Response.json({ iss: 'https://x' }))
+  test('degrades to undefined on invalid Publication, non-200, bad JSON, or dead host', async () => {
+    const noName = servePublication(() => Response.json({ iss: 'https://x' }))
     expect(await probeDeclaredOrigin(noName)).toBeUndefined()
 
-    const error = serveMeta(() => new Response('boom', { status: 500 }))
+    const error = servePublication(() => new Response('boom', { status: 500 }))
     expect(await probeDeclaredOrigin(error)).toBeUndefined()
 
-    const badJson = serveMeta(() => new Response('<html>', { status: 200 }))
+    const badJson = servePublication(() => new Response('<html>', { status: 200 }))
     expect(await probeDeclaredOrigin(badJson)).toBeUndefined()
 
     expect(await probeDeclaredOrigin('http://127.0.0.1:1')).toBeUndefined()

package/src/commands/__tests__/instance-list-rows.test.ts

@@ -5,7 +5,7 @@ import type { InstanceInfo } from '../../lib/admin-instance'
 import { buildInstanceRows, type Bookmark } from '../instance/list'
 
 const managed: InstanceInfo[] = [
-  { id: 'demo', slug: 'demo', url: 'https://demo.eu.astrale.ai', region: 'eu' },
+  { id: 'demo', slug: 'demo', url: 'https://demo.eu.astrale.ai', state: 'ready' },
 ]
 
 function bookmark(overrides: Partial<Bookmark> = {}): Bookmark {

package/src/commands/__tests__/instance-status.test.ts

@@ -0,0 +1,139 @@
+import { afterEach, beforeEach, describe, expect, mock, test } from 'bun:test'
+import { mkdtemp, readFile, rm, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+import type { InstanceInfo } from '../../lib/admin-instance'
+import type { ResolvedInstance } from '../../lib/instance'
+
+import { resolveStatus, type StatusDependencies } from '../instance/status'
+
+const cliRoot = join(import.meta.dir, '../../..')
+
+let home: string
+let server: ReturnType<typeof Bun.serve>
+
+beforeEach(async () => {
+  home = await mkdtemp(join(tmpdir(), 'astrale-instance-status-'))
+  server = Bun.serve({
+    port: 0,
+    fetch(request) {
+      const url = new URL(request.url)
+      const issuer = `http://127.0.0.1:${server.port}`
+      if (url.pathname === '/.well-known/openid-configuration') {
+        return Response.json({ issuer, jwks_uri: `${issuer}/.well-known/jwks.json` })
+      }
+      if (url.pathname === '/.well-known/jwks.json') {
+        return Response.json({ keys: [{ kid: 'status-test' }] })
+      }
+      return new Response('Not found', { status: 404 })
+    },
+  })
+})
+
+afterEach(async () => {
+  server.stop(true)
+  await rm(home, { recursive: true, force: true })
+})
+
+describe('instance status', () => {
+  test('keeps managed lifecycle authoritative when the slug is also bookmarked', async () => {
+    const managed: InstanceInfo = {
+      id: '@managed',
+      slug: 'shared',
+      url: 'https://managed.example.com',
+      state: 'provisioning',
+      phase: 'bootstrap',
+    }
+    const statusOwnedInstance: StatusDependencies['statusOwnedInstance'] = mock(async () => managed)
+    const resolveInstance: StatusDependencies['resolveInstance'] = mock(async () => {
+      throw new Error('bookmark resolution must not run')
+    })
+    const probeBookmark: StatusDependencies['probeBookmark'] = mock(async () => {
+      throw new Error('bookmark probe must not run')
+    })
+
+    await expect(
+      resolveStatus('shared', {}, { statusOwnedInstance, resolveInstance, probeBookmark }),
+    ).resolves.toEqual(managed)
+    expect(statusOwnedInstance).toHaveBeenCalledWith({}, 'shared')
+    expect(resolveInstance).not.toHaveBeenCalled()
+    expect(probeBookmark).not.toHaveBeenCalled()
+  })
+
+  test('probes only an explicitly selected bookmark and rejects mixed source flags', async () => {
+    const bookmark: ResolvedInstance = {
+      name: 'local',
+      kind: 'bookmark',
+      url: 'https://local.example.com',
+      issuer: 'https://issuer.example.com',
+    }
+    const statusOwnedInstance: StatusDependencies['statusOwnedInstance'] = mock(async () => {
+      throw new Error('managed status must not run')
+    })
+    const resolveInstance: StatusDependencies['resolveInstance'] = mock(async () => bookmark)
+    const probeBookmark: StatusDependencies['probeBookmark'] = mock(async () => undefined)
+    const dependencies = { statusOwnedInstance, resolveInstance, probeBookmark }
+
+    await expect(resolveStatus('local', { bookmarked: true }, dependencies)).resolves.toEqual({
+      slug: 'local',
+      url: bookmark.url,
+      issuer: 'https://issuer.example.com',
+      kind: 'bookmark',
+      state: 'ready',
+    })
+    expect(resolveInstance).toHaveBeenCalledWith('local', undefined, { persist: false })
+    expect(probeBookmark).toHaveBeenCalledWith(bookmark)
+    expect(statusOwnedInstance).not.toHaveBeenCalled()
+
+    await expect(
+      resolveStatus('local', { bookmarked: true, admin: 'admin' }, dependencies),
+    ).rejects.toMatchObject({ code: 'INVALID_FLAG' })
+  })
+
+  test('probes an explicit local bookmark without rewriting its registry', async () => {
+    const issuer = `http://127.0.0.1:${server.port}`
+    const registry = `${JSON.stringify({
+      active: 'local',
+      instances: {
+        local: {
+          url: issuer,
+          issuer,
+          mode: 'remote',
+        },
+      },
+    })}\n`
+    const path = join(home, 'instances.json')
+    await writeFile(path, registry)
+
+    const process = Bun.spawn({
+      cmd: [
+        'bun',
+        join(cliRoot, 'bin/astrale.ts'),
+        'instance',
+        'status',
+        'local',
+        '--bookmarked',
+        '--json',
+      ],
+      env: { ...Bun.env, ASTRALE_HOME: home },
+      stdout: 'pipe',
+      stderr: 'pipe',
+    })
+    const [stdout, stderr, exitCode] = await Promise.all([
+      new Response(process.stdout).text(),
+      new Response(process.stderr).text(),
+      process.exited,
+    ])
+
+    expect(exitCode, stderr).toBe(0)
+    expect(JSON.parse(stdout)).toEqual({
+      slug: 'local',
+      url: issuer,
+      issuer,
+      kind: 'bookmark',
+      state: 'ready',
+    })
+    expect(await readFile(path, 'utf8')).toBe(registry)
+  })
+})

package/src/commands/__tests__/read-commands.test.ts

@@ -36,6 +36,8 @@ let mutations: unknown[] = []
 let queryResult: unknown
 let getResult: unknown
 let mutationResult: unknown
+let selfFailure: unknown
+let selfContexts: unknown[] = []
 
 const queryMock = mock(async (ast: unknown, options?: unknown) => {
   queryCalls.push({ ast, options })
@@ -49,7 +51,9 @@ const mutateMock = mock(async (mutation: unknown) => {
   mutations.push(mutation)
   return mutationResult
 })
-const expandSelfInPathMock = mock(async (path: string) => {
+const expandSelfInPathMock = mock(async (path: string, context: unknown) => {
+  selfContexts.push(context)
+  if (selfFailure !== undefined) throw selfFailure
   if (path === '@self') {
     return {
       path: '@expanded-self',
@@ -59,10 +63,11 @@ const expandSelfInPathMock = mock(async (path: string) => {
   return { path, meta: undefined }
 })
 const withSelfHintMock = mock(async (action: () => Promise<unknown>) => action())
+const commandContext = {
+  graph: { query: queryMock, getOrThrow: getOrThrowMock, mutate: mutateMock },
+}
 const runKernelCommandMock = mock(async (run: RunOpts) => {
-  const result = await run.fn({
-    graph: { query: queryMock, getOrThrow: getOrThrowMock, mutate: mutateMock },
-  })
+  const result = await run.fn(commandContext)
   await run.format?.(result, run.opts, true)
 })
 
@@ -88,6 +93,8 @@ beforeEach(() => {
   }
   getResult = undefined
   mutationResult = { createdNodes: {} }
+  selfFailure = undefined
+  selfContexts = []
   queryMock.mockClear()
   getOrThrowMock.mockClear()
   mutateMock.mockClear()
@@ -161,7 +168,7 @@ describe('query command', () => {
     ])
   })
 
-  test('authors a Definition source through the same canonical Query V6 call', async () => {
+  test('authors a Class source through the same canonical Query V6 call', async () => {
     const { queryCommand } = await import('../query')
 
     await queryCommand([], {
@@ -179,8 +186,8 @@ describe('query command', () => {
             kind: 'node',
             terms: [
               {
-                kind: 'definition',
-                definition: { origin: 'issues.astrale.ai', kind: 'class', name: 'Issue' },
+                kind: 'class',
+                class: { origin: 'issues.astrale.ai', kind: 'class', name: 'Issue' },
               },
             ],
             binding: 'n0',
@@ -193,6 +200,17 @@ describe('query command', () => {
     ])
   })
 
+  test('resolves @self inside the command session and never relabels transport failure as input', async () => {
+    const { queryCommand } = await import('../query')
+    await queryCommand(['@self'], { json: true, limit: '2' })
+    expect(selfContexts).toEqual([commandContext])
+
+    const aggregate = new AggregateError([], '')
+    selfFailure = aggregate
+    await expect(queryCommand(['@self'], { json: true, limit: '2' })).rejects.toBe(aggregate)
+    expect(errors.join('\n')).not.toContain('INVALID_INPUT')
+  })
+
   /** @evidence TEST-CLI-QUERY-REJECTS-V1-BEFORE-CONNECTION */
   test('rejects a legacy AST before opening the command connection', async () => {
     const { queryCommand } = await import('../query')
@@ -215,7 +233,7 @@ describe('get command', () => {
     const { getCommand } = await import('../get')
     getResult = {
       id: 'note-1',
-      class: '/:notes.example.dev:class.Note',
+      class: 'notes.example.dev:class.Note',
       props: { 'notes.example.dev:class.Note.property.title': 'Hello' },
     }
 
@@ -226,6 +244,13 @@ describe('get command', () => {
     expect(stdout).not.toContain('__labels')
     expect(stdout).not.toContain('classId')
   })
+
+  test('resolves @self through the same point-read command context', async () => {
+    const { getCommand } = await import('../get')
+    await getCommand('@self', { json: true })
+    expect(selfContexts).toEqual([commandContext])
+    expect(getTargets).toEqual(['@expanded-self'])
+  })
 })
 
 describe('mutate command', () => {
@@ -242,7 +267,7 @@ describe('mutate command', () => {
           {
             op: 'node.create',
             as: 'note',
-            class: '/:notes.example.dev:class.Note',
+            class: 'notes.example.dev:class.Note',
             props: {},
           },
         ],
@@ -258,7 +283,7 @@ describe('mutate command', () => {
           {
             op: 'node.create',
             as: 'note',
-            class: '/:notes.example.dev:class.Note',
+            class: 'notes.example.dev:class.Note',
             props: {},
           },
         ],

package/src/commands/__tests__/studio-descriptor.test.ts

@@ -0,0 +1,22 @@
+import { expect, test } from 'bun:test'
+import { realpathSync } from 'node:fs'
+
+import { encodeStudioCliDescriptor } from '../studio'
+
+test('Studio descriptor preserves the exact runtime and script entrypoint', () => {
+  expect(JSON.parse(encodeStudioCliDescriptor(process.execPath, import.meta.path))).toEqual({
+    version: 1,
+    executable: process.execPath,
+    args: [realpathSync(import.meta.path)],
+  })
+})
+
+test('Studio descriptor reinvokes a compiled executable without its virtual bunfs entry', () => {
+  expect(JSON.parse(encodeStudioCliDescriptor('/opt/bin/astrale', '/$bunfs/root/astrale'))).toEqual(
+    {
+      version: 1,
+      executable: '/opt/bin/astrale',
+      args: [],
+    },
+  )
+})

package/src/commands/__tests__/update.test.ts

@@ -6,14 +6,17 @@ describe('CLI update staleness', () => {
   test('trusts the release manifest for a script install without consulting npm latest', async () => {
     const fetchPackageVersion = mock(async () => '0.8.1-alpha.7')
     const result = await cliStale(
-      { channel: 'beta' },
+      {},
       {
-        update: async () => ({
-          status: 'up-to-date',
-          currentVersion: '1.0.0-beta.0',
-          latestVersion: '1.0.0-beta.0',
-          channel: 'beta',
-        }),
+        update: async ({ channel }) => {
+          expect(channel).toBe('beta')
+          return {
+            status: 'up-to-date',
+            currentVersion: '1.0.0-beta.0',
+            latestVersion: '1.0.0-beta.0',
+            channel: 'beta',
+          }
+        },
         fetchPackageVersion,
       },
     )
@@ -28,37 +31,63 @@ describe('CLI update staleness', () => {
     expect(fetchPackageVersion).not.toHaveBeenCalled()
   })
 
-  test('uses the selected npm dist-tag only for package-managed installs', async () => {
+  test('uses an explicit npm dist-tag only for package-managed installs', async () => {
     const result = await cliStale(
-      { channel: 'beta' },
+      { channel: 'canary' },
       {
-        update: async () => {
-          throw new Error('package managed')
-        },
+        update: async () => ({
+          status: 'managed',
+          currentVersion: '1.0.0-beta.0',
+          executable: '/opt/homebrew/bin/node',
+        }),
         fetchPackageVersion: async ({ channel }) => {
-          expect(channel).toBe('beta')
-          return '1.0.0-beta.0'
+          expect(channel).toBe('canary')
+          return '1.0.0-canary.0'
         },
       },
     )
 
     expect(result).toMatchObject({
       managed: true,
-      latest: '1.0.0-beta.0',
+      latest: '1.0.0-canary.0',
       channel: 'npm',
     })
   })
 
-  test('maps the stable channel to the npm latest dist-tag', async () => {
+  test('does not misclassify a script update failure as package-managed', async () => {
+    const fetchPackageVersion = mock(async () => '9.9.9')
+    const result = await cliStale(
+      {},
+      {
+        update: async () => {
+          throw new Error('release endpoint unavailable')
+        },
+        fetchPackageVersion,
+      },
+    )
+
+    expect(result).toMatchObject({
+      stale: false,
+      managed: false,
+      error: 'release endpoint unavailable',
+    })
+    expect(fetchPackageVersion).not.toHaveBeenCalled()
+  })
+
+  test('maps the default to beta and the stable channel to npm latest', async () => {
     const originalFetch = globalThis.fetch
     const fetchMock = mock(async (input: RequestInfo | URL) => {
-      expect(String(input)).toBe('https://registry.npmjs.org/@astrale-os/cli/latest')
-      return Response.json({ version: '1.0.0' })
+      const target = String(input).split('/').at(-1)
+      return Response.json({ version: target === 'beta' ? '1.0.0-beta.0' : '1.0.0' })
     })
     globalThis.fetch = fetchMock as unknown as typeof fetch
     try {
+      expect(await fetchNpmTargetVersion({})).toBe('1.0.0-beta.0')
       expect(await fetchNpmTargetVersion({ channel: 'stable' })).toBe('1.0.0')
-      expect(fetchMock).toHaveBeenCalledTimes(1)
+      expect(fetchMock.mock.calls.map(([input]) => String(input))).toEqual([
+        'https://registry.npmjs.org/@astrale-os/cli/beta',
+        'https://registry.npmjs.org/@astrale-os/cli/latest',
+      ])
     } finally {
       globalThis.fetch = originalFetch
     }