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

package/studio/server/detect.ts

@@ -1,81 +0,0 @@
-/**
- * detect.ts — workspace domain detection. Walks a directory tree (symlink-safe,
- * ignoring node_modules/.git/.astrale/dist/…), registering every confirmed
- * domain. Also handles being pointed at a single astrale.config.ts.
- */
-import { existsSync, lstatSync, readdirSync } from 'node:fs'
-import { dirname, join, resolve } from 'node:path'
-
-import { type DomainHandle, registerDomain } from './domain'
-
-const IGNORE = new Set([
-  'node_modules',
-  '.git',
-  '.astrale',
-  'dist',
-  '.dist',
-  '.domain-studio',
-  '.next',
-  '.cache',
-  '.turbo',
-  '.vercel',
-  'coverage',
-])
-
-/** Resolve a CLI target: a path to astrale.config.ts, a domain dir, or a workspace to scan. */
-export function resolveTarget(target: string, schemaDirName = 'schema'): DomainHandle[] {
-  const abs = resolve(target)
-  if (abs.endsWith('astrale.config.ts')) {
-    const h = registerDomain(dirname(abs), schemaDirName)
-    return h ? [h] : []
-  }
-  // a single domain dir?
-  const single = registerDomain(abs, schemaDirName)
-  if (single) {
-    // still scan beneath for sibling/nested domains (e.g. a workspace whose root is also a domain)
-    const nested = scanWorkspace(abs, schemaDirName).filter((d) => d.id !== single.id)
-    return dedupe([single, ...nested])
-  }
-  return scanWorkspace(abs, schemaDirName)
-}
-
-export function scanWorkspace(
-  workspace: string,
-  schemaDirName = 'schema',
-  maxDepth = 4,
-): DomainHandle[] {
-  const found: DomainHandle[] = []
-  const root = resolve(workspace)
-  if (!existsSync(root)) return found
-
-  const walk = (dir: string, depth: number) => {
-    const h = registerDomain(dir, schemaDirName)
-    if (h) found.push(h)
-    if (depth >= maxDepth) return
-    let entries: string[]
-    try {
-      entries = readdirSync(dir)
-    } catch {
-      return
-    }
-    for (const e of entries) {
-      if (IGNORE.has(e) || e.startsWith('.')) continue
-      const full = join(dir, e)
-      let st
-      try {
-        st = lstatSync(full)
-      } catch {
-        continue
-      }
-      if (st.isSymbolicLink()) continue // never follow symlinks (pnpm farms)
-      if (st.isDirectory()) walk(full, depth + 1)
-    }
-  }
-  walk(root, 0)
-  return dedupe(found)
-}
-
-function dedupe(domains: DomainHandle[]): DomainHandle[] {
-  const seen = new Set<string>()
-  return domains.filter((d) => (seen.has(d.root) ? false : (seen.add(d.root), true)))
-}

package/studio/server/domain.test.ts

