@astrale-os/cli 0.4.0-alpha.13 → 0.6.0-alpha.0

package/studio/server/client-package.test.ts

@@ -0,0 +1,147 @@
+import { afterEach, describe, expect, test } from 'bun:test'
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+import { invalidateClientPackage, resolveClientPackage } from './client-package'
+
+const roots: string[] = []
+
+function fixture(rootPackage: Record<string, unknown> = {}): string {
+  const root = mkdtempSync(join(tmpdir(), 'studio-client-package-'))
+  roots.push(root)
+  writePackage(root, rootPackage)
+  return root
+}
+
+function writePackage(dir: string, pkg: Record<string, unknown>): void {
+  mkdirSync(dir, { recursive: true })
+  writeFileSync(join(dir, 'package.json'), JSON.stringify({ private: true, ...pkg }))
+}
+
+afterEach(() => {
+  for (const root of roots.splice(0)) {
+    invalidateClientPackage(root)
+    rmSync(root, { recursive: true, force: true })
+  }
+})
+
+describe('client package discovery', () => {
+  test('discovers the sole workspace preview package without executing domain config', async () => {
+    const root = fixture({ workspaces: ['frontend', 'schema'] })
+    const frontend = join(root, 'frontend')
+    writePackage(frontend, { scripts: { 'dev:hmr': 'vite' } })
+    writePackage(join(root, 'schema'), {})
+    writeFileSync(join(root, 'astrale.config.ts'), 'throw new Error("must not execute")\n')
+
+    const first = await resolveClientPackage(root)
+    const second = await resolveClientPackage(root)
+
+    expect(first).toEqual({
+      status: 'available',
+      packageDir: frontend,
+      sourceDir: frontend,
+      packageFile: join(frontend, 'package.json'),
+      devScript: 'vite',
+      source: 'workspace',
+    })
+    expect(second).toEqual(first)
+  })
+
+  test('discovers a conventional direct child without workspace metadata', async () => {
+    const root = fixture()
+    const client = join(root, 'client')
+    writePackage(client, { scripts: { 'dev:hmr': 'vite' } })
+
+    expect(await resolveClientPackage(root)).toMatchObject({
+      status: 'available',
+      packageDir: client,
+      sourceDir: client,
+      source: 'workspace',
+    })
+  })
+
+  test('discovers nested packages from pnpm-workspace.yaml', async () => {
+    const root = fixture()
+    const web = join(root, 'apps', 'web')
+    writeFileSync(join(root, 'pnpm-workspace.yaml'), "packages:\n  - 'apps/*'\n")
+    writePackage(web, { scripts: { 'dev:hmr': 'vite' } })
+
+    expect(await resolveClientPackage(root)).toMatchObject({
+      status: 'available',
+      packageDir: web,
+      sourceDir: web,
+      source: 'workspace',
+    })
+  })
+
+  test('uses an explicit root script to disambiguate multiple preview packages', async () => {
+    const root = fixture({
+      workspaces: ['apps/*'],
+      scripts: { 'dev:hmr': 'pnpm --dir apps/web dev:hmr' },
+    })
+    writePackage(join(root, 'apps', 'admin'), { scripts: { 'dev:hmr': 'vite' } })
+    writePackage(join(root, 'apps', 'web'), { scripts: { 'dev:hmr': 'vite' } })
+
+    expect(await resolveClientPackage(root)).toEqual({
+      status: 'available',
+      packageDir: root,
+      sourceDir: root,
+      packageFile: join(root, 'package.json'),
+      devScript: 'pnpm --dir apps/web dev:hmr',
+      source: 'root',
+    })
+  })
+
+  test('rejects ambiguous preview packages without guessing', async () => {
+    const root = fixture({ workspaces: ['apps/*'] })
+    writePackage(join(root, 'apps', 'admin'), { scripts: { 'dev:hmr': 'vite' } })
+    writePackage(join(root, 'apps', 'web'), { scripts: { 'dev:hmr': 'vite' } })
+
+    expect(await resolveClientPackage(root)).toEqual({
+      status: 'unavailable',
+      reason:
+        'Multiple packages define dev:hmr (apps/admin, apps/web). Add a dev:hmr script to the domain root to choose one.',
+    })
+  })
+
+  test('reports a domain with no preview package', async () => {
+    const root = fixture({ workspaces: ['frontend', 'schema'] })
+    writePackage(join(root, 'frontend'), {})
+    writePackage(join(root, 'schema'), {})
+
+    expect(await resolveClientPackage(root)).toEqual({
+      status: 'unavailable',
+      reason: 'This domain has no package that defines a dev:hmr script.',
+    })
+  })
+
+  test('invalidates cached discovery when an inspected package changes', async () => {
+    const root = fixture({ workspaces: ['frontend'] })
+    const frontend = join(root, 'frontend')
+    writePackage(frontend, {})
+    expect((await resolveClientPackage(root)).status).toBe('unavailable')
+
+    writePackage(frontend, { scripts: { 'dev:hmr': 'vite' } })
+
+    expect(await resolveClientPackage(root)).toMatchObject({
+      status: 'available',
+      packageDir: frontend,
+    })
+  })
+
+  test('invalidates cached discovery when a nested workspace package is added', async () => {
+    const root = fixture({ workspaces: ['apps/*'] })
+    const apps = join(root, 'apps')
+    mkdirSync(apps)
+    expect((await resolveClientPackage(root)).status).toBe('unavailable')
+
+    const web = join(apps, 'web')
+    writePackage(web, { scripts: { 'dev:hmr': 'vite' } })
+
+    expect(await resolveClientPackage(root)).toMatchObject({
+      status: 'available',
+      packageDir: web,
+    })
+  })
+})

