@astrale-os/cli 1.0.0-beta.32 → 1.0.0-beta.43

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

@@ -1,55 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-
-import { checkIssuerReachability } from '../meta'
-
-const ISSUER = 'https://host.example/kernel/child'
-const INVOCATION = `${ISSUER}/invoke`
-
-describe('issuer reachability', () => {
-  /** @evidence TEST-CLI-CONNECTION-PROBES-PINNED-ISSUER */
-  test('probes OIDC discovery at the separately pinned issuer, not the invocation endpoint', async () => {
-    const requests: string[] = []
-    const fetch = async (input: RequestInfo | URL): Promise<Response> => {
-      const url = String(input)
-      requests.push(url)
-      if (url === `${ISSUER}/.well-known/openid-configuration`) {
-        return Response.json({
-          issuer: ISSUER,
-          jwks_uri: `${ISSUER}/.well-known/jwks.json`,
-        })
-      }
-      if (url === `${ISSUER}/.well-known/jwks.json`) {
-        return Response.json({ keys: [{ kid: 'bootstrap' }] })
-      }
-      return new Response(null, { status: 404 })
-    }
-
-    await expect(checkIssuerReachability(INVOCATION, ISSUER, fetch)).resolves.toEqual({
-      issuer: ISSUER,
-      keys: [{ kid: 'bootstrap' }],
-    })
-    expect(requests).toEqual([
-      `${ISSUER}/.well-known/openid-configuration`,
-      `${ISSUER}/.well-known/jwks.json`,
-    ])
-  })
-
-  /** @evidence TEST-CLI-CONNECTION-REJECTS-DISCOVERY-ISSUER-MISMATCH */
-  test('rejects discovery that contradicts the separately pinned issuer', async () => {
-    const conflictingIssuer = 'https://attacker.example/kernel/child'
-    const fetch = async (input: RequestInfo | URL): Promise<Response> => {
-      const url = String(input)
-      if (url.endsWith('/.well-known/openid-configuration')) {
-        return Response.json({
-          issuer: conflictingIssuer,
-          jwks_uri: `${conflictingIssuer}/.well-known/jwks.json`,
-        })
-      }
-      return Response.json({ keys: [{ kid: 'attacker' }] })
-    }
-
-    await expect(checkIssuerReachability(INVOCATION, ISSUER, fetch)).rejects.toMatchObject({
-      code: 'ISSUER_UNREACHABLE',
-    })
-  })
-})

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

@@ -1,162 +0,0 @@
-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' } })
-  })
-
-  test('strips qualified property keys whose leaf is schema', () => {
-    const out = denoise({
-      props: {
-        'kernel.astrale.ai:class.Domain.property.schema': { huge: true },
-        'kernel.astrale.ai:class.Domain.property.origin': 'kernel.astrale.ai',
-      },
-    })
-    expect(out).toEqual({
-      props: { 'kernel.astrale.ai:class.Domain.property.origin': 'kernel.astrale.ai' },
-    })
-  })
-})
-
-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

@@ -1,40 +0,0 @@
-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')
-  })
-})

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

@@ -1,44 +0,0 @@
-import { describe, expect, it } from 'bun:test'
-import net from 'node:net'
-
-import { findFreePort, portFree } from '../port'
-
-function listen(port: number): Promise<net.Server> {
-  return new Promise((resolve, reject) => {
-    const s = net.createServer()
-    s.once('error', reject)
-    s.listen({ port, host: '127.0.0.1', exclusive: true }, () => resolve(s))
-  })
-}
-const close = (s: net.Server) => new Promise<void>((r) => s.close(() => r()))
-
-describe('port', () => {
-  it('portFree: true for an unbound port, false once it is bound', async () => {
-    const p = await findFreePort(48000, 200)
-    expect(p).not.toBeNull()
-    expect(await portFree(p as number)).toBe(true)
-    const srv = await listen(p as number)
-    try {
-      expect(await portFree(p as number)).toBe(false)
-    } finally {
-      await close(srv)
-    }
-  })
-
-  it('findFreePort: skips a busy port and returns a later free one', async () => {
-    const base = await findFreePort(48000, 200)
-    expect(base).not.toBeNull()
-    const srv = await listen(base as number)
-    try {
-      const next = await findFreePort(base as number, 10)
-      expect(next).not.toBeNull()
-      expect(next as number).toBeGreaterThan(base as number)
-    } finally {
-      await close(srv)
-    }
-  })
-
-  it('findFreePort: returns null when the band is empty (span 0)', async () => {
-    expect(await findFreePort(48000, 0)).toBeNull()
-  })
-})

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

@@ -1,25 +0,0 @@
-import { afterAll, beforeAll, describe, expect, test } from 'bun:test'
-
-import { promptText } from '../prompt'
-
-// The no-TTY branch IS the LLM / CI / piped case. promptText must resolve to a
-// default (never await a stdin read) there, so `astrale domain publish` fails
-// fast on its required-flag error instead of hanging. Force isTTY=false so this
-// holds even when the suite is run from an interactive terminal.
-describe('promptText — non-TTY never blocks on input', () => {
-  const original = process.stdin.isTTY
-  beforeAll(() => {
-    ;(process.stdin as { isTTY?: boolean }).isTTY = false
-  })
-  afterAll(() => {
-    ;(process.stdin as { isTTY?: boolean }).isTTY = original
-  })
-
-  test('returns the provided default', async () => {
-    expect(await promptText('Domain origin', { default: 'crm.acme.dev' })).toBe('crm.acme.dev')
-  })
-
-  test('returns undefined with no default (caller then hits its required-flag error)', async () => {
-    expect(await promptText('Published worker URL')).toBeUndefined()
-  })
-})

