@znight/cli 0.0.0-stage → 0.1.0

package/src/commands/start.ts

@@ -0,0 +1,79 @@
+/**
+ * `znight start`: runs the production build with Node.js (or Bun). On POSIX the CLI process is
+ * replaced by the runtime (`execve`): same PID, signals and exit code are native (ideal as a
+ * container entry point). Elsewhere the application runs as a child process; signals are forwarded
+ * and its exit code is returned.
+ */
+import type { Command } from '../command.ts'
+
+import { existsSync } from 'node:fs'
+import { resolve } from 'node:path'
+
+import { defineCommand } from '../command.ts'
+import { CliError } from '../errors.ts'
+import { exitCodeOf } from '../integrations/process.ts'
+import { type RuntimeOption, resolveRuntime, runtimeArguments, runtimeExecutable } from '../runtime.ts'
+import { displayPath, resolveRoot } from './shared.ts'
+
+/** Entries tried when `--entry` is not given. */
+const DEFAULT_ENTRIES = ['dist/main.js', 'dist/main.mjs']
+
+/** `znight start` */
+export const startCommand: Command = defineCommand({
+  meta: {
+    name: 'start',
+    description: 'Run the production build',
+    usage: '[options] [-- <application arguments>]',
+    examples: ['znight start', 'znight start --runtime bun', 'znight start --entry dist/worker.js -- --verbose'],
+    details:
+      'NODE_ENV defaults to "production". Signals (SIGINT, SIGTERM) reach the application, which stops gracefully.',
+  },
+  args: {
+    root: { type: 'string', valueHint: 'dir', description: 'Project root (default: the current directory)' },
+    entry: { type: 'string', valueHint: 'file', description: 'File to run (default: dist/main.js)' },
+    runtime: {
+      type: 'enum',
+      options: ['auto', 'node', 'bun'],
+      default: 'auto',
+      description: 'Runtime of the application (auto: the runtime running the CLI)',
+    },
+  },
+  async run({ args, cli, passthrough }) {
+    const root = resolveRoot(cli, args.root)
+    const candidates = args.entry === undefined ? DEFAULT_ENTRIES : [args.entry]
+    const entry = candidates.map(file => resolve(root, file)).find(file => existsSync(file))
+    if (entry === undefined) {
+      throw new CliError(`${displayPath(resolve(root, candidates[0] ?? ''), cli.cwd)} not found`, {
+        hints: ['build the application first: znight build'],
+      })
+    }
+    const runtime = resolveRuntime(args.runtime as RuntimeOption, cli.runtime)
+    const executable = runtimeExecutable(runtime, cli.runtime, cli.env)
+    if (executable === undefined) {
+      throw new CliError(`Cannot find "${runtime}" in PATH`, { hints: ['install it, or choose another --runtime'] })
+    }
+    const argv = [...runtimeArguments(runtime), entry, ...passthrough]
+    const env = { ...cli.env, NODE_ENV: cli.env['NODE_ENV'] ?? 'production' }
+    const { processes } = cli.services
+    if (processes.execve !== undefined) {
+      const clean: Record<string, string> = {}
+      for (const [key, value] of Object.entries(env)) if (value !== undefined) clean[key] = value
+      processes.execve(executable, [executable, ...argv], clean, root)
+      // only reached with a test double (a real execve never returns)
+      return 0
+    }
+    const child = processes.spawn(executable, argv, { cwd: root, env, detached: true })
+    const forward = (signal: NodeJS.Signals) => (): void => {
+      child.kill(signal)
+    }
+    const listeners = (['SIGINT', 'SIGTERM', 'SIGHUP'] as const).map(signal => [signal, forward(signal)] as const)
+    for (const [signal, listener] of listeners) cli.signals.on(signal, listener)
+    try {
+      const status = await child.exited
+      if (status.error !== undefined) throw new CliError(`Cannot start ${runtime}: ${status.error.message}`)
+      return exitCodeOf(status)
+    } finally {
+      for (const [signal, listener] of listeners) cli.signals.off(signal, listener)
+    }
+  },
+})

