@astrale-os/cli 1.0.0-beta.0 → 1.0.0-beta.10

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

@@ -3,6 +3,7 @@ import { describe, expect, test } from 'bun:test'
 import type { AstraleConfig } from '../config'
 import type { InstanceStore } from '../instance'
 
+import { AdminInstanceNotFoundError } from '../../admin/instance/model'
 import { AstraleError } from '../../errors'
 import { DEFAULT_CONFIG } from '../config'
 import {
@@ -112,6 +113,7 @@ describe('resolveInstanceTarget', () => {
             id: 'node-1',
             slug,
             url: `https://${slug}.eu.astrale.ai`,
+            state: 'ready',
           }),
         },
       ),
@@ -124,9 +126,6 @@ describe('resolveInstanceTarget', () => {
   })
 
   test('unknown slugs surface the original instance-not-found error', async () => {
-    const notFound = new Error('Path not found: "/admin/instances/missing"')
-    notFound.name = 'NotFoundError'
-
     await expect(
       resolveInstanceTarget(
         { source: 'name', name: 'missing' },
@@ -134,7 +133,7 @@ describe('resolveInstanceTarget', () => {
           config: DEFAULT_CONFIG,
           instances: emptyStore,
           managed: async () => {
-            throw notFound
+            throw new AdminInstanceNotFoundError('missing')
           },
         },
       ),
@@ -168,14 +167,8 @@ describe('instance target helpers', () => {
     expect(couldBeConfiguredAdminInstance('bryan', directAdminConfig)).toBe(false)
   })
 
-  test('treats wrapped remote Instance.info misses as managed lookup not-found', () => {
-    const wrapped = new Error('Path not found: "/admin/instances/admin"') as Error & {
-      data?: unknown
-    }
-    wrapped.name = 'KernelError'
-    wrapped.data = { type: 'NotFoundError' }
-
-    expect(isManagedInstanceNotFound(wrapped)).toBe(true)
+  test('treats the owner-scoped Admin error as managed lookup not-found', () => {
+    expect(isManagedInstanceNotFound(new AdminInstanceNotFoundError('admin'))).toBe(true)
   })
 
   test('does not hide non-not-found managed lookup failures', () => {
@@ -194,37 +187,12 @@ describe('instance target helpers', () => {
   })
 })
 
-describe('isManagedInstanceNotFound: kernel InternalKernelError wrap', () => {
-  test('NOT_FOUND-prefixed InternalKernelError is an instance miss', () => {
-    const e = new Error('NOT_FOUND: no instance node for "knowledge"')
-    e.name = 'InternalKernelError'
-    expect(isManagedInstanceNotFound(e)).toBe(true)
-  })
-  test('other InternalKernelError messages are not swallowed', () => {
+describe('isManagedInstanceNotFound: unknown errors', () => {
+  test('does not infer a miss from an InternalKernelError message', () => {
     const e = new Error('DISPATCH_FAILED: handler crashed')
     e.name = 'InternalKernelError'
     expect(isManagedInstanceNotFound(e)).toBe(false)
   })
-  test('resolveNamedInstanceTarget maps the wrap to typed INSTANCE_NOT_FOUND', async () => {
-    const managed = async () => {
-      const e = new Error('NOT_FOUND: no instance node for "ghost"')
-      e.name = 'InternalKernelError'
-      throw e
-    }
-    const opts = {
-      config: DEFAULT_CONFIG,
-      instances: { instances: {} },
-      managed,
-    } as unknown as Parameters<typeof resolveInstanceTarget>[1]
-    let caught: unknown
-    try {
-      await resolveInstanceTarget({ source: 'name', name: 'ghost' }, opts)
-    } catch (e) {
-      caught = e
-    }
-    expect(caught).toBeInstanceOf(AstraleError)
-    expect((caught as AstraleError).code).toBe('INSTANCE_NOT_FOUND')
-  })
 
   test('maps Admin token-exchange failure to INSTANCE_NOT_FOUND', async () => {
     const managed = async () => {

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

@@ -74,6 +74,12 @@ describe('InstanceStoreSchema', () => {
     expect(normalizeInstanceKernelUrl('https://testmarc.eu.astrale.ai/')).toBe(
       'https://testmarc.eu.astrale.ai/api',
     )
+    expect(normalizeInstanceKernelUrl('https://testmarc.eu.beta.astrale.ai')).toBe(
+      'https://testmarc.eu.beta.astrale.ai/api',
+    )
+    expect(normalizeInstanceKernelUrl('https://shell.beta.astrale.ai')).toBe(
+      'https://shell.beta.astrale.ai',
+    )
   })
 
   test('does not rewrite explicit kernel or non-managed URLs', () => {

package/src/lib/__tests__/log-errors.test.ts

@@ -0,0 +1,64 @@
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test'
+
+import { AstraleError } from '../../errors'
+import { failInput, fatal } from '../log'
+
+class ExitError extends Error {}
+
+let stderr = ''
+let exit: typeof process.exit
+let write: typeof process.stderr.write
+
+beforeEach(() => {
+  stderr = ''
+  exit = process.exit
+  write = process.stderr.write
+  process.exit = (() => {
+    throw new ExitError()
+  }) as typeof process.exit
+  process.stderr.write = ((chunk: string | Uint8Array) => {
+    stderr += String(chunk)
+    return true
+  }) as typeof process.stderr.write
+})
+
+afterEach(() => {
+  process.exit = exit
+  process.stderr.write = write
+})
+
+describe('terminal error safety', () => {
+  test('renders an empty aggregate as an honest non-blank unexpected failure', () => {
+    expect(() => fatal(new AggregateError([], ''), { json: true })).toThrow(ExitError)
+    expect(JSON.parse(stderr)).toEqual({
+      error: 'UNEXPECTED_ERROR',
+      message: 'The CLI encountered an unexpected internal failure.',
+    })
+  })
+
+  test('retains unknown failure evidence only under explicit debug output', () => {
+    const failure = new AggregateError([new Error('provider rejected organization scope')], '')
+
+    expect(() => fatal(failure, { json: true, debug: true })).toThrow(ExitError)
+
+    expect(stderr).toContain(
+      '{"error":"UNEXPECTED_ERROR","message":"The CLI encountered an unexpected internal failure."}',
+    )
+    expect(stderr).toContain('aggregate: Error: provider rejected organization scope')
+  })
+
+  test('rejects blank admitted CLI diagnostics', () => {
+    expect(() => new AstraleError('INVALID_INPUT', '  ')).toThrow(TypeError)
+  })
+
+  test('labels only expected admission failures as invalid input', () => {
+    expect(() => failInput(new TypeError('Authored value is invalid.'), { json: true })).toThrow(
+      ExitError,
+    )
+    expect(JSON.parse(stderr)).toMatchObject({ error: 'INVALID_INPUT' })
+
+    stderr = ''
+    expect(() => failInput(new AggregateError([], ''), { json: true })).toThrow(ExitError)
+    expect(JSON.parse(stderr)).toMatchObject({ error: 'UNEXPECTED_ERROR' })
+  })
+})

package/src/lib/__tests__/studio-server-deps.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, test } from 'bun:test'
-import { readFileSync } from 'node:fs'
-import { join } from 'node:path'
+import { readFileSync, readdirSync, statSync } from 'node:fs'
+import { join, relative } from 'node:path'
 import { Project } from 'ts-morph'
 
 /**
@@ -19,6 +19,18 @@ import { Project } from 'ts-morph'
 
 const CLI_ROOT = new URL('../../../', import.meta.url).pathname
 
+interface PackageManifest {
+  dependencies?: Record<string, string>
+  scripts?: Record<string, string>
+}
+
+const cliPackage = JSON.parse(
+  readFileSync(join(CLI_ROOT, 'package.json'), 'utf8'),
+) as PackageManifest
+const studioPackage = JSON.parse(
+  readFileSync(join(CLI_ROOT, 'studio/package.json'), 'utf8'),
+) as PackageManifest
+
 /** Base package of a bare specifier: `@scope/pkg/sub` → `@scope/pkg`, `pkg/sub` → `pkg`. */
 function basePackage(spec: string): string {
   const parts = spec.split('/')
@@ -29,26 +41,33 @@ function isBuiltin(spec: string): boolean {
   return spec.startsWith('node:') || spec === 'bun' || spec.startsWith('bun:')
 }
 
+function runtimeFiles(directory: string): string[] {
+  return readdirSync(directory).flatMap((entry) => {
+    const path = join(directory, entry)
+    if (statSync(path).isDirectory()) return runtimeFiles(path)
+    return /\.(?:ts|tsx)$/.test(path) && !/\.test\.(?:ts|tsx)$/.test(path) ? [path] : []
+  })
+}
+
+const studioPath = (path: string) => relative(CLI_ROOT, path).replaceAll('\\', '/')
+
 describe('studio server runtime deps', () => {
-  const deps = new Set(
-    Object.keys(
-      (
-        JSON.parse(readFileSync(join(CLI_ROOT, 'package.json'), 'utf8')) as {
-          dependencies?: Record<string, string>
-        }
-      ).dependencies ?? {},
-    ),
-  )
+  const deps = new Set(Object.keys(cliPackage.dependencies ?? {}))
 
   const project = new Project({ skipAddingFilesFromTsConfig: true })
   project.addSourceFilesAtPaths([
     join(CLI_ROOT, 'studio/server/**/*.ts'),
+    join(CLI_ROOT, 'studio/server/**/*.tsx'),
     join(CLI_ROOT, 'studio/shared/**/*.ts'),
+    join(CLI_ROOT, 'studio/shared/**/*.tsx'),
   ])
+  const runtimeSourceFiles = project
+    .getSourceFiles()
+    .filter((sourceFile) => !/\.test\.(?:ts|tsx)$/.test(sourceFile.getBaseName()))
 
   // getImportStringLiterals covers static imports, re-exports, and dynamic import().
   const offenders: Record<string, string[]> = {}
-  for (const sf of project.getSourceFiles()) {
+  for (const sf of runtimeSourceFiles) {
     const specs = sf.getImportStringLiterals().map((l) => l.getLiteralValue())
     for (const spec of specs) {
       if (spec.startsWith('.') || spec.startsWith('/') || isBuiltin(spec)) continue
@@ -66,9 +85,27 @@ describe('studio server runtime deps', () => {
     ).toEqual({})
   })
 
-  test('parsed at least the known studio server files', () => {
-    // Guard against the glob silently matching nothing (which would make the
-    // invariant vacuously pass).
-    expect(project.getSourceFiles().length).toBeGreaterThan(10)
+  test('parses every shipped Studio server and shared runtime source', () => {
+    const expected = [
+      ...runtimeFiles(join(CLI_ROOT, 'studio/server')),
+      ...runtimeFiles(join(CLI_ROOT, 'studio/shared')),
+    ]
+      .map(studioPath)
+      .sort()
+    const parsed = runtimeSourceFiles
+      .map((sourceFile) => studioPath(sourceFile.getFilePath()))
+      .sort()
+
+    expect(parsed).toEqual(expected)
+  })
+})
+
+describe('studio test gate', () => {
+  test('the root and Studio suites include all client, server, and shared tests', () => {
+    expect(cliPackage.scripts?.test).toBe(
+      'node scripts/qualification/source-boundary.mjs --target && bun test src studio/client/src studio/server studio/shared && node --test scripts/*.test.mjs',
+    )
+    expect(cliPackage.scripts?.['test:studio']).toBe('pnpm --dir studio test')
+    expect(studioPackage.scripts?.test).toBe('bun test client/src server shared')
   })
 })

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

@@ -1,14 +1,20 @@
 import { describe, expect, test } from 'bun:test'
-import { chmod, mkdir, mkdtemp, readFile, writeFile } from 'node:fs/promises'
+import { chmod, mkdir, mkdtemp, readFile, symlink, writeFile } from 'node:fs/promises'
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
 
 import {
+  admitScriptInstall,
+  classifyUpdateExecution,
+  DEFAULT_UPDATE_CHANNEL,
+  InstallMetadataSchema,
+  readInstallMetadata,
   releaseBase,
   shouldUpdate,
   updateAstrale,
   writeInstallMetadata,
   type InstallMetadata,
+  type UpdateExecution,
 } from '../update'
 
 async function makeFakeRelease(
@@ -63,7 +69,7 @@ async function makeFakeRelease(
 async function makeInstall(
   root: string,
   version: string,
-): Promise<{ meta: InstallMetadata; path: string }> {
+): Promise<{ meta: InstallMetadata; path: string; execution: UpdateExecution }> {
   const bin = join(root, 'bin', 'astrale')
   await mkdir(join(root, 'bin'), { recursive: true })
   await writeFile(
@@ -80,10 +86,43 @@ async function makeInstall(
     bin,
   }
   await writeInstallMetadata(meta, path)
-  return { meta, path }
+  return { meta, path, execution: { kind: 'standalone', executable: bin } }
 }
 
 describe('update helpers', () => {
+  test('classifies only a Bun-compiled executable as standalone', () => {
+    expect(
+      classifyUpdateExecution({
+        bunVersion: '1.3.14',
+        executable: '/tmp/astrale',
+        entry: '/$bunfs/root/astrale',
+      }),
+    ).toEqual({ kind: 'standalone', executable: '/tmp/astrale' })
+    expect(
+      classifyUpdateExecution({
+        bunVersion: '1.3.14',
+        executable: '/opt/homebrew/bin/bun',
+        entry: '/tmp/astrale.ts',
+      }),
+    ).toEqual({ kind: 'package-managed', executable: '/opt/homebrew/bin/bun' })
+    expect(
+      classifyUpdateExecution({
+        executable: '/opt/homebrew/bin/node',
+        entry: '/tmp/astrale.js',
+      }),
+    ).toEqual({ kind: 'package-managed', executable: '/opt/homebrew/bin/node' })
+  })
+
+  test('defaults missing install metadata to the beta channel', () => {
+    expect(DEFAULT_UPDATE_CHANNEL).toBe('beta')
+    expect(
+      InstallMetadataSchema.parse({
+        method: 'script',
+        bin: '/tmp/astrale',
+      }).channel,
+    ).toBe('beta')
+  })
+
   test('releaseBase resolves exact versions and channels', () => {
     const meta: InstallMetadata = {
       method: 'script',
@@ -106,10 +145,70 @@ describe('update helpers', () => {
   })
 })
 
+describe('script install admission', () => {
+  test('rejects malformed JSON with the stable metadata error', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'astrale-update-test-'))
+    const path = join(root, 'install.json')
+    await writeFile(path, '{')
+
+    await expect(readInstallMetadata(path)).rejects.toMatchObject({
+      code: 'UPDATE_BAD_INSTALL_METADATA',
+    })
+  })
+
+  test('admits a symlink only when it resolves to the recorded binary', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'astrale-update-test-'))
+    const { meta } = await makeInstall(root, '1.0.0')
+    const alias = join(root, 'astrale-alias')
+    await symlink(meta.bin, alias)
+
+    const admitted = await admitScriptInstall(meta, {
+      kind: 'standalone',
+      executable: alias,
+    })
+
+    expect(admitted.metadata).toEqual(meta)
+  })
+
+  test('rejects a standalone binary that does not own the recorded target', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'astrale-update-test-'))
+    const { meta } = await makeInstall(root, '1.0.0')
+    const other = join(root, 'other-astrale')
+    await writeFile(other, '#!/bin/sh\n')
+
+    await expect(
+      admitScriptInstall(meta, { kind: 'standalone', executable: other }),
+    ).rejects.toMatchObject({ code: 'UPDATE_INSTALL_MISMATCH' })
+  })
+})
+
 describe('updateAstrale', () => {
+  test('a package-managed process never consults or mutates a coexisting script install', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'astrale-update-test-'))
+    const { path, meta } = await makeInstall(root, '1.0.0')
+    const before = await readFile(meta.bin, 'utf8')
+    process.env.ASTRALE_UPDATE_BASE = 'file:///definitely-not-a-release'
+    try {
+      const result = await updateAstrale({
+        currentVersion: '2.0.0',
+        installPath: path,
+        execution: { kind: 'package-managed', executable: '/opt/homebrew/bin/node' },
+      })
+
+      expect(result).toEqual({
+        status: 'managed',
+        currentVersion: '2.0.0',
+        executable: '/opt/homebrew/bin/node',
+      })
+      expect(await readFile(meta.bin, 'utf8')).toBe(before)
+    } finally {
+      delete process.env.ASTRALE_UPDATE_BASE
+    }
+  })
+
   test('check compares the installed release identity from metadata', async () => {
     const root = await mkdtemp(join(tmpdir(), 'astrale-update-test-'))
-    const { path } = await makeInstall(root, 'main-abc123')
+    const { path, execution } = await makeInstall(root, 'main-abc123')
     const release = await makeFakeRelease(root, 'main-abc123', { binaryVersion: '1.0.0' })
     process.env.ASTRALE_UPDATE_BASE = `file://${release}`
     try {
@@ -118,6 +217,7 @@ describe('updateAstrale', () => {
         currentVersion: '1.0.0',
         platform: { os: 'darwin', arch: 'arm64' },
         installPath: path,
+        execution,
       })
 
       expect(result).toMatchObject({
@@ -132,7 +232,7 @@ describe('updateAstrale', () => {
 
   test('check reports available update without replacing the binary', async () => {
     const root = await mkdtemp(join(tmpdir(), 'astrale-update-test-'))
-    const { path, meta } = await makeInstall(root, '1.0.0')
+    const { path, meta, execution } = await makeInstall(root, '1.0.0')
     const release = await makeFakeRelease(root, '1.1.0')
     process.env.ASTRALE_UPDATE_BASE = `file://${release}`
     try {
@@ -141,6 +241,7 @@ describe('updateAstrale', () => {
         currentVersion: '1.0.0',
         platform: { os: 'darwin', arch: 'arm64' },
         installPath: path,
+        execution,
       })
 
       expect(result).toMatchObject({
@@ -156,7 +257,7 @@ describe('updateAstrale', () => {
 
   test('supports legacy string asset manifests', async () => {
     const root = await mkdtemp(join(tmpdir(), 'astrale-update-test-'))
-    const { path, meta } = await makeInstall(root, '1.0.0')
+    const { path, meta, execution } = await makeInstall(root, '1.0.0')
     const release = await makeFakeRelease(root, '1.1.0', { legacyManifest: true })
     process.env.ASTRALE_UPDATE_BASE = `file://${release}`
     try {
@@ -165,6 +266,7 @@ describe('updateAstrale', () => {
         currentVersion: '1.0.0',
         platform: { os: 'darwin', arch: 'arm64' },
         installPath: path,
+        execution,
       })
 
       expect(check).toMatchObject({
@@ -176,6 +278,7 @@ describe('updateAstrale', () => {
         currentVersion: '1.0.0',
         platform: { os: 'darwin', arch: 'arm64' },
         installPath: path,
+        execution,
       })
 
       expect(result).toMatchObject({
@@ -192,7 +295,7 @@ describe('updateAstrale', () => {
 
   test('updates the binary and install metadata', async () => {
     const root = await mkdtemp(join(tmpdir(), 'astrale-update-test-'))
-    const { path, meta } = await makeInstall(root, '1.0.0')
+    const { path, meta, execution } = await makeInstall(root, '1.0.0')
     const release = await makeFakeRelease(root, '1.1.0')
     process.env.ASTRALE_UPDATE_BASE = `file://${release}`
     try {
@@ -200,6 +303,7 @@ describe('updateAstrale', () => {
         currentVersion: '1.0.0',
         platform: { os: 'darwin', arch: 'arm64' },
         installPath: path,
+        execution,
       })
 
       expect(result).toMatchObject({
@@ -219,7 +323,7 @@ describe('updateAstrale', () => {
 
   test('updates canary-style releases whose binary reports the package version', async () => {
     const root = await mkdtemp(join(tmpdir(), 'astrale-update-test-'))
-    const { path, meta } = await makeInstall(root, 'main-old123')
+    const { path, meta, execution } = await makeInstall(root, 'main-old123')
     const release = await makeFakeRelease(root, 'main-new456', { binaryVersion: '1.0.0' })
     process.env.ASTRALE_UPDATE_BASE = `file://${release}`
     try {
@@ -227,6 +331,7 @@ describe('updateAstrale', () => {
         currentVersion: '1.0.0',
         platform: { os: 'darwin', arch: 'arm64' },
         installPath: path,
+        execution,
       })
 
       expect(result).toMatchObject({

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

@@ -23,7 +23,6 @@ const profile: ResolvedView = {
         kind: 'definition',
         definitions: [{ origin: 'shell.test', kind: 'class', name: 'Person' }],
       },
-      auth: 'required',
     },
     href: 'https://shell.test/profile',
     handshake: 'shell',
@@ -41,7 +40,6 @@ const card: ResolvedView = {
         kind: 'definition',
         definitions: [{ origin: 'shell.test', kind: 'class', name: 'Person' }],
       },
-      auth: 'public',
     },
     href: 'https://shell.test/card',
     handshake: 'none',

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

@@ -29,7 +29,7 @@ describe('view session server credentials', () => {
           target: target('/:example.test'),
           route: {
             key: 'example.test:view.public',
-            declaration: { target: { kind: 'domain' }, auth: 'required' },
+            declaration: { target: { kind: 'domain' } },
             href: 'https://example.test/ui/public',
             handshake: 'none',
             issuer: issuer('https://example.test'),

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

@@ -58,7 +58,7 @@ describe('view session private state', () => {
             issuer: issuer('https://example.test'),
             etag: `sha256:${'a'.repeat(64)}`,
             revision: revision('b'),
-            declaration: { target: { kind: 'domain' }, auth: 'required' },
+            declaration: { target: { kind: 'domain' } },
           },
         },
         createdAt: '2026-08-12T00:00:00.000Z',

package/src/lib/admin-instance.ts

@@ -6,7 +6,7 @@ import { withAdminClientSession } from '../connection'
 export {
   AdminInstanceNotFoundError,
   findOwnedInstance,
-  formatInstanceLocation,
+  formatInstanceState,
   type InstanceInfo,
   type InstanceState,
   type OwnedInstanceInfo,
@@ -19,19 +19,25 @@ export function listOwnedInstances(options: AdminConnectionOptions) {
   )
 }
 
+/** Read caller-visible inventory together with the exact local identity used for the Admin call. */
+export function listOwnedInstancesWithIdentity(options: AdminConnectionOptions) {
+  return withAdminClientSession(options, async (context) =>
+    Object.freeze({
+      instances: await (await connectAdminInstances(context)).list(),
+      ...(context.identity === undefined ? {} : { identity: context.identity }),
+    }),
+  )
+}
+
 /** Reuse an already-open Admin session for a caller-visible Instance inventory. */
 export async function listOwnedInstancesInContext(context: ConnectionContext) {
   return (await connectAdminInstances(context)).list()
 }
 
-/** Provision through Fleet placement or one explicitly resolved Host receiver. */
-export function createOwnedInstance(
-  options: AdminConnectionOptions,
-  slug: string,
-  hostId?: string,
-) {
+/** Request one managed Instance; Admin owns infrastructure placement. */
+export function createOwnedInstance(options: AdminConnectionOptions, slug: string) {
   return withAdminClientSession(options, async (context) =>
-    (await connectAdminInstances(context)).create(slug, hostId),
+    (await connectAdminInstances(context)).create(slug),
   )
 }
 

package/src/lib/admin-target.ts

@@ -5,11 +5,30 @@ import type { InstanceStore } from './instance'
 
 import { AstraleError } from '../errors'
 import { readInstances, resolveInstanceKey } from './instance'
+import { DEFAULT_UPDATE_CHANNEL } from './update'
 import { isHttpUrl } from './validation'
 
 export const DEFAULT_ADMIN_TARGET_NAME = 'admin'
-export const DEFAULT_ADMIN_TARGET_URL = 'https://admin.eu.astrale.ai/api'
-export const DEFAULT_ADMIN_DOMAIN_ISSUER = 'https://admin.beta.astrale.ai'
+
+export function defaultAdminTargetForChannel(channel: string): {
+  readonly url: string
+  readonly domainIssuer: string
+} {
+  return channel === 'stable'
+    ? {
+        url: 'https://admin.eu.astrale.ai/api',
+        domainIssuer: 'https://admin.astrale.ai',
+      }
+    : {
+        url: 'https://admin.eu.beta.astrale.ai/api',
+        domainIssuer: 'https://admin.beta.astrale.ai',
+      }
+}
+
+const DEFAULT_ADMIN_TARGET = defaultAdminTargetForChannel(DEFAULT_UPDATE_CHANNEL)
+
+export const DEFAULT_ADMIN_TARGET_URL = DEFAULT_ADMIN_TARGET.url
+export const DEFAULT_ADMIN_DOMAIN_ISSUER = DEFAULT_ADMIN_TARGET.domainIssuer
 
 export const DEFAULT_ADMIN_TARGET_CONFIG = {
   name: DEFAULT_ADMIN_TARGET_NAME,