package/studio/server/client-package.ts

@@ -0,0 +1,242 @@
+import { existsSync, readFileSync, statSync } from 'node:fs'
+import { isAbsolute, join, relative, resolve } from 'node:path'
+import { parse as parseYaml } from 'yaml'
+
+export type ClientPackageResolution =
+  | {
+      status: 'available'
+      packageDir: string
+      sourceDir: string
+      packageFile: string
+      devScript: string
+      source: 'root' | 'workspace'
+    }
+  | { status: 'unavailable'; reason: string }
+
+interface CacheEntry {
+  fingerprint: string
+  value: ClientPackageResolution
+}
+
+interface PackageManifest {
+  scripts?: Record<string, unknown>
+  workspaces?: string[] | { packages?: string[] }
+}
+
+interface PreviewPackage {
+  packageDir: string
+  packageFile: string
+  devScript: string
+}
+
+interface DiscoveryInputs {
+  packageFiles: string[]
+  rootPackage?: PackageManifest
+  error?: string
+}
+
+const cache = new Map<string, CacheEntry>()
+
+export async function resolveClientPackage(
+  root: string,
+  force = false,
+): Promise<ClientPackageResolution> {
+  const projectDir = resolve(root)
+  const inputs = discoverInputs(projectDir)
+  if (inputs.error) return unavailable(inputs.error)
+
+  const fingerprint = inputFingerprint(projectDir, inputs.packageFiles)
+  const previous = cache.get(projectDir)
+  if (!force && previous?.fingerprint === fingerprint) {
+    return previous.value
+  }
+
+  const value = resolveDiscovery(projectDir, inputs.rootPackage, inputs.packageFiles)
+  const entry: CacheEntry = {
+    fingerprint,
+    value,
+  }
+  cache.set(projectDir, entry)
+  return value
+}
+
+export function invalidateClientPackage(root: string): void {
+  cache.delete(resolve(root))
+}
+
+function discoverInputs(projectDir: string): DiscoveryInputs {
+  const rootPackageFile = join(projectDir, 'package.json')
+  let rootPackage: PackageManifest | undefined
+  try {
+    if (existsSync(rootPackageFile)) rootPackage = readPackage(rootPackageFile)
+  } catch (error) {
+    const reason = `Could not read ${rootPackageFile}: ${errorMessage(error)}`
+    return { packageFiles: [rootPackageFile], error: reason }
+  }
+
+  try {
+    const packageFiles = discoverPackageFiles(projectDir, rootPackage)
+    return {
+      packageFiles: [...new Set([rootPackageFile, ...packageFiles])],
+      rootPackage,
+    }
+  } catch (error) {
+    const reason = `Could not discover domain workspace packages: ${errorMessage(error)}`
+    return { packageFiles: [rootPackageFile], error: reason }
+  }
+}
+
+function resolveDiscovery(
+  projectDir: string,
+  rootPackage: PackageManifest | undefined,
+  inspectedFiles: string[],
+): ClientPackageResolution {
+  const rootPackageFile = join(projectDir, 'package.json')
+  const candidates: PreviewPackage[] = []
+  for (const packageFile of inspectedFiles) {
+    if (packageFile === rootPackageFile) continue
+    try {
+      const devScript = previewScript(readPackage(packageFile))
+      if (devScript) {
+        candidates.push({ packageDir: resolve(packageFile, '..'), packageFile, devScript })
+      }
+    } catch (error) {
+      return unavailable(`Could not read ${packageFile}: ${errorMessage(error)}`)
+    }
+  }
+
+  const rootScript = previewScript(rootPackage)
+  if (rootScript) {
+    return {
+      status: 'available',
+      packageDir: projectDir,
+      sourceDir: projectDir,
+      packageFile: rootPackageFile,
+      devScript: rootScript,
+      source: 'root',
+    }
+  }
+
+  if (candidates.length === 1) {
+    const candidate = candidates[0]!
+    return {
+      status: 'available',
+      ...candidate,
+      sourceDir: candidate.packageDir,
+      source: 'workspace',
+    }
+  }
+
+  if (candidates.length > 1) {
+    const names = candidates
+      .map((candidate) => relative(projectDir, candidate.packageDir).replaceAll('\\', '/'))
+      .sort()
+      .join(', ')
+    return unavailable(
+      `Multiple packages define dev:hmr (${names}). Add a dev:hmr script to the domain root to choose one.`,
+    )
+  }
+
+  return unavailable('This domain has no package that defines a dev:hmr script.')
+}
+
+function discoverPackageFiles(projectDir: string, rootPackage?: PackageManifest): string[] {
+  const workspaceFile = join(projectDir, 'pnpm-workspace.yaml')
+  const patterns = [...packageWorkspacePatterns(rootPackage)]
+  if (existsSync(workspaceFile)) {
+    const workspace = parseYaml(readFileSync(workspaceFile, 'utf8')) as {
+      packages?: unknown
+    } | null
+    if (Array.isArray(workspace?.packages)) {
+      patterns.push(
+        ...workspace.packages.filter((value): value is string => typeof value === 'string'),
+      )
+    }
+  }
+
+  const includes = ['*/package.json']
+  const excludes: string[] = []
+  for (const pattern of patterns) {
+    const raw = pattern.trim()
+    const excluded = raw.startsWith('!')
+    const normalized = normalizeWorkspacePattern(excluded ? raw.slice(1) : raw)
+    if (!normalized) continue
+    if (excluded) excludes.push(`${normalized}/package.json`)
+    else includes.push(`${normalized}/package.json`)
+  }
+
+  const excludedGlobs = excludes.map((pattern) => new Bun.Glob(pattern))
+  const files = new Set<string>()
+  for (const pattern of includes) {
+    const glob = new Bun.Glob(pattern)
+    for (const file of glob.scanSync({ cwd: projectDir, onlyFiles: true })) {
+      const normalized = file.replaceAll('\\', '/')
+      if (isIgnoredPackagePath(normalized)) continue
+      if (excludedGlobs.some((excluded) => excluded.match(normalized))) continue
+      const absolute = resolve(projectDir, normalized)
+      if (inside(projectDir, absolute)) files.add(absolute)
+    }
+  }
+
+  return [...files].sort()
+}
+
+function normalizeWorkspacePattern(pattern: string): string | undefined {
+  const normalized = pattern.replaceAll('\\', '/').replace(/^\.\//, '').replace(/\/+$/, '')
+  if (!normalized || normalized === '.' || isAbsolute(normalized)) return undefined
+  if (normalized.split('/').includes('..')) return undefined
+  return normalized
+}
+
+function isIgnoredPackagePath(path: string): boolean {
+  const segments = path.split('/')
+  return segments.includes('node_modules') || segments.includes('.git')
+}
+
+function packageWorkspacePatterns(pkg?: PackageManifest): string[] {
+  const workspaces = Array.isArray(pkg?.workspaces)
+    ? pkg.workspaces
+    : Array.isArray(pkg?.workspaces?.packages)
+      ? pkg.workspaces.packages
+      : []
+  return workspaces.filter((value): value is string => typeof value === 'string')
+}
+
+function readPackage(packageFile: string): PackageManifest {
+  return JSON.parse(readFileSync(packageFile, 'utf8')) as PackageManifest
+}
+
+function previewScript(pkg?: PackageManifest): string | undefined {
+  const script = pkg?.scripts?.['dev:hmr']
+  return typeof script === 'string' && script.trim() ? script : undefined
+}
+
+function inside(root: string, file: string): boolean {
+  const path = relative(root, file)
+  return path !== '..' && !path.startsWith('../') && !path.startsWith('..\\')
+}
+
+function inputFingerprint(projectDir: string, packageFiles: string[]): string {
+  return [
+    fileFingerprint(projectDir),
+    fileFingerprint(join(projectDir, 'pnpm-workspace.yaml')),
+    ...packageFiles.map(fileFingerprint),
+  ].join('|')
+}
+
+function fileFingerprint(path: string): string {
+  try {
+    const stat = statSync(path)
+    return `${path}:${stat.size}:${stat.mtimeMs}`
+  } catch {
+    return `${path}:missing`
+  }
+}
+
+function unavailable(reason: string): ClientPackageResolution {
+  return { status: 'unavailable', reason }
+}
+
+function errorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error)
+}

