@astrale-os/cli 0.4.0-alpha.13

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

@@ -0,0 +1,136 @@
+import { describe, expect, test } from 'bun:test'
+
+import { InstanceStoreSchema, normalizeInstanceKernelUrl, sanitizeStore } from '../instance'
+
+describe('InstanceStoreSchema', () => {
+  test('parses valid store with url', () => {
+    const result = InstanceStoreSchema.parse({
+      active: 'prod',
+      instances: {
+        prod: { url: 'https://prod.example.com', createdAt: '2024-01-01T00:00:00Z' },
+      },
+    })
+    expect(result.active).toBe('prod')
+    expect(result.instances.prod.url).toBe('https://prod.example.com')
+  })
+
+  test('parses legacy instance without url for migration compatibility', () => {
+    const result = InstanceStoreSchema.parse({
+      active: 'dev',
+      instances: {
+        dev: { createdAt: '2024-01-01T00:00:00Z' },
+      },
+    })
+    expect(result.instances.dev.url).toBeUndefined()
+  })
+
+  test('parses multiple instances', () => {
+    const result = InstanceStoreSchema.parse({
+      active: 'prod',
+      instances: {
+        local: { url: 'https://local.example.com', createdAt: '2024-01-01T00:00:00Z' },
+        prod: { url: 'https://prod.example.com', createdAt: '2024-06-01T00:00:00Z' },
+      },
+    })
+    expect(Object.keys(result.instances)).toHaveLength(2)
+  })
+
+  test('rejects missing active field', () => {
+    expect(() =>
+      InstanceStoreSchema.parse({
+        instances: { m: { createdAt: '2024-01-01' } },
+      }),
+    ).toThrow()
+  })
+
+  test('accepts instance without createdAt (optional at schema level)', () => {
+    // `createdAt` is intentionally optional on InstanceEntrySchema: only
+    // `createdAt` is metadata; the connection URL is the only required
+    // field for a usable bookmark.
+    const result = InstanceStoreSchema.parse({
+      active: 'm',
+      instances: { m: { url: 'http://test' } },
+    })
+    expect(result.instances.m.createdAt).toBeUndefined()
+  })
+
+  test('accepts empty instances record', () => {
+    const result = InstanceStoreSchema.parse({
+      active: 'none',
+      instances: {},
+    })
+    expect(Object.keys(result.instances)).toHaveLength(0)
+  })
+
+  test('normalizes region-routed managed instance roots to the kernel api URL', () => {
+    expect(normalizeInstanceKernelUrl('https://testmarc.eu.astrale.ai')).toBe(
+      'https://testmarc.eu.astrale.ai/api',
+    )
+    expect(normalizeInstanceKernelUrl('https://testmarc.eu.astrale.ai/')).toBe(
+      'https://testmarc.eu.astrale.ai/api',
+    )
+  })
+
+  test('does not rewrite explicit kernel or non-managed URLs', () => {
+    expect(normalizeInstanceKernelUrl('https://testmarc.eu.astrale.ai/api')).toBe(
+      'https://testmarc.eu.astrale.ai/api',
+    )
+    expect(normalizeInstanceKernelUrl('https://localhost:8443/kernel/host')).toBe(
+      'https://localhost:8443/kernel/host',
+    )
+    expect(normalizeInstanceKernelUrl('https://scw-admin.astrale.ai')).toBe(
+      'https://scw-admin.astrale.ai',
+    )
+    expect(normalizeInstanceKernelUrl('https://testmarc.svc.eu.astrale.ai')).toBe(
+      'https://testmarc.svc.eu.astrale.ai',
+    )
+    expect(normalizeInstanceKernelUrl('https://testmarc.eu.astrale.ai?debug=1')).toBe(
+      'https://testmarc.eu.astrale.ai?debug=1',
+    )
+  })
+})
+
+describe('sanitizeStore — read must not rewrite', () => {
+  test('an already-normalized store reports changed=false', () => {
+    // `changed` was computed via OBJECT IDENTITY (always true), so every
+    // read rewrote instances.json fire-and-forget — concurrent astrale
+    // processes clobbered each other's `active` from stale snapshots and
+    // calls silently targeted the wrong instance.
+    const store = {
+      active: 'a',
+      instances: {
+        a: { url: 'https://a.example/api', kind: 'bookmark' as const },
+      },
+    }
+    const { changed } = sanitizeStore(store)
+    expect(changed).toBe(false)
+  })
+
+  test('a dangling active pointer is preserved (not silently re-aimed)', () => {
+    const store = {
+      active: 'ghost',
+      instances: { a: { url: 'https://a.example/api', kind: 'bookmark' as const } },
+    }
+    const { store: out } = sanitizeStore(store)
+    expect(out.active).toBe('ghost')
+  })
+
+  test('organizationId survives sanitize without flagging a rewrite', () => {
+    // The org id captured at `instance create` is what makes token scoping
+    // immune to the router's eventually-consistent /auth/org — losing it on
+    // a read (or rewriting the file for it) would re-open the stale-org race.
+    const store = {
+      active: 'a',
+      instances: {
+        a: {
+          url: 'https://a.example/api',
+          kind: 'bookmark' as const,
+          organizationId: 'org_123',
+        },
+      },
+    }
+    const { store: out, changed } = sanitizeStore(store)
+    expect(out.instances.a.organizationId).toBe('org_123')
+    expect(changed).toBe(false)
+  })
+})

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

