@supatype/cli 0.1.0 → 0.1.2

package/src/compose-rename.ts

@@ -0,0 +1,73 @@
+/**
+ * Detect and clean up Docker Compose state when `project.name` changes.
+ */
+
+import { existsSync, readFileSync } from "node:fs"
+import { join } from "node:path"
+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 { success, warn } from "./ui/messages.js"
+
+/**
+ * When `project.name` changes, the compose project slug changes too (`supatype-{name}`).
+ * Offer to stop containers from the previous slug so volumes/ports do not linger.
+ */
+export async function handleComposeProjectRename(
+  cwd: string,
+  currentProjectName: string,
+  paths: SelfHostComposePaths,
+): Promise<void> {
+  const local = loadLocalEnvironment(cwd)
+  const previousRef = local?.projectRef?.trim()
+  if (!previousRef || previousRef === currentProjectName) return
+
+  const previousCompose = composeProjectName(previousRef)
+  const currentCompose = composeProjectName(currentProjectName)
+  if (previousCompose === currentCompose) return
+  if (!composeStackHasContainers(previousCompose)) return
+
+  const message =
+    `Project renamed from "${previousRef}" to "${currentProjectName}".\n` +
+    `Docker stack "${previousCompose}" may still be running.`
+
+  if (!isInteractive()) {
+    warn(message)
+    warn(`Stop it manually: docker compose -p ${previousCompose} down`)
+    return
+  }
+
+  const stopOld = await uiConfirm(`${message}\n\nStop the old Docker stack now?`, { default: true })
+
+  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) {
+    success(`Stopped old stack "${previousCompose}".`)
+    warnIfHardcodedComposeScripts(cwd, previousCompose)
+  } else {
+    warn(`Could not stop "${previousCompose}" (exit ${status}). Try: docker compose -p ${previousCompose} down`)
+  }
+}
+
+function warnIfHardcodedComposeScripts(cwd: string, oldComposeProject: string): void {
+  const pkgPath = join(cwd, "package.json")
+  if (!existsSync(pkgPath)) return
+  try {
+    const pkg = JSON.parse(readFileSync(pkgPath, "utf8")) as { scripts?: Record<string, string> }
+    const scripts = Object.values(pkg.scripts ?? {}).join("\n")
+    if (scripts.includes(`-p ${oldComposeProject}`)) {
+      warn(
+        `package.json scripts still reference compose project "${oldComposeProject}". ` +
+          "Update them if you renamed project.name in supatype.config.ts.",
+      )
+    }
+  } catch {
+    // ignore invalid package.json
+  }
+}

package/src/dev-compose.ts

@@ -2,11 +2,11 @@
  * `supatype dev` when `provider: docker` — full self-host Compose stack (Kong gateway).
  */
 
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs"
+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,
@@ -17,7 +17,11 @@ import {
   type SupatypeProjectConfig,
 } from "./project-config.js"
 import { signJwt } from "./jwt.js"
