@supatype/cli 0.1.0 → 0.1.2

package/src/dev-ports.ts

@@ -0,0 +1,223 @@
+/**
+ * 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 { CLACK_CANCEL, isCancel, p } from "./ui/clack.js"
+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 (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 (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 (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
+
+function devDbConnectionUrl(port: number): string {
+  return `postgresql://supatype_admin:postgres@localhost:${port}/supatype?sslmode=disable`
+}
+
+export async function ensureDevDbPort(cwd: string): Promise<number> {
+  const persisted = readEnvInt(cwd, "SUPATYPE_DEV_DB_PORT")
+
+  const persist = (port: number): number => {
+    upsertEnvFile(cwd, {
+      SUPATYPE_DEV_DB_PORT: String(port),
+      DATABASE_URL: devDbConnectionUrl(port),
+    })
+    return port
+  }
+
+  if (persisted !== null) {
+    if (!(await isPortInUse(persisted))) return persisted
+    const next = await findNextFreePort(persisted + 1)
+    return persist(next)
+  }
+
+  let port = COMPOSE_DEV_DB_PORT
+  if (await isPortInUse(port)) {
+    port = await findNextFreePort(port + 1)
+  }
+  return persist(port)
+}

package/src/dev-ready-panel.ts

@@ -0,0 +1,63 @@
+/**
+ * Pinned service URLs + dev keys for the Ink dashboard.
+ */
+
+import { appendStackOutput, getActiveDevSession } from "./dev-session.js"
+
+export interface DevServiceLink {
+  label: string
+  url: string
+}
+
+export interface DevReadyPanel {
+  title: string
+  links: DevServiceLink[]
+  anonKey?: string
+  serviceRoleKey?: string
+  hints?: string[]
+}
+
+/** Ink row budget for DevReadyPanelView (border, title, links, hints, keys, margin). */
+export function devReadyPanelRowCount(panel: DevReadyPanel): number {
+  let rows = 2 // round border top + bottom
+  rows += 1 // title
+  rows += panel.links.length
+  for (const hint of panel.hints ?? []) {
+    if (hint.trim()) rows += 1
+  }
+  if (panel.anonKey) {
+    rows += 1 // "API keys (local dev)"
+    rows += 1 // anon
+    if (panel.serviceRoleKey) rows += 1 // service_role
+  }
+  rows += 1 // marginBottom on panel box
+  return rows
+}
+
+function formatStreamBlock(panel: DevReadyPanel): string {
+  const lines = [`[supatype] ${panel.title}`]
+  for (const link of panel.links) {
+    lines.push(`  ${link.label.padEnd(16)} ${link.url}`)
+  }
+  for (const hint of panel.hints ?? []) {
+    lines.push(`  ${hint}`)
+  }
+  if (panel.anonKey) {
+    lines.push("  API keys (local dev only):")
+    lines.push(`    anon key       ${panel.anonKey}`)
+    lines.push(`    service_role   ${panel.serviceRoleKey ?? ""}`)
+  }
+  lines.push("  Press Ctrl+C to stop.")
+  return lines.join("\n")
+}
+
+/** Pin links in the TUI or print the classic block in stream mode. */
+export function publishDevReady(panel: DevReadyPanel): void {
+  const session = getActiveDevSession()
+  if (session?.isTui()) {
+    session.bus.setReadyPanel(panel)
+    appendStackOutput("Services running.", "log")
+    return
+  }
+  console.log(formatStreamBlock(panel))
+}

package/src/dev-session-lock.ts

@@ -0,0 +1,98 @@
+/**
+ * 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 { runDockerCompose } from "./self-host-compose.js"
+import { confirm as uiConfirm } from "./ui/confirm.js"
+import { success, warn } from "./ui/messages.js"
+import { isInteractive } from "./ui/interactive.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 uiConfirm(`${message}\n\nStop the orphaned stack before starting?`, { default: true })
+
+  if (!stop) {
+    warn(`Leaving "${lock.composeProject}" running.`)
+    return
+  }
+
+  const status = runDockerCompose(lock.composePath, ["down"], cwd, lock.composeProject, { quiet: true })
+  if (status === 0) {
+    clearDevSessionLock(cwd)
+    success(`Stopped orphaned stack "${lock.composeProject}".`)
+  } else {
+    warn(`Could not stop "${lock.composeProject}" (exit ${status}).`)
+  }
+}

package/src/dev-session.ts

@@ -1,11 +1,15 @@
 /**
- * `supatype dev` output session — TUI (default) or interleaved stream mode.
+ * `supatype dev` output session — Ink dashboard (default) or interleaved stream mode.
  */
 
+import { render, type Instance } from "ink"
+import React from "react"
 import type { ProcessOptions } from "./process-manager.js"
-import { filterDevSubprocessLine, formatConsoleArgs } from "./dev-log-filter.js"
+import { filterDevSubprocessLine, filterStackLogLine, formatConsoleArgs } from "./dev-log-filter.js"
 import { DevLogBus, type DevLogLevel } from "./dev-log-bus.js"
-import { DevTui } from "./dev-tui.js"
+import { DevDashboard } from "./ui/dev/DevDashboard.js"
+import { ensureDevShutdownHooks } from "./dev-shutdown.js"
+import { clearDevPromptQueue } from "./ui/runtime/dev-prompt-queue.js"
 
 export type DevUiMode = "tui" | "stream"
 