package/src/lib/__tests__/sdk-deps.test.ts

@@ -1,68 +0,0 @@
-import { afterEach, describe, expect, test } from 'bun:test'
-import { mkdtemp, rm, writeFile } from 'node:fs/promises'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-
-import { foreignPackageManager, inDomainProject, parseSdkOutdated } from '../sdk-deps'
-
-describe('parseSdkOutdated', () => {
-  test('keeps only deps with a strictly newer latest; uses wanted when current is absent', () => {
-    const json = JSON.stringify({
-      '@astrale-os/sdk': { current: '0.1.5', wanted: '0.1.5', latest: '0.1.9' }, // behind
-      '@astrale-os/sdk/schema': { current: '0.1.2', wanted: '0.1.2', latest: '0.1.2' }, // current
-      '@astrale-os/shell': { wanted: '0.1.0', latest: '0.1.1' }, // no `current` (not installed)
-    })
-    expect(parseSdkOutdated(json)).toEqual([
-      { pkg: '@astrale-os/sdk', current: '0.1.5', latest: '0.1.9' },
-      { pkg: '@astrale-os/shell', current: '0.1.0', latest: '0.1.1' },
-    ])
-  })
-
-  test('empty / non-JSON / no-latest input yields no upgrades (never throws)', () => {
-    expect(parseSdkOutdated('')).toEqual([])
-    expect(parseSdkOutdated('{}')).toEqual([])
-    expect(parseSdkOutdated('not json')).toEqual([])
-    expect(parseSdkOutdated(JSON.stringify({ '@astrale-os/sdk': { current: '0.1.9' } }))).toEqual(
-      [],
-    )
-  })
-})
-
-describe('inDomainProject', () => {
-  let tmp: string
-  afterEach(async () => {
-    if (tmp) await rm(tmp, { recursive: true, force: true })
-  })
-
-  test('true only where astrale.config.ts exists', async () => {
-    tmp = await mkdtemp(join(tmpdir(), 'sdk-deps-'))
-    expect(inDomainProject(tmp)).toBe(false)
-    await writeFile(join(tmp, 'astrale.config.ts'), 'export default {}\n')
-    expect(inDomainProject(tmp)).toBe(true)
-  })
-})
-
-describe('foreignPackageManager', () => {
-  let tmp: string
-  afterEach(async () => {
-    if (tmp) await rm(tmp, { recursive: true, force: true })
-  })
-
-  test('pnpm-lock / no lockfile → null (we own it); other lockfiles → that PM', async () => {
-    tmp = await mkdtemp(join(tmpdir(), 'sdk-deps-pm-'))
-    expect(foreignPackageManager(tmp)).toBeNull() // fresh → pnpm-first default
-
-    await writeFile(join(tmp, 'package-lock.json'), '{}')
-    expect(foreignPackageManager(tmp)).toBe('npm')
-
-    // pnpm-lock wins even alongside another lockfile (it's a pnpm project).
-    await writeFile(join(tmp, 'pnpm-lock.yaml'), "lockfileVersion: '9.0'\n")
-    expect(foreignPackageManager(tmp)).toBeNull()
-  })
-
-  test('yarn.lock → yarn', async () => {
-    tmp = await mkdtemp(join(tmpdir(), 'sdk-deps-yarn-'))
-    await writeFile(join(tmp, 'yarn.lock'), '')
-    expect(foreignPackageManager(tmp)).toBe('yarn')
-  })
-})

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

@@ -1,50 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-
-import { containsSelfRef, expandSelfReferences } from '../self'
-
-describe('containsSelfRef / expandSelfReferences', () => {
-  const ID = 'node-abc-123'
-
-  test.each([
-    ['@self', `@${ID}`],
-    ['@self::deployFunction', `@${ID}::deployFunction`],
-    ['@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}`],
-  ])('expands %p -> %p', (input, expected) => {
-    expect(containsSelfRef(input)).toBe(true)
-    expect(expandSelfReferences(input, ID)).toBe(expected)
-  })
-
-  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'],
-  ])('treats replacement metacharacters literally: %p x %p -> %p', (input, id, expected) => {
-    expect(expandSelfReferences(input, id)).toBe(expected)
-  })
-
-  test.each([
-    'prefix@self',
-    '@selfsuffix',
-    '@self.example',
-    '@self,@other',
-    'node=before@self',
-    '{"ref":"@self"}',
-    'no-self-here',
-  ])('does not expand %p', (input) => {
-    expect(containsSelfRef(input)).toBe(false)
-    expect(expandSelfReferences(input, ID)).toBe(input)
-  })
-
-  test('is stateless across calls', () => {
-    expect(containsSelfRef('@self')).toBe(true)
-    expect(containsSelfRef('@self')).toBe(true)
-    expect(containsSelfRef('@self')).toBe(true)
-  })
-})