@@ -1,77 +0,0 @@
-import { afterEach, describe, expect, test } from 'bun:test'
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { basename, join } from 'node:path'
-
-import {
-  depsInstalled,
-  isDomainDir,
-  registerDomain,
-  resolveApplicationEntry,
-  resolveSchemaEntry,
-  unregisterDomain,
-} from './domain'
-
-const roots: string[] = []
-const domainIds: string[] = []
-
-afterEach(() => {
-  while (domainIds.length) unregisterDomain(domainIds.pop()!)
-  while (roots.length) rmSync(roots.pop()!, { recursive: true, force: true })
-})
-
-function fixture(nested = false): string {
-  const root = mkdtempSync(join(tmpdir(), 'studio-application-layout-'))
-  roots.push(root)
-  const owner = nested ? join(root, 'domain') : root
-  mkdirSync(join(owner, 'schema'), { recursive: true })
-  writeFileSync(
-    join(root, 'astrale.config.ts'),
-    nested
-      ? "import application from './domain/application.js'\nexport default { application }\n"
-      : 'export default {}\n',
-  )
-  writeFileSync(join(owner, 'application.ts'), 'export default {}\n')
-  writeFileSync(join(owner, 'schema/index.ts'), 'export const schema = {}\n')
-  return root
-}
-
-describe('SDK V1 project discovery', () => {
-  test('discovers conventional root Application and Schema entries', () => {
-    const root = fixture()
-    expect(isDomainDir(root)).toBe(true)
-    expect(basename(resolveApplicationEntry(root)!)).toBe('application.ts')
-    expect(basename(resolveSchemaEntry(root, resolveApplicationEntry(root)!)!)).toBe('index.ts')
-    const handle = registerDomain(root)!
-    domainIds.push(handle.id)
-    expect(basename(handle.applicationFile)).toBe('application.ts')
-    expect(handle.schemaDirName).toBe('schema')
-  })
-
-  test('follows a config-imported nested Application and adjacent Schema', () => {
-    const root = fixture(true)
-    const application = resolveApplicationEntry(root)!
-    expect(application).toBe(join(root, 'domain/application.ts'))
-    expect(resolveSchemaEntry(root, application)).toBe(join(root, 'domain/schema/index.ts'))
-  })
-
-  test('requires the semantic SDK dependency, not Kernel implementation packages', () => {
-    const root = fixture()
-    expect(depsInstalled(root)).toBe(false)
-    mkdirSync(join(root, 'node_modules', '@astrale-os', 'kernel-core'), { recursive: true })
-    expect(depsInstalled(root)).toBe(false)
-    mkdirSync(join(root, 'node_modules', '@astrale-os', 'sdk'), { recursive: true })
-    expect(depsInstalled(root)).toBe(true)
-  })
-
-  test('rejects implementation.ts and domain.ts compatibility layouts', () => {
-    const root = mkdtempSync(join(tmpdir(), 'studio-legacy-layout-'))
-    roots.push(root)
-    mkdirSync(join(root, 'schema'))
-    writeFileSync(join(root, 'astrale.config.ts'), 'export default {}\n')
-    writeFileSync(join(root, 'implementation.ts'), 'export default {}\n')
-    writeFileSync(join(root, 'domain.ts'), 'export default {}\n')
-    writeFileSync(join(root, 'schema/index.ts'), 'export const schema = {}\n')
-    expect(isDomainDir(root)).toBe(false)
-  })
-})

package/studio/server/domain.ts

