@astrale-os/cli 1.0.0-beta.8 → 1.0.0-npm-deprecated.0

package/studio/server/cli.ts

@@ -1,240 +0,0 @@
-/**
- * Exact Astrale CLI bridge for Studio.
- *
- * The launching `astrale studio` process passes its runtime + entrypoint through a versioned
- * descriptor. Every Studio CLI delegation uses that exact pair; this module never falls back to
- * resolving an unrelated `astrale` binary from PATH.
- */
-import { isAbsolute } from 'node:path'
-
-import { asJsonRecord, asStringArray, parseJson as parseUntrustedJson } from './json'
-
-export const STUDIO_CLI_DESCRIPTOR_ENV = 'DOMAIN_STUDIO_CLI_DESCRIPTOR'
-
-export interface StudioCliDescriptorV1 {
-  version: 1
-  executable: string
-  args: string[]
-}
-
-export type StudioCliDecoder<T> = (value: unknown) => T | null
-
-export interface StudioCliMachineResult<T> {
-  version: 1
-  ok: boolean
-  data: T | null
-  value: unknown | null
-  detail: string
-  exitCode: number
-  stdout: string
-  stderr: string
-  timedOut: boolean
-}
-
-export interface StudioCliTextResult {
-  version: 1
-  ok: boolean
-  detail: string
-  exitCode: number
-  stdout: string
-  stderr: string
-  timedOut: boolean
-}
-
-interface RunOptions {
-  cwd?: string
-  timeoutMs?: number
-  acceptedExitCodes?: readonly number[]
-}
-
-interface CapturedProcess {
-  exitCode: number
-  stdout: string
-  stderr: string
-  timedOut: boolean
-  spawnError?: string
-}
-
-export function decodeStudioCliDescriptor(value: string | undefined): StudioCliDescriptorV1 | null {
-  if (!value) return null
-  const parsed = asJsonRecord(parseUntrustedJson(value))
-  const args = asStringArray(parsed?.args)
-  if (
-    parsed?.version !== 1 ||
-    typeof parsed.executable !== 'string' ||
-    !isAbsolute(parsed.executable) ||
-    !args ||
-    args.length > 1 ||
-    !args.every((arg) => isAbsolute(arg))
-  ) {
-    return null
-  }
-  return { version: 1, executable: parsed.executable, args }
-}
-
-export function studioCliCommand(
-  args: readonly string[],
-  encodedDescriptor = process.env[STUDIO_CLI_DESCRIPTOR_ENV],
-): string[] {
-  const descriptor = decodeStudioCliDescriptor(encodedDescriptor)
-  if (!descriptor) {
-    throw new Error(
-      `${STUDIO_CLI_DESCRIPTOR_ENV} is missing or invalid; launch Studio through this Astrale CLI`,
-    )
-  }
-  return [descriptor.executable, ...descriptor.args, ...args]
-}
-
-export function decodeJsonObject(value: unknown): Record<string, unknown> | null {
-  return asJsonRecord(value) ?? null
-}
-
-export function conciseCliFailure(raw: string): string | undefined {
-  const lines = raw
-    .split(/\r?\n/)
-    .map((line) => line.trim())
-    .filter(Boolean)
-  const error = lines.find((line) => /^[A-Za-z_$][\w$]*(?:Error|Exception):\s+\S/.test(line))
-  if (error) return error.slice(0, 600)
-  const explicit = lines.find((line) => /^(?:error|failed):\s+\S/i.test(line))
-  if (explicit) return explicit.slice(0, 600)
-  const useful = lines.find(
-    (line) =>
-      !/^\d+\s+\|/.test(line) &&
-      line !== '^' &&
-      !/^at\s/.test(line) &&
-      !/^Bun v\d/.test(line) &&
-      !/^details?:\s*[{[]?$/i.test(line),
-  )
-  return useful?.slice(0, 600)
-}
-
-function nonEmptyString(value: unknown): string | undefined {
-  return typeof value === 'string' && value.trim() ? value.trim() : undefined
-}
-
-function resultDetail(value: unknown, stdout: string, stderr: string): string {
-  const object = decodeJsonObject(value)
-  return (
-    nonEmptyString(object?.message) ??
-    nonEmptyString(object?.error) ??
-    conciseCliFailure(stderr) ??
-    conciseCliFailure(stdout) ??
-    ''
-  )
-}
-
-function parseJson(text: string): unknown | null {
-  const normalized = text.replace(/^\uFEFF/, '').trim()
-  if (!normalized) return null
-  try {
-    return JSON.parse(normalized)
-  } catch {
-    return null
-  }
-}
-
-async function captureStudioCli(
-  args: readonly string[],
-  options: RunOptions,
-): Promise<CapturedProcess> {
-  let command: string[]
-  try {
-    command = studioCliCommand(args)
-  } catch (error) {
-    return {
-      exitCode: -1,
-      stdout: '',
-      stderr: '',
-      timedOut: false,
-      spawnError: error instanceof Error ? error.message : String(error),
-    }
-  }
-
-  try {
-    const proc = Bun.spawn(command, {
-      ...(options.cwd ? { cwd: options.cwd } : {}),
-      stdout: 'pipe',
-      stderr: 'pipe',
-    })
-    let timedOut = false
-    const timer = options.timeoutMs
-      ? setTimeout(() => {
-          timedOut = true
-          try {
-            proc.kill()
-          } catch {
-            // Already exited.
-          }
-        }, options.timeoutMs)
-      : undefined
-    try {
-      const [stdout, stderr, exitCode] = await Promise.all([
-        new Response(proc.stdout).text(),
-        new Response(proc.stderr).text(),
-        proc.exited,
-      ])
-      return { exitCode, stdout, stderr, timedOut }
-    } finally {
-      if (timer) clearTimeout(timer)
-    }
-  } catch (error) {
-    return {
-      exitCode: -1,
-      stdout: '',
-      stderr: '',
-      timedOut: false,
-      spawnError: error instanceof Error ? error.message : String(error),
-    }
-  }
-}
-
-export async function runStudioCliJson<T>(
-  args: readonly string[],
-  decoder: StudioCliDecoder<T>,
-  options: RunOptions = {},
-): Promise<StudioCliMachineResult<T>> {
-  const machineArgs = args.includes('--json') ? [...args] : [...args, '--json']
-  const captured = await captureStudioCli(machineArgs, options)
-  const value = parseJson(captured.stdout) ?? parseJson(captured.stderr)
-  const data = value === null ? null : decoder(value)
-  const accepted = options.acceptedExitCodes ?? [0]
-  const detail =
-    captured.spawnError ??
-    (captured.timedOut
-      ? `Astrale CLI timed out after ${options.timeoutMs ?? 0}ms`
-      : resultDetail(value, captured.stdout, captured.stderr))
-  return {
-    version: 1,
-    ok: accepted.includes(captured.exitCode) && data !== null && !captured.timedOut,
-    data,
-    value,
-    detail,
-    exitCode: captured.exitCode,
-    stdout: captured.stdout,
-    stderr: captured.stderr,
-    timedOut: captured.timedOut,
-  }
-}
-
-export async function runStudioCliText(
-  args: readonly string[],
-  options: RunOptions = {},
-): Promise<StudioCliTextResult> {
-  const captured = await captureStudioCli(args, options)
-  const accepted = options.acceptedExitCodes ?? [0]
-  const detail =
-    captured.spawnError ??
-    (captured.timedOut
-      ? `Astrale CLI timed out after ${options.timeoutMs ?? 0}ms`
-      : (conciseCliFailure(captured.stderr) ?? conciseCliFailure(captured.stdout) ?? ''))
-  return {
-    version: 1,
-    ok: accepted.includes(captured.exitCode) && !captured.timedOut,
-    detail,
-    exitCode: captured.exitCode,
-    stdout: captured.stdout,
-    stderr: captured.stderr,
-    timedOut: captured.timedOut,
-  }
-}

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

@@ -1,147 +0,0 @@
-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

@@ -1,266 +0,0 @@
-import { existsSync, readFileSync, statSync } from 'node:fs'
-import { isAbsolute, join, relative, resolve } from 'node:path'
-import { parse as parseYaml } from 'yaml'
-
-import { asJsonRecord, asStringArray, parseJson } from './json'
-
-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 {
-  const record = asJsonRecord(parseJson(readFileSync(packageFile, 'utf8')))
-  if (!record) throw new TypeError('package.json must contain an object')
-  const scriptsRecord = asJsonRecord(record.scripts)
-  const scripts = scriptsRecord
-    ? Object.fromEntries(
-        Object.entries(scriptsRecord).filter(
-          (entry): entry is [string, string] => typeof entry[1] === 'string',
-        ),
-      )
-    : undefined
-  let workspaces: PackageManifest['workspaces']
-  const workspaceList = asStringArray(record.workspaces)
-  if (workspaceList) {
-    workspaces = workspaceList
-  } else {
-    const workspaceObject = asJsonRecord(record.workspaces)
-    const packages = asStringArray(workspaceObject?.packages)
-    if (workspaceObject) workspaces = packages ? { packages } : {}
-  }
-  return {
-    ...(scripts === undefined ? {} : { scripts }),
-    ...(workspaces === undefined ? {} : { workspaces }),
-  }
-}
-
-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)
-}