@supatype/cli 0.1.1 → 0.1.3

package/src/dev-ports.ts

@@ -4,7 +4,7 @@
  * availability so multiple projects and port collisions are surfaced clearly.
  */
 
-import * as p from "@clack/prompts"
+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"
@@ -119,7 +119,7 @@ export async function promptKongPortChoice(): Promise<number> {
     },
   })
 
-  if (p.isCancel(value)) {
+  if (isCancel(value)) {
     p.cancel("Cancelled.")
     process.exit(0)
   }
@@ -154,7 +154,7 @@ async function promptPortConflictWithoutPersist(
     ],
   })
 
-  if (p.isCancel(choice) || choice === "cancel") {
+  if (isCancel(choice) || choice === "cancel") {
     p.cancel("Cancelled.")
     process.exit(0)
   }
@@ -171,7 +171,7 @@ async function promptPortConflictWithoutPersist(
     },
   })
 
-  if (p.isCancel(custom)) {
+  if (isCancel(custom)) {
     p.cancel("Cancelled.")
     process.exit(0)
   }
@@ -194,19 +194,30 @@ async function promptPortConflictWithoutPersist(
 
 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)
-    upsertEnvFile(cwd, {
-      SUPATYPE_DEV_DB_PORT: String(next),
-      DATABASE_URL: `postgresql://supatype_admin:postgres@localhost:${next}/supatype?sslmode=disable`,
-    })
-    return next
+    return persist(next)
   }
 
   let port = COMPOSE_DEV_DB_PORT
-  while (await isPortInUse(port)) port++
-  return port
+  if (await isPortInUse(port)) {
+    port = await findNextFreePort(port + 1)
+  }
+  return persist(port)
 }

package/src/dev-ready-panel.ts