@@ -1,124 +0,0 @@
-/** SDK V1 project discovery and the in-process Studio registry. */
-import { existsSync, readFileSync } from 'node:fs'
-import { basename, dirname, extname, join, relative, resolve } from 'node:path'
-
-export interface DomainHandle {
-  readonly id: string
-  readonly root: string
-  readonly configFile: string
-  readonly applicationFile: string
-  readonly schemaDirName: string
-  readonly schemaDir: string
-  readonly schemaIndex: string
-  origin?: string
-}
-
-const registry = new Map<string, DomainHandle>()
-
-export function makeId(root: string): string {
-  return basename(resolve(root)).replace(/[^a-zA-Z0-9_-]/g, '-') || 'domain'
-}
-
-/** Resolve the Application imported by config, with root application.ts as convention. */
-export function resolveApplicationEntry(root: string): string | null {
-  const project = resolve(root)
-  const conventional = join(project, 'application.ts')
-  if (existsSync(conventional)) return conventional
-  const config = join(project, 'astrale.config.ts')
-  if (!existsSync(config)) return null
-  let source: string
-  try {
-    source = readFileSync(config, 'utf8')
-  } catch {
-    return null
-  }
-  for (const match of source.matchAll(/\bfrom\s+['"]([^'"]+)['"]/gu)) {
-    const specifier = match[1]
-    if (
-      !specifier?.startsWith('.') ||
-      basename(specifier).replace(/\.[^.]+$/u, '') !== 'application'
-    ) {
-      continue
-    }
-    const selected = resolveSourceFile(project, specifier)
-    if (selected !== null) return selected
-  }
-  return null
-}
-
-/** Resolve schema.ts or schema/index.ts beside the Application, then at project root. */
-export function resolveSchemaEntry(
-  root: string,
-  applicationFile: string,
-  schemaDirName = 'schema',
-): string | null {
-  const project = resolve(root)
-  const applicationDir = dirname(applicationFile)
-  const candidates = [
-    join(applicationDir, 'schema.ts'),
-    join(applicationDir, schemaDirName, 'index.ts'),
-    join(project, 'schema.ts'),
-    join(project, schemaDirName, 'index.ts'),
-  ]
-  return [...new Set(candidates)].find(existsSync) ?? null
-}
-
-export function isDomainDir(root: string, schemaDirName = 'schema'): boolean {
-  const project = resolve(root)
-  if (!existsSync(join(project, 'astrale.config.ts'))) return false
-  const application = resolveApplicationEntry(project)
-  return application !== null && resolveSchemaEntry(project, application, schemaDirName) !== null
-}
-
-export function registerDomain(root: string, schemaDirName = 'schema'): DomainHandle | null {
-  const project = resolve(root)
-  const applicationFile = resolveApplicationEntry(project)
-  if (applicationFile === null || !existsSync(join(project, 'astrale.config.ts'))) return null
-  const schemaIndex = resolveSchemaEntry(project, applicationFile, schemaDirName)
-  if (schemaIndex === null) return null
-  const schemaDir = dirname(schemaIndex)
-  const handle: DomainHandle = {
-    id: makeId(project),
-    root: project,
-    configFile: join(project, 'astrale.config.ts'),
-    applicationFile,
-    schemaDirName: relative(project, schemaDir).replaceAll('\\', '/') || '.',
-    schemaDir,
-    schemaIndex,
-  }
-  registry.set(handle.id, handle)
-  return handle
-}
-
-export function unregisterDomain(id: string): void {
-  registry.delete(id)
-}
-
-export function getDomain(id: string): DomainHandle | undefined {
-  return registry.get(id)
-}
-
-export function allDomains(): DomainHandle[] {
-  return [...registry.values()]
-}
-
-/** Studio's current project model always requires the semantic SDK Schema facade. */
-export function depsInstalled(root: string): boolean {
-  if (existsSync(join(root, 'node_modules', '@astrale-os', 'sdk'))) return true
-  try {
-    Bun.resolveSync('@astrale-os/sdk/schema', root)
-    return true
-  } catch {
-    return false
-  }
-}
-
-function resolveSourceFile(root: string, specifier: string): string | null {
-  const absolute = resolve(root, specifier)
-  const extension = extname(absolute)
-  const candidates =
-    extension === ''
-      ? [`${absolute}.ts`, join(absolute, 'index.ts')]
-      : [absolute, `${absolute.slice(0, -extension.length)}.ts`]
-  return candidates.find(existsSync) ?? null
-}

package/studio/server/environment/dotenv-preview.test.ts

@@ -1,39 +0,0 @@
-import { expect, test } from 'bun:test'
-
-import { parseDotenvPreview } from './dotenv-preview'
-
-test('environment preview mirrors the SDK declared-secrets subset without mutating process.env', () => {
-  const keys = ['BASE', 'EXPANDED', 'LITERAL', 'EMPTY'] as const
-  const before = Object.fromEntries(keys.map((key) => [key, process.env[key]]))
-  const seeded = {
-    BASE: 'process-base',
-    EXPANDED: 'process-expanded',
-    LITERAL: 'process-literal',
-    EMPTY: 'process-empty',
-  } as const
-  Object.assign(process.env, seeded)
-
-  try {
-    const values = parseDotenvPreview(`
-BASE=alpha
-EXPANDED="${'${BASE}'}/beta"
-LITERAL='${'${BASE}'}/beta'
-export EMPTY=
-# IGNORED=value
-`)
-
-    expect(values).toEqual({
-      BASE: 'alpha',
-      EXPANDED: 'alpha/beta',
-      LITERAL: '${BASE}/beta',
-      EMPTY: '',
-    })
-    expect(Object.fromEntries(keys.map((key) => [key, process.env[key]]))).toEqual(seeded)
-  } finally {
-    for (const key of keys) {
-      const value = before[key]
-      if (value === undefined) delete process.env[key]
-      else process.env[key] = value
-    }
-  }
-})

package/studio/server/environment/dotenv-preview.ts

