@supatype/cli 0.1.1 → 0.1.3

package/src/commands/link-helpers.ts

@@ -12,7 +12,7 @@ import { targetFetch } from "../target-client.js"
 import { error, info, plain } from "../ui/messages.js"
 import { nextSteps } from "../ui/next-steps.js"
 import { isInteractive } from "../ui/interactive.js"
-import { ensureNotCancelled, printLogo, clack as p } from "../ui/prompts.js"
+import { ensureNotCancelled, p, runClackFlow } from "../ui/prompts.js"
 
 function resolveLinkToken(opts: {
   token?: string
@@ -145,35 +145,36 @@ export async function runLinkAction(opts: {
   let url = opts.url
 
   if (isInteractive() && !project && !url) {
-    printLogo()
-    p.intro("Link this project")
-    const targetKind = ensureNotCancelled(
-      await p.select<"cloud" | "self-host">({
-        message: "Link target",
-        options: [
-          { value: "cloud", label: "Supatype Cloud", hint: "managed project on supatype.com" },
-          { value: "self-host", label: "Self-host", hint: "your Kong gateway URL" },
-        ],
-      }),
-    )
-    if (targetKind === "cloud") {
-      project = ensureNotCancelled(
-        await p.text({
-          message: "Cloud project slug",
-          placeholder: projectRef,
-          defaultValue: projectRef,
+    await runClackFlow(async () => {
+      p.intro("Link this project")
+      const targetKind = ensureNotCancelled(
+        await p.select<"cloud" | "self-host">({
+          message: "Link target",
+          options: [
+            { value: "cloud", label: "Supatype Cloud", hint: "managed project on supatype.com" },
+            { value: "self-host", label: "Self-host", hint: "your Kong gateway URL" },
+          ],
         }),
-      ).trim()
-    } else {
-      url = ensureNotCancelled(
-        await p.text({
-          message: "Kong gateway URL",
-          placeholder: "https://api.example.com",
-          defaultValue: "http://localhost:18473",
-        }),
-      ).trim()
-    }
-    p.outro("Linking...")
+      )
+      if (targetKind === "cloud") {
+        project = ensureNotCancelled(
+          await p.text({
+            message: "Cloud project slug",
+            placeholder: projectRef,
+            defaultValue: projectRef,
+          }),
+        ).trim()
+      } else {
+        url = ensureNotCancelled(
+          await p.text({
+            message: "Kong gateway URL",
+            placeholder: "https://api.example.com",
+            defaultValue: "http://localhost:18473",
+          }),
+        ).trim()
+      }
+      p.outro("Linking...")
+    })
   }
 
   const token = resolveLinkToken(opts)

package/src/compose-local-server-image.ts

@@ -0,0 +1,68 @@
+import { existsSync } from "node:fs"
+import { dirname, isAbsolute, join, resolve } from "node:path"
+import { spawnSync } from "node:child_process"
+import { VERSION_PIN_LOCAL } from "./binary-cache.js"
+import { appendStackOutput, getActiveDevSession } from "./dev-session.js"
+import { requireDockerDaemon } from "./docker-runtime.js"
+import type { SupatypeProjectConfig } from "./project-config.js"
+
+/** Docker tag for compose dev when `versions.server` is `local`. */
+export const LOCAL_SERVER_DOCKER_IMAGE = "supatype/server:local-dev"
+
+/** Find the server repo root (directory containing `Dockerfile`) from an overrides.server binary path. */
+export function resolveServerSourceRoot(serverOverride: string, cwd: string): string | null {
+  const binaryPath = isAbsolute(serverOverride) ? serverOverride : resolve(cwd, serverOverride)
+  let dir = dirname(binaryPath)
+  for (let depth = 0; depth < 5; depth++) {
+    if (existsSync(join(dir, "Dockerfile"))) return dir
+    const parent = dirname(dir)
+    if (parent === dir) break
+    dir = parent
+  }
+  return null
+}
+
+/**
+ * When `versions.server` is `local`, build a Linux server image from the source tree
+ * next to `overrides.server` so compose dev matches the contributor's binary.
+ */
+export async function ensureLocalServerDockerImage(
+  cwd: string,
+  config: SupatypeProjectConfig,
+  brand?: { intro?: string },
+): Promise<string | undefined> {
+  if (config.versions?.server !== VERSION_PIN_LOCAL) return undefined
+
+  const override = config.overrides?.server?.trim()
+  if (!override) return undefined
+
+  const root = resolveServerSourceRoot(override, cwd)
+  if (!root) {
+    console.warn(
+      `[supatype] ⚠  versions.server is "local" but no Dockerfile found near ${override}. ` +
+        "Compose will use the default supatype/server:latest image.",
+    )
+    return undefined
+  }
+
+  requireDockerDaemon(brand?.intro ? { brand: { intro: brand.intro } } : undefined)
+  const dockerfile = join(root, "Dockerfile")
+  console.log(`[supatype] Building local server Docker image from ${root}…`)
+  const result = spawnSync(
+    "docker",
+    ["build", "--progress=plain", "-t", LOCAL_SERVER_DOCKER_IMAGE, "-f", dockerfile, root],
+    { encoding: "utf8", stdio: "pipe" },
+  )
+  const tui = getActiveDevSession()?.isTui() ?? false
+  if (!tui) {
+    appendStackOutput(result.stdout, "log")
+    appendStackOutput(result.stderr, result.status === 0 ? "log" : "error")
+  } else if (result.status !== 0) {
+    appendStackOutput(result.stderr || result.stdout || "docker build failed", "error")
+  }
+  if (result.status !== 0) {
+    throw new Error(`docker build failed for local server (exit ${result.status ?? "unknown"})`)
+  }
+  console.log(`[supatype] Local server image ready: ${LOCAL_SERVER_DOCKER_IMAGE}`)
+  return LOCAL_SERVER_DOCKER_IMAGE
+}

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/config.ts

@@ -158,7 +158,7 @@ process.stdout.write(JSON.stringify(config))
     }
 
     const failure = result.stderr || result.stdout
-    if (!failure.includes("ERR_PACKAGE_PATH_NOT_EXPORTED")) {
+    if (!shouldStripCliImportOnLoadFailure(failure)) {
       throw new Error(`Failed to load ${candidate}:\n${failure}`)
     }
 
@@ -169,6 +169,18 @@ process.stdout.write(JSON.stringify(config))
   return null
 }
 
+/** When @supatype/cli is not installed yet (e.g. during `supatype init`), strip its import. */
+function shouldStripCliImportOnLoadFailure(failure: string): boolean {
+  if (failure.includes("ERR_PACKAGE_PATH_NOT_EXPORTED")) return true
+  if (!failure.includes("@supatype/cli")) return false
+  return (
+    failure.includes("ERR_MODULE_NOT_FOUND") ||
+    failure.includes("MODULE_NOT_FOUND") ||
+    failure.includes("Cannot find module '@supatype/cli'") ||
+    failure.includes('Cannot find package \'@supatype/cli\'')
+  )
+}
+
 function loadTsConfigWithoutCliImport(
   configPath: string,
   cwd: string,

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,
@@ -691,12 +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)
+
+  await ensureFirstAdminUserForProject(cwd, config, {
+    compose: { project, composePath: paths.composePath },
+  })
 
   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 { devReadyPanelCompactRowCount, 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,22 @@ export class DevLogBus {
     if (prev) this.setFocusedTaskId(prev)
   }
 
+  setReadyPanel(panel: DevReadyPanel): void {
+    this.readyPanel = panel
+    this.notify()
+  }
+
+  getReadyPanel(): DevReadyPanel | null {
+    return this.readyPanel
+  }
+
+  readyPanelRowCount(compact = false): number {
+    if (!this.readyPanel) return 0
+    return compact
+      ? devReadyPanelCompactRowCount(this.readyPanel)
+      : 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