@supatype/cli 0.1.0-alpha.9 → 0.1.1

package/src/dev-log-bus.ts

@@ -0,0 +1,101 @@
+/**
+ * Per-task log buffers for `supatype dev` TUI mode.
+ */
+
+export type DevLogLevel = "log" | "warn" | "error"
+
+export interface DevTask {
+  id: string
+  title: string
+  lines: string[]
+  unread: boolean
+}
+
+const DEFAULT_MAX_LINES = 5_000
+
+export class DevLogBus {
+  private readonly tasks = new Map<string, DevTask>()
+  private readonly order: string[] = []
+  private readonly listeners = new Set<() => void>()
+  private focusedTaskId = "stack"
+
+  constructor(private readonly maxLines = DEFAULT_MAX_LINES) {
+    this.registerTask("stack", "supatype")
+  }
+
+  registerTask(id: string, title: string): void {
+    if (this.tasks.has(id)) return
+    this.tasks.set(id, { id, title, lines: [], unread: false })
+    this.order.push(id)
+    this.notify()
+  }
+
+  ensureTask(id: string, title = id): void {
+    this.registerTask(id, title)
+  }
+
+  getTaskOrder(): readonly string[] {
+    return this.order
+  }
+
+  getTask(id: string): DevTask | undefined {
+    return this.tasks.get(id)
+  }
+
+  getFocusedTaskId(): string {
+    return this.focusedTaskId
+  }
+
+  setFocusedTaskId(id: string): void {
+    if (!this.tasks.has(id)) return
+    this.focusedTaskId = id
+    const task = this.tasks.get(id)
+    if (task) task.unread = false
+    this.notify()
+  }
+
+  focusNext(): void {
+    const idx = this.order.indexOf(this.focusedTaskId)
+    const next = this.order[(idx + 1) % this.order.length]
+    if (next) this.setFocusedTaskId(next)
+  }
+
+  focusPrevious(): void {
+    const idx = this.order.indexOf(this.focusedTaskId)
+    const prev = this.order[(idx - 1 + this.order.length) % this.order.length]
+    if (prev) this.setFocusedTaskId(prev)
+  }
+
+  append(taskId: string, line: string, level: DevLogLevel = "log"): void {
+    this.ensureTask(taskId, taskId)
+    const task = this.tasks.get(taskId)
+    if (!task) return
+
+    const levelPrefix = level === "warn" ? "⚠ " : level === "error" ? "✗ " : ""
+    const parts = line.split(/\r?\n/)
+
+    for (const part of parts) {
+      if (part.length === 0) continue
+      const text = taskId === "stack" ? part.replace(/^\[supatype\]\s*/, "") : part
+      if (text.length === 0) continue
+      task.lines.push(levelPrefix + text)
+      if (task.lines.length > this.maxLines) {
+        task.lines.splice(0, task.lines.length - this.maxLines)
+      }
+    }
+
+    if (taskId !== this.focusedTaskId && parts.some((p) => p.length > 0)) {
+      task.unread = true
+    }
+    this.notify()
+  }
+
+  onUpdate(listener: () => void): () => void {
+    this.listeners.add(listener)
+    return () => this.listeners.delete(listener)
+  }
+
+  private notify(): void {
+    for (const listener of this.listeners) listener()
+  }
+}

package/src/dev-log-filter.ts

