@astrale-os/cli 0.8.1-alpha.6 → 1.0.0-beta.0

package/studio/server/state/create.ts

@@ -15,7 +15,8 @@ import { existsSync, readFileSync, writeFileSync } from 'node:fs'
 import { join } from 'node:path'
 
 import { getBundle } from '../cache'
-import { registerDomain } from '../domain'
+import { isDomainDir, registerDomain } from '../domain'
+import { findSchemaDefinition } from '../introspect/anatomy-extras'
 import { bootDomain } from '../lifecycle'
 import { stoppers, workspaceRoot, workspaceSchemaDirName } from '../workspace-state'
 
@@ -87,7 +88,8 @@ export async function createDomain(
     ...(instance ? ['--instance', instance] : []),
   ]
   const scaffold = await run('npx', scaffoldArgs, root)
-  if (!existsSync(join(dir, 'domain.ts')) || !existsSync(join(dir, 'astrale.config.ts'))) {
+  const schemaDirName = workspaceSchemaDirName()
+  if (!isDomainDir(dir, schemaDirName)) {
     return {
       ok: false,
       error: 'Scaffolding did not produce a domain. See the log.',
@@ -97,7 +99,7 @@ export async function createDomain(
 
   // 1b. Flag the placeholder origin for the agent (we ask for the name only, so the
   //     origin is `<name>.example.dev` until someone — or the agent — sets the real one).
-  annotateOrigin(dir)
+  annotateOrigin(dir, schemaDirName)
 
   // 2. Install deps so the domain is fully introspectable + deployable. Best-effort:
   //    a scaffolded-but-uninstalled domain still loads (static fallback), so a failed
@@ -106,11 +108,11 @@ export async function createDomain(
 
   // 3. Register + boot with deps present. The live watcher may have already booted a
   //    deps-less fallback for this dir mid-install — stop it and boot fresh.
-  const handle = registerDomain(dir, workspaceSchemaDirName())
+  const handle = registerDomain(dir, schemaDirName)
   if (!handle) {
     return {
       ok: false,
-      error: 'Scaffold incomplete — the domain triple is missing.',
+      error: 'Scaffold incomplete — config, composition entry, or schema index is missing.',
       output: combine(scaffold, install),
     }
   }
@@ -129,27 +131,31 @@ function combine(a: { output: string }, b: { output: string }): string {
 }
 
 /**
- * Drop an agent-actionable marker on the origin line of the scaffolded
- * schema/index.ts. We only ask for the NAME, so the origin starts as the
+ * Drop an agent-actionable marker on the origin line of the scaffolded schema.
+ * The public schema/index.ts is now commonly a barrel, so the definition is
+ * located statically below it. We only ask for the NAME, so the origin starts as the
  * `<name>.example.dev` placeholder — this comment tells a human (or the studio's
  * agent) it's a placeholder to change, and that the studio re-parses the literal
  * as the source of truth so the rename takes effect on save. Best-effort: the
  * template already explains the origin, so a parse miss is harmless.
  */
-function annotateOrigin(dir: string): void {
-  const file = join(dir, workspaceSchemaDirName(), 'index.ts')
+export function annotateOrigin(dir: string, schemaDirName = 'schema'): void {
+  const definition = findSchemaDefinition(dir, schemaDirName)
+  if (!definition) return
+  const file = definition.file
   try {
     const src = readFileSync(file, 'utf8')
     if (src.includes('ORIGIN —')) return // already annotated (idempotent)
-    const m = src.match(/^([ \t]*)export const schema = defineSchema\(/m)
-    if (!m) return
-    const pad = m[1] ?? ''
+    const lines = src.split('\n')
+    const index = Math.max(0, definition.line - 1)
+    const pad = lines[index]?.match(/^[ \t]*/)?.[0] ?? ''
     const note =
       `${pad}// ORIGIN — the domain's permanent identity in the graph. It was set from the name as a\n` +
-      `${pad}// PLACEHOLDER below; change it to your real domain (e.g. "crm.acme.dev"), ideally BEFORE\n` +
+      `${pad}// PLACEHOLDER; change the literal or constant used here (e.g. to "crm.acme.dev"), ideally BEFORE\n` +
       `${pad}// the first deploy (the origin is hard to change once installed). The studio parses this\n` +
-      `${pad}// literal as the source of truth, so the rename refreshes on save — no other file to touch.\n`
-    writeFileSync(file, src.replace(m[0], note + m[0]))
+      `${pad}// schema statically as the source of truth, so the rename refreshes on save.\n`
+    lines.splice(index, 0, note.trimEnd())
+    writeFileSync(file, lines.join('\n'))
   } catch {
     /* best-effort */
   }

package/studio/server/state/instance.test.ts

@@ -0,0 +1,63 @@
+import { describe, expect, test } from 'bun:test'
+
+import { schemaHashOf } from '../introspect/hash'
+import {
+  installedBundleRootHash,
+  installedDomainCommand,
+  installedDomainProbeResult,
+} from './instance'
+
+describe('installed Domain introspection', () => {
+  test('uses the public bundle introspection command for the selected instance', () => {
+    expect(installedDomainCommand('issues.astrale.ai', 'staging')).toEqual([
+      'astrale',
+      'introspect',
+      'issues.astrale.ai',
+      '--bundle',
+      '--json',
+      '-i',
+      'staging',
+    ])
+  })
+
+  test('hashes the installed Bundle root with the same deterministic hash as local schema', () => {
+    const root = {
+      version: 'v1',
+      domain: 'issues.astrale.ai',
+      classes: { Issue: { properties: { title: { type: 'string' } } } },
+    }
+    const probe = installedDomainProbeResult(
+      JSON.stringify({
+        state: 'ready',
+        bundle: { format: 'astrale.dsl.bundle', version: 'v1', root, closure: [] },
+      }),
+      '',
+      0,
+    )
+    expect(probe.state).toBe('installed')
+    expect(installedBundleRootHash(probe)).toBe(schemaHashOf(root))
+  })
+
+  test('does not mistake the removed Domain Node shape for installation introspection', () => {
+    expect(
+      installedDomainProbeResult(
+        JSON.stringify({ path: '/issues.astrale.ai', props: { schema: '{"domain":"old"}' } }),
+        '',
+        0,
+      ),
+    ).toEqual({ state: 'unknown', root: null })
+  })
+
+  test('recognizes the current CLI not-installed diagnostic', () => {
+    expect(
+      installedDomainProbeResult(
+        '',
+        JSON.stringify({
+          error: 'DOMAIN_NOT_INSTALLED',
+          message: 'Domain issues.astrale.ai is not installed on this Kernel.',
+        }),
+        1,
+      ),
+    ).toEqual({ state: 'not-installed', root: null })
+  })
+})

package/studio/server/state/instance.ts

@@ -4,8 +4,9 @@
  * The ACTIVE instance is GLOBAL (not per-domain) and the `astrale` CLI owns it —
  * we never keep our own copy: `listInstances` reads `astrale instance list`,
  * `setActiveInstance` runs `astrale instance use`. Install + drift are GROUND
- * TRUTH, queried from the target instance (`astrale get /<origin>`) — NOT a local
- * record — so a deploy done outside the studio (CLI/terminal) is still seen.
+ * TRUTH, queried from the target instance (`astrale introspect <origin>`) — NOT
+ * a local record — so a deploy done outside the studio (CLI/terminal) is still
+ * seen.
  *
  * Deploy (`pnpm prod`) = the managed astrale adapter: deploy + auto-install on
  * the configured instance; we capture the printed service URL.
@@ -117,18 +118,70 @@ export function lastDeploy(root: string): DeployRecord | null {
 }
 
 /**
- * Ask the target instance for the domain node (`astrale get /<origin> -i <instance>`).
- * Installed ⇒ the kernel returns the Domain node (with the installed schema in
- * `props.schema`); `NOT_FOUND` ⇒ not installed; anything else (offline / not
- * authed / unknown instance) ⇒ unknown (never falsely "not installed").
+ * Ask the target instance for its public installation introspection. Installed
+ * ⇒ the Kernel returns the admitted Bundle, whose root is the exact schema value
+ * hashed locally; `DOMAIN_NOT_INSTALLED` ⇒ not installed; anything else
+ * (offline / not authed / unknown instance) ⇒ unknown (never falsely
+ * "not installed").
  */
+export function installedDomainCommand(origin: string, instance: string): string[] {
+  return ['astrale', 'introspect', origin, '--bundle', '--json', '-i', instance]
+}
+
+type InstalledDomainProbe =
+  | { state: 'installed'; root: unknown }
+  | { state: 'not-installed' | 'unknown'; root: null }
+
+function jsonObject(text: string): Record<string, unknown> | null {
+  try {
+    const value = JSON.parse(text)
+    return value !== null && typeof value === 'object' && !Array.isArray(value) ? value : null
+  } catch {
+    return null
+  }
+}
+
+export function installedDomainProbeResult(
+  stdout: string,
+  stderr: string,
+  exitCode: number,
+): InstalledDomainProbe {
+  const output = jsonObject(stdout)
+  const diagnostic = jsonObject(stderr)
+  const error = output?.error ?? diagnostic?.error
+  if (
+    error === 'DOMAIN_NOT_INSTALLED' ||
+    error === 'NOT_FOUND' ||
+    /\b(?:DOMAIN_NOT_INSTALLED|NOT_FOUND)\b/.test(`${stdout}\n${stderr}`)
+  ) {
+    return { state: 'not-installed', root: null }
+  }
+
+  if (exitCode === 0) {
+    const bundle = output?.bundle
+    if (
+      bundle !== null &&
+      typeof bundle === 'object' &&
+      !Array.isArray(bundle) &&
+      Object.prototype.hasOwnProperty.call(bundle, 'root')
+    ) {
+      return { state: 'installed', root: (bundle as { root: unknown }).root }
+    }
+  }
+  return { state: 'unknown', root: null }
+}
+
+export function installedBundleRootHash(probe: InstalledDomainProbe): string | null {
+  return probe.state === 'installed' ? schemaHashOf(probe.root) : null
+}
+
 async function getInstalledDomain(
   origin: string,
   instance: string,
   timeoutMs = 8000,
-): Promise<{ state: 'installed' | 'not-installed' | 'unknown'; schema: unknown | null }> {
+): Promise<InstalledDomainProbe> {
   try {
-    const proc = Bun.spawn(['astrale', 'get', `/${origin}`, '-i', instance, '--json'], {
+    const proc = Bun.spawn(installedDomainCommand(origin, instance), {
       stdout: 'pipe',
       stderr: 'pipe',
     })
@@ -144,30 +197,13 @@ async function getInstalledDomain(
         new Response(proc.stdout).text(),
         new Response(proc.stderr).text(),
       ])
-      await proc.exited
-      let parsed: any = null
-      try {
-        parsed = JSON.parse(out)
-      } catch {
-        /* non-JSON */
-      }
-      if (parsed?.error === 'NOT_FOUND' || /\bNOT_FOUND\b/.test(`${out}\n${err}`))
-        return { state: 'not-installed', schema: null }
-      if (parsed?.path && parsed?.props) {
-        let schema: unknown = null
-        try {
-          schema = parsed.props.schema ? JSON.parse(parsed.props.schema) : null
-        } catch {
-          /* schema absent/unparseable — still installed */
-        }
-        return { state: 'installed', schema }
-      }
-      return { state: 'unknown', schema: null }
+      const code = await proc.exited
+      return installedDomainProbeResult(out, err, code)
     } finally {
       clearTimeout(timer)
     }
   } catch {
-    return { state: 'unknown', schema: null }
+    return { state: 'unknown', root: null }
   }
 }
 
@@ -187,7 +223,7 @@ export async function instanceStatus(
     const probe = await getInstalledDomain(origin, deployTarget)
     if (probe.state === 'installed') {
       install = 'installed'
-      installedHash = probe.schema ? schemaHashOf(probe.schema) : null
+      installedHash = installedBundleRootHash(probe)
       drift =
         installedHash && localHash
           ? installedHash === localHash

package/studio/server/state/views.test.ts

@@ -1,24 +1,224 @@
 import { describe, expect, test } from 'bun:test'
 
-import type { RememberedViewTarget, ViewTargetCandidate } from '../../shared/types'
+import type {
+  RememberedViewTarget,
+  StudioSchemaBundle,
+  ViewInfo,
+  ViewTargetCandidate,
+} from '../../shared/types'
 
 import {
   conciseCliFailure,
-  localViewUrl,
+  readyViewSession,
   reconcileRememberedTarget,
   targetDefinition,
   targetFromRow,
+  viewDefinitionBindings,
+  viewSessionArgs,
 } from './views'
 
-describe('managed local view URLs', () => {
-  test('mounts each view beneath the Studio-assigned server origin', () => {
-    expect(localViewUrl('http://127.0.0.1:5173', '/ui/issues')).toBe(
-      'http://127.0.0.1:5173/ui/issues',
-    )
-    expect(localViewUrl('http://127.0.0.1:61001/ignored', 'ui/issue')).toBe(
-      'http://127.0.0.1:61001/ui/issue',
+describe('view session command', () => {
+  test('opens the installed ViewPath without rejected placement overrides', () => {
+    const args = viewSessionArgs('issues.astrale.ai', 'issue-detail', 'staging', '@issue-1')
+    expect(args).toEqual([
+      'view',
+      '/:issues.astrale.ai:view.issue-detail',
+      '--target',
+      '@issue-1',
+      '--no-open',
+      '--json',
+      '-i',
+      'staging',
+    ])
+    expect(args).not.toContain('--view-url')
+    expect(args).not.toContain('--handshake')
+  })
+
+  test('omits --target for a standalone view', () => {
+    expect(viewSessionArgs('issues.astrale.ai', 'dashboard', 'local')).toEqual([
+      'view',
+      '/:issues.astrale.ai:view.dashboard',
+      '--no-open',
+      '--json',
+      '-i',
+      'local',
+    ])
+  })
+
+  test('preserves canonical interface View target coordinates', () => {
+    const view = { slug: 'users', kind: 'unknown' } satisfies ViewInfo
+    const bundle = {
+      ir: {
+        views: {
+          users: {
+            name: 'users',
+            auth: 'required',
+            target: {
+              kind: 'definition',
+              definitions: [{ origin: 'kernel.astrale.ai', kind: 'interface', name: 'Identity' }],
+            },
+          },
+        },
+      },
+    } as unknown as StudioSchemaBundle
+
+    expect(viewDefinitionBindings('shell.astrale.ai', view, bundle)).toEqual([
+      {
+        className: 'Identity',
+        classOrigin: 'kernel.astrale.ai',
+        kind: 'interface',
+      },
+    ])
+    expect(targetDefinition('Identity', 'kernel.astrale.ai', 'interface')).toBe(
+      '/:kernel.astrale.ai:interface.Identity',
     )
   })
+
+  test('preserves every exact canonical homonym and ignores short-name metadata', () => {
+    const view = {
+      slug: 'named',
+      kind: 'unknown',
+      viewFor: 'WrongLegacyTarget',
+    } satisfies ViewInfo
+    const bundle = {
+      ir: {
+        views: {
+          named: {
+            name: 'named',
+            auth: 'required',
+            target: {
+              kind: 'definition',
+              definitions: [
+                { origin: 'directory.example.dev', kind: 'interface', name: 'Named' },
+                { origin: 'people.example.dev', kind: 'interface', name: 'Named' },
+                { origin: 'catalog.example.dev', kind: 'class', name: 'Named' },
+              ],
+            },
+          },
+        },
+      },
+    } as unknown as StudioSchemaBundle
+
+    expect(viewDefinitionBindings('shell.astrale.ai', view, bundle)).toEqual([
+      { className: 'Named', classOrigin: 'directory.example.dev', kind: 'interface' },
+      { className: 'Named', classOrigin: 'people.example.dev', kind: 'interface' },
+      { className: 'Named', classOrigin: 'catalog.example.dev', kind: 'class' },
+    ])
+  })
+
+  test('treats an exact Domain target as authoritative over legacy viewFor', () => {
+    const view = { slug: 'home', kind: 'unknown', viewFor: 'User' } satisfies ViewInfo
+    const bundle = {
+      ir: {
+        views: {
+          home: { name: 'home', auth: 'required', target: { kind: 'domain' } },
+        },
+      },
+    } as unknown as StudioSchemaBundle
+
+    expect(viewDefinitionBindings('shell.astrale.ai', view, bundle)).toEqual([])
+  })
+
+  test('uses every exact fallback candidate across origin and definition-kind collisions', () => {
+    const view = { slug: 'legacy-named', kind: 'unknown', viewFor: 'Named' } satisfies ViewInfo
+    const bundle = {
+      ir: {
+        domain: 'shell.astrale.ai',
+        views: {},
+        classes: {
+          Named: {
+            origin: 'shell.astrale.ai',
+            ref: { origin: 'shell.astrale.ai', kind: 'class', name: 'Named' },
+          },
+        },
+        interfaces: {
+          Named: {
+            origin: 'shell.astrale.ai',
+            ref: { origin: 'shell.astrale.ai', kind: 'interface', name: 'Named' },
+          },
+        },
+        imports: {
+          Named: { origin: 'legacy.invalid', definition: 'class' },
+        },
+        importsByKey: {
+          'directory.example.dev:interface.Named': {
+            origin: 'directory.example.dev',
+            definition: 'interface',
+          },
+          'catalog.example.dev:class.Named': {
+            origin: 'catalog.example.dev',
+            definition: 'class',
+          },
+        },
+      },
+    } as unknown as StudioSchemaBundle
+
+    expect(viewDefinitionBindings('shell.astrale.ai', view, bundle)).toEqual([
+      { className: 'Named', classOrigin: 'shell.astrale.ai', kind: 'class' },
+      { className: 'Named', classOrigin: 'shell.astrale.ai', kind: 'interface' },
+      { className: 'Named', classOrigin: 'directory.example.dev', kind: 'interface' },
+      { className: 'Named', classOrigin: 'catalog.example.dev', kind: 'class' },
+    ])
+  })
+
+  test('uses the short-name import only for legacy bundles without an exact index', () => {
+    const view = { slug: 'legacy-users', kind: 'unknown', viewFor: 'User' } satisfies ViewInfo
+    const legacy = {
+      ir: {
+        domain: 'shell.astrale.ai',
+        views: {},
+        classes: {},
+        interfaces: {},
+        imports: {
+          User: { origin: 'accounts.example.dev', definition: 'interface' },
+        },
+      },
+    } as unknown as StudioSchemaBundle
+    const exact = {
+      ir: {
+        ...legacy.ir,
+        importsByKey: {},
+      },
+    } as unknown as StudioSchemaBundle
+
+    expect(viewDefinitionBindings('shell.astrale.ai', view, legacy)).toEqual([
+      { className: 'User', classOrigin: 'accounts.example.dev', kind: 'interface' },
+    ])
+    expect(viewDefinitionBindings('shell.astrale.ai', view, exact)).toEqual([])
+  })
+
+  test('reads the verified placement URL from the current CLI session route', () => {
+    expect(
+      readyViewSession(
+        {
+          session: {
+            id: 'v-a1b2',
+            pageUrl: 'http://127.0.0.1:4419/s/nonce/',
+            view: { route: { href: 'https://issues.example/ui/issue' } },
+          },
+        },
+        null,
+      ),
+    ).toEqual({
+      status: 'ready',
+      sessionId: 'v-a1b2',
+      pageUrl: 'http://127.0.0.1:4419/s/nonce/',
+      viewUrl: 'https://issues.example/ui/issue',
+      target: null,
+    })
+    expect(
+      readyViewSession(
+        {
+          session: {
+            id: 'v-old',
+            pageUrl: 'http://127.0.0.1:4419/s/old/',
+            view: { url: 'https://legacy.invalid/view' },
+          },
+        } as never,
+        null,
+      ),
+    ).toBeNull()
+  })
 })
 
 test('reduces CLI stack output to the actionable kernel failure', () => {