@supatype/cli 0.1.1 → 0.1.2

package/src/compose-rename.ts

@@ -4,12 +4,12 @@
 
 import { existsSync, readFileSync } from "node:fs"
 import { join } from "node:path"
-import * as p from "@clack/prompts"
 import { loadLocalEnvironment } from "./link.js"
 import { composeStackHasContainers } from "./dev-session-lock.js"
 import { composeProjectName, runDockerCompose, type SelfHostComposePaths } from "./self-host-compose.js"
+import { confirm as uiConfirm } from "./ui/confirm.js"
 import { isInteractive } from "./ui/interactive.js"
-import { warn } from "./ui/messages.js"
+import { success, warn } from "./ui/messages.js"
 
 /**
  * When `project.name` changes, the compose project slug changes too (`supatype-{name}`).
@@ -39,19 +39,16 @@ export async function handleComposeProjectRename(
     return
   }
 
-  const stopOld = await p.confirm({
-    message: `${message}\n\nStop the old Docker stack now?`,
-    initialValue: true,
-  })
+  const stopOld = await uiConfirm(`${message}\n\nStop the old Docker stack now?`, { default: true })
 
-  if (p.isCancel(stopOld) || !stopOld) {
+  if (!stopOld) {
     warn(`Leaving "${previousCompose}" running. Stop it with: docker compose -p ${previousCompose} down`)
     return
   }
 
   const status = runDockerCompose(paths.composePath, ["down"], cwd, previousCompose, { quiet: true })
   if (status === 0) {
-    p.log.success(`Stopped old stack "${previousCompose}".`)
+    success(`Stopped old stack "${previousCompose}".`)
     warnIfHardcodedComposeScripts(cwd, previousCompose)
   } else {
     warn(`Could not stop "${previousCompose}" (exit ${status}). Try: docker compose -p ${previousCompose} down`)

package/src/dev-compose.ts

@@ -6,7 +6,7 @@ import { existsSync, mkdirSync, writeFileSync } from "node:fs"
 import { homedir } from "node:os"
 import { dirname, join, resolve } from "node:path"
 import { spawnSync } from "node:child_process"
-import { startProxyDevApp } from "./app/proxy-dev-app.js"
+import { startProxyDevApp, resolveProxyDevScript } from "./app/proxy-dev-app.js"
 import { loadSchemaAst } from "./config.js"
 import {
   COMPOSE_DEV_KONG_PORT,
@@ -20,7 +20,8 @@ import { signJwt } from "./jwt.js"
 import { ensureDevDbPort, ensureKongPort } from "./dev-ports.js"
 import { handleComposeProjectRename } from "./compose-rename.js"
 import { recoverStaleDevSession, writeDevSessionLock } from "./dev-session-lock.js"
-import { readEnvValue, upsertEnvFile } from "./env-file.js"
+import { endDevSession, startDevSession } from "./dev-session.js"
+import { ensureDevApiConfig } from "./ensure-dev-api-config.js"
 import {
   COMPOSE_PINNED_IMAGE_ENV_KEYS,
   composeDockerImageEnv,
@@ -33,10 +34,11 @@ import {
 } from "./self-host-compose.js"
 import type { DockerBrandOptions } from "./docker-runtime.js"
 import { hasEngineOverride } from "./binary-cache.js"
-import { startStudioViteDevServer } from "./studio-dev-server.js"
+import { STUDIO_DEV_PORT, startStudioViteDevServer } from "./studio-dev-server.js"
+import { ensureLocalServerDockerImage } from "./compose-local-server-image.js"
 import { ensureEngine, engineRequest, type DiffResult } from "./engine-client.js"
 import { writeSchemaSourcePushArtifacts, type SchemaSourcePushArtifacts } from "./schema-sources.js"
-import { endDevSession } from "./dev-session.js"
+import { readEnvValue, upsertEnvFile } from "./env-file.js"
 import { writeLocalEnvironment } from "./link.js"
 import { registerDevShutdown } from "./dev-shutdown.js"
 import {
@@ -50,6 +52,7 @@ import { restoreSystemRelationTargets } from "./restore-system-relation-targets.
 import { provisionBucketsFromAst } from "./storage-provision.js"
 import type { ExtractedSchemaAstV2 } from "./schema-ast-v2.js"
 import { ensureFirstAdminUserForProject } from "./commands/admin.js"
+import { publishDevReady } from "./dev-ready-panel.js"
 
 const LOCAL_JWT_SECRET = "super-secret-jwt-token-with-at-least-32-characters-long"
 
@@ -171,6 +174,7 @@ function upsertDevComposeEnv(
   serviceRoleKey: string,
   kongPort: number,
   devDbPort?: number,
+  localServerImage?: string,
 ): void {
   const apiUrl = `http://localhost:${kongPort}`
   const imagePins = composeDockerImageEnv(config)
@@ -189,6 +193,7 @@ function upsertDevComposeEnv(
     SITE_URL: apiUrl,
     GOTRUE_MAILER_AUTOCONFIRM: "true",
     ...imagePins,
+    ...(localServerImage !== undefined && { SUPATYPE_SERVER_IMAGE: localServerImage }),
   }
   if (devDbPort !== undefined) {
     updates.SUPATYPE_DEV_DB_PORT = String(devDbPort)
@@ -207,8 +212,9 @@ function ensureDevComposeEnv(
   serviceRoleKey: string,
   kongPort: number,
   devDbPort?: number,
+  localServerImage?: string,
 ): void {
-  upsertDevComposeEnv(cwd, config, anonKey, serviceRoleKey, kongPort, devDbPort)
+  upsertDevComposeEnv(cwd, config, anonKey, serviceRoleKey, kongPort, devDbPort, localServerImage)
 }
 
 async function waitComposeHealthy(paths: SelfHostComposePaths, cwd: string, maxMs: number, composeProject: string): Promise<void> {
@@ -244,6 +250,34 @@ async function waitKongReady(kongPort: number, maxSec: number): Promise<void> {
   throw new Error(`Kong gateway at ${base} did not become ready within ${maxSec}s`)
 }
 
+/** Kong may be up while server → storage is still starting (503 or upstream errors). */
+async function waitStorageApiReady(
+  kongPort: number,
+  serviceRoleKey: string,
+  maxSec: number,
+): Promise<void> {
+  const url = `http://localhost:${kongPort}/storage/v1/bucket`
+  const headers = { Authorization: `Bearer ${serviceRoleKey}` }
+  for (let i = 0; i < maxSec; i++) {
+    try {
+      const res = await fetch(url, { headers })
+      if (res.ok) return
+      const body = await res.text()
+      const kongUpstreamDown = body.includes("invalid response was received from the upstream server")
+      if (!kongUpstreamDown && res.status !== 503) {
+        // Non-transient storage response (e.g. 401) — stop waiting.
+        return
+      }
+    } catch {
+      /* retry */
+    }
+    await new Promise((r) => setTimeout(r, 1000))
+  }
+  console.warn(
+    `[supatype] Storage API at ${url} did not become ready within ${maxSec}s — bucket provisioning may fail.`,
+  )
+}
+
 async function provisionDockerStorageBuckets(
   ast: ExtractedSchemaAstV2,
   kongPort: number,
@@ -641,6 +675,7 @@ export async function pushSchemaDocker(cwd: string, config: SupatypeProjectConfi
     exitComposeFailed(upGateway, "Could not start the Compose gateway stack.", pushBrand)
   }
   await waitKongReady(kongPort, 120)
+  await waitStorageApiReady(kongPort, serviceRoleKey, 90)
   await provisionDockerStorageBuckets(ast, kongPort, serviceRoleKey)
 
   await ensureFirstAdminUserForProject(cwd, config, {
@@ -666,14 +701,56 @@ export async function runDevCompose(cwd: string, config: SupatypeProjectConfig,
   const anonKey = signJwt({ ...jwtBase, role: "anon" }, LOCAL_JWT_SECRET)
   const serviceRoleKey = signJwt({ ...jwtBase, role: "service_role" }, LOCAL_JWT_SECRET)
 
-  ensureDevComposeEnv(cwd, config, anonKey, serviceRoleKey, kongPort, devDbPort)
+  const devBrand = { intro: "Local development" }
+  const localServerImage = await ensureLocalServerDockerImage(cwd, config, devBrand)
+
+  ensureDevComposeEnv(cwd, config, anonKey, serviceRoleKey, kongPort, devDbPort, localServerImage)
 
   console.log(`[supatype] provider: docker — starting self-host Compose stack (project ${project}, gateway :${kongPort})...`)
   const paths = writeSelfHostCompose(cwd, config, { devLocal: true })
+  if (ensureDevApiConfig(cwd)) {
+    console.log("[supatype] API config written to .supatype/api-config.json")
+  }
+
+  type StudioProc = Awaited<ReturnType<typeof startStudioViteDevServer>>
+  type AppProc = ReturnType<typeof startProxyDevApp>
+  const shutdownState: {
+    studioProc: StudioProc
+    appProc: AppProc
+    schemaWatcher: import("node:fs").FSWatcher | null
+    debounceTimer: ReturnType<typeof setTimeout> | null
+  } = {
+    studioProc: null,
+    appProc: null,
+    schemaWatcher: null,
+    debounceTimer: null,
+  }
+
+  registerDevShutdown(async () => {
+    shutdownState.schemaWatcher?.close()
+    shutdownState.schemaWatcher = null
+    if (shutdownState.debounceTimer) {
+      clearTimeout(shutdownState.debounceTimer)
+      shutdownState.debounceTimer = null
+    }
+    console.log("[supatype] Shutting down compose...")
+    await shutdownState.studioProc?.stop()
+    await shutdownState.appProc?.stop()
+    const downStatus = runDockerCompose(paths.composePath, ["down"], cwd, project, { quiet: true })
+    if (downStatus === 0) {
+      console.log("[supatype] Compose stack stopped.")
+    } else {
+      console.warn(`[supatype] Compose down exited with status ${downStatus}.`)
+    }
+  }, {
+    cwd,
+    compose: { cwd, composePath: paths.composePath, composeProject: project },
+  })
+
   await recoverStaleDevSession(cwd)
   await handleComposeProjectRename(cwd, config.project.name, paths)
-  const devBrand = { intro: "Local development" }
 
+  console.log("[supatype] Bringing up Docker Compose services...")
   const upStatus = runDockerCompose(paths.composePath, ["up", "-d"], cwd, project, {
     quiet: true,
     brand: devBrand,
@@ -695,8 +772,25 @@ export async function runDevCompose(cwd: string, config: SupatypeProjectConfig,
     compose: { project, composePath: paths.composePath },
   })
 
+  if (localServerImage !== undefined) {
+    console.log("[supatype] Recreating server with local image...")
+    const recreateStatus = runDockerCompose(
+      paths.composePath,
+      ["up", "-d", "--force-recreate", "--no-deps", "server"],
+      cwd,
+      project,
+      { quiet: true, brand: devBrand },
+    )
+    if (recreateStatus !== 0) {
+      endDevSession()
+      exitComposeFailed(recreateStatus, "Could not recreate the server container with the local image.", devBrand)
+    }
+  }
+
   console.log("[supatype] Waiting for API gateway...")
   await waitKongReady(kongPort, 120)
+  console.log("[supatype] Waiting for storage API...")
+  await waitStorageApiReady(kongPort, serviceRoleKey, 90)
 
   writeLocalEnvironment(cwd, {
     target: "local",
@@ -721,7 +815,9 @@ export async function runDevCompose(cwd: string, config: SupatypeProjectConfig,
   const pidDir = join(homedir(), ".supatype", "projects", config.project.name, "pid")
   mkdirSync(pidDir, { recursive: true })
 
-  let studioProc: Awaited<ReturnType<typeof startStudioViteDevServer>> = null
+  startDevSession()
+
+  let studioProc: StudioProc = null
   const studioOverride = config.overrides?.studio
   if (studioOverride) {
     studioProc = startStudioViteDevServer({
@@ -730,66 +826,55 @@ export async function runDevCompose(cwd: string, config: SupatypeProjectConfig,
       pidDir,
       serviceRoleKey,
       proxyTarget: `http://localhost:${kongPort}`,
-      viteSupatypeUrl: `http://localhost:${kongPort}`,
+      viteSupatypeUrl: `http://localhost:${STUDIO_DEV_PORT}`,
       basePath: "/studio/",
     })
     studioProc?.start()
+    shutdownState.studioProc = studioProc
     if (studioProc) {
-      console.log("[supatype] Studio Vite dev server (overrides.studio) — live reload at /studio/")
+      console.log(
+        `[supatype] Studio (overrides.studio) — live reload proxied at http://localhost:${kongPort}/studio/`,
+      )
     }
   }
 
-  console.log(`
-[supatype] Services running (Docker Compose · project ${project}):
-  API (Kong)       http://localhost:${kongPort}
-    REST API       http://localhost:${kongPort}/rest/v1/
-    Auth           http://localhost:${kongPort}/auth/v1/
-    Storage        http://localhost:${kongPort}/storage/v1/
-    Realtime       ws://localhost:${kongPort}/realtime/v1/
-  Studio           http://localhost:${kongPort}/studio/
+  const links = [
+    { label: "API", url: `http://localhost:${kongPort}` },
+    { label: "REST", url: `http://localhost:${kongPort}/rest/v1/` },
+    { label: "Auth", url: `http://localhost:${kongPort}/auth/v1/` },
+    { label: "Storage", url: `http://localhost:${kongPort}/storage/v1/` },
+    { label: "Realtime", url: `ws://localhost:${kongPort}/realtime/v1/` },
+  ]
+  if (resolveProxyDevScript(config) !== null) {
+    links.push({ label: "App", url: `http://localhost:${kongPort}/` })
+  }
+  links.push({ label: "Studio", url: `http://localhost:${kongPort}/studio/` })
 
-  API keys (local dev only):
-    anon key       ${anonKey}
-    service_role   ${serviceRoleKey}
+  const hints: string[] = []
+  if (existsSync(join(cwd, "seed.ts"))) {
+    hints.push("Demo data: pnpm seed")
+  }
 
-  Press Ctrl+C to stop.
-`)
+  publishDevReady({
+    title: `Services running (Docker · ${project})`,
+    links,
+    anonKey,
+    serviceRoleKey,
+    ...(hints.length > 0 ? { hints } : {}),
+  })
 
   const appProc = startProxyDevApp(cwd, config, pidDir)
-
-  let schemaWatcher: import("node:fs").FSWatcher | null = null
-  let debounceTimer: ReturnType<typeof setTimeout> | null = null
-
-  registerDevShutdown(async () => {
-    schemaWatcher?.close()
-    schemaWatcher = null
-    if (debounceTimer) {
-      clearTimeout(debounceTimer)
-      debounceTimer = null
-    }
-    console.log("[supatype] Shutting down compose...")
-    await studioProc?.stop()
-    await appProc?.stop()
-    const downStatus = runDockerCompose(paths.composePath, ["down"], cwd, project, { quiet: true })
-    if (downStatus === 0) {
-      console.log("[supatype] Compose stack stopped.")
-    } else {
-      console.warn(`[supatype] Compose down exited with status ${downStatus}.`)
-    }
-  }, {
-    cwd,
-    compose: { cwd, composePath: paths.composePath, composeProject: project },
-  })
+  shutdownState.appProc = appProc
 
   if (opts.watch) {
     const schemaDir = join(projectRootFromConfig(config, cwd), config.schema?.path ?? "schema/index.ts", "..")
     console.log(`[supatype] Watching ${schemaDir} for changes...`)
     const { watch } = await import("node:fs")
-    schemaWatcher = watch(schemaDir, { recursive: true }, (_eventType, filename) => {
+    shutdownState.schemaWatcher = watch(schemaDir, { recursive: true }, (_eventType, filename) => {
       if (!filename?.endsWith(".ts")) return
-      if (debounceTimer) clearTimeout(debounceTimer)
-      debounceTimer = setTimeout(() => {
-        debounceTimer = null
+      if (shutdownState.debounceTimer) clearTimeout(shutdownState.debounceTimer)
+      shutdownState.debounceTimer = setTimeout(() => {
+        shutdownState.debounceTimer = null
         console.log(`\n[supatype] Change detected in ${filename}, pushing schema...`)
         runComposeSchemaPushQueued(cwd, config, paths, schemaPath, project)
           .then(async () => {

package/src/dev-log-bus.ts

@@ -2,6 +2,9 @@
  * Per-task log buffers for `supatype dev` TUI mode.
  */
 
+import type { DevReadyPanel } from "./dev-ready-panel.js"
+import { devReadyPanelRowCount } from "./dev-ready-panel.js"
+
 export type DevLogLevel = "log" | "warn" | "error"
 
 export interface DevTask {
@@ -18,6 +21,7 @@ export class DevLogBus {
   private readonly order: string[] = []
   private readonly listeners = new Set<() => void>()
   private focusedTaskId = "stack"
+  private readyPanel: DevReadyPanel | null = null
 
   constructor(private readonly maxLines = DEFAULT_MAX_LINES) {
     this.registerTask("stack", "supatype")
@@ -66,6 +70,20 @@ export class DevLogBus {
     if (prev) this.setFocusedTaskId(prev)
   }
 
+  setReadyPanel(panel: DevReadyPanel): void {
+    this.readyPanel = panel
+    this.notify()
+  }
+
+  getReadyPanel(): DevReadyPanel | null {
+    return this.readyPanel
+  }
+
+  readyPanelRowCount(): number {
+    if (!this.readyPanel) return 0
+    return devReadyPanelRowCount(this.readyPanel)
+  }
+
   append(taskId: string, line: string, level: DevLogLevel = "log"): void {
     this.ensureTask(taskId, taskId)
     const task = this.tasks.get(taskId)

package/src/dev-log-filter.ts

@@ -2,6 +2,8 @@
  * Line filters for subprocess output during `supatype dev`.
  */
 
+import { isComposeProgressLine } from "./engine-push-output.js"
+
 /** Strip ANSI SGR sequences for TUI rendering. */
 export function stripAnsi(text: string): string {
   return text.replace(/\x1b\[[0-9;]*m/g, "")
@@ -17,6 +19,46 @@ export function filterDevSubprocessLine(taskId: string, line: string): boolean {
   return true
 }
 
+const DOCKER_BUILD_NOISE =
+  /^#\d+\s|^#\d+ \[|^\s*=> \[|^\s*=>\s|^\s*--->\s|^\s*\d+\.\d+s\s|^\s*CACHED\s|^\s*DONE\s[\d.]+s?$|^Step \d+\/\d+|^Successfully (built|tagged)|^WARNING:|^DEPRECATED:|^View build details:|^What's next:|^The push refers to|^Using docker|^Sending build context|^Pulling fs layer|^Waiting$|^Verifying Checksum|^Download complete|^Pull complete|^Extracting \[|^Already exists$|^Building dependency tree|^Reading state information|^Get:\d+ |^Fetched \d+ |^Reading package lists|^Preparing to unpack|^Unpacking |^Setting up /i
+
+/** Drop docker build / compose progress from the orchestrator (stack) pane. */
+export function filterStackLogLine(line: string): boolean {
+  const t = stripAnsi(line).trim()
+  if (!t) return false
+
+  if (t.startsWith("✗ ") || t.startsWith("⚠ ")) return true
+  if (/https?:\/\//.test(t) || /^ws:\/\//.test(t)) return true
+  if (/\[supatype\]/.test(line)) return true
+  if (/^Services running/i.test(t)) return true
+  if (/^(anon key|service_role|API \(Kong\)|REST API|Auth|Storage|Realtime|Studio|App|Demo data|Postgres|supatype-server|Press Ctrl)/.test(t)) {
+    return true
+  }
+  if (/^Applied \d+ operation|^Schema up to date|^Schema pushed|^Watching .+ for changes|^Change detected|^Shutting down|^Compose stack stopped|^Local server image ready|^Building local server|^Waiting for |^Recreating server|^API config written|^provider: docker|^Bringing up Docker|^Schema push failed|^Initial schema push failed|^Storage bucket|^Storage API at|^Local binary overrides active|^Resolving component binaries|^Postgres |^Demo data:|^JWT secret:/.test(t)) {
+    return true
+  }
+  if (/^\S+\s+→\s/.test(t)) return true
+  if (isComposeProgressLine(t)) return false
+  if (DOCKER_BUILD_NOISE.test(t)) return false
+  if (/^Container\s+/i.test(t)) return false
+  if (/^Image\s+/i.test(t)) return false
+  if (/^network\s+\S+\s+(Creating|Created)/i.test(t)) return false
+  if (/^volume\s+\S+\s+(Creating|Created)/i.test(t)) return false
+
+  return false
+}
+
+/** Drop docker noise only — keep diff tables, push status, and command output. */
+export function filterCommandLogLine(line: string): boolean {
+  const t = stripAnsi(line).trim()
+  if (!t) return false
+  if (isComposeProgressLine(t)) return false
+  if (DOCKER_BUILD_NOISE.test(t)) return false
+  if (/^Container\s+/i.test(t)) return false
+  if (/^Image\s+/i.test(t)) return false
+  return true
+}
+
 /** Format console.* arguments the way Node does for a single log line. */
 export function formatConsoleArgs(args: unknown[]): string {
   return args

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,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

@@ -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}).`)
   }