@@ -0,0 +1,32 @@
+/**
+ * Line filters for subprocess output during `supatype dev`.
+ */
+
+/** Strip ANSI SGR sequences for TUI rendering. */
+export function stripAnsi(text: string): string {
+  return text.replace(/\x1b\[[0-9;]*m/g, "")
+}
+
+/** Drop npm/vite noise from frontend dev servers (proxy app + Studio). */
+export function filterDevSubprocessLine(taskId: string, line: string): boolean {
+  if (taskId !== "app" && taskId !== "studio") return true
+  const trimmed = stripAnsi(line).trim()
+  if (!trimmed) return false
+  if (/^>\s+\S/.test(trimmed)) return false
+  if (trimmed.includes("Network:") && trimmed.includes("➜")) return false
+  return true
+}
+
+/** Format console.* arguments the way Node does for a single log line. */
+export function formatConsoleArgs(args: unknown[]): string {
+  return args
+    .map((arg) => {
+      if (typeof arg === "string") return arg
+      try {
+        return JSON.stringify(arg)
+      } catch {
+        return String(arg)
+      }
+    })
+    .join(" ")
+}

package/src/dev-logo.ts

@@ -0,0 +1,61 @@
+/**
+ * Supatype ASCII wordmark for the dev TUI header.
+ * Baked from `figlet -f slant supatype` → assets/supatype-logo-wordmark.ascii.txt
+ */
+
+import { existsSync, readFileSync } from "node:fs"
+import { dirname, join } from "node:path"
+import { fileURLToPath } from "node:url"
+import { BOLD, BRAND_COLOR, RESET } from "./ui/brand.js"
+
+const EMBEDDED_LOGO_WORDMARK = [
+  "                           __                 ",
+  "   _______  ______  ____ _/ /___  ______  ___ ",
+  "  / ___/ / / / __ \\/ __ `/ __/ / / / __ \\/ _ \\",
+  " (__  ) /_/ / /_/ / /_/ / /_/ /_/ / /_/ /  __/",
+  "/____/\\__,_/ .___/\\__,_/\\__/\\__, / .___/\\___/ ",
+  "          /_/              /____/_/           ",
+] as const
+
+function readLogoFile(basename: string): readonly string[] | null {
+  const here = dirname(fileURLToPath(import.meta.url))
+  const candidates = [
+    join(here, "assets", basename),
+    join(here, "..", "assets", basename),
+  ]
+  for (const path of candidates) {
+    if (!existsSync(path)) continue
+    const lines = readFileSync(path, "utf8")
+      .split(/\r?\n/)
+      .map((line) => (line.endsWith("\r") ? line.slice(0, -1) : line))
+      .filter((line) => line.length > 0)
+    if (lines.length > 0) return lines
+  }
+  return null
+}
+
+function loadWordmarkLogoLines(): readonly string[] {
+  const fromFile = readLogoFile("supatype-logo-wordmark.ascii.txt")
+  if (fromFile) return fromFile
+  return [...EMBEDDED_LOGO_WORDMARK]
+}
+
+/** Figlet slant wordmark (~46×6). */
+export const SUPATYPE_ASCII_LOGO_WORDMARK = loadWordmarkLogoLines()
+
+export function pickLogoLines(): readonly string[] {
+  return SUPATYPE_ASCII_LOGO_WORDMARK
+}
+
+export function logoRowCount(): number {
+  return pickLogoLines().length
+}
+
+/** Return logo rows exactly as authored (spaces preserved). */
+export function layoutLogoBlock(lines: readonly string[]): string[] {
+  return [...lines]
+}
+
+export function colorLogoLines(lines: readonly string[]): string[] {
+  return lines.map((line) => `${BRAND_COLOR}${BOLD}${line}${RESET}`)
+}

package/src/dev-ports.ts

@@ -0,0 +1,212 @@
+/**
+ * Kong / Postgres host port resolution for local Docker dev.
+ * Persists SUPATYPE_KONG_PORT in `.env` so re-runs are stable, but re-checks
+ * availability so multiple projects and port collisions are surfaced clearly.
+ */
+
+import * as p from "@clack/prompts"
+import { COMPOSE_DEV_KONG_PORT } from "./project-config.js"
+import { isPortInUse } from "./postgres-ctl.js"
+import { readEnvInt, upsertEnvFile } from "./env-file.js"
+import { isInteractive } from "./ui/interactive.js"
+import { fatalError } from "./ui/fatal.js"
+
+const MIN_PORT = 1024
+const MAX_PORT = 65535
+
+export function isValidHostPort(port: number): boolean {
+  return Number.isInteger(port) && port >= MIN_PORT && port <= MAX_PORT
+}
+
+export function parseHostPortInput(raw: string): number | null {
+  const port = Number(raw.trim())
+  return isValidHostPort(port) ? port : null
+}
+
+/** Next free TCP port on 127.0.0.1 starting at `start`. */
+export async function findNextFreePort(start: number): Promise<number> {
+  let port = Math.max(MIN_PORT, start)
+  while (port <= MAX_PORT && (await isPortInUse(port))) port++
+  if (port > MAX_PORT) {
+    throw new Error(`No free local port found in range ${start}–${MAX_PORT}.`)
+  }
+  return port
+}
+
+export function readPersistedKongPort(cwd: string): number | null {
+  return readEnvInt(cwd, "SUPATYPE_KONG_PORT")
+}
+
+function persistKongPort(cwd: string, port: number): void {
+  const apiUrl = `http://localhost:${port}`
+  upsertEnvFile(cwd, {
+    SUPATYPE_KONG_PORT: String(port),
+    PUBLIC_SUPATYPE_URL: apiUrl,
+    API_EXTERNAL_URL: apiUrl,
+    SITE_URL: apiUrl,
+  })
+}
+
+async function promptPortConflict(
+  cwd: string,
+  blockedPort: number,
+  reason: "in_use" | "init",
+): Promise<number> {
+  const port = await promptPortConflictWithoutPersist(blockedPort, reason)
+  persistKongPort(cwd, port)
+  return port
+}
+
+export interface EnsureKongPortOptions {
+  /** When false, fail fast instead of prompting (CI / scripts). */
+  interactive?: boolean
+  /** init wizard — slightly different copy */
+  context?: "dev" | "init"
+}
+
+/**
+ * Resolve the Kong host port for this project directory.
+ * - Uses `.env` when set and available.
+ * - Prompts (or errors) when the configured port is taken.
+ * - Auto-picks the next free port on first run when unset.
+ */
+export async function ensureKongPort(
+  cwd: string,
+  opts: EnsureKongPortOptions = {},
+): Promise<number> {
+  const interactive = opts.interactive ?? isInteractive()
+  const context = opts.context ?? "dev"
+  const persisted = readPersistedKongPort(cwd)
+
+  if (persisted !== null) {
+    if (!(await isPortInUse(persisted))) return persisted
+
+    if (!interactive) {
+      fatalError(`Port ${persisted} is already in use (SUPATYPE_KONG_PORT in .env).`, [
+        "Stop the other service or set a different SUPATYPE_KONG_PORT.",
+        "Run `supatype dev` in a terminal to pick a new port interactively.",
+      ])
+    }
+
+    return promptPortConflict(cwd, persisted, "in_use")
+  }
+
+  const preferred = COMPOSE_DEV_KONG_PORT
+  const port =
+    (await isPortInUse(preferred))
+      ? interactive && context === "init"
+        ? await promptPortConflict(cwd, preferred, "init")
+        : await findNextFreePort(preferred)
+      : preferred
+
+  return port
+}
+
+/** Wizard / init — pick a Kong port without writing `.env` (scaffold writes it). */
+export async function promptKongPortChoice(): Promise<number> {
+  const freeDefault = (await isPortInUse(COMPOSE_DEV_KONG_PORT))
+    ? await findNextFreePort(COMPOSE_DEV_KONG_PORT)
+    : COMPOSE_DEV_KONG_PORT
+
+  const value = await p.text({
+    message: "Local API gateway port (Kong)",
+    defaultValue: String(freeDefault),
+    placeholder: String(COMPOSE_DEV_KONG_PORT),
+    validate: (raw) => {
+      const port = parseHostPortInput(raw ?? "")
+      if (!port) return `Enter a port between ${MIN_PORT} and ${MAX_PORT}.`
+      return undefined
+    },
+  })
+
+  if (p.isCancel(value)) {
+    p.cancel("Cancelled.")
+    process.exit(0)
+  }
+
+  const port = parseHostPortInput(value)!
+  if (await isPortInUse(port)) {
+    return promptPortConflictWithoutPersist(port, "init")
+  }
+  return port
+}
+
+async function promptPortConflictWithoutPersist(
+  blockedPort: number,
+  reason: "in_use" | "init",
+): Promise<number> {
+  const suggested = await findNextFreePort(blockedPort + 1)
+  const headline =
+    reason === "init"
+      ? `Port ${blockedPort} is already in use on this machine.`
+      : `Port ${blockedPort} is in use — another Supatype project or service may already be bound to it.`
+
+  const choice = await p.select<"suggested" | "custom" | "cancel">({
+    message: headline,
+    options: [
+      {
+        value: "suggested",
+        label: `Use ${suggested} instead`,
+        hint: "next available port",
+      },
+      { value: "custom", label: "Enter a different port" },
+      { value: "cancel", label: "Cancel" },
+    ],
+  })
+
+  if (p.isCancel(choice) || choice === "cancel") {
+    p.cancel("Cancelled.")
+    process.exit(0)
+  }
+
+  if (choice === "suggested") return suggested
+
+  const custom = await p.text({
+    message: "Local API gateway port (Kong)",
+    defaultValue: String(suggested),
+    validate: (value) => {
+      const port = parseHostPortInput(value ?? "")
+      if (!port) return `Enter a port between ${MIN_PORT} and ${MAX_PORT}.`
+      return undefined
+    },
+  })
+
+  if (p.isCancel(custom)) {
+    p.cancel("Cancelled.")
+    process.exit(0)
+  }
+
+  const port = parseHostPortInput(custom)
+  if (!port) {
+    p.cancel("Invalid port.")
+    process.exit(1)
+  }
+
+  if (await isPortInUse(port)) {
+    fatalError(`Port ${port} is still in use.`, [
+      "Pick another port or stop the service using it.",
+      "Check Docker Desktop for other Supatype stacks.",
+    ])
+  }
+
+  return port
+}
+
+const COMPOSE_DEV_DB_PORT = 54329
+
+export async function ensureDevDbPort(cwd: string): Promise<number> {
+  const persisted = readEnvInt(cwd, "SUPATYPE_DEV_DB_PORT")
+  if (persisted !== null) {
+    if (!(await isPortInUse(persisted))) return persisted
+    const next = await findNextFreePort(persisted + 1)
+    upsertEnvFile(cwd, {
+      SUPATYPE_DEV_DB_PORT: String(next),
+      DATABASE_URL: `postgresql://supatype_admin:postgres@localhost:${next}/supatype?sslmode=disable`,
+    })
+    return next
+  }
+
+  let port = COMPOSE_DEV_DB_PORT
+  while (await isPortInUse(port)) port++
+  return port
+}

package/src/dev-session-lock.ts

@@ -0,0 +1,101 @@
+/**
+ * Tracks an active `supatype dev` session so we can recover when the CLI exits
+ * without graceful shutdown (terminal closed, kill signal, etc.).
+ */
+
+import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs"
+import { join, resolve } from "node:path"
+import { spawnSync } from "node:child_process"
+import * as p from "@clack/prompts"
+import { runDockerCompose } from "./self-host-compose.js"
+import { isInteractive } from "./ui/interactive.js"
+import { warn } from "./ui/messages.js"
+
+const LOCK_VERSION = 1 as const
+
+export interface DevSessionLock {
+  version: typeof LOCK_VERSION
+  composeProject: string
+  projectRef: string
+  composePath: string
+  kongPort: number
+  startedAt: string
+}
+
+export function devSessionLockPath(cwd: string): string {
+  return resolve(cwd, ".supatype/dev-session.json")
+}
+
+export function readDevSessionLock(cwd: string): DevSessionLock | null {
+  const path = devSessionLockPath(cwd)
+  if (!existsSync(path)) return null
+  try {
+    const data = JSON.parse(readFileSync(path, "utf8")) as DevSessionLock
+    if (data.version !== LOCK_VERSION) return null
+    return data
+  } catch {
+    return null
+  }
+}
+
+export function writeDevSessionLock(cwd: string, lock: Omit<DevSessionLock, "version">): void {
+  const dir = join(cwd, ".supatype")
+  mkdirSync(dir, { recursive: true })
+  const payload: DevSessionLock = { version: LOCK_VERSION, ...lock }
+  writeFileSync(devSessionLockPath(cwd), `${JSON.stringify(payload, null, 2)}\n`, "utf8")
+}
+
+export function clearDevSessionLock(cwd: string): void {
+  const path = devSessionLockPath(cwd)
+  if (existsSync(path)) unlinkSync(path)
+}
+
+export function composeStackHasContainers(composeProject: string): boolean {
+  const result = spawnSync(
+    "docker",
+    ["ps", "-a", "--filter", `label=com.docker.compose.project=${composeProject}`, "--format", "{{.Names}}"],
+    { encoding: "utf8", shell: process.platform === "win32" },
+  )
+  return Boolean(result.stdout?.trim())
+}
+
+/**
+ * When a previous dev session did not shut down cleanly, offer to stop its stack
+ * before starting a new one.
+ */
+export async function recoverStaleDevSession(cwd: string): Promise<void> {
+  const lock = readDevSessionLock(cwd)
+  if (!lock) return
+  if (!composeStackHasContainers(lock.composeProject)) {
+    clearDevSessionLock(cwd)
+    return
+  }
+
+  const message =
+    `Previous dev session for "${lock.projectRef}" may not have shut down cleanly ` +
+    `(stack "${lock.composeProject}" is still running).`
+
+  if (!isInteractive()) {
+    warn(message)
+    warn(`Stop it manually: docker compose -p ${lock.composeProject} down`)
+    return
+  }
+
+  const stop = await p.confirm({
+    message: `${message}\n\nStop the orphaned stack before starting?`,
+    initialValue: true,
+  })
+
+  if (p.isCancel(stop) || !stop) {
+    warn(`Leaving "${lock.composeProject}" running.`)
+    return
+  }
+
+  const status = runDockerCompose(lock.composePath, ["down"], cwd, lock.composeProject, { quiet: true })
+  if (status === 0) {
+    clearDevSessionLock(cwd)
+    p.log.success(`Stopped orphaned stack "${lock.composeProject}".`)
+  } else {
+    warn(`Could not stop "${lock.composeProject}" (exit ${status}).`)
+  }
+}

package/src/dev-session.ts

@@ -0,0 +1,130 @@
+/**
+ * `supatype dev` output session — TUI (default) or interleaved stream mode.
+ */
+
+import type { ProcessOptions } from "./process-manager.js"
+import { filterDevSubprocessLine, formatConsoleArgs } from "./dev-log-filter.js"
+import { DevLogBus, type DevLogLevel } from "./dev-log-bus.js"
+import { DevTui } from "./dev-tui.js"
+
+export type DevUiMode = "tui" | "stream"
+
+export function resolveDevUiMode(streamFlag: boolean): DevUiMode {
+  if (streamFlag) return "stream"
+  if (!process.stdout.isTTY || !process.stdin.isTTY) return "stream"
+  return "tui"
+}
+
+let activeSession: DevSession | null = null
+
+export function beginDevSession(mode: DevUiMode): DevSession {
+  activeSession?.stop()
+  activeSession = new DevSession(mode)
+  return activeSession
+}
+
+/** Enter console capture + TUI. */
+export function startDevSession(): void {
+  activeSession?.start()
+}
+
+export function endDevSession(): void {
+  activeSession?.stop()
+  activeSession = null
+}
+
+export function getActiveDevSession(): DevSession | null {
+  return activeSession
+}
+
+/** Log to a TUI task stream, or prefixed console output in stream mode. */
+export function appendDevTaskLog(
+  taskId: string,
+  taskTitle: string,
+  line: string,
+  level: DevLogLevel = "log",
+): void {
+  const session = getActiveDevSession()
+  if (session?.isTui()) {
+    session.bus.ensureTask(taskId, taskTitle)
+    session.bus.append(taskId, line, level)
+    return
+  }
+  const prefix = taskId === "stack" ? "[supatype]" : `[${taskId}]`
+  const write = level === "warn" ? console.warn : level === "error" ? console.error : console.log
+  write(`${prefix} ${line}`)
+}
+
+export class DevSession {
+  readonly bus = new DevLogBus()
+  readonly mode: DevUiMode
+  private tui: DevTui | null = null
+  private restoreConsole: (() => void) | null = null
+
+  constructor(mode: DevUiMode) {
+    this.mode = mode
+  }
+
+  isTui(): boolean {
+    return this.mode === "tui"
+  }
+
+  start(): void {
+    if (!this.isTui()) return
+    this.restoreConsole = patchConsole(this.bus)
+    this.tui = new DevTui(this.bus)
+    this.tui.start()
+  }
+
+  stop(): void {
+    this.tui?.stop()
+    this.tui = null
+    this.restoreConsole?.()
+    this.restoreConsole = null
+  }
+}
+
+export function enhanceProcessOptions(label: string, opts: ProcessOptions): ProcessOptions {
+  const session = getActiveDevSession()
+  const subprocessFilter =
+    label === "app" || label === "studio"
+      ? { shouldLogLine: (line: string) => filterDevSubprocessLine(label, line) }
+      : {}
+
+  if (!session?.isTui()) {
+    return { ...opts, ...subprocessFilter }
+  }
+
+  session.bus.ensureTask(label, label)
+  return {
+    ...opts,
+    ...subprocessFilter,
+    onLine: (line, stream) => {
+      session.bus.append(label, line, stream === "stderr" ? "error" : "log")
+    },
+  }
+}
+
+function patchConsole(bus: DevLogBus): () => void {
+  const original = {
+    log: console.log,
+    warn: console.warn,
+    error: console.error,
+  }
+
+  console.log = (...args: unknown[]) => {
+    bus.append("stack", formatConsoleArgs(args), "log")
+  }
+  console.warn = (...args: unknown[]) => {
+    bus.append("stack", formatConsoleArgs(args), "warn")
+  }
+  console.error = (...args: unknown[]) => {
+    bus.append("stack", formatConsoleArgs(args), "error")
+  }
+
+  return () => {
+    console.log = original.log
+    console.warn = original.warn
+    console.error = original.error
+  }
+}