-import { isPortInUse } from "./postgres-ctl.js"
+import { ensureDevDbPort, ensureKongPort } from "./dev-ports.js"
+import { handleComposeProjectRename } from "./compose-rename.js"
+import { recoverStaleDevSession, writeDevSessionLock } from "./dev-session-lock.js"
+import { endDevSession, startDevSession } from "./dev-session.js"
+import { ensureDevApiConfig } from "./ensure-dev-api-config.js"
 import {
   COMPOSE_PINNED_IMAGE_ENV_KEYS,
   composeDockerImageEnv,
@@ -30,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 {
@@ -46,6 +51,8 @@ import { withAdminRoles } from "./studio-admin-roles.js"
 import { restoreSystemRelationTargets } from "./restore-system-relation-targets.js"
 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"
 
@@ -70,30 +77,12 @@ export function composeDbUrl(): string {
 
 /**
  * Resolve the host Kong port for this project. Persisted in `.env` as
- * SUPATYPE_KONG_PORT so re-runs are stable; on first run it picks the default
- * (18473) or the next free port, so multiple projects can run concurrently.
+ * SUPATYPE_KONG_PORT; prompts when the configured port is already taken.
  */
 async function resolveDevDbPort(cwd: string): Promise<number> {
-  const envPath = join(cwd, ".env")
-  if (existsSync(envPath)) {
-    const m = readFileSync(envPath, "utf8").match(/^SUPATYPE_DEV_DB_PORT=(\d+)/m)
-    if (m && m[1]) return Number(m[1])
-  }
-  let port = COMPOSE_DEV_DB_PORT
-  while (await isPortInUse(port)) port++
-  return port
+  return ensureDevDbPort(cwd)
 }
 
-function readEnvValue(cwd: string, key: string, fallback: string): string {
-  const envPath = join(cwd, ".env")
-  if (existsSync(envPath)) {
-    const m = readFileSync(envPath, "utf8").match(new RegExp(`^${key}=(.+)$`, "m"))
-    if (m?.[1]) return m[1].trim()
-  }
-  return fallback
-}
-
-/** Postgres DSN for compose db when published to the host (local engine push). */
 function hostComposeDbUrl(cwd: string): string {
   const port = readEnvValue(cwd, "SUPATYPE_DEV_DB_PORT", String(COMPOSE_DEV_DB_PORT))
   const user = readEnvValue(cwd, "POSTGRES_USER", "supatype_admin")
@@ -175,42 +164,17 @@ export async function resolveHostEngineDatabaseUrl(
 }
 
 async function resolveKongPort(cwd: string): Promise<number> {
-  const envPath = join(cwd, ".env")
-  if (existsSync(envPath)) {
-    const m = readFileSync(envPath, "utf8").match(/^SUPATYPE_KONG_PORT=(\d+)/m)
-    if (m && m[1]) return Number(m[1])
-  }
-  let port = COMPOSE_DEV_KONG_PORT
-  while (await isPortInUse(port)) port++
-  return port
+  return ensureKongPort(cwd, { context: "dev" })
 }
 
-function upsertEnvFile(
-  cwd: string,
-  updates: Record<string, string>,
-  removeKeys: readonly string[] = [],
-): void {
-  const envPath = join(cwd, ".env")
-  const existing = existsSync(envPath) ? readFileSync(envPath, "utf8") : ""
-  const keys = new Set([...Object.keys(updates), ...removeKeys])
-  const kept = existing
-    .split("\n")
-    .filter((line) => {
-      const key = line.split("=")[0]?.trim()
-      return key && line.includes("=") && !keys.has(key)
-    })
-  const merged = [...kept, ...Object.entries(updates).map(([key, value]) => `${key}=${value}`)]
-  writeFileSync(envPath, `${merged.join("\n").trimEnd()}\n`, "utf8")
-}
-
-/** Keep compose + Studio on the same freshly signed dev JWTs; sync optional image pins from config. */
-function ensureDevComposeEnv(
+function upsertDevComposeEnv(
   cwd: string,
   config: SupatypeProjectConfig,
   anonKey: string,
   serviceRoleKey: string,
   kongPort: number,
   devDbPort?: number,
+  localServerImage?: string,
 ): void {
   const apiUrl = `http://localhost:${kongPort}`
   const imagePins = composeDockerImageEnv(config)
@@ -222,12 +186,14 @@ function ensureDevComposeEnv(
     ANON_KEY: anonKey,
     SERVICE_ROLE_KEY: serviceRoleKey,
     PUBLIC_SUPATYPE_ANON_KEY: anonKey,
+    VITE_SUPATYPE_ANON_KEY: anonKey,
     PUBLIC_SUPATYPE_URL: apiUrl,
     SUPATYPE_KONG_PORT: String(kongPort),
     API_EXTERNAL_URL: apiUrl,
     SITE_URL: apiUrl,
     GOTRUE_MAILER_AUTOCONFIRM: "true",
     ...imagePins,
+    ...(localServerImage !== undefined && { SUPATYPE_SERVER_IMAGE: localServerImage }),
   }
   if (devDbPort !== undefined) {
     updates.SUPATYPE_DEV_DB_PORT = String(devDbPort)
@@ -238,6 +204,19 @@ function ensureDevComposeEnv(
   upsertEnvFile(cwd, updates, removeImageKeys)
 }
 
+/** Keep compose + Studio on the same freshly signed dev JWTs; sync optional image pins from config. */
+function ensureDevComposeEnv(
+  cwd: string,
+  config: SupatypeProjectConfig,
+  anonKey: string,
+  serviceRoleKey: string,
+  kongPort: number,
+  devDbPort?: number,
+  localServerImage?: string,
+): void {
+  upsertDevComposeEnv(cwd, config, anonKey, serviceRoleKey, kongPort, devDbPort, localServerImage)
+}
+
 async function waitComposeHealthy(paths: SelfHostComposePaths, cwd: string, maxMs: number, composeProject: string): Promise<void> {
   const composeDir = dirname(paths.composePath)
   const envFile = join(cwd, ".env")
@@ -271,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,
@@ -668,8 +675,13 @@ 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, {
+    compose: { project, composePath: paths.composePath },
+  })
+
   console.log("[supatype] Schema pushed.")
 }
 
@@ -689,12 +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 })
-  const devBrand = { intro: "Local development" }
+  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)
+
+  console.log("[supatype] Bringing up Docker Compose services...")
   const upStatus = runDockerCompose(paths.composePath, ["up", "-d"], cwd, project, {
     quiet: true,
     brand: devBrand,
@@ -712,8 +768,29 @@ export async function runDevCompose(cwd: string, config: SupatypeProjectConfig,
     console.error("[supatype] Initial schema push failed:", (e as Error).message),
   )
 
+  await ensureFirstAdminUserForProject(cwd, config, {
+    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",
@@ -724,13 +801,23 @@ export async function runDevCompose(cwd: string, config: SupatypeProjectConfig,
     provider: "docker",
   })
 
+  writeDevSessionLock(cwd, {
+    composeProject: project,
+    projectRef: config.project.name,
+    composePath: paths.composePath,
+    kongPort,
+    startedAt: new Date().toISOString(),
+  })
+
   const ast = loadSchemaAst(schemaPath, cwd)
   await provisionDockerStorageBuckets(ast, kongPort, serviceRoleKey)
 
   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({
@@ -739,63 +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}.`)
-    }
-  })
+  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