@astrale-os/cli 0.6.3-alpha.0 → 0.8.0-alpha.0

package/src/lib/login-flow.ts

@@ -29,27 +29,6 @@ import { log } from './log'
  * behavior; presentation (the device URL is logged here; success lines are the
  * caller's) does not.
  */
-/**
- * Interactive device-flow progress. Emitted once, when the device authorization
- * has been requested and the user must approve it in a browser. The caller
- * decides how to present it (the CLI logs it; the desktop opens the URL and
- * pushes it to the renderer). Structurally identical to connect-host's wire
- * `AuthVerificationEvent`, but declared here so the CLI carries no dependency on
- * connect-host (which depends on the CLI, not the reverse).
- */
-export type DeviceVerification = {
-  /** The base verification URL (fallback to the complete one when absent). */
-  verificationUri: string
-  /** Pre-filled verification URL (opens straight to the approval page). */
-  verificationUriComplete?: string
-  /** The short user code to confirm — a reassurance fallback when the URL is pre-filled. */
-  userCode?: string
-  /** Seconds until the device code expires. */
-  expiresIn?: number
-  /** Human-readable instruction from the IdP. */
-  message?: string
-}
-
 export type LoginFlowOpts = {
   idp?: string
   name?: string
@@ -63,12 +42,6 @@ export type LoginFlowOpts = {
   codeVerifier?: string
   /** Switch the default identity to the one we just logged in (default true). */
   use?: boolean
-  /**
-   * When set, receives the device-flow verification details and REPLACES the
-   * default `log.info` presentation (a headless/GUI caller drives the UI). The
-   * `auth login` command passes nothing, so its terminal output is unchanged.
-   */
-  onVerification?: (e: DeviceVerification) => void
 }
 
 export type LoginResult = {
@@ -175,20 +148,10 @@ async function obtainToken(
     scope,
     audience: opts.audience,
   })
-  if (opts.onVerification) {
-    opts.onVerification({
-      verificationUri: device.verification_uri ?? device.verification_uri_complete ?? '',
-      verificationUriComplete: device.verification_uri_complete,
-      userCode: device.user_code,
-      expiresIn: device.expires_in,
-      message: device.message,
-    })
-  } else {
-    if (device.verification_uri_complete) log.info(`Open: ${device.verification_uri_complete}`)
-    else if (device.verification_uri) log.info(`Open: ${device.verification_uri}`)
-    if (device.user_code) log.info(`Code: ${device.user_code}`)
-    if (device.message) log.dim(`  ${device.message}`)
-  }
+  if (device.verification_uri_complete) log.info(`Open: ${device.verification_uri_complete}`)
+  else if (device.verification_uri) log.info(`Open: ${device.verification_uri}`)
+  if (device.user_code) log.info(`Code: ${device.user_code}`)
+  if (device.message) log.dim(`  ${device.message}`)
 
   return pollDeviceToken({
     idp,

package/src/lib/view/assets.ts

@@ -0,0 +1,64 @@
+import { existsSync } from 'node:fs'
+import { copyFile } from 'node:fs/promises'
+import { dirname, join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+/**
+ * The prebuilt host-page bundle, shipped next to the CLI module
+ * (`<pkg>/viewer/dist`). The module URL is authoritative because npm global
+ * installs expose the CLI through a bin symlink outside the package root.
+ */
+export function viewerDistDir(moduleUrl = import.meta.url, entry = process.argv[1] ?? '.'): string {
+  const override = process.env.ASTRALE_VIEWER_DIR
+  if (override) return override
+
+  const moduleDirectory = dirname(fileURLToPath(moduleUrl))
+  const published = join(moduleDirectory, '..', 'viewer', 'dist')
+  const source = join(moduleDirectory, '..', '..', '..', 'viewer', 'dist')
+  const legacy = join(dirname(entry), '..', 'viewer', 'dist')
+  const complete = [published, source, legacy].find(hasViewerBundle)
+  if (complete) return complete
+
+  // A source checkout may intentionally omit generated dist assets. Keep the
+  // source-derived destination so ensureViewerAssets can build it on demand.
+  if (hasViewerSource(join(source, '..'))) return source
+
+  // Published installs cannot rebuild: preserve the package-relative path in
+  // the diagnostic instead of pointing at the npm prefix beside the bin link.
+  return published
+}
+
+/** Ensure the host bundle exists; on a dev checkout, build it with Bun. */
+export async function ensureViewerAssets(
+  moduleUrl = import.meta.url,
+  entry = process.argv[1] ?? '.',
+): Promise<string> {
+  const dist = viewerDistDir(moduleUrl, entry)
+  if (hasViewerBundle(dist)) return dist
+  const srcDir = join(dist, '..')
+  const bun = (
+    globalThis as { Bun?: { build: (o: object) => Promise<{ success: boolean; logs: unknown[] }> } }
+  ).Bun
+  if (bun && hasViewerSource(srcDir)) {
+    const result = await bun.build({
+      entrypoints: [join(srcDir, 'main.ts')],
+      outdir: dist,
+      target: 'browser',
+      minify: false,
+    })
+    if (!result.success) throw new Error(`viewer build failed: ${result.logs.join('\n')}`)
+    await copyFile(join(srcDir, 'index.html'), join(dist, 'index.html'))
+    return dist
+  }
+  throw new Error(
+    `viewer bundle missing at ${dist} — reinstall the CLI (or run \`bun scripts/build.ts\` in a dev checkout)`,
+  )
+}
+
+function hasViewerBundle(directory: string): boolean {
+  return existsSync(join(directory, 'main.js')) && existsSync(join(directory, 'index.html'))
+}
+
+function hasViewerSource(directory: string): boolean {
+  return existsSync(join(directory, 'main.ts')) && existsSync(join(directory, 'index.html'))
+}

package/src/lib/view/port-allocation.ts

@@ -0,0 +1,19 @@
+import { join } from 'node:path'
+
+import { withFileLock } from '../fs-atomic'
+import { VIEW_DIR } from './session'
+
+const VIEW_PORT_LOCK = join(VIEW_DIR, 'ports.lock')
+
+/**
+ * Keep the free-port probe and detached server startup in one cross-process
+ * critical section. A probe alone is only advisory: without this lock, two
+ * concurrent `astrale view` processes can both observe 4419 as free before
+ * either child binds it.
+ */
+export function withViewPortAllocationLock<T>(
+  fn: () => Promise<T>,
+  lockPath = VIEW_PORT_LOCK,
+): Promise<T> {
+  return withFileLock(lockPath, fn)
+}

package/src/lib/view/server.ts

@@ -1,17 +1,19 @@
 import type { ReadableStream as WebReadableStream } from 'node:stream/web'
 
-import { existsSync } from 'node:fs'
 import { readFile } from 'node:fs/promises'
 import { createServer, type IncomingMessage, type Server, type ServerResponse } from 'node:http'
-import { dirname, join } from 'node:path'
+import { join } from 'node:path'
 import { Readable } from 'node:stream'
 
 import type { ViewServeConfig } from './session'
 
 import { withKernelClient } from '../../kernel'
 import { fetchWithCaFile } from '../../kernel/ca-fetch'
+import { viewerDistDir } from './assets'
 import { removeSessionFiles } from './session'
 
+export { ensureViewerAssets, viewerDistDir } from './assets'
+
 /**
  * The view-session server: serves the host page, hands it config and fresh
  * credentials, receives its lifecycle reports, and proxies the view's kernel
@@ -197,41 +199,6 @@ export function startViewServer(config: ViewServeConfig): Server {
   return server
 }
 
-/**
- * The prebuilt host-page bundle, shipped next to the CLI entry
- * (`<pkg>/viewer/dist`). Dev runs (bun, no dist) build it on demand.
- */
-export function viewerDistDir(): string {
-  const override = process.env.ASTRALE_VIEWER_DIR
-  if (override) return override
-  return join(dirname(process.argv[1] ?? '.'), '..', 'viewer', 'dist')
-}
-
-/** Ensure the host bundle exists; on a dev checkout, build it with Bun. */
-export async function ensureViewerAssets(): Promise<string> {
-  const dist = viewerDistDir()
-  if (existsSync(join(dist, 'main.js')) && existsSync(join(dist, 'index.html'))) return dist
-  const srcDir = join(dist, '..')
-  const bun = (
-    globalThis as { Bun?: { build: (o: object) => Promise<{ success: boolean; logs: unknown[] }> } }
-  ).Bun
-  if (bun && existsSync(join(srcDir, 'main.ts'))) {
-    const result = await bun.build({
-      entrypoints: [join(srcDir, 'main.ts')],
-      outdir: dist,
-      target: 'browser',
-      minify: false,
-    })
-    if (!result.success) throw new Error(`viewer build failed: ${result.logs.join('\n')}`)
-    const { copyFile } = await import('node:fs/promises')
-    await copyFile(join(srcDir, 'index.html'), join(dist, 'index.html'))
-    return dist
-  }
-  throw new Error(
-    `viewer bundle missing at ${dist} — reinstall the CLI (or run \`bun scripts/build.ts\` in a dev checkout)`,
-  )
-}
-
 function jwtExpiry(token: string): number | null {
   try {
     const payload = JSON.parse(Buffer.from(token.split('.')[1], 'base64url').toString('utf8')) as {

package/src/setup/__tests__/instance-step.test.ts

@@ -0,0 +1,239 @@
+import { describe, expect, mock, test } from 'bun:test'
+
+import type { OwnedInstanceInfo } from '../../lib/admin-instance'
+import type { SetupContext } from '../types'
+
+import { AstraleError } from '../../errors'
+import {
+  adoptOwnedInstance,
+  ensureOwnedInstance,
+  type InstanceSetupDependencies,
+} from '../steps/instance'
+
+const ctx: SetupContext = {
+  interactive: true,
+  machine: true,
+  opts: {},
+  slug: 'new-instance',
+}
+
+function instance(slug: string, state: OwnedInstanceInfo['state'] = 'ready'): OwnedInstanceInfo {
+  return {
+    id: `${slug}-id`,
+    slug,
+    url: `https://${slug}.eu.astrale.ai`,
+    state,
+    organizationId: `org_${slug}`,
+  }
+}
+
+function dependencies(
+  overrides: Partial<InstanceSetupDependencies> = {},
+): InstanceSetupDependencies {
+  return {
+    fetchOwned: mock(async () => []),
+    adopt: mock(async () => {}),
+    selectReady: mock(async (instances) => instances[0] ?? null),
+    confirmCreate: mock(async () => true),
+    promptSlug: mock(async () => 'new-instance'),
+    provision: mock(async (slug) => ({
+      created: { url: `https://${slug}.eu.astrale.ai`, organizationId: `org_${slug}` },
+      slug,
+    })),
+    ...overrides,
+  }
+}
+
+describe('setup owned-instance reconciliation', () => {
+  test('silently adopts the sole owned ready instance', async () => {
+    const ready = instance('only')
+    const failed = instance('old-attempt', 'failed')
+    const deps = dependencies({ fetchOwned: mock(async () => [failed, ready]) })
+
+    await expect(ensureOwnedInstance(ctx, deps)).resolves.toBe('fixed')
+
+    expect(deps.adopt).toHaveBeenCalledTimes(1)
+    expect(deps.adopt).toHaveBeenCalledWith(ready)
+    expect(deps.selectReady).not.toHaveBeenCalled()
+    expect(deps.confirmCreate).not.toHaveBeenCalled()
+    expect(deps.provision).not.toHaveBeenCalled()
+  })
+
+  test('asks the user to pick when several owned instances are ready', async () => {
+    const first = instance('first')
+    const second = instance('second')
+    const pending = instance('pending', 'provisioning')
+    const deps = dependencies({
+      fetchOwned: mock(async () => [first, pending, second]),
+      selectReady: mock(async (instances) => instances[1] ?? null),
+    })
+
+    await expect(ensureOwnedInstance(ctx, deps)).resolves.toBe('fixed')
+
+    expect(deps.selectReady).toHaveBeenCalledWith([first, second])
+    expect(deps.adopt).toHaveBeenCalledWith(second)
+    expect(deps.confirmCreate).not.toHaveBeenCalled()
+    expect(deps.provision).not.toHaveBeenCalled()
+  })
+
+  test('leaves setup skipped when the ready-instance picker is cancelled', async () => {
+    const first = instance('first')
+    const second = instance('second')
+    const deps = dependencies({
+      fetchOwned: mock(async () => [first, second]),
+      selectReady: mock(async () => null),
+    })
+
+    await expect(ensureOwnedInstance(ctx, deps)).resolves.toBe('skipped')
+
+    expect(deps.selectReady).toHaveBeenCalledWith([first, second])
+    expect(deps.adopt).not.toHaveBeenCalled()
+    expect(deps.confirmCreate).not.toHaveBeenCalled()
+    expect(deps.provision).not.toHaveBeenCalled()
+  })
+
+  test('offers first-instance creation only after a confirmed empty owner list', async () => {
+    const deps = dependencies()
+    const original = console.log
+    console.log = mock(() => {})
+
+    try {
+      await expect(ensureOwnedInstance(ctx, deps)).resolves.toBe('fixed')
+    } finally {
+      console.log = original
+    }
+
+    expect(deps.confirmCreate).toHaveBeenCalledTimes(1)
+    expect(deps.promptSlug).toHaveBeenCalledTimes(1)
+    expect(deps.provision).toHaveBeenCalledWith('new-instance')
+    expect(deps.adopt).not.toHaveBeenCalled()
+  })
+
+  test('does not provision when first-instance creation is declined', async () => {
+    const deps = dependencies({ confirmCreate: mock(async () => false) })
+
+    await expect(ensureOwnedInstance(ctx, deps)).resolves.toBe('skipped')
+
+    expect(deps.confirmCreate).toHaveBeenCalledTimes(1)
+    expect(deps.promptSlug).not.toHaveBeenCalled()
+    expect(deps.provision).not.toHaveBeenCalled()
+  })
+
+  test('does not provision when the slug prompt is cancelled', async () => {
+    const deps = dependencies({ promptSlug: mock(async () => undefined) })
+
+    await expect(ensureOwnedInstance(ctx, deps)).resolves.toBe('skipped')
+
+    expect(deps.confirmCreate).toHaveBeenCalledTimes(1)
+    expect(deps.promptSlug).toHaveBeenCalledTimes(1)
+    expect(deps.provision).not.toHaveBeenCalled()
+  })
+
+  test('does not report setup fixed when provisioning could not select the instance', async () => {
+    const deps = dependencies({
+      provision: mock(async (slug) => ({
+        created: { url: `https://${slug}.eu.astrale.ai`, organizationId: `org_${slug}` },
+        slug,
+        selectionError: new Error('instances.json is read-only'),
+      })),
+    })
+    const logged: string[] = []
+    const original = console.log
+    console.log = mock((...args: unknown[]) => {
+      logged.push(args.map(String).join(' '))
+    })
+
+    let caught: unknown
+    try {
+      await ensureOwnedInstance(ctx, deps)
+    } catch (error) {
+      caught = error
+    } finally {
+      console.log = original
+    }
+
+    expect(caught).toBeInstanceOf(AstraleError)
+    expect((caught as AstraleError).code).toBe('INSTANCE_SELECTION_FAILED')
+    expect((caught as AstraleError).message).toContain('instances.json is read-only')
+    expect((caught as AstraleError).hint).toContain('astrale instance use new-instance')
+    expect(logged.join('\n')).not.toContain('https://new-instance.eu.astrale.ai')
+  })
+
+  test('does not create a duplicate while an owned instance is provisioning or failed', async () => {
+    const provisioning = {
+      ...instance('pending', 'provisioning'),
+      phase: 'installing:default-domains',
+    }
+    const failed = { ...instance('broken', 'failed'), error: 'postInstall failed' }
+    const deps = dependencies({ fetchOwned: mock(async () => [provisioning, failed]) })
+    const logged: string[] = []
+    const original = console.log
+    console.log = mock((...args: unknown[]) => {
+      logged.push(args.map(String).join(' '))
+    })
+
+    try {
+      await expect(ensureOwnedInstance(ctx, deps)).resolves.toBe('skipped')
+    } finally {
+      console.log = original
+    }
+
+    expect(deps.selectReady).not.toHaveBeenCalled()
+    expect(deps.confirmCreate).not.toHaveBeenCalled()
+    expect(deps.promptSlug).not.toHaveBeenCalled()
+    expect(deps.provision).not.toHaveBeenCalled()
+    expect(logged.join('\n')).toContain('pending: provisioning (installing:default-domains)')
+    expect(logged.join('\n')).toContain('broken: failed')
+    expect(logged.join('\n')).toContain('postInstall failed')
+    expect(logged.join('\n')).toContain('astrale instance status')
+  })
+
+  test('does not treat owner-discovery failure as an empty account', async () => {
+    const deps = dependencies({
+      fetchOwned: mock(async () => {
+        throw new Error('admin unavailable')
+      }),
+    })
+
+    let caught: unknown
+    try {
+      await ensureOwnedInstance(ctx, deps)
+    } catch (error) {
+      caught = error
+    }
+
+    expect(caught).toBeInstanceOf(AstraleError)
+    expect((caught as AstraleError).code).toBe('INSTANCE_DISCOVERY_FAILED')
+    expect((caught as AstraleError).hint).toContain('No instance was created')
+    expect(deps.confirmCreate).not.toHaveBeenCalled()
+    expect(deps.provision).not.toHaveBeenCalled()
+  })
+})
+
+describe('owned-instance adoption', () => {
+  test('persists the owner organization before activating the bookmark', async () => {
+    const owned = instance('existing')
+    const calls: unknown[][] = []
+    const original = console.log
+    console.log = mock(() => {})
+
+    try {
+      await adoptOwnedInstance(owned, {
+        upsert: mock(async (...args) => {
+          calls.push(['upsert', ...args])
+          return {}
+        }),
+        activate: mock(async (...args) => {
+          calls.push(['activate', ...args])
+        }),
+      })
+    } finally {
+      console.log = original
+    }
+
+    expect(calls).toEqual([
+      ['upsert', 'existing', 'existing', 'https://existing.eu.astrale.ai', 'org_existing'],
+      ['activate', 'existing'],
+    ])
+  })
+})