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

package/src/lib/__tests__/use-target.test.ts

@@ -1,56 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-
-import type { IdentityStore } from '../../identity/index'
-import type { InstanceStore } from '../instance'
-
-import { resolveUseTarget } from '../use-target'
-
-const instances: InstanceStore = {
-  active: 'staging',
-  instances: {
-    staging: { url: 'https://staging.example.com', slug: 'stage' },
-    prod: { url: 'https://prod.example.com' },
-  },
-}
-
-const identities: IdentityStore = {
-  default: 'alice',
-  identities: {
-    alice: { subject: 'alice', createdAt: '2026-01-01T00:00:00.000Z', source: 'key' },
-    prod: { subject: 'prod-user', createdAt: '2026-01-01T00:00:00.000Z', source: 'key' },
-  },
-}
-
-describe('resolveUseTarget', () => {
-  test('resolves identity-only names', () => {
-    expect(resolveUseTarget('alice', instances, identities)).toEqual({
-      kind: 'identity',
-      name: 'alice',
-    })
-  })
-
-  test('resolves instance keys and slugs', () => {
-    expect(resolveUseTarget('staging', instances, identities)).toEqual({
-      kind: 'instance',
-      name: 'staging',
-    })
-    expect(resolveUseTarget('stage', instances, identities)).toEqual({
-      kind: 'instance',
-      name: 'staging',
-    })
-  })
-
-  test('refuses ambiguous names', () => {
-    expect(resolveUseTarget('prod', instances, identities)).toEqual({
-      kind: 'ambiguous',
-      name: 'prod',
-    })
-  })
-
-  test('reports missing names', () => {
-    expect(resolveUseTarget('missing', instances, identities)).toEqual({
-      kind: 'missing',
-      name: 'missing',
-    })
-  })
-})

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

@@ -1,34 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-
-import { validateName } from '../validation'
-
-describe('validateName', () => {
-  test('accepts valid names', () => {
-    expect(() => validateName('manager', 'Instance')).not.toThrow()
-    expect(() => validateName('my-instance', 'Instance')).not.toThrow()
-    expect(() => validateName('my_instance', 'Instance')).not.toThrow()
-    expect(() => validateName('my.instance', 'Instance')).not.toThrow()
-    expect(() => validateName('Instance123', 'Instance')).not.toThrow()
-    expect(() => validateName('a', 'Identity')).not.toThrow()
-  })
-
-  test('rejects empty string', () => {
-    expect(() => validateName('', 'Instance')).toThrow(/Invalid instance name/)
-  })
-
-  test('rejects whitespace', () => {
-    expect(() => validateName(' ', 'Instance')).toThrow(/Invalid instance name/)
-    expect(() => validateName('my instance', 'Instance')).toThrow(/Invalid instance name/)
-  })
-
-  test('rejects special characters', () => {
-    expect(() => validateName('my/instance', 'Instance')).toThrow(/Invalid instance name/)
-    expect(() => validateName('my@instance', 'Identity')).toThrow(/Invalid identity name/)
-    expect(() => validateName('name!', 'Instance')).toThrow()
-  })
-
-  test('includes entity type in error message', () => {
-    expect(() => validateName('', 'Instance')).toThrow('instance')
-    expect(() => validateName('', 'Identity')).toThrow('identity')
-  })
-})

package/src/lib/__tests__/view-assets.test.ts