package/studio/server/index.ts

@@ -17,6 +17,7 @@ import { resolveTarget } from './detect'
 import { allDomains } from './domain'
 import { bootDomain } from './lifecycle'
 import { broadcast, sseResponse } from './sse'
+import { shutdownViewDevServers } from './view-dev-server'
 import { initWorkspaceState, stoppers } from './workspace-state'
 import { watchWorkspace } from './workspace-watch'
 
@@ -116,6 +117,18 @@ const server = Bun.serve({
   },
 })
 
+let shuttingDown = false
+async function shutdown(signal: NodeJS.Signals): Promise<void> {
+  if (shuttingDown) return
+  shuttingDown = true
+  await shutdownViewDevServers()
+  for (const stop of stoppers.values()) stop()
+  server.stop(true)
+  process.exit(signal === 'SIGINT' ? 130 : 143)
+}
+process.once('SIGINT', () => void shutdown('SIGINT'))
+process.once('SIGTERM', () => void shutdown('SIGTERM'))
+
 setBridgePort(server.port ?? port)
 const urlStr = `http://localhost:${server.port}`
 console.log(`\n  ▸ ${urlStr}${DEV ? '  (dev proxy → Vite)' : ''}\n`)

package/studio/server/introspect/anatomy-extras.test.ts

