@astrale-os/cli 0.6.2-alpha.0 → 0.7.0-alpha.0

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'],
+    ])
+  })
+})

package/src/setup/steps/instance.ts

@@ -1,30 +1,35 @@
 import chalk from 'chalk'
 
+import type { OwnedInstanceInfo } from '../../lib/admin-instance'
 import type { SetupContext, SetupStep } from '../types'
 
-import { withAdminKernelClient } from '../../kernel/client'
-import { adminInstanceMethod, type InstanceInfo } from '../../lib/admin-instance'
+import { AstraleError } from '../../errors'
+import { listOwnedInstances } from '../../kernel/client'
 import { normalizeInstanceKernelUrl, setActive, upsertManagedBookmark } from '../../lib/instance'
 import { readLocalStatus } from '../../lib/local-status'
 import { log, withSpinner } from '../../lib/log'
 import { renderInstanceHero } from '../../lib/panel'
 import { confirmDefaultYes, promptText, selectFrom } from '../../lib/prompt'
-import { provisionInstance } from '../../lib/provision-instance'
+import { provisionInstance, type ProvisionResult } from '../../lib/provision-instance'
 import { guiOrigin, slugError } from '../util'
 
-/** All admin-managed instances; degrades to [] when the admin kernel is unreachable. */
-async function fetchManaged(ctx: SetupContext): Promise<InstanceInfo[]> {
-  try {
-    return await withSpinner('Checking for existing instances', !ctx.machine, () =>
-      withAdminKernelClient(
-        ctx.opts,
-        async (client) =>
-          (await client.client.call(adminInstanceMethod('list'), {})) as InstanceInfo[],
-      ),
-    )
-  } catch {
-    return []
-  }
+export type InstanceSetupDependencies = {
+  fetchOwned: (ctx: SetupContext) => Promise<OwnedInstanceInfo[]>
+  adopt: (info: OwnedInstanceInfo) => Promise<void>
+  selectReady: (instances: OwnedInstanceInfo[]) => Promise<OwnedInstanceInfo | null>
+  confirmCreate: () => Promise<boolean>
+  promptSlug: () => Promise<string | undefined>
+  provision: (slug: string) => Promise<ProvisionResult>
+}
+
+export type OwnedInstanceAdoptionDependencies = {
+  upsert: (
+    key: string,
+    slug: string,
+    url: string,
+    organizationId?: string,
+  ) => Promise<{ repointedFrom?: string }>
+  activate: (slug: string) => Promise<unknown>
 }
 
 /** Print the click-inviting hero for a freshly-active instance. */
@@ -34,9 +39,15 @@ function hero(slug: string, kernelUrl: string): void {
   console.log('')
 }
 
-async function adopt(info: InstanceInfo): Promise<void> {
-  const { repointedFrom } = await upsertManagedBookmark(info.slug, info.slug, info.url)
-  await setActive(info.slug)
+export async function adoptOwnedInstance(
+  info: OwnedInstanceInfo,
+  deps: OwnedInstanceAdoptionDependencies = {
+    upsert: upsertManagedBookmark,
+    activate: setActive,
+  },
+): Promise<void> {
+  const { repointedFrom } = await deps.upsert(info.slug, info.slug, info.url, info.organizationId)
+  await deps.activate(info.slug)
   if (repointedFrom) {
     log.warn(
       `Bookmark "${info.slug}" repointed: ${repointedFrom} → ${normalizeInstanceKernelUrl(info.url)}`,
@@ -46,10 +57,118 @@ async function adopt(info: InstanceInfo): Promise<void> {
   hero(info.slug, info.url)
 }
 
+function defaultDependencies(ctx: SetupContext): InstanceSetupDependencies {
+  return {
+    fetchOwned: (setupCtx) =>
+      withSpinner('Checking for existing instances', !setupCtx.machine, () =>
+        listOwnedInstances(setupCtx.opts),
+      ),
+    adopt: adoptOwnedInstance,
+    selectReady: (instances) =>
+      selectFrom(
+        'No active instance. Pick one:',
+        instances.map((info) => ({
+          label: `${info.slug}  ${chalk.dim(guiOrigin(info.url))}`,
+          value: info,
+        })),
+      ),
+    confirmCreate: () => confirmDefaultYes('No instances yet. Provision your first one now?'),
+    promptSlug: () =>
+      ctx.slug
+        ? Promise.resolve(ctx.slug)
+        : promptText('Pick a slug for your instance', { validate: slugError }),
+    provision: (slug) => provisionInstance(slug, ctx.opts),
+  }
+}
+
+/**
+ * Reconcile owner-scoped admin instances when no local active bookmark exists.
+ * A failed ownership lookup is never treated as an empty account: setup stops
+ * before creation so a transient auth/network failure cannot create a duplicate.
+ */
+export async function ensureOwnedInstance(
+  ctx: SetupContext,
+  deps: InstanceSetupDependencies = defaultDependencies(ctx),
+): Promise<'fixed' | 'skipped'> {
+  let owned: OwnedInstanceInfo[]
+  try {
+    owned = await deps.fetchOwned(ctx)
+  } catch (cause) {
+    const detail = cause instanceof Error ? cause.message : String(cause)
+    throw new AstraleError(
+      'INSTANCE_DISCOVERY_FAILED',
+      `Could not check your Astrale instances: ${detail}`,
+      'No instance was created. Check `astrale admin status`, then rerun `astrale setup`.',
+    )
+  }
+
+  const ready = owned.filter((info) => info.state === 'ready')
+  if (ready.length === 1) {
+    await deps.adopt(ready[0]!)
+    return 'fixed'
+  }
+
+  if (ready.length > 1) {
+    const choice = await deps.selectReady(ready)
+    if (choice === null) {
+      log.dim('  Skipped — no active instance set.')
+      return 'skipped'
+    }
+    await deps.adopt(choice)
+    return 'fixed'
+  }
+
+  if (owned.length > 0) {
+    reportNotReady(owned)
+    return 'skipped'
+  }
+
+  if (!(await deps.confirmCreate())) {
+    log.dim('  Skipped — create one later: astrale instance create <slug>')
+    return 'skipped'
+  }
+
+  const slug = await deps.promptSlug()
+  if (!slug) {
+    log.dim('  Skipped — no slug given.')
+    return 'skipped'
+  }
+
+  const { created, selectionError } = await deps.provision(slug)
+  if (selectionError) {
+    const detail = selectionError instanceof Error ? selectionError.message : String(selectionError)
+    throw new AstraleError(
+      'INSTANCE_SELECTION_FAILED',
+      `Instance "${slug}" was provisioned, but the CLI could not select it: ${detail}`,
+      `Fix local CLI storage, then run \`astrale instance use ${slug}\`.`,
+    )
+  }
+  hero(slug, created.url)
+  return 'fixed'
+}
+
+function reportNotReady(instances: OwnedInstanceInfo[]): void {
+  log.warn(
+    `${instances.length === 1 ? 'Your instance is' : 'Your instances are'} not ready; setup will not create another.`,
+  )
+  for (const info of instances) {
+    const phase = info.phase && info.phase !== info.state ? ` (${info.phase})` : ''
+    log.dim(`  ${info.slug}: ${info.state}${phase} · astrale instance status ${info.slug}`)
+    if (info.error) log.dim(`    ${info.error}`)
+  }
+  if (instances.some((info) => info.state === 'failed')) {
+    log.dim(
+      '  Inspect the failure, then deliberately delete/recreate it with `astrale instance` commands.',
+    )
+  } else {
+    log.dim('  Wait for provisioning to finish, then rerun `astrale setup`.')
+  }
+}
+
 /**
  * Step 3 — an active instance, the heart of the flow. If the user already has
- * managed instances, offer to adopt one or create another; otherwise offer to
- * provision their first. Either way ends on the instance hero.
+ * owned instances, adopt the sole ready one or ask among several; only a
+ * confirmed empty owner list may fall through to first-instance provisioning.
  */
 export const instanceStep: SetupStep = {
   id: 'instance',
@@ -75,45 +194,6 @@ export const instanceStep: SetupStep = {
       return 'unchanged'
     }
 
-    const managed = await fetchManaged(ctx)
-
-    // Pick an existing instance or fall through to creating a new one.
-    if (managed.length > 0) {
-      const choice = await selectFrom<InstanceInfo | 'create'>(
-        'No active instance. Pick one or create a new instance:',
-        [
-          ...managed.map((info) => ({
-            label: `${info.slug}  ${chalk.dim(guiOrigin(info.url))}`,
-            value: info as InstanceInfo | 'create',
-          })),
-          { label: chalk.cyan('➕  Create a new instance'), value: 'create' as const },
-        ],
-      )
-      if (choice === null) {
-        log.dim('  Skipped — no active instance set.')
-        return 'skipped'
-      }
-      if (choice !== 'create') {
-        await adopt(choice)
-        return 'fixed'
-      }
-    } else {
-      const yes = await confirmDefaultYes('No instances yet. Provision your first one now?')
-      if (!yes) {
-        log.dim('  Skipped — create one later: astrale instance create <slug>')
-        return 'skipped'
-      }
-    }
-
-    const slug =
-      ctx.slug ?? (await promptText('Pick a slug for your instance', { validate: slugError }))
-    if (!slug) {
-      log.dim('  Skipped — no slug given.')
-      return 'skipped'
-    }
-
-    const { created } = await provisionInstance(slug, ctx.opts)
-    hero(slug, created.url)
-    return 'fixed'
+    return ensureOwnedInstance(ctx)
   },
 }