@@ -18,26 +22,74 @@ export function resolveDevUiMode(streamFlag: boolean): DevUiMode {
 let activeSession: DevSession | null = null
 
 export function beginDevSession(mode: DevUiMode): DevSession {
+  ensureDevShutdownHooks()
   activeSession?.stop()
   activeSession = new DevSession(mode)
+  if (activeSession.isTui()) {
+    activeSession.enableConsoleCapture(false)
+    activeSession.startInk()
+  }
   return activeSession
 }
 
-/** Enter console capture + TUI. */
+/** @deprecated Ink starts in beginDevSession — kept for callers that invoke late. */
 export function startDevSession(): void {
-  activeSession?.start()
+  activeSession?.startInk()
+}
+
+export function isDevTuiActive(): boolean {
+  return activeSession?.isInkMounted() ?? false
 }
 
 export function endDevSession(): void {
+  clearDevPromptQueue()
   activeSession?.stop()
   activeSession = null
 }
 
+/** @deprecated Dev prompts render inside the Ink dashboard — no suspend needed. */
+export function suspendDevSessionForPrompt(): void {
+  prepareStdinForInteractivePrompt()
+}
+
+export function prepareStdinForInteractivePrompt(): void {
+  if (!process.stdin.isTTY) return
+  process.stdin.setRawMode(false)
+  process.stdin.resume()
+}
+
+/** @deprecated Dev prompts render inside the Ink dashboard — no resume needed. */
+export function resumeDevSessionAfterPrompt(): void {
+  // no-op — prompts are Ink overlays
+}
+
+/** @deprecated Use Ink overlay prompts — runs fn without tearing down the dashboard. */
+export async function withDevSessionSuspended<T>(fn: () => Promise<T>): Promise<T> {
+  return fn()
+}
+
 export function getActiveDevSession(): DevSession | null {
   return activeSession
 }
 
-/** Log to a TUI task stream, or prefixed console output in stream mode. */
+export function appendStackOutput(
+  text: string | null | undefined,
+  level: DevLogLevel = "log",
+): void {
+  if (text == null || text.trim() === "") return
+  const session = getActiveDevSession()
+  for (const line of text.split(/\r?\n/)) {
+    if (line.trim() === "") continue
+    if (session?.isTui() && !filterStackLogLine(line)) continue
+    if (session?.isConsoleCaptured()) {
+      session.bus.append("stack", line, level)
+      continue
+    }
+    const write = level === "warn" ? console.warn : level === "error" ? console.error : console.log
+    write(`[supatype] ${line}`)
+  }
+}
+
 export function appendDevTaskLog(
   taskId: string,
   taskTitle: string,
@@ -58,8 +110,9 @@ export function appendDevTaskLog(
 export class DevSession {
   readonly bus = new DevLogBus()
   readonly mode: DevUiMode
-  private tui: DevTui | null = null
+  private ink: Instance | null = null
   private restoreConsole: (() => void) | null = null
+  private consoleCaptured = false
 
   constructor(mode: DevUiMode) {
     this.mode = mode
@@ -69,18 +122,37 @@ export class DevSession {
     return this.mode === "tui"
   }
 
-  start(): void {
-    if (!this.isTui()) return
+  isInkMounted(): boolean {
+    return this.ink !== null
+  }
+
+  isConsoleCaptured(): boolean {
+    return this.consoleCaptured
+  }
+
+  needsPromptSuspend(): boolean {
+    return false
+  }
+
+  enableConsoleCapture(_tee: boolean): void {
+    if (!this.isTui() || this.consoleCaptured) return
     this.restoreConsole = patchConsole(this.bus)
-    this.tui = new DevTui(this.bus)
-    this.tui.start()
+    this.consoleCaptured = true
+  }
+
+  startInk(): void {
+    if (!this.isTui() || this.ink) return
+    this.ink = render(React.createElement(DevDashboard, { bus: this.bus }))
   }
 
   stop(): void {
-    this.tui?.stop()
-    this.tui = null
-    this.restoreConsole?.()
-    this.restoreConsole = null
+    this.ink?.unmount()
+    this.ink = null
+    if (this.restoreConsole) {
+      this.restoreConsole()
+      this.restoreConsole = null
+      this.consoleCaptured = false
+    }
   }
 }
 
@@ -105,6 +177,14 @@ export function enhanceProcessOptions(label: string, opts: ProcessOptions): Proc
   }
 }
 
+function appendFilteredStackLine(bus: DevLogBus, line: string, level: DevLogLevel): void {
+  for (const part of line.split(/\r?\n/)) {
+    if (!part.trim()) continue
+    if (!filterStackLogLine(part)) continue
+    bus.append("stack", part, level)
+  }
+}
+
 function patchConsole(bus: DevLogBus): () => void {
   const original = {
     log: console.log,
@@ -113,13 +193,13 @@ function patchConsole(bus: DevLogBus): () => void {
   }
 
   console.log = (...args: unknown[]) => {
-    bus.append("stack", formatConsoleArgs(args), "log")
+    appendFilteredStackLine(bus, formatConsoleArgs(args), "log")
   }
   console.warn = (...args: unknown[]) => {
-    bus.append("stack", formatConsoleArgs(args), "warn")
+    appendFilteredStackLine(bus, formatConsoleArgs(args), "warn")
   }
   console.error = (...args: unknown[]) => {
-    bus.append("stack", formatConsoleArgs(args), "error")
+    appendFilteredStackLine(bus, formatConsoleArgs(args), "error")
   }
 
   return () => {