@@ -0,0 +1,91 @@
+import { afterEach, expect, test } from 'bun:test'
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+import { buildClientTree, buildViews } from './anatomy-extras'
+
+const roots: string[] = []
+
+afterEach(() => {
+  for (const root of roots.splice(0)) rmSync(root, { recursive: true, force: true })
+})
+
+test('discovers view mounts from any top-level client route registry', () => {
+  const root = mkdtempSync(join(tmpdir(), 'studio-client-tree-'))
+  roots.push(root)
+  const src = join(root, 'client', 'src')
+  mkdirSync(src, { recursive: true })
+  writeFileSync(
+    join(src, 'views.tsx'),
+    `const VIEW_REGISTRY = {
+      '/ui/issues': IssuesView,
+      '/ui/issue': TargetIssueView,
+    }`,
+  )
+  writeFileSync(join(src, 'app.tsx'), `const ROUTES = { '/ui/settings': SettingsView }`)
+
+  expect(buildClientTree(root).routes).toEqual({
+    '/ui/issue': 'TargetIssueView',
+    '/ui/issues': 'IssuesView',
+    '/ui/settings': 'SettingsView',
+  })
+})
+
+test('reads the discovered client directory', () => {
+  const root = mkdtempSync(join(tmpdir(), 'studio-client-tree-configured-'))
+  roots.push(root)
+  const clientDir = join(root, 'frontend')
+  const src = join(clientDir, 'src')
+  mkdirSync(src, { recursive: true })
+  writeFileSync(join(src, 'views.tsx'), `const VIEWS = { '/ui/models': ModelsView }`)
+
+  expect(buildClientTree(root, clientDir)).toMatchObject({
+    present: true,
+    routes: { '/ui/models': 'ModelsView' },
+  })
+})
+
+test('resolves views declared in the registry file itself', () => {
+  const root = mkdtempSync(join(tmpdir(), 'studio-inline-view-registry-'))
+  roots.push(root)
+  const viewsDir = join(root, 'views')
+  mkdirSync(viewsDir, { recursive: true })
+  writeFileSync(
+    join(viewsDir, 'index.ts'),
+    `import { defineView } from '@astrale-os/sdk'
+const services = defineView({
+  auth: 'required',
+  mount: '/ui/services',
+  description: 'Browse services.',
+})
+const service = defineView({
+  auth: 'required',
+  mount: '/ui/service',
+  viewFor: [selfOf(CloudflareWorker)],
+})
+export const views = { services, service }
+`,
+  )
+
+  expect(buildViews(root)).toEqual([
+    {
+      slug: 'services',
+      kind: 'spa',
+      url: undefined,
+      file: 'views/index.ts',
+      auth: 'required',
+      mount: '/ui/services',
+      description: 'Browse services.',
+    },
+    {
+      slug: 'service',
+      kind: 'spa',
+      url: undefined,
+      file: 'views/index.ts',
+      auth: 'required',
+      mount: '/ui/service',
+      viewFor: 'CloudflareWorker',
+    },
+  ])
+})

