@supatype/cli 0.1.0-alpha.8 → 0.1.0

package/src/link.ts

@@ -0,0 +1,243 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs"
+import { resolve } from "node:path"
+import { warn } from "./ui/messages.js"
+
+export const LINK_VERSION = 1 as const
+export const LINK_FILE = ".supatype/link.json"
+export const LEGACY_CLOUD_FILE = ".supatype/cloud.json"
+export const LEGACY_LINKED_FILE = ".supatype/linked.json"
+
+export type ProjectLinkKind = "cloud" | "self-host" | "local"
+
+export interface EnvironmentTarget {
+  name: string
+  apiUrl: string
+  token?: string
+  linkedAt: string
+}
+
+export interface ProjectLink {
+  version: typeof LINK_VERSION
+  kind: ProjectLinkKind
+  projectRef: string
+  defaultEnvironment: string
+  token?: string
+  orgId?: string | undefined
+  cloudApiUrl?: string
+  linkedAt: string
+  environments: Record<string, EnvironmentTarget>
+}
+
+export interface LocalEnvironment {
+  target: "local"
+  apiUrl: string
+  databaseUrl: string
+  projectRef: string
+  kongPort: number
+  provider: "docker" | "native"
+}
+
+export interface BranchContext {
+  mode: "branch"
+  branchId: string
+  apiUrl: string
+  token?: string | undefined
+}
+
+interface LegacyCloudFile {
+  apiUrl?: string
+  token?: string
+  projectSlug?: string
+  orgId?: string
+}
+
+interface LegacyLinkedFile {
+  ref?: string
+  orgId?: string
+}
+
+export function writeLocalEnvironment(cwd: string, env: LocalEnvironment): void {
+  const dir = resolve(cwd, ".supatype")
+  mkdirSync(dir, { recursive: true })
+  writeFileSync(resolve(dir, "environment.json"), `${JSON.stringify(env, null, 2)}\n`, "utf8")
+}
+
+export function loadLocalEnvironment(cwd: string): LocalEnvironment | null {
+  const path = resolve(cwd, ".supatype/environment.json")
+  if (!existsSync(path)) return null
+  return JSON.parse(readFileSync(path, "utf8")) as LocalEnvironment
+}
+
+export function linkPath(cwd: string): string {
+  return resolve(cwd, LINK_FILE)
+}
+
+export function loadProjectLink(cwd: string): ProjectLink | null {
+  migrateLegacyLinkFiles(cwd)
+  const path = linkPath(cwd)
+  if (!existsSync(path)) return null
+  return JSON.parse(readFileSync(path, "utf8")) as ProjectLink
+}
+
+export function saveProjectLink(cwd: string, link: ProjectLink): void {
+  const dir = resolve(cwd, ".supatype")
+  mkdirSync(dir, { recursive: true })
+  writeFileSync(linkPath(cwd), `${JSON.stringify(link, null, 2)}\n`, "utf8")
+}
+
+export function isProjectLinked(cwd: string): boolean {
+  const link = loadProjectLink(cwd)
+  return Boolean(link?.projectRef && Object.keys(link.environments).length > 0)
+}
+
+export function resolveEnvironmentName(link: ProjectLink, envFlag?: string): string {
+  if (envFlag?.trim()) return envFlag.trim()
+  return link.defaultEnvironment || "production"
+}
+
+export function getEnvironmentTarget(link: ProjectLink, envName: string): EnvironmentTarget | null {
+  return link.environments[envName] ?? null
+}
+
+export function resolveEnvironmentToken(link: ProjectLink, env: EnvironmentTarget): string | undefined {
+  return env.token ?? link.token
+}
+
+let migrationWarned = false
+
+/** Merge legacy cloud.json + linked.json into link.json once. */
+export function migrateLegacyLinkFiles(cwd: string): void {
+  const target = linkPath(cwd)
+  if (existsSync(target)) return
+
+  const cloudPath = resolve(cwd, LEGACY_CLOUD_FILE)
+  const linkedPath = resolve(cwd, LEGACY_LINKED_FILE)
+  const hasCloud = existsSync(cloudPath)
+  const hasLinked = existsSync(linkedPath)
+  if (!hasCloud && !hasLinked) return
+
+  let cloud: LegacyCloudFile | null = null
+  let linked: LegacyLinkedFile | null = null
+
+  if (hasCloud) {
+    cloud = JSON.parse(readFileSync(cloudPath, "utf8")) as LegacyCloudFile
+  }
+  if (hasLinked) {
+    linked = JSON.parse(readFileSync(linkedPath, "utf8")) as LegacyLinkedFile
+  }
+
+  const projectRef = cloud?.projectSlug ?? linked?.ref
+  if (!projectRef || !cloud?.token) {
+    return
+  }
+
+  const now = new Date().toISOString()
+  const link: ProjectLink = {
+    version: LINK_VERSION,
+    kind: "cloud",
+    projectRef,
+    defaultEnvironment: "production",
+    token: cloud.token,
+    cloudApiUrl: cloud.apiUrl ?? "https://api.supatype.com",
+    linkedAt: now,
+    environments: {
+      production: {
+        name: "production",
+        apiUrl: cloud.apiUrl ?? "https://api.supatype.com",
+        linkedAt: now,
+      },
+    },
+    ...(cloud.orgId !== undefined
+      ? { orgId: cloud.orgId }
+      : linked?.orgId !== undefined
+        ? { orgId: linked.orgId }
+        : {}),
+  }
+
+  saveProjectLink(cwd, link)
+
+  if (!migrationWarned) {
+    migrationWarned = true
+    warn(
+      "Migrated .supatype/cloud.json → .supatype/link.json (legacy files kept; remove manually when ready).",
+    )
+  }
+}
+
+export function createSelfHostLink(params: {
+  projectRef: string
+  apiUrl: string
+  token: string
+  envName?: string
+  existing?: ProjectLink | null
+}): ProjectLink {
+  const envName = params.envName ?? "production"
+  const now = new Date().toISOString()
+  const env: EnvironmentTarget = {
+    name: envName,
+    apiUrl: params.apiUrl.replace(/\/$/, ""),
+    token: params.token,
+    linkedAt: now,
+  }
+
+  if (params.existing) {
+    return {
+      ...params.existing,
+      kind: params.existing.kind === "cloud" ? "self-host" : params.existing.kind,
+      projectRef: params.projectRef,
+      defaultEnvironment: params.existing.defaultEnvironment || envName,
+      linkedAt: now,
+      environments: {
+        ...params.existing.environments,
+        [envName]: env,
+      },
+    }
+  }
+
+  return {
+    version: LINK_VERSION,
+    kind: "self-host",
+    projectRef: params.projectRef,
+    defaultEnvironment: envName,
+    token: params.token,
+    linkedAt: now,
+    environments: { [envName]: env },
+  }
+}
+
+export function createCloudLink(params: {
+  projectRef: string
+  cloudApiUrl: string
+  token: string
+  orgId?: string | undefined
+  environments?: Array<{ name: string; apiUrl: string }>
+  existing?: ProjectLink | null
+}): ProjectLink {
+  const now = new Date().toISOString()
+  const envMap: Record<string, EnvironmentTarget> = {}
+  const envs = params.environments?.length
+    ? params.environments
+    : [{ name: "production", apiUrl: params.cloudApiUrl }]
+
+  for (const e of envs) {
+    envMap[e.name] = {
+      name: e.name,
+      apiUrl: e.apiUrl.replace(/\/$/, ""),
+      linkedAt: now,
+    }
+  }
+
+  return {
+    version: LINK_VERSION,
+    kind: "cloud",
+    projectRef: params.projectRef,
+    defaultEnvironment: "production",
+    token: params.token,
+    cloudApiUrl: params.cloudApiUrl.replace(/\/$/, ""),
+    linkedAt: now,
+    environments: params.existing
+      ? { ...params.existing.environments, ...envMap }
+      : envMap,
+    ...(params.orgId !== undefined ? { orgId: params.orgId } : {}),
+  }
+}

