@supatype/cli 0.1.12 → 0.2.0

package/src/commands/dev.ts

@@ -65,21 +65,21 @@ import {
   isPortInUse,
   pgSpawnEnv,
 } from "../postgres-ctl.js"
-/** Map `email.smtp` from supatype.config.ts into GOTRUE_SMTP_* for the embedded GoTrue process. */
-function gotrueSMTPFromEmailConfig(email: SupatypeProjectConfig["email"] | undefined): Record<string, string> {
+/** Map `email.smtp` from supatype.config.ts into SUPATYPE_SMTP_* for the embedded auth service. */
+function authSMTPFromEmailConfig(email: SupatypeProjectConfig["email"] | undefined): Record<string, string> {
   const s = email?.smtp
   if (!s) return {}
   const out: Record<string, string> = {}
   const host = s.host?.trim()
-  if (host) out.GOTRUE_SMTP_HOST = host
-  if (s.port !== undefined) out.GOTRUE_SMTP_PORT = String(s.port)
+  if (host) out.SUPATYPE_SMTP_HOST = host
+  if (s.port !== undefined) out.SUPATYPE_SMTP_PORT = String(s.port)
   const user = s.user?.trim()
-  if (user) out.GOTRUE_SMTP_USER = user
-  if (s.pass !== undefined && s.pass !== "") out.GOTRUE_SMTP_PASS = s.pass
+  if (user) out.SUPATYPE_SMTP_USER = user
+  if (s.pass !== undefined && s.pass !== "") out.SUPATYPE_SMTP_PASS = s.pass
   const admin = s.admin_email?.trim()
-  if (admin) out.GOTRUE_SMTP_ADMIN_EMAIL = admin
+  if (admin) out.SUPATYPE_SMTP_ADMIN_EMAIL = admin
   const sender = s.sender_name?.trim()
-  if (sender) out.GOTRUE_SMTP_SENDER_NAME = sender
+  if (sender) out.SUPATYPE_SMTP_SENDER_NAME = sender
   return out
 }
 
@@ -287,10 +287,10 @@ ALTER DEFAULT PRIVILEGES IN SCHEMA public GRANT ALL ON SEQUENCES TO authenticate
         ? `${dbURL}&search_path=auth`
         : `${dbURL}?search_path=auth`
 
-      // ── 8. GoTrue migrations (auth.users before engine studio SQL) ─────────
-      console.log("[supatype] Running GoTrue migrations...")
-      const migrateEnv = gotrueMigrateEnv(serverPort, dbURL, LOCAL_JWT_SECRET)
-      runGotrueMigrations(serverBin, migrateEnv)
+      // ── 8. auth migrations (auth.users before engine studio SQL) ─────────
+      console.log("[supatype] Running auth migrations...")
+      const migrateEnv = authMigrateEnv(serverPort, dbURL, LOCAL_JWT_SECRET)
+      runAuthMigrations(serverBin, migrateEnv)
 
       // ── 9. Engine: apply schema ───────────────────────────────────────────
       const schemaPath = schemaPathFromProject(config, cwd)
@@ -348,7 +348,7 @@ ALTER DEFAULT PRIVILEGES IN SCHEMA public GRANT ALL ON SEQUENCES TO authenticate
         }
       }
 
-      // Matches GOTRUE_HOOK_SEND_EMAIL_SECRETS symmetric format (dev only). Override via .env.
+      // Matches SUPATYPE_HOOK_SEND_EMAIL_SECRETS symmetric format (dev only). Override via .env.
       const LOCAL_SEND_EMAIL_HOOK_SECRETS =
         "v1,whsec_abcdefghijklmnopqrstuvwxyz01234567"
       const now = Math.floor(Date.now() / 1000)
@@ -390,7 +390,7 @@ ALTER DEFAULT PRIVILEGES IN SCHEMA public GRANT ALL ON SEQUENCES TO authenticate
 
 
       const emailProvider = config.email?.provider ?? "console"
-      const gotrueMailerProvider =
+      const authMailerProvider =
         emailProvider === "console"
           ? "console"
           : emailProvider === "resend"