@@ -0,0 +1,129 @@
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test'
+import { CompactEncrypt, compactDecrypt, decodeProtectedHeader } from 'jose'
+import { access, mkdtemp, rm, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+import { IdentityKeyMissingError } from '../../errors'
+import {
+  generateEd25519Jwk,
+  keypairPaths,
+  listIdentityKeys,
+  persistKeypair,
+  removeKeypair,
+  signAs,
+} from '../keys'
+
+describe('DESIGN — per-identity keys', () => {
+  let tmp = ''
+  const savedStrict = process.env.ASTRALE_STRICT_IDENTITIES
+
+  beforeEach(async () => {
+    tmp = await mkdtemp(join(tmpdir(), 'astrale-keys-test-'))
+    delete process.env.ASTRALE_STRICT_IDENTITIES
+  })
+
+  afterEach(async () => {
+    if (savedStrict) process.env.ASTRALE_STRICT_IDENTITIES = savedStrict
+    else delete process.env.ASTRALE_STRICT_IDENTITIES
+    await rm(tmp, { recursive: true, force: true })
+  })
+
+  test('keypairPaths routes manager to legacy filenames', () => {
+    const p = keypairPaths('manager', tmp)
+    expect(p.privatePath.endsWith('manager.private.jwk')).toBe(true)
+    expect(p.publicPath.endsWith('manager.public.jwk')).toBe(true)
+  })
+
+  test('keypairPaths routes others to <name>.*.jwk', () => {
+    const p = keypairPaths('alice', tmp)
+    expect(p.privatePath.endsWith('alice.private.jwk')).toBe(true)
+    expect(p.publicPath.endsWith('alice.public.jwk')).toBe(true)
+  })
+
+  test('persistKeypair writes both files with kid', async () => {
+    const result = await persistKeypair('alice', { keysDir: tmp })
+    expect(result.kid).toMatch(/^alice-key-/)
+    const { privatePath, publicPath } = keypairPaths('alice', tmp)
+    await access(privatePath)
+    await access(publicPath)
+  })
+
+  test('signAs(alice) works when alice has her own key', async () => {
+    await persistKeypair('alice', { keysDir: tmp })
+    const jwt = await signAs('alice', tmp)
+    expect(jwt.split('.').length).toBe(3)
+  })
+
+  test('signAs(alice) uses the key file algorithm for EdDSA identities', async () => {
+    const { privateJwk, publicJwk } = await generateEd25519Jwk('alice-ed25519')
+    const { privatePath, publicPath } = keypairPaths('alice', tmp)
+    await writeFile(privatePath, JSON.stringify(privateJwk, null, 2))
+    await writeFile(publicPath, JSON.stringify(publicJwk, null, 2))
+
+    const jwt = await signAs('alice', tmp)
+
+    expect(decodeProtectedHeader(jwt).alg).toBe('EdDSA')
+  })
+
+  test('signAs(alice) falls back to manager key with warning', async () => {
+    await persistKeypair('manager', { keysDir: tmp })
+    const jwt = await signAs('alice', tmp)
+    expect(jwt.split('.').length).toBe(3)
+  })
+
+  test('signAs(alice) errors when strict mode and no alice key', async () => {
+    await persistKeypair('manager', { keysDir: tmp })
+    process.env.ASTRALE_STRICT_IDENTITIES = '1'
+    await expect(signAs('alice', tmp)).rejects.toThrow(IdentityKeyMissingError)
+  })
+
+  test('signAs errors when no keys at all', async () => {
+    await expect(signAs('manager', tmp)).rejects.toThrow(IdentityKeyMissingError)
+  })
+
+  test('removeKeypair is idempotent', async () => {
+    await persistKeypair('alice', { keysDir: tmp })
+    await removeKeypair('alice', tmp)
+    await removeKeypair('alice', tmp)
+    const { privatePath } = keypairPaths('alice', tmp)
+    await expect(access(privatePath)).rejects.toThrow()
+  })
+
+  test('listIdentityKeys returns names with private keys', async () => {
+    await persistKeypair('manager', { keysDir: tmp })
+    await persistKeypair('alice', { keysDir: tmp })
+    await persistKeypair('bob', { keysDir: tmp })
+    const names = await listIdentityKeys(tmp)
+    expect(names.sort()).toEqual(['alice', 'bob', 'manager'])
+  })
+
+  test('encrypted export envelope round-trip (JWE PBES2)', async () => {
+    await persistKeypair('alice', { keysDir: tmp })
+    const plain = JSON.stringify({ subject: 'alice', secret: 'x' })
+    const passphrase = 'correct-horse-battery'
+    const enc = await new CompactEncrypt(new TextEncoder().encode(plain))
+      .setProtectedHeader({ alg: 'PBES2-HS256+A128KW', enc: 'A256GCM' })
+      .encrypt(new TextEncoder().encode(passphrase))
+
+    expect(enc.split('.').length).toBe(5)
+
+    const { plaintext } = await compactDecrypt(enc, new TextEncoder().encode(passphrase), {
+      keyManagementAlgorithms: ['PBES2-HS256+A128KW'],
+    })
+    expect(new TextDecoder().decode(plaintext)).toBe(plain)
+  })
+
+  test('encrypted export fails with wrong passphrase', async () => {
+    const plain = JSON.stringify({ subject: 'alice' })
+    const enc = await new CompactEncrypt(new TextEncoder().encode(plain))
+      .setProtectedHeader({ alg: 'PBES2-HS256+A128KW', enc: 'A256GCM' })
+      .encrypt(new TextEncoder().encode('correct'))
+
+    await expect(
+      compactDecrypt(enc, new TextEncoder().encode('wrong'), {
+        keyManagementAlgorithms: ['PBES2-HS256+A128KW'],
+      }),
+    ).rejects.toThrow()
+  })
+})

package/src/lib/__tests__/local-status.test.ts

@@ -0,0 +1,202 @@
+import { describe, expect, test } from 'bun:test'
+
+import type { IdentityStore } from '../identity'
+import type { IdpSession } from '../idp'
+import type { InstanceStore } from '../instance'
+
+import { DEFAULT_ADMIN_TARGET_URL } from '../admin-target'
+import { buildLocalStatus, decodeJwtExpiration } from '../local-status'
+
+describe('local status snapshot', () => {
+  test('summarizes active bookmark and key identity registration', async () => {
+    const instances: InstanceStore = {
+      active: 'staging',
+      instances: {
+        staging: { url: 'https://kernel.example.com', issuer: 'https://issuer.example.com' },
+      },
+    }
+    const identities: IdentityStore = {
+      default: 'alice',
+      identities: {
+        alice: {
+          subject: 'alice',
+          source: 'key',
+          createdAt: '2026-01-01T00:00:00.000Z',
+          registrations: {
+            staging: {
+              iss: 'https://kernel.example.com/iss/thumbprint',
+              sub: 'node-1',
+              registeredAt: '2026-01-02T00:00:00.000Z',
+            },
+            admin: {
+              iss: 'https://admin.eu.astrale.ai/api/iss/thumbprint',
+              sub: 'admin-node-1',
+              registeredAt: '2026-01-02T00:00:00.000Z',
+            },
+          },
+        },
+      },
+    }
+
+    const status = await buildLocalStatus(instances, identities, async () => null)
+
+    expect(status.instance?.active).toBe('staging')
+    expect(status.instance?.url).toBe('https://kernel.example.com')
+    expect('error' in status.admin).toBe(false)
+    if (!('error' in status.admin)) {
+      expect(status.admin.url).toBe(DEFAULT_ADMIN_TARGET_URL)
+    }
+    expect(status.identity?.name).toBe('alice')
+    expect(status.identity?.source).toBe('key')
+    expect(status.identity?.session).toBeNull()
+  })
+
+  test('keeps a refreshable cached IdP session ready when the access token is stale', async () => {
+    const instances: InstanceStore = {
+      active: '',
+      instances: {},
+    }
+    const identities: IdentityStore = {
+      default: 'workos-user',
+      identities: {
+        'workos-user': {
+          subject: 'user_123',
+          source: 'idp',
+          mode: 'remote',
+          idp: 'workos',
+          issuer: 'https://idp.example.com',
+          createdAt: '2026-01-01T00:00:00.000Z',
+        },
+      },
+    }
+    const session: IdpSession = {
+      identity: 'workos-user',
+      idp: 'workos',
+      issuer: 'https://idp.example.com',
+      subject: 'user_123',
+      access_token: 'redacted',
+      refresh_token: 'redacted-refresh',
+      expires_at: '2000-01-01T00:00:00.000Z',
+      updatedAt: '2026-01-01T00:00:00.000Z',
+    }
+
+    const status = await buildLocalStatus(instances, identities, async () => session)
+
+    expect(status.instance).toBeNull()
+    expect(status.identity?.source).toBe('idp')
+    expect(status.identity?.session?.cached).toBe(true)
+    expect(status.identity?.session?.requiresLogin).toBe(false)
+    expect(status.identity?.session?.hasRefreshToken).toBe(true)
+  })
+
+  test('requires login when the cached IdP access token is stale and cannot refresh', async () => {
+    const instances: InstanceStore = {
+      active: '',
+      instances: {},
+    }
+    const identities: IdentityStore = {
+      default: 'workos-user',
+      identities: {
+        'workos-user': {
+          subject: 'user_123',
+          source: 'idp',
+          mode: 'remote',
+          idp: 'workos',
+          issuer: 'https://idp.example.com',
+          createdAt: '2026-01-01T00:00:00.000Z',
+        },
+      },
+    }
+    const session: IdpSession = {
+      identity: 'workos-user',
+      idp: 'workos',
+      issuer: 'https://idp.example.com',
+      subject: 'user_123',
+      access_token: 'redacted',
+      expires_at: '2000-01-01T00:00:00.000Z',
+      updatedAt: '2026-01-01T00:00:00.000Z',
+    }
+
+    const status = await buildLocalStatus(instances, identities, async () => session)
+
+    expect(status.identity?.session?.cached).toBe(true)
+    expect(status.identity?.session?.requiresLogin).toBe(true)
+    expect(status.identity?.session?.hasRefreshToken).toBe(false)
+  })
+
+  test('summarizes active managed slug without requiring a local bookmark', async () => {
+    const instances: InstanceStore = {
+      active: 'testmarc',
+      instances: {},
+    }
+    const identities: IdentityStore = {
+      default: 'workos-user',
+      identities: {
+        'workos-user': {
+          subject: 'user_123',
+          source: 'idp',
+          mode: 'remote',
+          idp: 'workos',
+          issuer: 'https://idp.example.com',
+          createdAt: '2026-01-01T00:00:00.000Z',
+        },
+      },
+    }
+
+    const status = await buildLocalStatus(instances, identities, async () => null)
+
+    expect(status.instance).toEqual({
+      active: 'testmarc',
+      url: '',
+      issuer: null,
+      defaultIdentity: null,
+    })
+  })
+
+  test('falls back to identity exp claim when IdP session has no expires_at', async () => {
+    const identities: IdentityStore = {
+      default: 'workos-user',
+      identities: {
+        'workos-user': {
+          subject: 'user_123',
+          source: 'idp',
+          mode: 'remote',
+          idp: 'workos',
+          issuer: 'https://idp.example.com',
+          createdAt: '2026-01-01T00:00:00.000Z',
+          claims: { exp: 946684800 },
+        },
+      },
+    }
+    const session: IdpSession = {
+      identity: 'workos-user',
+      idp: 'workos',
+      issuer: 'https://idp.example.com',
+      subject: 'user_123',
+      access_token: 'redacted',
+      updatedAt: '2026-01-01T00:00:00.000Z',
+    }
+
+    const status = await buildLocalStatus(
+      { active: '', instances: {} },
+      identities,
+      async () => session,
+    )
+
+    expect(status.identity?.session?.requiresLogin).toBe(true)
+  })
+})
+
+describe('decodeJwtExpiration', () => {
+  test('decodes exp without exposing token content', async () => {
+    const b64u = (value: unknown) => Buffer.from(JSON.stringify(value)).toString('base64url')
+    const token = `${b64u({ alg: 'none' })}.${b64u({ exp: 946684800 })}.signature`
+
+    const expiration = decodeJwtExpiration(token, Date.parse('2026-01-01T00:00:00.000Z'))
+
+    expect(expiration).toEqual({
+      expiresAt: '2000-01-01T00:00:00.000Z',
+      expired: true,
+    })
+  })
+})

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

@@ -0,0 +1,150 @@
+import { afterEach, beforeEach, describe, expect, mock, test } from 'bun:test'
+
+import { denoise, isMachine, output, present, presentList } from '../output'
+
+function captureStdout(): { writes: string[]; restore: () => void } {
+  const writes: string[] = []
+  const original = process.stdout.write.bind(process.stdout)
+  process.stdout.write = mock((chunk: string | Uint8Array) => {
+    writes.push(typeof chunk === 'string' ? chunk : new TextDecoder().decode(chunk))
+    return true
+  }) as typeof process.stdout.write
+  return { writes, restore: () => (process.stdout.write = original) }
+}
+
+describe('output — void/undefined normalization', () => {
+  let writes: string[] = []
+  let originalWrite: typeof process.stdout.write
+
+  beforeEach(() => {
+    writes = []
+    originalWrite = process.stdout.write.bind(process.stdout)
+    process.stdout.write = mock((chunk: string | Uint8Array) => {
+      writes.push(typeof chunk === 'string' ? chunk : new TextDecoder().decode(chunk))
+      return true
+    }) as typeof process.stdout.write
+  })
+
+  afterEach(() => {
+    process.stdout.write = originalWrite
+  })
+
+  test('--raw output for void syscall is "null", not bare "undefined"', () => {
+    // Regression: JSON.stringify(undefined) returns undefined (not "undefined"),
+    // so concatenating with '\n' coerced to the literal string 'undefined\n'.
+    // Any wrapper doing JSON.parse(stdout) would blow up.
+    output(undefined, { raw: true })
+    expect(writes.join('')).toBe('null\n')
+  })
+
+  test('--json output for void syscall is "null"', () => {
+    output(undefined, { json: true })
+    expect(writes.join('')).toBe('null\n')
+  })
+
+  test('explicit format=json on non-TTY yields "null" for void', () => {
+    output(undefined, { format: 'json' })
+    const out = writes.join('')
+    // On TTY the value gets ANSI-colored; either way the parseable token is `null`.
+    expect(out).toContain('null')
+    expect(out).not.toContain('undefined')
+  })
+
+  test('--raw output for actual data is unchanged', () => {
+    output({ a: 1 }, { raw: true })
+    expect(writes.join('')).toBe('{\n  "a": 1\n}\n')
+  })
+})
+
+describe('isMachine', () => {
+  test('returns true for --raw', () => {
+    expect(isMachine({ raw: true })).toBe(true)
+  })
+
+  test('returns true for --json', () => {
+    expect(isMachine({ json: true })).toBe(true)
+  })
+
+  test('returns true when both are set', () => {
+    expect(isMachine({ raw: true, json: true })).toBe(true)
+  })
+
+  test('returns false for empty opts when TTY', () => {
+    // This test depends on the test runner's TTY state.
+    // In a non-TTY environment (CI), isMachine({}) returns true.
+    const result = isMachine({})
+    expect(typeof result).toBe('boolean')
+  })
+
+  test('handles undefined opts', () => {
+    const result = isMachine()
+    expect(typeof result).toBe('boolean')
+  })
+})
+
+describe('present — scalar', () => {
+  let cap: ReturnType<typeof captureStdout>
+  beforeEach(() => (cap = captureStdout()))
+  afterEach(() => cap.restore())
+
+  test('--raw prints a bare string (no quotes) for shell capture', () => {
+    present('alice', { raw: true })
+    expect(cap.writes.join('')).toBe('alice\n')
+  })
+
+  test('--json prints a quoted JSON string', () => {
+    present('alice', { json: true })
+    expect(cap.writes.join('')).toBe('"alice"\n')
+  })
+
+  test('objects fall back to JSON under --raw (nothing rawer to give)', () => {
+    present({ a: 1 }, { raw: true })
+    expect(cap.writes.join('')).toBe('{\n  "a": 1\n}\n')
+  })
+})
+
+describe('denoise', () => {
+  test('strips schema / icon / code at any depth, keeps the rest', () => {
+    const out = denoise({
+      id: 'x',
+      icon: '<svg/>',
+      props: { schema: 'huge', name: 'n', code: 'c' },
+    })
+    expect(out).toEqual({ id: 'x', props: { name: 'n' } })
+  })
+})
+
+describe('presentList', () => {
+  let cap: ReturnType<typeof captureStdout>
+  beforeEach(() => (cap = captureStdout()))
+  afterEach(() => cap.restore())
+
+  const project = (items: Array<{ name: string; path?: string; props?: unknown }>) => ({
+    columns: [{ key: 'name', header: 'NAME' }],
+    rows: items.map((i) => ({ name: i.name })),
+    paths: items.map((i) => i.path ?? ''),
+  })
+
+  test('--count prints only the number', () => {
+    presentList([{ name: 'a' }, { name: 'b' }], { count: true }, project)
+    expect(cap.writes.join('')).toBe('2\n')
+  })
+
+  test('-q prints one path per line', () => {
+    presentList(
+      [
+        { name: 'a', path: '/a' },
+        { name: 'b', path: '/b' },
+      ],
+      { quiet: true },
+      project,
+    )
+    expect(cap.writes.join('')).toBe('/a\n/b\n')
+  })
+
+  test('machine output is the denoised raw items, not the projected rows', () => {
+    presentList([{ name: 'a', props: { schema: 'big', keep: 1 } }], { json: true }, project)
+    const out = JSON.parse(cap.writes.join(''))
+    expect(out).toEqual([{ name: 'a', props: { keep: 1 } }])
+  })
+})

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

@@ -0,0 +1,40 @@
+import { describe, expect, test } from 'bun:test'
+import chalk from 'chalk'
+
+import { panel, renderInstanceHero } from '../panel'
+
+// Built from a char code so the regex source carries no literal control char.
+const ANSI_RE = new RegExp(String.fromCharCode(27) + '\\[[0-9;]*m', 'g')
+const stripAnsi = (s: string): string => s.replace(ANSI_RE, '')
+
+describe('panel — rounded box framing', () => {
+  test('every visible line is the same width (ANSI excluded)', () => {
+    const lines = stripAnsi(panel(['short', 'a much longer line here'])).split('\n')
+    const widths = new Set(lines.map((l) => l.length))
+    expect(widths.size).toBe(1)
+  })
+
+  test('draws rounded corners top and bottom', () => {
+    const lines = stripAnsi(panel(['x'])).split('\n')
+    expect(lines[0]).toContain('╭')
+    expect(lines[0]).toContain('╮')
+    expect(lines[lines.length - 1]).toContain('╰')
+    expect(lines[lines.length - 1]).toContain('╯')
+  })
+
+  test('colored content does not break alignment', () => {
+    // A bold/underlined cell carries ANSI; visible width must still align.
+    const out = panel(['plain', chalk.bold.cyan.underline('https://my-app.eu.astrale.ai')])
+    const lines = stripAnsi(out).split('\n')
+    expect(new Set(lines.map((l) => l.length)).size).toBe(1)
+  })
+})
+
+describe('renderInstanceHero', () => {
+  test('puts the URL front and center', () => {
+    const out = stripAnsi(renderInstanceHero('my-app', 'https://my-app.eu.astrale.ai'))
+    expect(out).toContain('Your instance is live')
+    expect(out).toContain('https://my-app.eu.astrale.ai')
+    expect(out).toContain('my-app')
+  })
+})