@@ -1,27 +0,0 @@
-/**
- * Isolated preview of an adapter secrets file for Studio's editor.
- *
- * The SDK adapter remains authoritative when deploying. It is not a runtime
- * dependency of the raw Studio server shipped inside the CLI package, so this
- * isolated parser intentionally mirrors only the SDK's documented dotenv
- * subset and never mutates process.env.
- */
-export function parseDotenvPreview(contents: string): Record<string, string> {
-  const values: Record<string, string> = {}
-  for (const raw of contents.split('\n')) {
-    const line = raw.trim()
-    if (!line || line.startsWith('#')) continue
-    const match = /^(?:export\s+)?([A-Za-z_]\w*)\s*=\s*(.*)$/.exec(line)
-    if (!match) continue
-    const key = match[1]!
-    let value = match[2]!.trim()
-    const singleQuoted = value.length >= 2 && value.startsWith("'") && value.endsWith("'")
-    if (singleQuoted || (value.length >= 2 && value.startsWith('"') && value.endsWith('"'))) {
-      value = value.slice(1, -1)
-    }
-    values[key] = singleQuoted
-      ? value
-      : value.replace(/\$\{(\w+)\}/g, (_, name: string) => values[name] ?? '')
-  }
-  return values
-}

package/studio/server/environment/files.test.ts