@@ -1,171 +0,0 @@
-import { afterEach, describe, expect, test } from 'bun:test'
-import {
-  mkdtemp,
-  mkdir,
-  readFile,
-  realpath,
-  rm,
-  symlink,
-  utimes,
-  writeFile,
-} from 'node:fs/promises'
-import { tmpdir } from 'node:os'
-import { dirname, join, relative } from 'node:path'
-import { pathToFileURL } from 'node:url'
-
-import { ensureViewerAssets, viewerDistDir } from '../view/assets'
-
-const temporaryDirectories: string[] = []
-
-afterEach(async () => {
-  await Promise.all(
-    temporaryDirectories
-      .splice(0)
-      .map((directory) => rm(directory, { recursive: true, force: true })),
-  )
-})
-
-describe('viewer asset resolution', () => {
-  test('keeps long placement labels from widening the mounted View viewport', async () => {
-    const source = await readFile(
-      join(import.meta.dirname, '..', '..', '..', 'viewer', 'index.html'),
-      'utf8',
-    )
-
-    expect(source).toContain('#view-label,')
-    expect(source).toContain('text-overflow: ellipsis;')
-    expect(source).toContain('#frame {\n        flex: 1;\n        min-width: 0;')
-  })
-
-  test('skips partial candidates and prefers complete package-owned assets', async () => {
-    const root = await mkdtemp(join(tmpdir(), 'astrale-view-candidates-'))
-    temporaryDirectories.push(root)
-    const prefix = join(root, '.npm-global')
-    const packageRoot = join(prefix, 'lib', 'node_modules', '@astrale-os', 'cli')
-    const entry = join(prefix, 'bin', 'astrale')
-    const bundle = join(packageRoot, 'dist', 'astrale.js')
-    const published = join(packageRoot, 'viewer', 'dist')
-    const legacy = join(prefix, 'viewer', 'dist')
-
-    await mkdir(dirname(bundle), { recursive: true })
-    await mkdir(published, { recursive: true })
-    await mkdir(legacy, { recursive: true })
-    await writeFile(bundle, '')
-    await writeFile(join(published, 'main.js'), '')
-    await writeFile(join(legacy, 'main.js'), '')
-    await writeFile(join(legacy, 'index.html'), '')
-
-    expect(viewerDistDir(pathToFileURL(bundle).href, entry)).toBe(legacy)
-
-    await writeFile(join(published, 'index.html'), '')
-    expect(viewerDistDir(pathToFileURL(bundle).href, entry)).toBe(published)
-  })
-
-  test('builds missing viewer assets in a clean source checkout', async () => {
-    const root = await mkdtemp(join(tmpdir(), 'astrale-view-source-'))
-    temporaryDirectories.push(root)
-    const module = join(root, 'src', 'lib', 'view', 'assets.ts')
-    const source = join(root, 'viewer')
-    const dist = join(source, 'dist')
-
-    await mkdir(dirname(module), { recursive: true })
-    await mkdir(source, { recursive: true })
-    await writeFile(module, '')
-    await writeFile(join(source, 'main.ts'), 'document.body.textContent = "viewer ready"\n')
-    await writeFile(join(source, 'index.html'), '<!doctype html><body></body>\n')
-
-    expect(await ensureViewerAssets(pathToFileURL(module).href, join(root, 'bin', 'astrale'))).toBe(
-      dist,
-    )
-    expect(await readFile(join(dist, 'index.html'), 'utf8')).toContain('<body>')
-    expect(await readFile(join(dist, 'main.js'), 'utf8')).toContain('viewer ready')
-  })
-
-  test('rebuilds stale viewer assets in a source checkout', async () => {
-    const root = await mkdtemp(join(tmpdir(), 'astrale-view-stale-'))
-    temporaryDirectories.push(root)
-    const module = join(root, 'src', 'lib', 'view', 'assets.ts')
-    const source = join(root, 'viewer')
-    const dist = join(source, 'dist')
-
-    await mkdir(dirname(module), { recursive: true })
-    await mkdir(dist, { recursive: true })
-    await writeFile(module, '')
-    await writeFile(join(source, 'main.ts'), 'document.body.textContent = "fresh viewer"\n')
-    await writeFile(join(source, 'index.html'), '<!doctype html><body>fresh</body>\n')
-    await writeFile(join(dist, 'main.js'), 'document.body.textContent = "stale viewer"\n')
-    await writeFile(join(dist, 'index.html'), '<!doctype html><body>stale</body>\n')
-    const future = new Date(Date.now() + 2_000)
-    await utimes(join(source, 'main.ts'), future, future)
-
-    await ensureViewerAssets(pathToFileURL(module).href, join(root, 'bin', 'astrale'))
-
-    expect(await readFile(join(dist, 'main.js'), 'utf8')).toContain('fresh viewer')
-    expect(await readFile(join(dist, 'index.html'), 'utf8')).toContain('fresh')
-  })
-
-  test('uses the bundled module location when invoked through a global bin symlink', async () => {
-    const root = await mkdtemp(join(tmpdir(), 'astrale-view-bundle-'))
-    temporaryDirectories.push(root)
-    const prefix = join(root, '.npm-global')
-    const packageRoot = join(prefix, 'lib', 'node_modules', '@astrale-os', 'cli')
-    const entry = join(prefix, 'bin', 'astrale')
-    const sourceEntry = join(root, 'entry.ts')
-    const viewer = join(packageRoot, 'viewer', 'dist')
-    const assetsPath = join(import.meta.dirname, '..', 'view', 'assets.ts')
-    const relativeAssetsPath = relative(
-      await realpath(dirname(sourceEntry)),
-      await realpath(assetsPath),
-    )
-    const assetsModule = relativeAssetsPath.startsWith('.')
-      ? relativeAssetsPath
-      : `./${relativeAssetsPath}`
-
-    await mkdir(join(prefix, 'bin'), { recursive: true })
-    await mkdir(viewer, { recursive: true })
-    await writeFile(join(viewer, 'main.js'), '')
-    await writeFile(join(viewer, 'index.html'), '')
-    await writeFile(
-      sourceEntry,
-      `import { viewerDistDir } from ${JSON.stringify(assetsModule)}\nconsole.log(viewerDistDir())\n`,
-    )
-    const build = await Bun.build({
-      entrypoints: [sourceEntry],
-      outdir: join(packageRoot, 'dist'),
-      target: 'node',
-      format: 'esm',
-    })
-    expect(build.success).toBe(true)
-    await symlink(
-      join('..', 'lib', 'node_modules', '@astrale-os', 'cli', 'dist', 'entry.js'),
-      entry,
-    )
-
-    const node = Bun.which('node')
-    expect(node).not.toBeNull()
-    const process = Bun.spawn([node!, entry], { 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).toBe(0)
-    expect(stderr).toBe('')
-    expect(stdout.trim()).toBe(await realpath(viewer))
-  })
-
-  test('resolves assets shipped beside a Bun-compiled standalone executable', async () => {
-    const root = await mkdtemp(join(tmpdir(), 'astrale-view-standalone-'))
-    temporaryDirectories.push(root)
-    const executable = join(root, 'bin', 'astrale')
-    const viewer = join(root, 'bin', 'viewer', 'dist')
-    await mkdir(viewer, { recursive: true })
-    await writeFile(join(viewer, 'main.js'), '')
-    await writeFile(join(viewer, 'index.html'), '')
-
-    expect(viewerDistDir('file:///$bunfs/root/assets.ts', '/$bunfs/root/astrale', executable)).toBe(
-      viewer,
-    )
-  })
-})

package/src/lib/__tests__/view-external-open-intent.test.ts

@@ -1,150 +0,0 @@
-import type { ChildrenChannel, ExternalOpenRequest, Shell } from '@astrale-os/shell'
-
-import { capabilitiesMiddleware, createIntentPipeline, createIntentRouter } from '@astrale-os/shell'
-import { describe, expect, mock, test } from 'bun:test'
-
-import type { ExternalOpenIntentMessage } from '../view/external-open-intent'
-
-import {
-  installExternalOpenIntentHandler,
-  openExternalBrowserWindow,
-} from '../view/external-open-intent'
-import { viewHostCapabilities } from '../view/host-capabilities'
-
-describe('View external navigation host effect', () => {
-  test('the real Shell pipeline opens only an exact granted origin and replies to the physical child', async () => {
-    const sent: Array<{ windowId: string; message: unknown }> = []
-    const children = {
-      send: (windowId: string, value: unknown) => sent.push({ windowId, message: value }),
-      has: () => true,
-      on: () => () => undefined,
-      onClose: () => () => undefined,
-    } as ChildrenChannel
-    const capabilities = viewHostCapabilities(['https://connect.nango.dev'])
-    const pipeline = createIntentPipeline()
-    pipeline.use(
-      capabilitiesMiddleware({
-        lookup: (sender) => (sender === 'physical-child' ? capabilities : undefined),
-      }),
-    )
-    const router = createIntentRouter({
-      selfWindowId: 'root',
-      pipeline,
-      parent: null,
-      children,
-    })
-    const open = mock((_request: ExternalOpenRequest) => true)
-    installExternalOpenIntentHandler(
-      {
-        children,
-        onIntent: router.onLocal.bind(router),
-      } as unknown as Shell,
-      { open },
-    )
-
-    await router.handleInbound(
-      'child',
-      message('https://connect.nango.dev/session', 'forged-sibling'),
-      'physical-child',
-    )
-
-    expect(open).toHaveBeenCalledTimes(1)
-    expect(sent).toEqual([
-      {
-        windowId: 'physical-child',
-        message: expect.objectContaining({
-          envelope: expect.objectContaining({
-            payload: { correlationId: 'request-1', result: { outcome: 'opened' } },
-          }),
-        }),
-      },
-    ])
-
-    for (const denied of [
-      'http://connect.nango.dev/session',
-      'https://sub.connect.nango.dev/session',
-      'https://connect.nango.dev:444/session',
-      'https://evil.example/session',
-    ]) {
-      await router.handleInbound('child', message(denied), 'physical-child')
-    }
-    await router.handleInbound('child', message('https://connect.nango.dev/session'), 'ungranted')
-    expect(open).toHaveBeenCalledTimes(1)
-    expect(sent).toHaveLength(1)
-  })
-
-  test('reports a popup block through the admitted pipeline', async () => {
-    const sent = mock((_windowId: string, _message: unknown) => undefined)
-    const children = {
-      send: sent,
-      has: () => true,
-      on: () => () => undefined,
-      onClose: () => () => undefined,
-    } as ChildrenChannel
-    const pipeline = createIntentPipeline()
-    pipeline.use(
-      capabilitiesMiddleware({
-        lookup: () => viewHostCapabilities(['https://connect.nango.dev']),
-      }),
-    )
-    const router = createIntentRouter({ selfWindowId: 'root', pipeline, parent: null, children })
-    installExternalOpenIntentHandler(
-      { children, onIntent: router.onLocal.bind(router) } as unknown as Shell,
-      { open: () => false },
-    )
-
-    await router.handleInbound('child', message('https://connect.nango.dev/session'), 'child-1')
-
-    expect(sent).toHaveBeenCalledWith(
-      'child-1',
-      expect.objectContaining({
-        envelope: expect.objectContaining({
-          payload: { correlationId: 'request-1', result: { outcome: 'blocked' } },
-        }),
-      }),
-    )
-  })
-
-  test('isolates a fresh inert context before navigating and closes it when isolation fails', () => {
-    const replace = mock((_url: string) => undefined)
-    const opened = { opener: {}, location: { replace }, close: mock(() => undefined) }
-    const open = mock(() => opened)
-
-    expect(
-      openExternalBrowserWindow({ open } as never, {
-        url: 'https://connect.nango.dev/session',
-        mode: 'popup',
-      }),
-    ).toBe(true)
-    expect(open).toHaveBeenCalledWith('', '_blank', 'popup,width=720,height=760')
-    expect(opened.opener).toBeNull()
-    expect(replace).toHaveBeenCalledWith('https://connect.nango.dev/session')
-
-    const close = mock(() => undefined)
-    const unsafe = Object.defineProperty({ close, location: { replace: mock() } }, 'opener', {
-      set: () => {
-        throw new Error('opener isolation refused')
-      },
-    })
-    expect(
-      openExternalBrowserWindow({ open: () => unsafe } as never, {
-        url: 'https://connect.nango.dev/session',
-        mode: 'tab',
-      }),
-    ).toBe(false)
-    expect(close).toHaveBeenCalledTimes(1)
-  })
-})
-
-function message(url: string, sender = 'child-1'): ExternalOpenIntentMessage {
-  return {
-    type: 'intent',
-    version: 1,
-    envelope: {
-      name: 'browser.openExternal',
-      payload: { url, mode: 'popup' },
-      sender: { windowId: sender },
-      correlationId: 'request-1',
-    },
-  }
-}

package/src/lib/__tests__/view-external-open-origins.test.ts

@@ -1,27 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-
-import { admitExternalOpenOrigins } from '../view/external-open-origins'
-
-describe('View external navigation grants', () => {
-  test('defaults to no authority and canonicalizes exact HTTPS origins', () => {
-    expect(admitExternalOpenOrigins(undefined)).toEqual([])
-    expect(
-      admitExternalOpenOrigins([
-        'https://connect.nango.dev',
-        'https://connect.nango.dev/',
-        'https://connect.composio.dev:443',
-      ]),
-    ).toEqual(['https://connect.nango.dev', 'https://connect.composio.dev'])
-  })
-
-  test.each([
-    'http://connect.nango.dev',
-    'https://user@connect.nango.dev',
-    'https://connect.nango.dev/path',
-    'https://connect.nango.dev?session=secret',
-    'https://*.example.com',
-    'not-a-url',
-  ])('rejects a non-origin grant: %s', (candidate) => {
-    expect(() => admitExternalOpenOrigins([candidate])).toThrow('exact HTTPS origin')
-  })
-})