package/src/context.ts

@@ -0,0 +1,126 @@
+/**
+ * Everything a command needs from the outside world: streams, environment, runtime and the
+ * services (compiler, Vite, processes, prompts, file watching). Tests replace any of them.
+ */
+import type { CompilerApi } from './integrations/compiler.ts'
+import type { OpenApiEmitApi, OpenApiViteApi } from './integrations/openapi.ts'
+import type { ProcessService } from './integrations/process.ts'
+import type { Prompts } from './integrations/prompts.ts'
+import type { ViteApi } from './integrations/vite.ts'
+import type { WatchFactory } from './integrations/watch.ts'
+import type { Colors, OutputStream, Reporter } from './output.ts'
+import type { HostRuntime } from './runtime.ts'
+
+import { loadCompiler } from './integrations/compiler.ts'
+import { loadOpenApiEmit, loadOpenApiVite } from './integrations/openapi.ts'
+import { createProcessService } from './integrations/process.ts'
+import { loadPrompts } from './integrations/prompts.ts'
+import { loadVite } from './integrations/vite.ts'
+import { watchFiles } from './integrations/watch.ts'
+import { createColors, createReporter, shouldUseColor } from './output.ts'
+import { detectHostRuntime } from './runtime.ts'
+import { cliVersion } from './version.ts'
+
+/** A source of process signals (`process` by default). */
+export interface SignalSource {
+  on(signal: NodeJS.Signals, listener: () => void): void
+  off(signal: NodeJS.Signals, listener: () => void): void
+}
+
+/** External services, lazily loaded. */
+export interface CliServices {
+  /** Loads `@znight/compiler` for the project at `root`. */
+  loadCompiler(root: string): Promise<CompilerApi>
+  /** Loads `vite` for the project at `root`. */
+  loadVite(root: string): Promise<ViteApi>
+  /** Loads the interactive prompts. */
+  loadPrompts(): Promise<Prompts>
+  /** Loads `@znight/openapi/emit` for the project at `root` (`znight openapi`). */
+  loadOpenApi(root: string): Promise<OpenApiEmitApi>
+  /** Loads `@znight/openapi/vite` for the project at `root` (`znight build --openapi`). */
+  loadOpenApiVite(root: string): Promise<OpenApiViteApi>
+  readonly processes: ProcessService
+  readonly watch: WatchFactory
+}
+
+/** The execution context of a command. */
+export interface CliContext {
+  readonly cwd: string
+  readonly env: Readonly<Record<string, string | undefined>>
+  readonly stdout: OutputStream
+  readonly stderr: OutputStream
+  /** Whether prompts may be shown (stdin and stdout are TTYs, not in CI). */
+  readonly interactive: boolean
+  readonly colors: Colors
+  readonly reporter: Reporter
+  readonly runtime: HostRuntime
+  /** Version of `@znight/cli`. */
+  readonly version: string
+  readonly signals: SignalSource
+  readonly services: CliServices
+  /** Print stack traces of unexpected errors. */
+  readonly debug: boolean
+}
+
+/** Overrides accepted by {@link createContext}. */
+export interface CliContextOptions {
+  readonly cwd?: string
+  readonly env?: Readonly<Record<string, string | undefined>>
+  readonly stdout?: OutputStream
+  readonly stderr?: OutputStream
+  readonly interactive?: boolean
+  /** `--color` / `--no-color`. */
+  readonly color?: boolean | undefined
+  readonly runtime?: HostRuntime
+  readonly version?: string
+  readonly signals?: SignalSource
+  readonly services?: Partial<CliServices>
+  readonly debug?: boolean
+}
+
+const processSignals: SignalSource = {
+  on: (signal, listener) => {
+    process.on(signal, listener)
+  },
+  off: (signal, listener) => {
+    process.off(signal, listener)
+  },
+}
+
+/**
+ * Creates a context from the current process, with optional overrides. The environment is a copy
+ * of `process.env` taken now: tools running in the CLI process (Vite sets `NODE_ENV`) do not change
+ * what the commands see and pass to the application.
+ */
+export function createContext(options: CliContextOptions = {}): CliContext {
+  const env = options.env ?? { ...process.env }
+  const stdout = options.stdout ?? process.stdout
+  const stderr = options.stderr ?? process.stderr
+  const colors = createColors(shouldUseColor({ env, stream: stdout, flag: options.color }))
+  const interactive =
+    options.interactive ??
+    (process.stdin.isTTY === true && stdout.isTTY === true && env['CI'] === undefined && env['TERM'] !== 'dumb')
+  return {
+    cwd: options.cwd ?? process.cwd(),
+    env,
+    stdout,
+    stderr,
+    interactive,
+    colors,
+    reporter: createReporter(stdout, stderr, colors),
+    runtime: options.runtime ?? detectHostRuntime(),
+    version: options.version ?? cliVersion(),
+    signals: options.signals ?? processSignals,
+    debug:
+      options.debug ?? (env['ZNIGHT_DEBUG'] !== undefined && env['ZNIGHT_DEBUG'] !== '' && env['ZNIGHT_DEBUG'] !== '0'),
+    services: {
+      loadCompiler: options.services?.loadCompiler ?? loadCompiler,
+      loadVite: options.services?.loadVite ?? loadVite,
+      loadPrompts: options.services?.loadPrompts ?? loadPrompts,
+      loadOpenApi: options.services?.loadOpenApi ?? loadOpenApiEmit,
+      loadOpenApiVite: options.services?.loadOpenApiVite ?? loadOpenApiVite,
+      processes: options.services?.processes ?? createProcessService(),
+      watch: options.services?.watch ?? watchFiles,
+    },
+  }
+}

