@supatype/cli 0.1.13 → 0.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@supatype/cli",
-  "version": "0.1.13",
+  "version": "0.2.0",
   "license": "Apache-2.0",
   "description": "Supatype CLI: schema push, introspect, generate",
   "type": "module",
@@ -41,7 +41,7 @@
     "@types/pg": "^8",
     "@types/react": "^18.3.18",
     "vitest": "^4.0.18",
-    "@supatype/types": "0.1.13"
+    "@supatype/types": "0.2.0"
   },
   "scripts": {
     "build": "tsc --project tsconfig.json && node --input-type=module -e \"import{cpSync,mkdirSync}from'node:fs';const a='dist/assets';mkdirSync(a,{recursive:true});cpSync('assets/supatype-logo-wordmark.ascii.txt',a+'/supatype-logo-wordmark.ascii.txt')\"",

package/src/cli-version-embedded.ts

@@ -9,4 +9,4 @@
 // Annotated `string`, not left to inference: once a release stamps a value here, the
 // inferred literal type makes the `!== ""` test in cliPackageVersion() a compile error
 // (TS2367, no overlap), so the build would only fail during a release.
-export const EMBEDDED_CLI_VERSION: string = "0.1.13"
+export const EMBEDDED_CLI_VERSION: string = "0.2.0"

package/src/commands/admin.ts

@@ -52,18 +52,18 @@ function assertStudioRole(role: string): void {
   process.exit(1)
 }
 
-/** GoTrue scopes users to the nil instance id in single-tenant/self-host mode. */
-export const GOTRUE_NIL_INSTANCE_ID = "00000000-0000-0000-0000-000000000000"
+/** The auth service scopes users to the nil instance id in single-tenant/self-host mode. */
+export const SUPATYPE_NIL_INSTANCE_ID = "00000000-0000-0000-0000-000000000000"
 
-/** Audience claim used by GoTrue when looking up users (matches GOTRUE_JWT_AUD in compose). */
-export function gotrueJwtAud(cwd: string): string {
-  return readEnvValue(cwd, "GOTRUE_JWT_AUD", "authenticated")
+/** Audience claim used when looking up users (matches SUPATYPE_JWT_AUD in compose). */
+export function authJwtAud(cwd: string): string {
+  return readEnvValue(cwd, "SUPATYPE_JWT_AUD", "authenticated")
 }
 
 type DbQuery = (sql: string, params?: unknown[]) => Promise<QueryResult>
 type AuthConfirmedColumn = "email_confirmed_at" | "confirmed_at"
 
-/** Prefer GoTrue's column when migrated; fall back to postgres init `confirmed_at`. */
+/** Prefer the migrated column when present; fall back to postgres init `confirmed_at`. */
 export async function resolveAuthConfirmedAtColumn(query: DbQuery): Promise<AuthConfirmedColumn> {
   const result = await query(
     `SELECT column_name
@@ -464,14 +464,14 @@ async function createAdminUser(
       : (db as DbQuery)
 
   const normalized = email.toLowerCase()
-  const aud = opts.aud ?? (opts.cwd ? gotrueJwtAud(opts.cwd) : "authenticated")
+  const aud = opts.aud ?? (opts.cwd ? authJwtAud(opts.cwd) : "authenticated")
   const existing = await query(
     `SELECT id FROM auth.users
      WHERE instance_id = $1::uuid
        AND LOWER(email) = $2
        AND aud = $3
        AND is_sso_user = false`,
-    [GOTRUE_NIL_INSTANCE_ID, normalized, aud],
+    [SUPATYPE_NIL_INSTANCE_ID, normalized, aud],
   )
   if (existing.rows.length > 0) {
     throw new Error(`User with email "${email}" already exists.`)
@@ -507,7 +507,7 @@ async function createAdminUser(
       false, false,
       now(), now()
     ) RETURNING id, email`,
-    [GOTRUE_NIL_INSTANCE_ID, aud, normalized, passwordHash, appMetadata, userMetadata],
+    [SUPATYPE_NIL_INSTANCE_ID, aud, normalized, passwordHash, appMetadata, userMetadata],
   )
 
   const user = result.rows[0] as { id: string; email: string }
@@ -601,7 +601,7 @@ async function hasAdminUsers(query: DbQuery): Promise<boolean> {
   if (!(await studioMembersTableExists(query))) return false
 
   // Inner JOIN on purpose, unlike `list-users`: a membership held by a cloud
-  // account cannot log in to a self-hosted GoTrue, so a project exported from
+  // account cannot log in to a self-hosted auth service, so a project exported from
   // cloud with only those grants genuinely still needs a first admin.
   const adminCount = await query(
     `SELECT COUNT(*)::int as count

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

@@ -18,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"
@@ -72,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)

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`
-}