@@ -1,53 +0,0 @@
-import { afterEach, expect, test } from 'bun:test'
-import { mkdtempSync, rmSync, writeFileSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-
-import { readEnvModel } from './files'
-
-const roots: string[] = []
-
-afterEach(() => {
-  for (const root of roots.splice(0)) rmSync(root, { recursive: true, force: true })
-})
-
-test('env editor composes typed fields with isolated config and dotenv previews', () => {
-  const root = mkdtempSync(join(tmpdir(), 'studio-env-preview-'))
-  roots.push(root)
-  writeFileSync(
-    join(root, 'env.ts'),
-    `export interface Env {
-  /** API credential. */
-  API_TOKEN: string
-  OPTIONAL_NOTE?: string
-  WORKER_URL: string
-}`,
-  )
-  writeFileSync(
-    join(root, 'astrale.config.ts'),
-    `// astrale({ dev: { secrets: '.env.fake' } })
-export default cloudflare({ dev: { secrets: '.env.dev' } })`,
-  )
-  writeFileSync(join(root, '.env.dev'), `BASE=token\nAPI_TOKEN="${'${BASE}'}-value"\nORPHAN=kept\n`)
-
-  expect(readEnvModel(root, 'dev')).toEqual({
-    env: 'dev',
-    file: '.env.dev',
-    configured: true,
-    exists: true,
-    adapter: 'cloudflare',
-    requiredMissing: 0,
-    rows: [
-      {
-        name: 'API_TOKEN',
-        value: 'token-value',
-        declared: true,
-        optional: false,
-        doc: 'API credential.',
-      },
-      { name: 'OPTIONAL_NOTE', value: '', declared: true, optional: true },
-      { name: 'BASE', value: 'token', declared: false, optional: true },
-      { name: 'ORPHAN', value: 'kept', declared: false, optional: true },
-    ],
-  })
-})

package/studio/server/environment/files.ts

@@ -1,120 +0,0 @@
-/**
- * Environment file editor. Reconciles a domain's `.env.<env>` file
- * (the actual secrets/vars, dotenv format) against the `Env` interface in
- * `env.ts` (the typed contract, parsed by buildEnvFields), and is the ONE place
- * the otherwise read-only studio writes a domain file — the explicit exception
- * the user sanctioned for env editing.
- *
- * Env injection is adapter-specific (cloudflare dev: merged into wrangler vars;
- * cloudflare/astrale prod: pushed to the worker/platform secret store), but the
- * secrets FILE is universal (`@astrale-os/sdk` loads `secrets: '.env.<env>'`
- * wholesale via its dotenv parser). We edit that file; we never deploy.
- */
-import { existsSync, readFileSync, writeFileSync } from 'node:fs'
-import { join, resolve } from 'node:path'
-
-import type { EnvFileModel, EnvName, EnvVarRow } from '../../shared/types'
-
-import { buildEnvFields } from '../introspect/anatomy-extras'
-import { readConfigPreview } from '../introspect/config-preview'
-import { parseDotenvPreview } from './dotenv-preview'
-
-const ENV_NAMES: EnvName[] = ['dev', 'prod']
-export const isEnvName = (v: unknown): v is EnvName =>
-  typeof v === 'string' && (ENV_NAMES as string[]).includes(v)
-
-/** The conventional secrets file for an env — what create-astrale-domain scaffolds
- *  and every domain uses. The filename is fixed, so no path-traversal is possible. */
-const envFileName = (env: EnvName) => `.env.${env}`
-
-/** Build the merged model for one env: env.ts fillable fields ⨯ the `.env.<env>` values. */
-export function readEnvModel(root: string, env: EnvName): EnvFileModel {
-  const file = envFileName(env)
-  const abs = join(root, file)
-  const exists = existsSync(abs)
-  const values = exists ? parseDotenvPreview(readFileSync(abs, 'utf8')) : {}
-
-  // env.ts contract — only fillable (non-binding) fields; bindings are adapter-injected.
-  const declared = buildEnvFields(root).filter((f) => f.secret)
-  const declaredNames = new Set(declared.map((f) => f.name))
-
-  const rows: EnvVarRow[] = declared.map((f) => ({
-    name: f.name,
-    value: values[f.name] ?? '',
-    declared: true,
-    optional: f.optional,
-    ...(f.doc ? { doc: f.doc } : {}),
-  }))
-  // orphans — present in the file but not declared in env.ts (kept, flagged, removable)
-  for (const [name, value] of Object.entries(values)) {
-    if (!declaredNames.has(name)) rows.push({ name, value, declared: false, optional: true })
-  }
-
-  const requiredMissing = rows.filter((r) => r.declared && !r.optional && r.value === '').length
-  const config = readConfigPreview(root)
-  return {
-    env,
-    file,
-    configured: config.configuredSecretFiles.includes(file),
-    exists,
-    adapter: config.adapter,
-    rows,
-    requiredMissing,
-  }
-}
-
-/** Quote a value for the dotenv file: bare when safe, single-quoted (literal) for
- *  most specials, double-quoted+escaped only when it contains a single quote. */
-function formatValue(v: string): string {
-  if (v === '') return ''
-  if (/^[A-Za-z0-9_./:@+-]+$/.test(v)) return v
-  if (!v.includes("'")) return `'${v}'`
-  return `"${v.replace(/(["\\$`])/g, '\\$1')}"`
-}
-
-/** Apply key→value updates to dotenv text IN PLACE — comments, blank lines and key
- *  order are preserved; `null` deletes a key; unknown keys are appended. */
-function applyUpdates(contents: string, updates: Record<string, string | null>): string {
-  const lines = contents.split('\n')
-  const seen = new Set<string>()
-  const out: string[] = []
-  for (const line of lines) {
-    const m = /^(\s*(?:export\s+)?)([A-Za-z_]\w*)\s*=.*$/.exec(line)
-    if (m && !line.trim().startsWith('#') && m[2] in updates) {
-      const key = m[2]
-      seen.add(key)
-      const val = updates[key]
-      if (val === null) continue // drop the line
-      out.push(`${m[1]}${key}=${formatValue(val)}`)
-      continue
-    }
-    out.push(line)
-  }
-  // preserve a single trailing newline while appending new keys after content
-  const trailing = out.length > 0 && out[out.length - 1] === ''
-  if (trailing) out.pop()
-  for (const [key, val] of Object.entries(updates)) {
-    if (val === null || seen.has(key) || !/^[A-Za-z_]\w*$/.test(key)) continue
-    out.push(`${key}=${formatValue(val)}`)
-  }
-  out.push('') // final newline
-  return out.join('\n')
-}
-
-const SCAFFOLD_HEADER = (env: EnvName) =>
-  `# ${env === 'dev' ? 'Dev' : 'Prod'} secrets — the ENTIRE file is treated as secrets by the adapter.\n# Gitignored. Edited via the Domain Studio settings.\n`
-
-/** Write key→value updates to `.env.<env>`, creating it if absent. Returns the
- *  fresh model. Confined to `<root>/.env.<env>` (fixed name, validated inside root). */
-export function writeEnvUpdates(
-  root: string,
-  env: EnvName,
-  updates: Record<string, string | null>,
-): EnvFileModel {
-  const abs = join(root, envFileName(env))
-  if (!resolve(abs).startsWith(resolve(root)))
-    throw new Error('refused: path escapes the domain root')
-  const prior = existsSync(abs) ? readFileSync(abs, 'utf8') : SCAFFOLD_HEADER(env)
-  writeFileSync(abs, applyUpdates(prior, updates), 'utf8')
-  return readEnvModel(root, env)
-}