package/src/dev/orphan-guard.ts

@@ -0,0 +1,49 @@
+/**
+ * Preloaded into the application by `znight dev` (see `orphan.ts`): stops the application when the
+ * CLI that started it is gone without stopping it (`kill -9`, the OOM killer).
+ *
+ * Configured by `ZNIGHT_DEV_PARENT` (removed from the environment right away: the processes the
+ * application starts, `fork()` included, are left alone), and only in the process the CLI started
+ * (whose parent is the CLI). Every poll interval it checks that it was not re-parented and that the
+ * CLI still exists (an unref'd timer: it never keeps the application alive). Once the CLI is gone,
+ * the application gets SIGTERM (its process group when it leads one, as the CLI would send it), so
+ * it stops gracefully, then SIGKILL after the kill timeout.
+ */
+import { ORPHAN_GUARD_ENV, parseOrphanGuard } from './orphan.ts'
+
+const settings = parseOrphanGuard(process.env[ORPHAN_GUARD_ENV])
+Reflect.deleteProperty(process.env, ORPHAN_GUARD_ENV)
+
+if (settings !== undefined && process.ppid === settings.parentPid) {
+  const { parentPid, pollMs, killTimeoutMs } = settings
+  const poll = setInterval(() => {
+    if (process.ppid === parentPid && isAlive(parentPid)) return
+    clearInterval(poll)
+    setTimeout(() => signal('SIGKILL'), killTimeoutMs).unref()
+    signal('SIGTERM')
+  }, pollMs)
+  poll.unref()
+}
+
+/** Whether `pid` exists (EPERM: it does, but is not the CLI, which runs as the same user). */
+function isAlive(pid: number): boolean {
+  try {
+    process.kill(pid, 0)
+    return true
+  } catch {
+    return false
+  }
+}
+
+/** Signals the process group of the application (it leads one when detached), else the process. */
+function signal(name: NodeJS.Signals): void {
+  try {
+    if (process.platform !== 'win32') {
+      process.kill(-process.pid, name)
+      return
+    }
+  } catch {
+    // not a group leader
+  }
+  process.kill(process.pid, name)
+}