@@ -430,47 +430,47 @@ ALTER DEFAULT PRIVILEGES IN SCHEMA public GRANT ALL ON SEQUENCES TO authenticate
         ...(config.app.vite_dev_url !== undefined && config.app.vite_dev_url.trim() !== ""
           ? { SUPATYPE_VITE_DEV_URL: config.app.vite_dev_url.trim() }
           : {}),
-        // GoTrue required fields (sensible local-dev defaults)
-        GOTRUE_DB_DATABASE_URL: authDbURL,
+        // Auth service required fields (sensible local-dev defaults)
+        SUPATYPE_DB_DATABASE_URL: authDbURL,
         DATABASE_URL: authDbURL,
         SUPATYPE_SQL_DATABASE_URL: dbURL,
         PGSSLMODE: "disable",
-        GOTRUE_DB_NAMESPACE: "auth",
-        GOTRUE_DB_DRIVER: "postgres",
-        GOTRUE_JWT_SECRET: LOCAL_JWT_SECRET,
-        GOTRUE_JWT_EXP: "3600",
-        GOTRUE_JWT_AUD: "authenticated",
-        GOTRUE_JWT_ADMIN_ROLES: "supatype_admin,service_role",
-        API_EXTERNAL_URL: `http://localhost:${serverPort}/auth/v1`,
-        GOTRUE_API_HOST: "localhost",
-        GOTRUE_SITE_URL: `http://localhost:${serverPort}`,
-        GOTRUE_MAILER_MAILER_PROVIDER: gotrueMailerProvider,
-        GOTRUE_MAILER_AUTOCONFIRM: "true",
-        GOTRUE_LOG_LEVEL: "info",
-        GOTRUE_DISABLE_SIGNUP: "false",
+        SUPATYPE_DB_NAMESPACE: "auth",
+        SUPATYPE_DB_DRIVER: "postgres",
+        SUPATYPE_JWT_SECRET: LOCAL_JWT_SECRET,
+        SUPATYPE_JWT_EXP: "3600",
+        SUPATYPE_JWT_AUD: "authenticated",
+        SUPATYPE_JWT_ADMIN_ROLES: "supatype_admin,service_role",
+        SUPATYPE_API_EXTERNAL_URL: `http://localhost:${serverPort}/auth/v1`,
+        SUPATYPE_API_HOST: "localhost",
+        SUPATYPE_SITE_URL: `http://localhost:${serverPort}`,
+        SUPATYPE_MAILER_MAILER_PROVIDER: authMailerProvider,
+        SUPATYPE_MAILER_AUTOCONFIRM: "true",
+        SUPATYPE_LOG_LEVEL: "info",
+        SUPATYPE_DISABLE_SIGNUP: "false",
         ...(config.email?.resend_api_key !== undefined && config.email.resend_api_key !== ""
           ? { RESEND_API_KEY: config.email.resend_api_key }
           : {}),