@@ -0,0 +1,80 @@
+/**
+ * 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
+}
+
+/** Shorter panel when the terminal is too small for every service row. */
+export function devReadyPanelCompactRowCount(panel: DevReadyPanel): number {
+  let rows = 2 // border
+  rows += 1 // title
+  rows += 2 // gateway + studio summary
+  for (const hint of panel.hints ?? []) {
+    if (hint.trim()) rows += 1
+  }
+  if (panel.anonKey) {
+    rows += 1
+    rows += 1
+    if (panel.serviceRoleKey) rows += 1
+  }
+  rows += 1 // marginBottom
+  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

@@ -6,10 +6,10 @@
 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 { confirm as uiConfirm } from "./ui/confirm.js"
+import { success, warn } from "./ui/messages.js"
 import { isInteractive } from "./ui/interactive.js"
-import { warn } from "./ui/messages.js"
 
 const LOCK_VERSION = 1 as const
 
@@ -81,12 +81,9 @@ export async function recoverStaleDevSession(cwd: string): Promise<void> {
     return
   }
 
-  const stop = await p.confirm({
-    message: `${message}\n\nStop the orphaned stack before starting?`,
-    initialValue: true,
-  })
+  const stop = await uiConfirm(`${message}\n\nStop the orphaned stack before starting?`, { default: true })
 
-  if (p.isCancel(stop) || !stop) {
+  if (!stop) {
     warn(`Leaving "${lock.composeProject}" running.`)
     return
   }
@@ -94,7 +91,7 @@ export async function recoverStaleDevSession(cwd: string): Promise<void> {
   const status = runDockerCompose(lock.composePath, ["down"], cwd, lock.composeProject, { quiet: true })
   if (status === 0) {
     clearDevSessionLock(cwd)
-    p.log.success(`Stopped orphaned stack "${lock.composeProject}".`)
+    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 () => {

package/src/dev-shutdown.ts

@@ -21,8 +21,28 @@ let shuttingDown = false
 let shutdownCompleted = false
 let forceQuitRequested = false
 let hooksRegistered = false
+let ignoreSigintUntil = 0
+
+/** SIGINT/SIGTERM hooks — call as soon as `supatype dev` starts (before compose is up). */
+export function ensureDevShutdownHooks(): void {
+  if (hooksRegistered) return
+  hooksRegistered = true
+
+  process.on("SIGINT", onSignal)
+  process.on("SIGTERM", onSignal)
+  if (process.platform === "win32") {
+    process.on("SIGBREAK", onSignal)
+  }
+  process.on("exit", onProcessExit)
+
+  if (process.stdin.isTTY) {
+    process.stdin.on("end", onStdinClose)
+    process.stdin.on("close", onStdinClose)
+  }
+}
 
 function onSignal(): void {
+  if (Date.now() < ignoreSigintUntil) return
   void runDevShutdown()
 }
 
@@ -66,25 +86,12 @@ export function registerDevShutdown(
   shutdownWork = work
   composeFallback = opts?.compose ?? null
   shutdownCwd = opts?.cwd ?? opts?.compose?.cwd ?? null
-
-  if (hooksRegistered) return
-  hooksRegistered = true
-
-  process.on("SIGINT", onSignal)
-  process.on("SIGTERM", onSignal)
-  if (process.platform === "win32") {
-    process.on("SIGBREAK", onSignal)
-  }
-  process.on("exit", onProcessExit)
-
-  if (process.stdin.isTTY) {
-    process.stdin.on("end", onStdinClose)
-    process.stdin.on("close", onStdinClose)
-  }
+  ensureDevShutdownHooks()
 }
 
 /** TUI Ctrl+C — do not re-emit SIGINT (avoids double-fire on Windows raw mode). */
 export function requestDevShutdown(): void {
+  ignoreSigintUntil = Date.now() + 400
   void runDevShutdown()
 }
 
@@ -101,6 +108,7 @@ export function resetDevShutdownForTests(): void {
   shutdownCompleted = false
   forceQuitRequested = false
   hooksRegistered = false
+  ignoreSigintUntil = 0
 }
 
 async function runDevShutdown(): Promise<void> {
@@ -125,8 +133,12 @@ async function runDevShutdown(): Promise<void> {
 
   try {
     endDevSession()
-    process.stdout.write("\n")
-    await shutdownWork?.()
+    process.stderr.write("\n[supatype] Shutting down…\n")
+    if (!shutdownWork) {
+      if (shutdownCwd) clearDevSessionLock(shutdownCwd)
+      process.exit(130)
+    }
+    await shutdownWork()
     shutdownCompleted = true
     if (shutdownCwd) clearDevSessionLock(shutdownCwd)
     process.exit(0)

package/src/dev-task-colors.ts

@@ -41,7 +41,26 @@ export function colorizeLogLine(taskId: string, line: string): string {
   return `${base}${line}${RESET}`
 }
 
-export function colorizeTaskLabel(taskId: string, label: string, focused: boolean): string {
-  const style = focused ? BOLD + taskColor(taskId) : taskColor(taskId)
-  return `${style}${label}${RESET}`
+/** Ink colour names for React components (parallel to ANSI taskColor). */
+export function taskInkColor(taskId: string): string {
+  switch (taskId) {
+    case "stack":
+      return "magenta"
+    case "app":
+      return "green"
+    case "studio":
+      return "cyan"
+    case "server":
+      return "green"
+    case "postgrest":
+      return "blue"
+    default:
+      return "white"
+  }
+}
+
+export function logInkColor(taskId: string, line: string): string {
+  if (line.startsWith("✗ ")) return "red"
+  if (line.startsWith("⚠ ")) return "yellow"
+  return taskInkColor(taskId)
 }

package/src/docker-runtime.ts

@@ -7,7 +7,7 @@ import { platform } from "node:os"
 import { endDevSession, getActiveDevSession } from "./dev-session.js"
 import { isInteractive } from "./ui/interactive.js"
 import { error, plain } from "./ui/messages.js"
-import { clack as p, printLogo } from "./ui/prompts.js"
+import { p, printLogo } from "./ui/prompts.js"
 
 export type DockerDaemonProbe =
   | { ok: true }

package/src/engine-push-output.ts

@@ -59,6 +59,10 @@ export function formatEnginePushMessage(result: EnginePushResult): string {
 const COMPOSE_PROGRESS_LINE =
   /^Container\s+.+\s+(Running|Waiting|Healthy|Created|Starting|Started|Exited|Stopped)\s*$/i
 
+export function isComposeProgressLine(line: string): boolean {
+  return COMPOSE_PROGRESS_LINE.test(line.trim())
+}
+
 /** Drop docker compose progress noise; keep engine JSON and real errors. */
 export function filterComposeNoise(output: string): string {
   return output
@@ -67,7 +71,7 @@ export function filterComposeNoise(output: string): string {
     .filter((line) => {
       const t = line.trim()
       if (!t) return false
-      if (COMPOSE_PROGRESS_LINE.test(t)) return false
+      if (isComposeProgressLine(t)) return false
       return true
     })
     .join("\n")

package/src/ensure-binary.ts

@@ -7,8 +7,10 @@ import {
   download,
   currentPlatform,
   resolveVersionFor,
+  isCachedBinaryReady,
   type Component,
 } from "./binary-cache.js"
+import { isDownloadInProgress, waitForComponentDownload } from "./binary-download-lock.js"
 import type { SupatypeProjectConfig } from "./project-config.js"
 
 export async function ensureBinary(
@@ -24,5 +26,23 @@ export async function ensureBinary(
     }
   }
 
-  return download(component, await resolveVersionFor(component, config), currentPlatform())
+  const version = await resolveVersionFor(component, config)
+  const platform = currentPlatform()
+
+  if (isDownloadInProgress(component, version)) {
+    console.log(`[supatype] Waiting for in-progress ${component} download...`)
+    const outcome = await waitForComponentDownload(
+      component,
+      version,
+      () => isCachedBinaryReady(component, version, platform),
+      (c) => {
+        console.log(`[supatype] Still waiting for ${c}...`)
+      },
+    )
+    if (outcome === "ready") {
+      return resolveBinary(component, config)
+    }
+  }
+
+  return download(component, version, platform)
 }

package/src/ensure-component-binaries.ts

@@ -0,0 +1,71 @@
+/**
+ * Ensure CDN component binaries are cached when the host CLI needs them.
+ */
+
+import { ensureBinary } from "./ensure-binary.js"
+import type { Component } from "./components.js"
+import type { SupatypeProjectConfig } from "./project-config.js"
+import {
+  describeRequiredHostComponents,
+  requiredHostComponents,
+} from "./required-host-components.js"
+import { resolveRuntimeProvider } from "./project-config.js"
+import { error, info, warn } from "./ui/messages.js"
+
+export interface ComponentBinaryFailure {
+  component: Component
+  message: string
+}
+
+export interface EnsureComponentBinariesResult {
+  ok: boolean
+  failures: ComponentBinaryFailure[]
+  skipped: boolean
+}
+
+export async function ensureComponentBinaries(
+  config: SupatypeProjectConfig,
+  cwd: string = process.cwd(),
+): Promise<EnsureComponentBinariesResult> {
+  const components = requiredHostComponents(config, cwd)
+  const provider = resolveRuntimeProvider(config)
+
+  if (components.length === 0) {
+    return { ok: true, failures: [], skipped: true }
+  }
+
+  const list = describeRequiredHostComponents(components)
+  if (provider === "docker") {
+    info(
+      `Preparing host CLI tools (${list}) — Compose still runs Postgres and the API stack.`,
+    )
+  } else {
+    info(`Preparing local runtime components (${list})…`)
+  }
+
+  const failures: ComponentBinaryFailure[] = []
+
+  for (const component of components) {
+    try {
+      await ensureBinary(component, config)
+      info(`${component} ready.`)
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err)
+      failures.push({ component, message })
+      error(`Could not prepare ${component}: ${message}`)
+    }
+  }
+
+  return { ok: failures.length === 0, failures, skipped: false }
+}
+
+export function reportComponentBinaryFailures(failures: ComponentBinaryFailure[]): void {
+  if (failures.length === 0) return
+
+  warn("Some component binaries are still missing.")
+  for (const { component, message } of failures) {
+    warn(`  ${component}: ${message}`)
+  }
+  warn("Run manually from your project directory: supatype update")
+  warn("If downloads keep failing, check your network or try again in a few minutes.")
+}

package/src/ensure-dev-api-config.ts

@@ -0,0 +1,18 @@
+import { copyFileSync, existsSync, mkdirSync } from "node:fs"
+import { dirname, join } from "node:path"
+
+const TEMPLATE_REL = join("config", "api-config.json")
+const TARGET_REL = join(".supatype", "api-config.json")
+
+/** Copy committed `config/api-config.json` when `.supatype/api-config.json` is missing. */
+export function ensureDevApiConfig(cwd: string): boolean {
+  const target = join(cwd, TARGET_REL)
+  if (existsSync(target)) return false
+
+  const template = join(cwd, TEMPLATE_REL)
+  if (!existsSync(template)) return false
+
+  mkdirSync(dirname(target), { recursive: true })
+  copyFileSync(template, target)
+  return true
+}