package/src/dev/orphan.ts

@@ -0,0 +1,74 @@
+/**
+ * The orphan guard of `znight dev`. The application runs detached (its own process group, so that a
+ * terminal Ctrl+C reaches the CLI only), so when the CLI dies without stopping it (`kill -9`, the OOM
+ * killer) it keeps running, holding its port. The CLI therefore preloads `orphan-guard.ts` into the
+ * application (`--import` on Node.js, `--preload` on Bun): it watches the CLI process and stops the
+ * application once the CLI is gone. No cooperation of the application is needed.
+ */
+import type { RuntimeName } from '../runtime.ts'
+
+import { existsSync } from 'node:fs'
+import { fileURLToPath } from 'node:url'
+
+/**
+ * Environment variable configuring the guard in the application process:
+ * `<CLI pid>:<poll interval ms>:<kill timeout ms>`. The guard removes it from the environment right
+ * away, so that the processes the application starts itself are not guarded.
+ */
+export const ORPHAN_GUARD_ENV = 'ZNIGHT_DEV_PARENT'
+
+/** Package export of the preloaded module (resolved from the CLI itself). */
+const ORPHAN_GUARD_MODULE = '@znight/cli/orphan-guard'
+
+/** Settings of the guard. */
+export interface OrphanGuardSettings {
+  /** The CLI process, parent of the application. */
+  readonly parentPid: number
+  /** How often the guard checks that the CLI is still there. */
+  readonly pollMs: number
+  /** Time the application gets to stop after SIGTERM before SIGKILL. */
+  readonly killTimeoutMs: number
+}
+
+/** What a spawned application needs for the guard: runtime arguments and environment. */
+export interface OrphanGuard {
+  /** Runtime arguments preloading the guard (before the entry file). */
+  readonly args: readonly string[]
+  /** Environment variables configuring it. */
+  readonly env: Readonly<Record<string, string>>
+}
+
+/** Default {@link OrphanGuardSettings.pollMs}. */
+export const ORPHAN_GUARD_POLL_MS = 500
+
+/**
+ * The runtime arguments and environment installing the guard in an application run with `runtime`,
+ * `undefined` when the guard module cannot be located (the application then runs without it).
+ */
+export function orphanGuard(
+  runtime: RuntimeName,
+  settings: OrphanGuardSettings,
+  resolveModule: (specifier: string) => string = specifier => import.meta.resolve(specifier),
+): OrphanGuard | undefined {
+  let url: string
+  try {
+    url = resolveModule(ORPHAN_GUARD_MODULE)
+  } catch {
+    return undefined
+  }
+  // a missing preload would stop the application from starting
+  if (!url.startsWith('file:') || !existsSync(fileURLToPath(url))) return undefined
+  // Node.js imports URLs; Bun preloads paths (and ignores data: URLs)
+  const args = runtime === 'node' ? ['--import', url] : ['--preload', fileURLToPath(url)]
+  const value = `${settings.parentPid}:${settings.pollMs}:${settings.killTimeoutMs}`
+  return { args, env: { [ORPHAN_GUARD_ENV]: value } }
+}
+
+/** Reads {@link ORPHAN_GUARD_ENV}: `undefined` when it is missing or malformed. */
+export function parseOrphanGuard(value: string | undefined): OrphanGuardSettings | undefined {
+  const parts = value?.split(':') ?? []
+  if (parts.length !== 3 || parts.some(part => !/^\d+$/.test(part))) return undefined
+  const [parentPid = 0, pollMs = 0, killTimeoutMs = 0] = parts.map(Number)
+  if (parentPid <= 0 || pollMs <= 0) return undefined
+  return { parentPid, pollMs, killTimeoutMs }
+}

package/src/dev/supervisor.ts