package/src/process-manager.ts

@@ -3,10 +3,11 @@
  * colored prefix, and restart on crash with exponential backoff.
  */
 
-import { type ChildProcess, spawn } from "node:child_process"
+import { type ChildProcess, spawn, spawnSync } from "node:child_process"
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs"
 import { unlink } from "node:fs/promises"
 import { join } from "node:path"
+import { enhanceProcessOptions } from "./dev-session.js"
 
 export interface ProcessOptions {
   /** Human-readable label (used in log prefix and PID filename). */
@@ -27,6 +28,12 @@ export interface ProcessOptions {
   onExit?: () => void
   /** Use shell to spawn (required for pnpm/npm/yarn .cmd shims on Windows). */
   shell?: boolean
+  /** When set (TUI mode), receive log lines instead of writing to stdout/stderr. */
+  onLine?: (line: string, stream: "stdout" | "stderr") => void
+  /** Return false to drop a line before logging. */
+  shouldLogLine?: (line: string) => boolean
+  /** Called before auto-restart after a non-zero exit (e.g. free a stale port). */
+  beforeRestart?: () => void
 }
 
 const RESET = "\x1b[0m"
@@ -35,13 +42,24 @@ export class ProcessManager {
   private child: ChildProcess | null = null
   private stopped = false
   private backoffMs: number
-  private opts: Required<ProcessOptions>
+  private opts: ProcessOptions & {
+    colour: string
+    cwd: string
+    env: Record<string, string>
+    initialBackoffMs: number
+    maxBackoffMs: number
+    onExit: () => void
+    shell: boolean
+  }
+  /** Skip immediate duplicate lines (npm prints script banners to both streams). */
+  private lastLoggedLine = ""
 
   constructor(
     private readonly bin: string,
     private readonly args: string[],
     opts: ProcessOptions,
   ) {
+    const merged = enhanceProcessOptions(opts.label, opts)
     this.opts = {
       colour: "\x1b[36m",
       cwd: process.cwd(),
@@ -50,7 +68,7 @@ export class ProcessManager {
       maxBackoffMs: 30_000,
       onExit: () => {},
       shell: false,
-      ...opts,
+      ...merged,
     }
     this.backoffMs = this.opts.initialBackoffMs
   }
@@ -64,7 +82,20 @@ export class ProcessManager {
   /** Stop the process and clear the PID file. */
   async stop(): Promise<void> {
     this.stopped = true
-    if (this.child && !this.child.killed) {
+    if (!this.child || this.child.killed) {
+      await this.clearPid()
+      return
+    }
+
+    const pid = this.child.pid
+    if (process.platform === "win32" && this.opts.shell && pid) {
+      spawnSync("taskkill", ["/pid", String(pid), "/T", "/F"], { stdio: "ignore" })
+      this.child = null
+      await this.clearPid()
+      return
+    }
+
+    if (!this.child.killed) {
       this.child.kill("SIGTERM")
       // Give it 5s to exit gracefully, then SIGKILL.
       await new Promise<void>((resolve) => {
@@ -99,22 +130,43 @@ export class ProcessManager {
       ? `${this.opts.colour}[${this.opts.label}]${RESET} `
       : `[${this.opts.label}] `
 
+    const logLine = (line: string, stream: NodeJS.WriteStream): void => {
+      if (!line) return
+      if (this.opts.shouldLogLine && !this.opts.shouldLogLine(line)) return
+      if (this.opts.onLine) {
+        if (line !== this.lastLoggedLine) {
+          this.lastLoggedLine = line
+          this.opts.onLine(line, stream === process.stderr ? "stderr" : "stdout")
+        }
+        return
+      }
+      if (line === this.lastLoggedLine) return
+      this.lastLoggedLine = line
+      stream.write(prefix + line + "\n")
+    }
+
     this.child.stdout?.on("data", (chunk: Buffer) => {
       for (const line of chunk.toString().split("\n")) {
-        if (line) process.stdout.write(prefix + line + "\n")
+        logLine(line, process.stdout)
       }
     })
 
     this.child.stderr?.on("data", (chunk: Buffer) => {
       for (const line of chunk.toString().split("\n")) {
-        if (line) process.stderr.write(prefix + line + "\n")
+        logLine(line, process.stderr)
       }
     })
 
     this.child.once("error", (err) => {
       if (this.stopped) return
-      process.stderr.write(`${prefix}failed to start: ${err.message}\n`)
+      const message = `${prefix}failed to start: ${err.message}\n`
+      if (this.opts.onLine) {
+        this.opts.onLine(`failed to start: ${err.message}`, "stderr")
+      } else {
+        process.stderr.write(message)
+      }
       setTimeout(() => {
+        this.opts.beforeRestart?.()
         this.backoffMs = Math.min(this.backoffMs * 2, this.opts.maxBackoffMs)
         this.spawn()
       }, this.backoffMs)
@@ -129,11 +181,15 @@ export class ProcessManager {
       }
 
       const reason = signal ? `signal ${signal}` : `code ${code}`
-      process.stderr.write(
-        `${prefix}process exited (${reason}), restarting in ${this.backoffMs}ms\n`,
-      )
+      const restartMsg = `${prefix}process exited (${reason}), restarting in ${this.backoffMs}ms\n`
+      if (this.opts.onLine) {
+        this.opts.onLine(`process exited (${reason}), restarting in ${this.backoffMs}ms`, "stderr")
+      } else {
+        process.stderr.write(restartMsg)
+      }
 
       setTimeout(() => {
+        this.opts.beforeRestart?.()
         this.backoffMs = Math.min(this.backoffMs * 2, this.opts.maxBackoffMs)
         this.spawn()
       }, this.backoffMs)

package/src/project-config.ts

@@ -59,6 +59,16 @@ export interface SupatypeProjectConfig {
     postgrestPort?: number
     /** Domain for ACME TLS certificate (mode=standalone). */
     domain?: string
+    /**
+     * TLS for self-host HTTPS (Kong ACME / Let's Encrypt).
+     * Requires `mode: "standalone"` and a non-empty `domain`.
+     */
+    tls?: {
+      /** ACME contact email for Let's Encrypt (required to enable HTTPS). */
+      email?: string
+      /** "kong" (default) = Kong acme plugin; "none" = stay HTTP even with a domain. */
+      provider?: "kong" | "none"
+    }
   }
   app: {
     /**
@@ -85,10 +95,13 @@ export interface SupatypeProjectConfig {
     start?: string
   }
   /**
-   * Pinned binary versions per component. Use **`"local"`** with the matching **`overrides.*`**
-   * entry when testing a local build (Phase 10.7).
+   * Optional pins for engine, server, postgres, and deno.
+   * Omitted = resolve latest from CDN at runtime (native) or use Docker :latest.
+   * When set, native binaries cache under ~/.supatype/cache/{component}/{version}/
+   * and Docker image tags are synced to `.env` on `supatype dev` / `supatype push`.
+   * Use **`"local"`** with the matching **`overrides.*`** entry for contributor builds.
    */
-  versions: ComponentVersions
+  versions?: Partial<ComponentVersions>
   /**
    * Override component binaries with local build paths.
    * Intended for supatype contributors testing local changes.
@@ -198,6 +211,14 @@ export interface SupatypeProjectConfig {
     /** Custom response headers for the deployed static site. */
     headers?: Record<string, string>
   }
+  /**
+   * Persistent environment defaults for `resolveTarget()` when `--env` is omitted.
+   * Ephemeral schema branches (Phase 22) use `.supatype/branch.json`, not this block.
+   */
+  environments?: {
+    default?: string
+    branchDefaults?: Record<string, string>
+  }
   /**
    * Optional Postgres URL for CLI commands that talk to the DB (`push`, `migrate`, …).
    * When omitted, `DATABASE_URL` from the environment is used, then a local default DSN.
@@ -233,7 +254,9 @@ export function mergeProjectConfig(
     database: { ...base.database, ...override.database },
     server: { ...base.server, ...override.server },
     app: { ...base.app, ...override.app },
-    versions: { ...base.versions, ...override.versions },
+    ...(base.versions !== undefined || override.versions !== undefined
+      ? { versions: { ...base.versions, ...override.versions } }
+      : {}),
     ...(base.overrides !== undefined || override.overrides !== undefined
       ? {
           overrides: {
@@ -285,6 +308,23 @@ export function mergeProjectConfig(
     ...(base.admin !== undefined || override.admin !== undefined
       ? { admin: { ...base.admin, ...override.admin } as NonNullable<SupatypeProjectConfig["admin"]> }
       : {}),
+    ...(base.environments !== undefined || override.environments !== undefined
+      ? (() => {
+          const b = base.environments
+          const o = override.environments
+          const mergedBranchDefaults =
+            b?.branchDefaults !== undefined || o?.branchDefaults !== undefined
+              ? { ...(b?.branchDefaults ?? {}), ...(o?.branchDefaults ?? {}) }
+              : undefined
+          return {
+            environments: {
+              ...b,
+              ...o,
+              ...(mergedBranchDefaults !== undefined ? { branchDefaults: mergedBranchDefaults } : {}),
+            } as NonNullable<SupatypeProjectConfig["environments"]>,
+          }
+        })()
+      : {}),
   }
 }
 
@@ -307,9 +347,6 @@ export function validateProjectConfig(raw: unknown, filename: string): SupatypeP
   if (!cfg["app"]) {
     throw new Error(`${filename}: app section is required`)
   }
-  if (!cfg["versions"]) {
-    throw new Error(`${filename}: versions section is required`)
-  }
 
   return raw as SupatypeProjectConfig
 }
@@ -363,6 +400,24 @@ export function serverBaseUrl(cfg: SupatypeProjectConfig): string | undefined {
   }
 }
 
+/**
+ * True when `supatype self-host compose` should render Kong ACME TLS (Let's Encrypt).
+ * Gated on a real self-host render (not `supatype dev`), standalone mode, a non-empty
+ * domain, an ACME contact email, and `tls.provider !== "none"`.
+ */
+export function selfHostTlsEnabled(
+  cfg: SupatypeProjectConfig,
+  devLocal = false,
+): boolean {
+  if (devLocal) return false
+  if (cfg.server.mode !== "standalone") return false
+  const domain = cfg.server.domain?.trim()
+  if (!domain) return false
+  const tls = cfg.server.tls
+  if (!tls || tls.provider === "none") return false
+  return Boolean(tls.email?.trim())
+}
+
 /** Resolved runtime provider (`config.provider` ?? `database.provider` ?? native). */
 export function resolveRuntimeProvider(cfg: SupatypeProjectConfig): "native" | "docker" {
   return cfg.provider ?? cfg.database.provider ?? "native"

package/src/prompts.ts

@@ -0,0 +1,2 @@
+/** @deprecated Import from `./ui/prompts.js` or `./ui/index.js`. */
+export { printLogo, ensureNotCancelled, clack } from "./ui/prompts.js"