-        ...(gotrueMailerProvider === "resend" &&
+        ...(authMailerProvider === "resend" &&
         config.email?.resend_from !== undefined &&
         config.email.resend_from.trim() !== ""
           ? { RESEND_FROM: config.email.resend_from.trim() }
           : {}),
-        ...(gotrueMailerProvider === "ses" &&
+        ...(authMailerProvider === "ses" &&
         config.email?.ses_from !== undefined &&
         config.email.ses_from.trim() !== ""
           ? { SES_FROM: config.email.ses_from.trim() }
           : {}),
-        ...(gotrueMailerProvider === "smtp" ? gotrueSMTPFromEmailConfig(config.email) : {}),
+        ...(authMailerProvider === "smtp" ? authSMTPFromEmailConfig(config.email) : {}),
         ...(config.email?.send_email_hook === true
           ? {
-              GOTRUE_HOOK_SEND_EMAIL_ENABLED: "true",
-              GOTRUE_HOOK_SEND_EMAIL_URI:
+              SUPATYPE_HOOK_SEND_EMAIL_ENABLED: "true",
+              SUPATYPE_HOOK_SEND_EMAIL_URI:
                 config.email?.send_email_hook_uri !== undefined &&
                 config.email.send_email_hook_uri.trim() !== ""
                   ? config.email.send_email_hook_uri.trim()
                   : `http://127.0.0.1:${serverPort}/internal/v0hooks/send-email`,
-              GOTRUE_HOOK_SEND_EMAIL_SECRETS:
+              SUPATYPE_HOOK_SEND_EMAIL_SECRETS:
                 config.email?.send_email_hook_secrets !== undefined &&
                 config.email.send_email_hook_secrets.trim() !== ""
                   ? config.email.send_email_hook_secrets.trim()
@@ -526,7 +526,7 @@ ALTER DEFAULT PRIVILEGES IN SCHEMA public GRANT ALL ON SEQUENCES TO authenticate
           PGRST_DB_ANON_ROLE: "anon",
           PGRST_SERVER_PORT: postgrestPort,
           PGRST_SERVER_HOST: "127.0.0.1",
-          PGRST_JWT_SECRET: serverEnv["GOTRUE_JWT_SECRET"] ?? "",
+          PGRST_JWT_SECRET: serverEnv["SUPATYPE_JWT_SECRET"] ?? "",
           PGRST_LOG_LEVEL: "warn",
           // On Windows, PostgREST (MinGW/GHC binary) needs libpq.dll and
           // OpenSSL DLLs. Prepend a Postgres bin dir which bundles these
@@ -571,7 +571,7 @@ ALTER DEFAULT PRIVILEGES IN SCHEMA public GRANT ALL ON SEQUENCES TO authenticate
           cwd,
           studioOverride,
           pidDir,
-          serviceRoleKey,
+          anonKey,
           proxyTarget: `http://localhost:${serverPort}`,
           viteSupatypeUrl: `http://localhost:${studioPort}`,
         })
@@ -1079,30 +1079,30 @@ function adaptUnsupportedKinds(
 // .env loader
 // ---------------------------------------------------------------------------
 
-/** Minimal GoTrue env for `migrate` (matches required fields in serverEnv below). */
-function gotrueMigrateEnv(
+/** Minimal auth env for `migrate` (matches required fields in serverEnv below). */
+function authMigrateEnv(
   serverPort: string,
   sqlDbURL: string,
   jwtSecret: string,
 ): Record<string, string> {
   const base = `http://localhost:${serverPort}`
   return {
-    // envconfig: gotrue + DB.DATABASE_URL → GOTRUE_DB_DATABASE_URL
-    GOTRUE_DB_DATABASE_URL: sqlDbURL,
+    // envconfig: the service prefix + DB.DATABASE_URL → SUPATYPE_DB_DATABASE_URL
+    SUPATYPE_DB_DATABASE_URL: sqlDbURL,
     DATABASE_URL: sqlDbURL,
-    GOTRUE_DB_DRIVER: "postgres",
-    GOTRUE_DB_NAMESPACE: "auth",
+    SUPATYPE_DB_DRIVER: "postgres",
+    SUPATYPE_DB_NAMESPACE: "auth",
     PGSSLMODE: "disable",
-    GOTRUE_JWT_SECRET: jwtSecret,
-    API_EXTERNAL_URL: `${base}/auth/v1`,
-    GOTRUE_API_HOST: "localhost",
-    GOTRUE_SITE_URL: base,
-    GOTRUE_MAILER_AUTOCONFIRM: "true",
+    SUPATYPE_JWT_SECRET: jwtSecret,
+    SUPATYPE_API_EXTERNAL_URL: `${base}/auth/v1`,
+    SUPATYPE_API_HOST: "localhost",
+    SUPATYPE_SITE_URL: base,
+    SUPATYPE_MAILER_AUTOCONFIRM: "true",
   }
 }
 
-/** Apply GoTrue DDL (auth.users, etc.) before engine push references auth schema. */
-function runGotrueMigrations(
+/** Apply auth DDL (auth.users, etc.) before engine push references auth schema. */
+function runAuthMigrations(
   serverBin: string,
   migrateEnv: Record<string, string>,
 ): void {
@@ -1117,7 +1117,7 @@ function runGotrueMigrations(
   if (result.status !== 0) {
     const detail = (result.stderr ?? result.stdout ?? "").trim()
     throw new Error(
-      `GoTrue migrations failed (exit ${result.status ?? "unknown"})` +
+      `auth migrations failed (exit ${result.status ?? "unknown"})` +
         (detail ? `:\n${detail}` : ""),
     )
   }

package/src/commands/doctor.ts

@@ -117,7 +117,37 @@ export function registerDoctor(program: Command): void {
  * stack with functions switched off, produces no error anywhere, the write just succeeds
  * unvalidated. Drift you cannot see is the thing doctor exists for.
  */
+/**
+ * Field validators, reported separately from hooks because the consequence differs.
+ *
+ * A hook that never fires is a step that did not happen. A validator that never fires would be a
+ * field written unchecked, so the server refuses the write instead: these fields cannot be saved at
+ * all until the function exists, and the line has to say that rather than imply a silent gap.
+ */
+function printFieldValidators(report: HooksReport): void {
+  if (report.validators.length === 0) return
+
+  plain(`\nField validators (${report.validators.length}):\n`)
+  for (const entry of report.validators) {
+    const broken = report.validatorsMissing.some(
+      (m) => m.model === entry.model && m.field === entry.field,
+    )
+    plain(`  ${broken ? "✗" : "•"} ${entry.model}.${entry.field} → ${entry.function}`)
+  }
+
+  if (report.validatorsMissing.length > 0) {
+    plain("\n  Those marked ✗ name a function that does not exist. An unreachable validator refuses")
+    plain("  the write, so these fields cannot be saved until the function is created.")
+    plain("  Create it with: supatype hooks new <name>")
+  }
+  if (report.validatorMapMissing) {
+    plain("\n  .supatype/manifest.json carries no validator map, so no field is being checked.")
+    plain("  Run: supatype push")
+  }
+}
+
 export function printHooks(report: HooksReport): void {
+  printFieldValidators(report)
   if (report.declared.length === 0) return
 
   plain(`\nHooks (${report.declared.length}):\n`)

package/src/commands/init.ts

@@ -1226,7 +1226,7 @@ JWT_SECRET=${randomBytes(48).toString("base64url")}
 ANON_KEY=
 SERVICE_ROLE_KEY=`)
 
-  sections.push(`# Site URL (used by GoTrue for email redirects)
+  sections.push(`# Site URL (used for email redirects)
 SITE_URL=http://localhost:3000`)
 
   if (opts.provider === "docker" && opts.kongPort !== undefined) {

package/src/commands/logs.ts

@@ -1,56 +1,53 @@
 /**
- * supatype logs: tail aggregated logs from local Docker containers.
+ * supatype logs: tail logs from the local stack.
  */
 import type { Command } from "commander"
 import { spawn } from "node:child_process"
-import { error } from "../ui/messages.js"
+import { composeArgs, composeContext, composeServiceNames } from "../compose-services.js"
+import { error, info } from "../ui/messages.js"
 
-const SERVICES = ["postgres", "postgrest", "gotrue", "kong", "minio", "realtime", "studio"]
+/**
+ * logsArgs builds the compose invocation.
+ *
+ * Compose is asked for the logs rather than `docker logs <name>`, because the
+ * container names are Compose's to choose: the generated file sets no
+ * `container_name`, so a container is `<project>-<service>-<n>` and guessing at
+ * that name is what left this command tailing containers that never existed.
+ */
+export function logsArgs(
+  base: string[],
+  opts: { service?: string; since?: string; follow?: boolean },
+): string[] {
+  const args = [...base, "logs", "--tail", "100"]
+  if (opts.follow) args.push("--follow")
+  if (opts.since) args.push("--since", opts.since)
+  if (opts.service) args.push(opts.service)
+  return args
+}
 
 export function registerLogs(program: Command): void {
   program
     .command("logs")
-    .description("Tail aggregated logs from local dev services")
-    .option("--service <name>", "Filter to a specific service")
-    .option("--since <duration>", "Show logs since duration (e.g., 5m, 1h)", "5m")
+    .description("Tail logs from the local stack")
+    .option("--service <name>", "Filter to a single service")
+    .option("--since <duration>", "Show logs since duration (e.g. 5m, 1h)", "5m")
     .option("-f, --follow", "Follow log output", true)
     .action((opts: { service?: string; since?: string; follow?: boolean }) => {
-      const services = opts.service
-        ? [`supatype-${opts.service}`]
-        : SERVICES.map((s) => `supatype-${s}`)
-
-      if (opts.service && !SERVICES.includes(opts.service)) {
-        error(`Unknown service: ${opts.service}`)
-        error(`Available: ${SERVICES.join(", ")}`)
+      const ctx = composeContext(process.cwd())
+      if (!ctx) {
+        error("No generated compose file here.")
+        info("Run `supatype self-host compose up` to create the stack.")
         process.exit(1)
       }
 
-      const args = ["compose", "logs"]
-      if (opts.follow) args.push("-f")
-      if (opts.since) args.push("--since", opts.since)
-      args.push("--tail", "100")
-
-      // If filtering by service, use docker logs for that container
-      if (opts.service) {
-        const containerArgs = ["logs"]
-        if (opts.follow) containerArgs.push("-f")
-        if (opts.since) containerArgs.push("--since", opts.since)
-        containerArgs.push("--tail", "100")
-        containerArgs.push(`supatype-${opts.service}`)
-
-        const child = spawn("docker", containerArgs, { stdio: "inherit" })
-        child.on("error", () => {
-          error("Docker not found. Ensure Docker is installed and running.")
-          process.exit(1)
-        })
-        return
+      const available = composeServiceNames(ctx)
+      if (opts.service && available.length > 0 && !available.includes(opts.service)) {
+        error(`Unknown service: ${opts.service}`)
+        error(`Available: ${available.join(", ")}`)
+        process.exit(1)
       }
 
-      // Aggregated logs via docker compose
-      const child = spawn("docker", args, {
-        stdio: "inherit",
-        cwd: process.cwd(),
-      })
+      const child = spawn("docker", logsArgs(composeArgs(ctx), opts), { stdio: "inherit" })
       child.on("error", () => {
         error("Docker not found. Ensure Docker is installed and running.")
         process.exit(1)

package/src/commands/push.ts

@@ -2,7 +2,12 @@ import type { Command } from "commander"
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs"
 import { join } from "node:path"
 import { loadConfig, loadSchemaAst } from "../config.js"
-import { syncManifestHooks, validateModelHooks, writeHooksModule } from "../model-hooks.js"
+import {
+  syncManifestHooks,
+  validateModelHooks,
+  validateModelValidators,
+  writeHooksModule,
+} from "../model-hooks.js"
 import { adapterEntry, readHookUpload } from "../hook-upload.js"
 import { checkServiceRoleRoutes, serviceRoleProblemLines } from "../service-role-check.js"
 import { fatalError } from "../ui/fatal.js"
@@ -13,6 +18,8 @@ import {
   serverBaseUrl,
 } from "../project-config.js"
 import { ensureEngine, engineRequest, type DiffResult } from "../engine-client.js"
+import { assertEngineSupportsSchema } from "../engine-floor.js"
+import { pinnedVersion } from "../binary-cache.js"
 import { printDiffOperations, printDiffWarnings } from "../diff-output.js"
 import { signJwt } from "../jwt.js"
 import { provisionBucketsFromAst } from "../storage-provision.js"
@@ -67,6 +74,7 @@ export function registerPush(program: Command): void {
       const ast = loadSchemaAst(schemaPathFromProject(config, cwd), cwd)
       assertModelHooksResolve(cwd, config, ast)
       assertServiceRoleGrantsResolve(cwd, config)
+      assertEngineSupportsSchema(ast, pinnedVersion("engine", config))
 
       const linked = loadProjectLink(cwd)
       const useDirect = opts.direct || opts.local || Boolean(opts.connection)
@@ -312,9 +320,24 @@ function assertServiceRoleGrantsResolve(cwd: string, config: SupatypeProjectConf
 }
 
 function assertModelHooksResolve(cwd: string, config: SupatypeProjectConfig, ast: unknown): void {
-  const problems = validateModelHooks(ast, hooksPathFromProject(config, cwd), cwd)
-  if (problems.length === 0) return
-  fatalError("A model declares a hook whose function does not exist.", problems, {
-    brand: { intro: "Push" },
-  })
+  const dir = hooksPathFromProject(config, cwd)
+
+  const problems = validateModelHooks(ast, dir, cwd)
+  if (problems.length > 0) {
+    fatalError("A model declares a hook whose function does not exist.", problems, {
+      brand: { intro: "Push" },
+    })
+  }
+
+  // Reported separately from hooks, because the fix is different: a missing validator means a field
+  // nobody is checking, and the message should say so rather than talk about lifecycle events.
+  const validatorProblems = validateModelValidators(ast, dir, cwd)
+  if (validatorProblems.length > 0) {
+    fatalError(
+      "A model declares a field validator whose function does not exist, so that field would be " +
+        "written unchecked.",
+      validatorProblems,
+      { brand: { intro: "Push" } },
+    )
+  }
 }

package/src/commands/status.ts

@@ -1,27 +1,19 @@
 /**
- * supatype status: show linked target or local dev stack state.
+ * supatype status: show linked target or local stack state.
  */
 import type { Command } from "commander"
-import { spawnSync } from "node:child_process"
 import { existsSync } from "node:fs"
 import { resolve } from "node:path"
-import { LOCAL_KONG_HOST_PORT, localKongBaseUrl } from "../local-gateway.js"
+import { composeContext, composeServices } from "../compose-services.js"
+import { localKongBaseUrl } from "../local-gateway.js"
 import { loadLocalEnvironment, loadProjectLink } from "../link.js"
 import { resolveTarget, targetStatus } from "../resolve-target.js"
 import { error, info, plain, warn } from "../ui/messages.js"
 
-interface ServiceStatus {
-  name: string
-  container: string
-  status: "running" | "stopped" | "error"
-  port?: number
-  uptime?: string
-}
-
 export function registerStatus(program: Command): void {
   program
     .command("status")
-    .description("Show linked target status or local dev services")
+    .description("Show linked target status or local stack services")
     .option("--env <name>", "Target environment when linked")
     .action(async (opts: { env?: string }) => {
       const cwd = process.cwd()
@@ -73,47 +65,48 @@ async function printLinkedStatus(target: ReturnType<typeof resolveTarget>): Prom
   }
 }
 
+/**
+ * printLocalStackStatus reports what the stack is actually running.
+ *
+ * It asks Docker rather than checking a list of container names held here. The
+ * list this replaced named containers the compose file does not create, and
+ * omitted every one it does, so the command described an eight-service stack
+ * that has not existed since those services moved in-process behind
+ * supatype-server.
+ */
 function printLocalStackStatus(cwd: string): void {
-  const localEnv = loadLocalEnvironment(cwd)
-  const kongPort = localEnv?.kongPort ?? LOCAL_KONG_HOST_PORT
+  const ctx = composeContext(cwd)
+  if (!ctx) {
+    plain("Supatype local stack\n")
+    info("No generated compose file here.")
+    info("Run `supatype self-host compose up` to create the stack, or `supatype dev`,")
+    info("which runs the development stack outside Docker.")
+    return
+  }
 
-  const services: ServiceStatus[] = [
-    { name: "Postgres", container: "supatype-postgres", port: 5432 },
-    { name: "PostgREST", container: "supatype-postgrest", port: 3000 },
-    { name: "GoTrue", container: "supatype-gotrue", port: 9999 },
-    { name: "Kong", container: "supatype-kong", port: kongPort },
-    { name: "Control plane", container: "supatype-control-plane" },
-    { name: "MinIO", container: "supatype-minio", port: 9000 },
-    { name: "Realtime", container: "supatype-realtime", port: 4000 },
-    { name: "Studio", container: "supatype-studio", port: 3100 },
-  ].map((svc) => {
-    const status = getContainerStatus(svc.container)
-    const uptime = getContainerUptime(svc.container)
-    return { ...svc, status, ...(uptime !== undefined && { uptime }) }
-  })
+  const services = composeServices(ctx)
+  plain(`Supatype local stack (${ctx.projectName})\n`)
 
-  plain("Supatype Local Development Stack\n")
+  if (services.length === 0) {
+    info("No containers yet. Start the stack with `supatype self-host compose up`.")
+    return
+  }
 
-  const maxName = Math.max(...services.map((s) => s.name.length))
+  const width = Math.max(...services.map((svc) => svc.service.length))
   for (const svc of services) {
-    const icon = svc.status === "running" ? "●" : svc.status === "stopped" ? "○" : "✕"
-    const status = svc.status.padEnd(8)
-    const port = svc.port ? `:${svc.port}` : ""
-    const uptime = svc.uptime ? ` (${svc.uptime})` : ""
-    plain(`  ${icon} ${svc.name.padEnd(maxName)}  ${status}  ${port}${uptime}`)
+    const icon = svc.state === "running" ? "●" : svc.state === "exited" ? "○" : "✕"
+    const ports = svc.ports ? `  ${svc.ports}` : ""
+    plain(`  ${icon} ${svc.service.padEnd(width)}  ${svc.state.padEnd(10)}${ports}`)
   }
 
-  const running = services.filter((s) => s.status === "running")
+  const running = services.filter((svc) => svc.state === "running")
   plain(`\n${running.length}/${services.length} services running`)
 
   if (running.length > 0) {
-    const apiUrl = localEnv?.apiUrl ?? localKongBaseUrl()
-    plain(`\nAPI URL:    ${apiUrl}`)
-    plain(`Studio:     http://localhost:3100`)
+    const localEnv = loadLocalEnvironment(cwd)
+    plain(`\nAPI URL:    ${localEnv?.apiUrl ?? localKongBaseUrl()}`)
     if (localEnv?.databaseUrl) {
       plain(`Database:   ${localEnv.databaseUrl}`)
-    } else {
-      plain(`Database:   postgresql://supatype_admin:postgres@localhost:5432/postgres`)
     }
   }
 
@@ -122,32 +115,3 @@ function printLocalStackStatus(cwd: string): void {
     info("Link remote ops: supatype link --url <api> --token $SERVICE_ROLE_KEY")
   }
 }
-
-function getContainerStatus(name: string): "running" | "stopped" | "error" {
-  const result = spawnSync("docker", ["inspect", "--format", "{{.State.Status}}", name], {
-    timeout: 5000,
-  })
-  const status = result.stdout?.toString().trim()
-  if (status === "running") return "running"
-  if (result.status !== 0) return "stopped"
-  return "error"
-}
-
-function getContainerUptime(name: string): string | undefined {
-  const result = spawnSync("docker", ["inspect", "--format", "{{.State.StartedAt}}", name], {
-    timeout: 5000,
-  })
-  if (result.status !== 0) return undefined
-  const startedAt = result.stdout?.toString().trim()
-  if (!startedAt) return undefined
-
-  const started = new Date(startedAt)
-  const now = new Date()
-  const diffMs = now.getTime() - started.getTime()
-  if (diffMs < 0) return undefined
-
-  const hours = Math.floor(diffMs / (1000 * 60 * 60))
-  const minutes = Math.floor((diffMs % (1000 * 60 * 60)) / (1000 * 60))
-  if (hours > 0) return `${hours}h ${minutes}m`
-  return `${minutes}m`
-}

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

@@ -22,6 +22,23 @@ export function resolveServerSourceRoot(serverOverride: string, cwd: string): st
   return null
 }
 
+/**
+ * Whether this project's compose stack should run the locally built server image.
+ *
+ * Synchronous and cheap, so any code path that writes `.env` can ask rather than being handed the
+ * answer. It used to be handed down as an argument from the one path that built the image, and the
+ * four paths that did not know about it wrote `.env` without `SUPATYPE_SERVER_IMAGE` while still
+ * asking for unpinned image keys to be cleaned up. Each of those removed the key `dev` had just
+ * written, so `overrides.server` held only until the next `push`, after which compose silently
+ * recreated the container from the published image and the local build was not running at all.
+ */
+export function usesLocalServerImage(cwd: string, config: SupatypeProjectConfig): boolean {
+  if (config.versions?.server !== VERSION_PIN_LOCAL) return false
+  const override = config.overrides?.server?.trim()
+  if (!override) return false
+  return resolveServerSourceRoot(override, cwd) !== 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.