@@ -0,0 +1,175 @@
+/**
+ * Restart orchestration of `znight dev`: one application process at a time, restarted (debounced)
+ * after each successful build. Stopping sends SIGTERM, waits for the exit and sends SIGKILL after a
+ * timeout. Restarts are serialised and coalesced: a burst of builds causes one restart with the
+ * latest output. A failed build simply does not schedule a restart (and cancels a pending one when
+ * its output is broken), so the last good process keeps running.
+ */
+import type { ChildHandle, ExitStatus } from '../integrations/process.ts'
+
+/** Notifications of an {@link AppSupervisor}. */
+export interface SupervisorEvents {
+  /** A process was started (`restart` is false for the first one). */
+  onStart?(child: ChildHandle, restart: boolean): void
+  /** A process stopped by the supervisor exited (`forced`: it needed SIGKILL). */
+  onStop?(status: ExitStatus, forced: boolean): void
+  /** The current process exited by itself (crash, or the application ended). */
+  onExit?(status: ExitStatus): void
+  /** Starting a process failed synchronously. */
+  onError?(error: unknown): void
+}
+
+/** Options of {@link AppSupervisor}. */
+export interface AppSupervisorOptions {
+  /** Starts a new application process. */
+  readonly spawn: () => ChildHandle
+  /** Delay applied by {@link AppSupervisor.scheduleRestart}. Default 100 ms. */
+  readonly debounceMs?: number
+  /** Time a process gets to exit after SIGTERM before SIGKILL. Default 5000 ms. */
+  readonly killTimeoutMs?: number
+  readonly events?: SupervisorEvents
+}
+
+/** Keeps one application process running and restarts it on demand. */
+export class AppSupervisor {
+  readonly #spawn: () => ChildHandle
+  readonly #debounceMs: number
+  readonly #killTimeoutMs: number
+  readonly #events: SupervisorEvents
+  readonly #stopping = new Set<ChildHandle>()
+  #current: ChildHandle | undefined
+  #debounce: ReturnType<typeof setTimeout> | undefined
+  #queue: Promise<void> = Promise.resolve()
+  #queued = false
+  #closed = false
+  #started = 0
+
+  constructor(options: AppSupervisorOptions) {
+    this.#spawn = options.spawn
+    this.#debounceMs = options.debounceMs ?? 100
+    this.#killTimeoutMs = options.killTimeoutMs ?? 5000
+    this.#events = options.events ?? {}
+  }
+
+  /** Whether an application process is running. */
+  get running(): boolean {
+    return this.#current !== undefined
+  }
+
+  /** The running process. */
+  get current(): ChildHandle | undefined {
+    return this.#current
+  }
+
+  /** Number of processes started so far. */
+  get starts(): number {
+    return this.#started
+  }
+
+  /** Restarts after `debounceMs`; calls in between postpone it. */
+  scheduleRestart(): void {
+    if (this.#closed) return
+    if (this.#debounce !== undefined) clearTimeout(this.#debounce)
+    this.#debounce = setTimeout(() => {
+      this.#debounce = undefined
+      void this.restart()
+    }, this.#debounceMs)
+  }
+
+  /**
+   * Cancels a restart scheduled by {@link scheduleRestart} and not started yet (the output it would
+   * run turned out to be broken, e.g. a failed compilation). Returns whether one was pending.
+   */
+  cancelRestart(): boolean {
+    if (this.#debounce === undefined) return false
+    clearTimeout(this.#debounce)
+    this.#debounce = undefined
+    return true
+  }
+
+  /**
+   * Stops the current process (if any) and starts a new one. Restarts never overlap; a restart
+   * requested while another one is waiting to run is merged with it.
+   */
+  restart(): Promise<void> {
+    if (this.#closed) return this.#queue
+    if (this.#queued) return this.#queue
+    this.#queued = true
+    this.#queue = this.#queue
+      .then(async () => {
+        this.#queued = false
+        if (this.#closed) return
+        await this.#stopCurrent('SIGTERM')
+        if (this.#closed) return
+        this.#startNew()
+      })
+      .catch((error: unknown) => {
+        // keep the queue usable: a failing listener must not block later restarts
+        this.#queued = false
+        this.#events.onError?.(error)
+      })
+    return this.#queue
+  }
+
+  /** Stops the current process with `signal` (SIGKILL after the timeout) and refuses new starts. */
+  async stop(signal: NodeJS.Signals = 'SIGTERM'): Promise<void> {
+    this.#closed = true
+    if (this.#debounce !== undefined) {
+      clearTimeout(this.#debounce)
+      this.#debounce = undefined
+    }
+    await this.#queue
+    await this.#stopCurrent(signal)
+  }
+
+  /** Immediately SIGKILLs every process (a second Ctrl+C). */
+  kill(): void {
+    this.#closed = true
+    if (this.#debounce !== undefined) clearTimeout(this.#debounce)
+    this.#current?.kill('SIGKILL')
+    for (const child of this.#stopping) child.kill('SIGKILL')
+  }
+
+  #startNew(): void {
+    let child: ChildHandle
+    try {
+      child = this.#spawn()
+    } catch (error) {
+      this.#events.onError?.(error)
+      return
+    }
+    const restart = this.#started > 0
+    this.#started++
+    this.#current = child
+    void child.exited.then(status => {
+      if (this.#current !== child) return
+      this.#current = undefined
+      this.#events.onExit?.(status)
+    })
+    this.#events.onStart?.(child, restart)
+  }
+
+  async #stopCurrent(signal: NodeJS.Signals): Promise<void> {
+    const child = this.#current
+    if (child === undefined) return
+    this.#current = undefined
+    this.#stopping.add(child)
+    try {
+      child.kill(signal)
+      let timer: ReturnType<typeof setTimeout> | undefined
+      const timeout = new Promise<'timeout'>(resolve => {
+        timer = setTimeout(() => resolve('timeout'), this.#killTimeoutMs)
+      })
+      const first = await Promise.race([child.exited, timeout])
+      clearTimeout(timer)
+      if (first === 'timeout') {
+        child.kill('SIGKILL')
+        this.#events.onStop?.(await child.exited, true)
+      } else {
+        this.#events.onStop?.(first, false)
+      }
+    } finally {
+      this.#stopping.delete(child)
+    }
+  }
+}

package/src/errors.ts

@@ -0,0 +1,64 @@
+/**
+ * Errors thrown by commands. The dispatcher turns them into a message on stderr and an exit code;
+ * any other error is reported as an unexpected failure (exit code 1, stack trace with `--debug`).
+ */
+
+/** Exit codes of the `znight` binary. */
+export const ExitCode = {
+  /** The command succeeded. */
+  Ok: 0,
+  /** The command failed (compilation errors, failed build, stale generated file...). */
+  Failure: 1,
+  /** Invalid usage: unknown command or option, missing or invalid argument. */
+  Usage: 2,
+  /** The user cancelled an interactive prompt or interrupted the command. */
+  Cancelled: 130,
+} as const
+
+/** One of the {@link ExitCode} values (or any process exit code). */
+export type ExitCodeValue = number
+
+/** Options of a {@link CliError}. */
+export interface CliErrorOptions {
+  /** Exit code of the process. Default {@link ExitCode.Failure}. */
+  readonly exitCode?: number
+  /** Lines printed after the message (`= hint: ...`). */
+  readonly hints?: readonly string[]
+  /** Original error. */
+  readonly cause?: unknown
+}
+
+/** An expected failure: printed without stack trace. */
+export class CliError extends Error {
+  readonly exitCode: number
+  readonly hints: readonly string[]
+
+  constructor(message: string, options: CliErrorOptions = {}) {
+    super(message, options.cause === undefined ? undefined : { cause: options.cause })
+    this.name = 'CliError'
+    this.exitCode = options.exitCode ?? ExitCode.Failure
+    this.hints = options.hints ?? []
+  }
+}
+
+/** Invalid command line usage (exit code 2). The usage of the command is printed after the message. */
+export class UsageError extends CliError {
+  constructor(message: string, hints: readonly string[] = []) {
+    super(message, { exitCode: ExitCode.Usage, hints })
+    this.name = 'UsageError'
+  }
+}
+
+/** The user cancelled a prompt (exit code 130). */
+export class CancelledError extends CliError {
+  constructor(message = 'Cancelled') {
+    super(message, { exitCode: ExitCode.Cancelled })
+    this.name = 'CancelledError'
+  }
+}
+
+/** Message of an unknown thrown value. */
+export function errorMessage(error: unknown): string {
+  if (error instanceof Error) return error.message
+  return String(error)
+}

package/src/index.ts

@@ -0,0 +1,73 @@
+/**
+ * `@znight/cli`: the `znight` command (`znight new`, `generate`, `g`, `dev`, `build`, `start`).
+ *
+ * The programmatic API runs the CLI in-process (`main(['build'])`) and exposes the pure building
+ * blocks: project templates, schematics and the restart supervisor of `znight dev`.
+ */
+export type { Command, CommandDefinition, CommandMeta, CommandRunContext } from './command.ts'
+export type { CliContext, CliContextOptions, CliServices, SignalSource } from './context.ts'
+export type {
+  AppSupervisorOptions,
+  SupervisorEvents,
+} from './dev/supervisor.ts'
+export type {
+  CheckResultLike,
+  CompileResultLike,
+  CompilerApi,
+  CompilerChanges,
+  CompilerModule,
+  Diagnostic,
+  DiagnosticLocation,
+  FormatDiagnosticsOptions,
+  GenerateResultLike,
+  IncrementalCompiler,
+  ZnightConfigLike,
+  ZnightOptions,
+} from './integrations/compiler.ts'
+export type {
+  OpenApiEmitApi,
+  OpenApiEmitOptionsLike,
+  OpenApiEmitResultLike,
+  OpenApiViteApi,
+  OpenApiVitePluginOptionsLike,
+  OpenApiWarningLike,
+} from './integrations/openapi.ts'
+export type {
+  ChildHandle,
+  ExecveFunction,
+  ExitStatus,
+  ProcessService,
+  RunOptions,
+  RunResult,
+  SpawnOptions,
+} from './integrations/process.ts'
+export type { PromptChoice, Prompts } from './integrations/prompts.ts'
+export type { FileWatcher, WatchFactory, WatchTarget } from './integrations/watch.ts'
+export type { OutputStream, Reporter } from './output.ts'
+export type { HostRuntime, RuntimeName, RuntimeOption } from './runtime.ts'
+export type {
+  Feature,
+  HttpAdapterName,
+  PackageManager,
+  ProjectOptions,
+} from './scaffold/options.ts'
+export type { ProjectFile } from './scaffold/templates.ts'
+export type {
+  PlanSchematicOptions,
+  Schematic,
+  SchematicContext,
+  SchematicName,
+  SchematicNames,
+  SchematicPlan,
+} from './schematics/index.ts'
+
+export { defineCommand } from './command.ts'
+export { createContext } from './context.ts'
+export { AppSupervisor } from './dev/supervisor.ts'
+export { CancelledError, CliError, ExitCode, UsageError } from './errors.ts'
+export { adaptCompilerModule, loadCompiler } from './integrations/compiler.ts'
+export { COMMANDS, main } from './main.ts'
+export { DEFAULT_FEATURES, FEATURES, HTTP_ADAPTERS, PACKAGE_MANAGERS } from './scaffold/options.ts'
+export { renderProject } from './scaffold/templates.ts'
+export { findSchematic, planSchematic, SCHEMATICS } from './schematics/index.ts'
+export { cliVersion } from './version.ts'