package/studio/server/introspect/anatomy-extras.ts

@@ -125,7 +125,7 @@ export function buildViews(root: string): ViewInfo[] {
   for (const imp of index.getImportDeclarations()) {
     const spec = imp.getModuleSpecifierValue()
     for (const named of imp.getNamedImports()) {
-      importSpecByName.set(named.getName(), spec)
+      importSpecByName.set(named.getAliasNode()?.getText() ?? named.getName(), spec)
     }
     const def = imp.getDefaultImport()
     if (def) importSpecByName.set(def.getText(), spec)
@@ -174,15 +174,31 @@ export function buildViews(root: string): ViewInfo[] {
       info.file = relative(root, indexFile)
       applyParsed(info, parseViewObject(inlineArg))
     } else {
-      // referenced view file (e.g. my-domain) — resolve the import + parse the file
-      const spec = refName ? importSpecByName.get(refName) : undefined
-      const viewFile = spec ? resolveLocalModule(indexFile, spec) : null
-      if (viewFile) {
-        info.file = relative(root, viewFile)
-        try {
-          applyParsed(info, parseViewFile(project, viewFile))
-        } catch {
-          /* keep the unknown-kind stub */
+      // A shorthand may reference a defineView declared earlier in this same
+      // registry file (services), or one imported from another module (ai-gateway).
+      const localInit = refName
+        ? index.getVariableDeclaration(refName)?.getInitializer()
+        : undefined
+      if (
+        localInit &&
+        Node.isCallExpression(localInit) &&
+        localInit.getExpression().getText() === 'defineView'
+      ) {
+        const arg = localInit.getArguments()[0]
+        if (arg) {
+          info.file = relative(root, indexFile)
+          applyParsed(info, parseViewObject(arg))
+        }
+      } else {
+        const spec = refName ? importSpecByName.get(refName) : undefined
+        const viewFile = spec ? resolveLocalModule(indexFile, spec) : null
+        if (viewFile) {
+          info.file = relative(root, viewFile)
+          try {
+            applyParsed(info, parseViewFile(project, viewFile))
+          } catch {
+            /* keep the unknown-kind stub */
+          }
         }
       }
     }
@@ -294,8 +310,11 @@ function parseViewObject(arg: Node): ParsedView {
 
 const RESERVED_CLIENT_DIRS = new Set(['shell', 'ui', 'views'])
 
-export function buildClientTree(root: string): ClientTree {
-  const srcDir = join(root, 'client', 'src')
+export function buildClientTree(
+  root: string,
+  clientDir: string | null = join(root, 'client'),
+): ClientTree {
+  const srcDir = clientDir ? join(clientDir, 'src') : ''
   if (!existsSync(srcDir)) {
     return { shell: [], features: [], routes: {}, present: false }
   }
@@ -306,50 +325,30 @@ export function buildClientTree(root: string): ClientTree {
     .filter((d) => !RESERVED_CLIENT_DIRS.has(d))
     .map((name) => ({ name, files: listFiles(join(srcDir, name)) }))
 
-  const routes = parseRoutes(join(srcDir, 'app.tsx'))
+  const routes = parseRoutes(
+    listFiles(srcDir)
+      .filter((file) => /\.[cm]?[jt]sx?$/.test(file))
+      .map((file) => join(srcDir, file)),
+  )
 
   return { shell, features, routes, present: true }
 }
 
-/** Best-effort parse of the `ROUTES` map (mountPath → ComponentName) in app.tsx. */
-function parseRoutes(appFile: string): Record<string, string> {
+/**
+ * Best-effort parse of top-level client route registries. Domains call these
+ * maps ROUTES, VIEW_REGISTRY, or another local name; the stable contract is a
+ * quoted `/ui/…` key pointing at a component identifier.
+ */
+function parseRoutes(files: string[]): Record<string, string> {
   const routes: Record<string, string> = {}
-  const src = readTextSafe(appFile)
-  if (!src) return routes
-
-  // Isolate the ROUTES object literal body: `const ROUTES[: Type] = { ... }`.
-  // The identifier may carry a type annotation but never a newline/backtick — that
-  // keeps us from latching onto a `ROUTES` mention inside a JSDoc comment.
-  const startMatch = src.match(/\bROUTES\b\s*(?::\s*[\w<>.\[\], ]+)?\s*=\s*\{/)
-  if (!startMatch || startMatch.index === undefined) {
-    return routes
-  }
-  const openIdx = src.indexOf('{', startMatch.index + startMatch[0].length - 1)
-  if (openIdx === -1) return routes
-
-  // Balance braces to find the matching close.
-  let depth = 0
-  let endIdx = -1
-  for (let i = openIdx; i < src.length; i++) {
-    const ch = src[i]
-    if (ch === '{') depth++
-    else if (ch === '}') {
-      depth--
-      if (depth === 0) {
-        endIdx = i
-        break
-      }
+  for (const file of files) {
+    const src = readTextSafe(file)
+    const entryRe = /['"`](\/ui\/[^'"`]+)['"`]\s*:\s*([A-Za-z_$][\w$.]*)/g
+    let match: RegExpExecArray | null
+    while ((match = entryRe.exec(src)) !== null) {
+      routes[match[1]] = match[2]
     }
   }
-  if (endIdx === -1) return routes
-
-  const body = src.slice(openIdx + 1, endIdx)
-  // Each entry:  '/ui/status-page': StatusView   (quoted key → identifier/expr).
-  const entryRe = /['"`]([^'"`]+)['"`]\s*:\s*([A-Za-z_$][\w$.]*)/g
-  let m: RegExpExecArray | null
-  while ((m = entryRe.exec(body)) !== null) {
-    routes[m[1]] = m[2]
-  }
   return routes
 }
 

package/studio/server/introspect/anatomy.ts

@@ -8,7 +8,7 @@
  * never executed (its deps→integrations chain has import side effects).
  */
 import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs'
-import { join } from 'node:path'
+import { join, relative } from 'node:path'
 
 import type { DomainAnatomy, DomainOverview } from '../../shared/types'
 
@@ -18,19 +18,20 @@ import { buildClientTree, buildEnvFields, buildViews } from './anatomy-extras'
 export interface AnatomyArgs {
   root: string
   schemaDirName: string
+  clientDir?: string
 }
 
-export function buildAnatomy({ root, schemaDirName }: AnatomyArgs): DomainAnatomy {
+export function buildAnatomy({ root, schemaDirName, clientDir }: AnatomyArgs): DomainAnatomy {
   return {
-    overview: buildOverview(root, schemaDirName),
+    overview: buildOverview(root, schemaDirName, clientDir),
     views: buildViews(root),
-    client: buildClientTree(root),
+    client: buildClientTree(root, clientDir ?? null),
     env: buildEnvFields(root),
     detectedIntegrations: detectIntegrations(root),
   }
 }
 
-function buildOverview(root: string, schemaDirName: string): DomainOverview {
+function buildOverview(root: string, schemaDirName: string, clientDir?: string): DomainOverview {
   const pkg = readJsonSafe(join(root, 'package.json'))
   const astraleDeps: Record<string, string> = {}
   for (const [k, v] of Object.entries({
@@ -52,7 +53,6 @@ function buildOverview(root: string, schemaDirName: string): DomainOverview {
     config.match(/secrets\s*:\s*['"]([^'"]+)['"]/)?.[1]
 
   const domainSrc = readTextSafe(join(root, 'domain.ts'))
-  const clientDir = domainSrc.match(/client\s*:\s*\{\s*dir\s*:\s*['"]([^'"]+)['"]/)?.[1]
   const origin =
     domainSrc.match(/defineSchema\(\s*['"]([^'"]+)['"]/)?.[1] ??
     readTextSafe(join(root, schemaDirName, 'index.ts')).match(
@@ -71,7 +71,7 @@ function buildOverview(root: string, schemaDirName: string): DomainOverview {
     packageVersion: pkg?.version,
     astraleDeps,
     schemaDir: schemaDirName,
-    client: clientDir,
+    client: clientDir ? relative(root, clientDir).replaceAll('\\', '/') || '.' : undefined,
   }
 }