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

package/studio/server/cli-consumers.test.ts

@@ -0,0 +1,494 @@
+import { afterEach, describe, expect, test } from 'bun:test'
+import { existsSync, mkdtempSync, readFileSync, realpathSync, rmSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+import type { StudioSchemaBundle, ViewInfo } from '../shared/types'
+
+import { STUDIO_CLI_DESCRIPTOR_ENV } from './cli'
+import { activeInstanceName, listInstances, setActiveInstance } from './instances/active'
+import { readRememberedTarget } from './views/selection-repository'
+import { launchViewSession } from './views/session'
+import { listViewTargets } from './views/target'
+import { applyUpdates, getUpdates } from './workspace/updates'
+
+interface FakeResponse {
+  stdout?: unknown
+  stderr?: unknown
+  exitCode?: number
+}
+
+interface FakeCall {
+  args: string[]
+  cwd: string
+}
+
+const priorDescriptor = process.env[STUDIO_CLI_DESCRIPTOR_ENV]
+const roots: string[] = []
+
+afterEach(() => {
+  if (priorDescriptor === undefined) delete process.env[STUDIO_CLI_DESCRIPTOR_ENV]
+  else process.env[STUDIO_CLI_DESCRIPTOR_ENV] = priorDescriptor
+  while (roots.length > 0) rmSync(roots.pop()!, { recursive: true, force: true })
+})
+
+function exactArgs(args: string[]): string {
+  return JSON.stringify(args)
+}
+
+function installFakeCli(responses: Array<{ args: string[]; responses: FakeResponse[] }>): {
+  root: string
+  calls: () => FakeCall[]
+} {
+  const root = mkdtempSync(join(tmpdir(), 'studio-cli-consumer-'))
+  roots.push(root)
+  const scenarioFile = join(root, 'scenario.json')
+  const callsFile = join(root, 'calls.ndjson')
+  const entry = join(root, 'fake-cli.ts')
+  const scenario = Object.fromEntries(
+    responses.map((rule) => [exactArgs(rule.args), rule.responses]),
+  )
+  writeFileSync(scenarioFile, JSON.stringify(scenario))
+  writeFileSync(
+    entry,
+    `import { appendFileSync, existsSync, readFileSync } from 'node:fs'
+
+const scenarioFile = ${JSON.stringify(scenarioFile)}
+const callsFile = ${JSON.stringify(callsFile)}
+const args = process.argv.slice(2)
+const prior = existsSync(callsFile)
+  ? readFileSync(callsFile, 'utf8').split('\\n').filter(Boolean).map((line) => JSON.parse(line))
+  : []
+const matchingCalls = prior.filter((call) => JSON.stringify(call.args) === JSON.stringify(args)).length
+appendFileSync(callsFile, JSON.stringify({ args, cwd: process.cwd() }) + '\\n')
+const scenario = JSON.parse(readFileSync(scenarioFile, 'utf8'))
+const responses = scenario[JSON.stringify(args)]
+const response = Array.isArray(responses) ? responses[matchingCalls] : undefined
+if (!response) {
+  process.stderr.write(JSON.stringify({ message: 'Unexpected fake CLI call', args }))
+  process.exit(91)
+}
+const render = (value) => typeof value === 'string' ? value : JSON.stringify(value)
+if (response.stdout !== undefined) process.stdout.write(render(response.stdout))
+if (response.stderr !== undefined) process.stderr.write(render(response.stderr))
+process.exit(response.exitCode ?? 0)
+`,
+  )
+  process.env[STUDIO_CLI_DESCRIPTOR_ENV] = JSON.stringify({
+    version: 1,
+    executable: process.execPath,
+    args: [realpathSync(entry)],
+  })
+  return {
+    root,
+    calls: () =>
+      existsSync(callsFile)
+        ? readFileSync(callsFile, 'utf8')
+            .split('\n')
+            .filter(Boolean)
+            .map((line) => JSON.parse(line) as FakeCall)
+        : [],
+  }
+}
+
+const activeArgs = ['instance', 'active', '--json']
+const bookmarkedArgs = ['instance', 'list', '--bookmarked', '--json']
+const managedArgs = ['instance', 'list', '--admin-only', '--json']
+
+describe('instance CLI orchestration', () => {
+  test('reads active/list from the exact CLI and merges bookmarks with managed instances', async () => {
+    const fake = installFakeCli([
+      { args: activeArgs, responses: [{ stdout: { name: 'local' } }] },
+      {
+        args: bookmarkedArgs,
+        responses: [
+          {
+            stdout: {
+              active: 'staging',
+              bookmarks: [
+                { name: 'local', url: 'http://127.0.0.1:7200' },
+                { name: 'staging', url: 'https://staging.example', active: true },
+              ],
+            },
+          },
+        ],
+      },
+      {
+        args: managedArgs,
+        responses: [
+          {
+            stdout: {
+              instances: [
+                { slug: 'staging', url: 'https://duplicate.example' },
+                { slug: 'production', url: 'https://production.example' },
+              ],
+            },
+          },
+        ],
+      },
+    ])
+
+    expect(await activeInstanceName()).toBe('local')
+    expect(await listInstances()).toEqual({
+      active: 'staging',
+      instances: [
+        {
+          name: 'local',
+          url: 'http://127.0.0.1:7200',
+          active: false,
+          kind: 'bookmark',
+        },
+        {
+          name: 'staging',
+          url: 'https://staging.example',
+          active: true,
+          kind: 'bookmark',
+        },
+        {
+          name: 'production',
+          url: 'https://production.example',
+          active: false,
+          kind: 'managed',
+        },
+      ],
+    })
+    expect(fake.calls().map((call) => call.args)).toEqual([activeArgs, bookmarkedArgs, managedArgs])
+  })
+
+  test('uses the exact non-interactive instance switch flags and re-reads CLI-owned state', async () => {
+    const useArgs = ['instance', 'use', 'staging', '--adopt-default', '--skip-jwks-check']
+    const fake = installFakeCli([
+      { args: useArgs, responses: [{ stdout: 'Now using staging.\n' }] },
+      { args: activeArgs, responses: [{ stdout: { name: 'staging' } }] },
+    ])
+
+    expect(await setActiveInstance('staging')).toEqual({
+      ok: true,
+      active: 'staging',
+      output: 'Now using staging.',
+    })
+    expect(fake.calls().map((call) => call.args)).toEqual([useArgs, activeArgs])
+  })
+
+  test('does not invent active state from malformed or failed CLI output', async () => {
+    const fake = installFakeCli([
+      {
+        args: activeArgs,
+        responses: [
+          { stdout: 'not-json' },
+          {
+            stdout: { name: 'must-not-be-used' },
+            stderr: 'Instance store is unavailable.',
+            exitCode: 7,
+          },
+        ],
+      },
+    ])
+
+    expect(await activeInstanceName()).toBeNull()
+    expect(await activeInstanceName()).toBeNull()
+    expect(fake.calls().map((call) => call.args)).toEqual([activeArgs, activeArgs])
+  })
+})
+
+describe('workspace update CLI orchestration', () => {
+  test('accepts stale exit 10 and applies updates in the domain root', async () => {
+    const checkArgs = ['update', '--check', '--json']
+    const applyArgs = ['update', '--yes']
+    const fake = installFakeCli([
+      {
+        args: checkArgs,
+        responses: [
+          {
+            stdout: {
+              stale: true,
+              cli: {
+                stale: true,
+                managed: true,
+                current: '0.7.0',
+                latest: '0.8.0',
+                channel: 'latest',
+              },
+              sdk: {
+                stale: true,
+                inProject: true,
+                outdated: [{ pkg: '@astrale-os/sdk', current: '0.5.0', latest: '0.6.0' }],
+              },
+            },
+            exitCode: 10,
+          },
+        ],
+      },
+      {
+        args: applyArgs,
+        responses: [{ stdout: 'CLI updated.\n', stderr: 'SDK updated.\n' }],
+      },
+    ])
+    const domainRoot = realpathSync(fake.root)
+
+    expect(await getUpdates(domainRoot)).toEqual({
+      stale: true,
+      cli: {
+        stale: true,
+        managed: true,
+        current: '0.7.0',
+        latest: '0.8.0',
+        channel: 'latest',
+      },
+      sdk: {
+        stale: true,
+        inProject: true,
+        outdated: [{ pkg: '@astrale-os/sdk', current: '0.5.0', latest: '0.6.0' }],
+      },
+    })
+    expect(await applyUpdates(domainRoot)).toEqual({
+      ok: true,
+      output: 'CLI updated.\nSDK updated.',
+    })
+    expect(fake.calls()).toEqual([
+      { args: checkArgs, cwd: domainRoot },
+      { args: applyArgs, cwd: domainRoot },
+    ])
+  })
+
+  test('hides the badge when check output is malformed or fails', async () => {
+    const checkArgs = ['update', '--check', '--json']
+    const fake = installFakeCli([
+      {
+        args: checkArgs,
+        responses: [
+          { stdout: { stale: true, cli: {}, sdk: {} }, exitCode: 10 },
+          {
+            stdout: {
+              stale: true,
+              cli: { stale: true, managed: true },
+              sdk: {
+                stale: true,
+                inProject: true,
+                outdated: [{ pkg: '@astrale-os/sdk', current: '0.5.0', latest: '0.6.0' }],
+              },
+            },
+            stderr: 'Registry offline.',
+            exitCode: 7,
+          },
+        ],
+      },
+    ])
+    const expected = {
+      stale: false,
+      cli: { stale: false, managed: true },
+      sdk: { stale: false, inProject: false, outdated: [] },
+    }
+
+    expect(await getUpdates(fake.root)).toEqual(expected)
+    expect(await getUpdates(fake.root)).toEqual(expected)
+    const domainRoot = realpathSync(fake.root)
+    expect(fake.calls()).toEqual([
+      { args: checkArgs, cwd: domainRoot },
+      { args: checkArgs, cwd: domainRoot },
+    ])
+  })
+})
+
+const view = {
+  slug: 'issue-detail',
+  kind: 'unknown',
+  viewFor: 'Issue',
+} satisfies ViewInfo
+
+const bundle = {
+  ir: {
+    views: {
+      'issue-detail': {
+        name: 'issue-detail',
+        auth: 'required',
+        target: {
+          kind: 'definition',
+          definitions: [{ origin: 'issues.example.dev', kind: 'class', name: 'Issue' }],
+        },
+      },
+    },
+  },
+} as unknown as StudioSchemaBundle
+
+const queryArgs = [
+  'query',
+  '--definition',
+  '/:issues.example.dev:class.Issue',
+  '--limit',
+  '201',
+  '--json',
+  '-i',
+  'staging',
+]
+
+const targetQuery = {
+  graph: {
+    nodes: [
+      {
+        id: 'issue-1',
+        props: {
+          'kernel.astrale.ai:interface.Named.property.name': 'First issue',
+        },
+      },
+    ],
+  },
+}
+
+describe('View CLI orchestration', () => {
+  test('queries exact target coordinates and preserves malformed/nonzero failures', async () => {
+    const fake = installFakeCli([
+      {
+        args: queryArgs,
+        responses: [
+          { stdout: targetQuery },
+          { stdout: { graph: { nodes: 'invalid' } } },
+          { stderr: { message: 'Instance is offline.' }, exitCode: 7 },
+        ],
+      },
+    ])
+
+    expect(
+      await listViewTargets(fake.root, 'issues.example.dev', view, bundle, 'staging', 2000),
+    ).toEqual({
+      status: 'available',
+      items: [
+        {
+          id: 'issue-1',
+          ref: '@issue-1',
+          className: 'Issue',
+          classOrigin: 'issues.example.dev',
+          label: 'First issue',
+        },
+      ],
+      selected: null,
+      stale: null,
+      truncated: false,
+    })
+    expect(
+      await listViewTargets(fake.root, 'issues.example.dev', view, bundle, 'staging', 2000),
+    ).toMatchObject({ status: 'unavailable', items: [] })
+    expect(
+      await listViewTargets(fake.root, 'issues.example.dev', view, bundle, 'staging', 2000),
+    ).toMatchObject({ status: 'unavailable', reason: 'Instance is offline.' })
+    expect(fake.calls().map((call) => call.args)).toEqual([queryArgs, queryArgs, queryArgs])
+  })
+
+  test('launches against the selected target, trusts route.href, and remembers the target', async () => {
+    const launchArgs = [
+      'view',
+      '/:issues.example.dev:view.issue-detail',
+      '--target',
+      '@issue-1',
+      '--no-open',
+      '--json',
+      '-i',
+      'staging',
+    ]
+    const fake = installFakeCli([
+      { args: activeArgs, responses: [{ stdout: { name: 'staging' } }] },
+      { args: queryArgs, responses: [{ stdout: targetQuery }] },
+      {
+        args: launchArgs,
+        responses: [
+          {
+            stdout: {
+              session: {
+                id: 'v-a1b2',
+                pageUrl: 'http://127.0.0.1:4419/s/nonce/',
+                view: { route: { href: 'https://shell.example.dev/views/issue-1' } },
+              },
+            },
+          },
+        ],
+      },
+    ])
+
+    expect(
+      await launchViewSession(
+        fake.root,
+        'issues.example.dev',
+        view,
+        bundle,
+        { targetId: 'issue-1' },
+        2000,
+      ),
+    ).toEqual({
+      status: 'ready',
+      sessionId: 'v-a1b2',
+      pageUrl: 'http://127.0.0.1:4419/s/nonce/',
+      viewUrl: 'https://shell.example.dev/views/issue-1',
+      target: {
+        id: 'issue-1',
+        ref: '@issue-1',
+        className: 'Issue',
+        classOrigin: 'issues.example.dev',
+        label: 'First issue',
+      },
+    })
+    expect(readRememberedTarget(fake.root, 'staging', 'issue-detail')).toEqual({
+      id: 'issue-1',
+      className: 'Issue',
+      classOrigin: 'issues.example.dev',
+      label: 'First issue',
+    })
+    expect(fake.calls().map((call) => call.args)).toEqual([activeArgs, queryArgs, launchArgs])
+  })
+
+  test('does not expose a session when the CLI payload is malformed or exits nonzero', async () => {
+    const standalone = { slug: 'dashboard', kind: 'unknown' } satisfies ViewInfo
+    const launchArgs = [
+      'view',
+      '/:issues.example.dev:view.dashboard',
+      '--no-open',
+      '--json',
+      '-i',
+      'staging',
+    ]
+    const fake = installFakeCli([
+      {
+        args: activeArgs,
+        responses: [{ stdout: { name: 'staging' } }, { stdout: { name: 'staging' } }],
+      },
+      {
+        args: launchArgs,
+        responses: [
+          { stdout: { session: { id: 'v-no-route', pageUrl: 'http://127.0.0.1/' } } },
+          {
+            stdout: {
+              session: {
+                id: 'v-must-not-open',
+                pageUrl: 'http://127.0.0.1/forbidden',
+                view: { route: { href: 'https://shell.example.dev/forbidden' } },
+              },
+            },
+            stderr: 'Permission denied.',
+            exitCode: 7,
+          },
+        ],
+      },
+    ])
+
+    const malformed = await launchViewSession(
+      fake.root,
+      'issues.example.dev',
+      standalone,
+      null,
+      {},
+      2000,
+    )
+    expect(malformed.status).toBe('unavailable')
+    if (malformed.status !== 'unavailable')
+      throw new Error('expected the malformed session to fail')
+    expect(malformed.reason).toContain('v-no-route')
+    expect(
+      await launchViewSession(fake.root, 'issues.example.dev', standalone, null, {}, 2000),
+    ).toEqual({ status: 'unavailable', reason: 'Permission denied.' })
+    expect(fake.calls().map((call) => call.args)).toEqual([
+      activeArgs,
+      launchArgs,
+      activeArgs,
+      launchArgs,
+    ])
+  })
+})

package/studio/server/cli.test.ts

@@ -0,0 +1,88 @@
+import { afterEach, expect, test } from 'bun:test'
+import { mkdirSync, mkdtempSync, realpathSync, rmSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+import {
+  decodeJsonObject,
+  runStudioCliJson,
+  STUDIO_CLI_DESCRIPTOR_ENV,
+  studioCliCommand,
+} from './cli'
+
+const priorDescriptor = process.env[STUDIO_CLI_DESCRIPTOR_ENV]
+const roots: string[] = []
+
+afterEach(() => {
+  if (priorDescriptor === undefined) delete process.env[STUDIO_CLI_DESCRIPTOR_ENV]
+  else process.env[STUDIO_CLI_DESCRIPTOR_ENV] = priorDescriptor
+  for (const root of roots.splice(0)) rmSync(root, { recursive: true, force: true })
+})
+
+test('exact command rejects missing and incompatible descriptors instead of using PATH', () => {
+  delete process.env[STUDIO_CLI_DESCRIPTOR_ENV]
+  expect(() => studioCliCommand(['instance', 'active'])).toThrow(
+    'launch Studio through this Astrale CLI',
+  )
+  expect(() =>
+    studioCliCommand(
+      ['instance', 'active'],
+      JSON.stringify({ version: 2, executable: '/usr/bin/astrale', args: [] }),
+    ),
+  ).toThrow('launch Studio through this Astrale CLI')
+})
+
+test('machine runner uses the exact descriptor, appends json mode, and versions decoded output', async () => {
+  const root = mkdtempSync(join(tmpdir(), 'studio-cli-runner-'))
+  roots.push(root)
+  mkdirSync(root, { recursive: true })
+  const entry = join(root, 'fake-cli.ts')
+  writeFileSync(entry, `process.stdout.write(JSON.stringify({ command: process.argv.slice(2) }))\n`)
+  process.env[STUDIO_CLI_DESCRIPTOR_ENV] = JSON.stringify({
+    version: 1,
+    executable: process.execPath,
+    args: [realpathSync(entry)],
+  })
+
+  const result = await runStudioCliJson(
+    ['query', '--definition', '/:example.dev:class.Issue'],
+    decodeJsonObject,
+  )
+
+  expect(result).toMatchObject({
+    version: 1,
+    ok: true,
+    exitCode: 0,
+    timedOut: false,
+    data: {
+      command: ['query', '--definition', '/:example.dev:class.Issue', '--json'],
+    },
+  })
+})
+
+test('machine runner decodes structured CLI errors without treating them as success', async () => {
+  const root = mkdtempSync(join(tmpdir(), 'studio-cli-error-'))
+  roots.push(root)
+  const entry = join(root, 'fake-cli.ts')
+  writeFileSync(
+    entry,
+    `process.stderr.write(JSON.stringify({ error: 'NOT_FOUND', message: 'Missing instance.' }))
+process.exit(7)
+`,
+  )
+  process.env[STUDIO_CLI_DESCRIPTOR_ENV] = JSON.stringify({
+    version: 1,
+    executable: process.execPath,
+    args: [realpathSync(entry)],
+  })
+
+  const result = await runStudioCliJson(['instance', 'active'], decodeJsonObject)
+
+  expect(result).toMatchObject({
+    version: 1,
+    ok: false,
+    exitCode: 7,
+    detail: 'Missing instance.',
+    data: { error: 'NOT_FOUND', message: 'Missing instance.' },
+  })
+})