@supatype/cli 0.1.0-alpha.8 → 0.1.0

package/src/commands/dev.ts

@@ -16,6 +16,7 @@ import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs"
 import { homedir } from "node:os"
 import { isAbsolute, join, relative, resolve } from "node:path"
 import { loadConfig } from "../config.js"
+import type { ExtractedSchemaAstV2 } from "../schema-ast-v2.js"
 import {
   functionsPathCandidatesFromProject,
   resolveRuntimeProvider,
@@ -36,7 +37,12 @@ import { ensureBinary } from "../ensure-binary.js"
 import { startProxyDevApp } from "../app/proxy-dev-app.js"
 import { ProcessManager } from "../process-manager.js"
 import { startStudioViteDevServer } from "../studio-dev-server.js"
+import { restoreSystemRelationTargets } from "../restore-system-relation-targets.js"
 import { localStorageEnv } from "../local-storage.js"
+import { beginDevSession, endDevSession, resolveDevUiMode, startDevSession } from "../dev-session.js"
+import { probeDockerDaemon, reportDockerUnavailable } from "../docker-runtime.js"
+import { fatalError } from "../ui/fatal.js"
+import { registerDevShutdown } from "../dev-shutdown.js"
 import {
   initdb,
   start as pgStart,
@@ -63,17 +69,71 @@ function gotrueSMTPFromEmailConfig(email: SupatypeProjectConfig["email"] | undef
   return out
 }
 
+const NATIVE_PG_PORT = 5432
+
+function portCheckCommand(port: number): string {
+  return process.platform === "win32"
+    ? `netstat -ano | findstr :${port}`
+    : `lsof -i :${port}`
+}
+
+async function assertNativeDevPortsFree(serverPort: number, postgrestPort: number): Promise<void> {
+  const brand = { intro: "Local development" }
+  if (await isPortInUse(NATIVE_PG_PORT)) {
+    fatalError(
+      `Port ${NATIVE_PG_PORT} is already in use.`,
+      ["Another Postgres instance may be running.", `Check: ${portCheckCommand(NATIVE_PG_PORT)}`],
+      { brand },
+    )
+  }
+  if (await isPortInUse(serverPort)) {
+    fatalError(
+      `Port ${serverPort} is already in use.`,
+      ["Another supatype-server may be running.", `Check: ${portCheckCommand(serverPort)}`],
+      { brand },
+    )
+  }
+  if (await isPortInUse(postgrestPort)) {
+    fatalError(
+      `Port ${postgrestPort} is already in use.`,
+      ["Another service may be running.", `Check: ${portCheckCommand(postgrestPort)}`],
+      { brand },
+    )
+  }
+}
+
 export function registerDev(program: Command): void {
   program
     .command("dev")
     .description("Start local Postgres, apply schema, and run supatype-server")
     .option("--no-watch", "Start services but do not watch for schema changes")
+    .option("--stream", "Print interleaved logs instead of the interactive TUI")
     .option("--port <port>", "Port for supatype-server (overrides config)", String)
-    .action(async (opts: { watch: boolean; port?: string }) => {
+    .action(async (opts: { watch: boolean; stream?: boolean; port?: string }) => {
       const cwd = process.cwd()
 
-      // ── 1. Load project config ─────────────────────────────────────────────
+      // ── 1. Load project config (before TUI — fatal errors must hit real stderr) ──
       const config = loadConfig(cwd)
+      const provider = resolveRuntimeProvider(config)
+
+      if (provider === "docker") {
+        const probe = probeDockerDaemon()
+        if (!probe.ok) {
+          reportDockerUnavailable(probe, { brand: { intro: "Local development" } })
+          process.exit(1)
+        }
+      }
+
+      const projectName = config.project.name
+      const serverPort = opts.port ?? String(config.server.port ?? 54321)
+      const postgrestPort = String(config.server.postgrestPort ?? 3001)
+
+      if (provider !== "docker") {
+        await assertNativeDevPortsFree(Number(serverPort), Number(postgrestPort))
+      }
+
+      beginDevSession(resolveDevUiMode(opts.stream === true))
+      startDevSession()
       if (hasMeaningfulOverrides(config)) {
         console.warn("[supatype] Local binary overrides active:")
         for (const line of describeActiveOverrides(config)) {
@@ -81,10 +141,6 @@ export function registerDev(program: Command): void {
         }
         console.warn("")
       }
-      const projectName = config.project.name
-      const serverPort = opts.port ?? String(config.server.port ?? 54321)
-      const postgrestPort = String(config.server.postgrestPort ?? 3001)
-      const provider = resolveRuntimeProvider(config)
 
       if (provider === "docker") {
         const { runDevCompose } = await import("../dev-compose.js")
@@ -109,33 +165,10 @@ export function registerDev(program: Command): void {
         mkdirSync(d, { recursive: true })
       }
 
-      // ── 4. Port collision check ───────────────────────────────────────────
-      const pgPort = 5432
-      if (await isPortInUse(pgPort)) {
-        console.error(
-          `[supatype] Port ${pgPort} is already in use. Another Postgres instance may be running.\n` +
-            `  Check: lsof -i :${pgPort}`,
-        )
-        process.exit(1)
-      }
-      if (await isPortInUse(Number(serverPort))) {
-        console.error(
-          `[supatype] Port ${serverPort} is already in use. Another supatype-server may be running.\n` +
-            `  Check: lsof -i :${serverPort}`,
-        )
-        process.exit(1)
-      }
-      if (await isPortInUse(Number(postgrestPort))) {
-        console.error(
-          `[supatype] Port ${postgrestPort} is already in use. Another service may be running.\n` +
-            `  Check: lsof -i :${postgrestPort}`,
-        )
-        process.exit(1)
-      }
-
       // ── 5–7. Start Postgres ───────────────────────────────────────────────
       let dbURL: string
       let stopPostgres: () => void | Promise<void>
+      const pgPort = NATIVE_PG_PORT
       const pgPassword = "postgres"
       // pgBinDir is set on the native path and used to add DLL search path for
       // PostgREST on Windows (PostgREST links against libpq + SSL from MinGW).
@@ -252,7 +285,8 @@ ALTER DEFAULT PRIVILEGES IN SCHEMA public GRANT ALL ON SEQUENCES TO authenticate
         console.log(`[supatype] Edge functions enabled (${functionsDir})`)
         try {
           denoBinPath = await ensureBinary("deno", config)
-          console.log(`[supatype] Deno runtime: ${denoBinPath} (v${config.versions.deno})`)
+          const denoVersion = await (await import("../binary-cache.js")).resolveVersionFor("deno", config)
+          console.log(`[supatype] Deno runtime: ${denoBinPath} (v${denoVersion})`)
           if (functionRoutes.length > 0) {
             console.log(
               `[supatype] Edge functions router: ${relative(cwd, denoServeScriptAbs) || ".supatype/functions-router.ts"} ` +
@@ -263,7 +297,7 @@ ALTER DEFAULT PRIVILEGES IN SCHEMA public GRANT ALL ON SEQUENCES TO authenticate
           }
         } catch (err) {
           console.warn(
-            `[supatype] ⚠  Found ${functionsDir} but could not provision Deno v${config.versions.deno} — edge functions will not run.\n` +
+            `[supatype] ⚠  Found ${functionsDir} but could not provision Deno — edge functions will not run.\n` +
               `  ${(err as Error).message}\n` +
               "  (Functions still appear in Studio; invocations need Deno.)",
           )
@@ -473,8 +507,8 @@ ALTER DEFAULT PRIVILEGES IN SCHEMA public GRANT ALL ON SEQUENCES TO authenticate
 
 
       // ── Shutdown handler ──────────────────────────────────────────────────
-      const cleanup = async () => {
-        console.log("\n[supatype] Shutting down...")
+      registerDevShutdown(async () => {
+        console.log("[supatype] Shutting down...")
         await Promise.all([
           serverProc.stop(),
           postgrestProc?.stop(),
@@ -482,10 +516,7 @@ ALTER DEFAULT PRIVILEGES IN SCHEMA public GRANT ALL ON SEQUENCES TO authenticate
           appProc?.stop(),
         ])
         await stopPostgres()
-        process.exit(0)
-      }
-      process.once("SIGINT", cleanup)
-      process.once("SIGTERM", cleanup)
+      })
 
       // ── 10. Schema watch ──────────────────────────────────────────────────
       if (opts.watch) {
@@ -564,14 +595,27 @@ async function runSchemaPush(
 
   // Push schema.
   console.log("[supatype] Applying schema...")
-  const pushResult = spawnSync(
-    engineBin,
-    ["push", "-i", astPath, "--database-url", dbURL, "--force", "--non-interactive"],
-    { cwd, stdio: "inherit", encoding: "utf8" },
-  )
-  if (pushResult.status !== 0) {
+  const { ensureEngine, engineRequest } = await import("../engine-client.js")
+  const { writeSchemaSourcePushArtifacts } = await import("../schema-sources.js")
+  await ensureEngine()
+  const pgSchema = config?.schema?.pg_schema ?? "public"
+  const sources = writeSchemaSourcePushArtifacts(cwd)
+  try {
+    await engineRequest("/push", {
+      ast,
+      database_url: dbURL,
+      schema: pgSchema,
+      force: true,
+      ...(sources
+        ? {
+            schema_sources_gz_base64: sources.payload.dataBase64,
+            schema_sources_manifest: sources.payload.manifest,
+          }
+        : {}),
+    })
+  } catch (err) {
     _lastFailedAst = astJson
-    throw new Error(`Engine schema push failed (exit ${pushResult.status})`)
+    throw err
   }
   _lastPushedAst = astJson
   _lastFailedAst = null
@@ -623,6 +667,7 @@ async function runSchemaPush(
       } catch {
         admin = adminResult.stdout
       }
+      restoreSystemRelationTargets(admin, ast)
       const merged = config ? withAdminRoles(admin, config) : admin
       writeFileSync(adminConfigPath, `${JSON.stringify(merged, null, 2)}\n`)
     }
@@ -631,10 +676,6 @@ async function runSchemaPush(
   console.log("[supatype] Schema applied.")
 }
 
-// ---------------------------------------------------------------------------
-// Storage bucket provisioning (local dev only)
-// ---------------------------------------------------------------------------
-
 function provisionStorageBuckets(
   declared: Array<{
     id: string
@@ -702,10 +743,9 @@ async function resolvePgBinDir(config: Awaited<ReturnType<typeof loadConfig>>):
   }
 
   // Locate cached Postgres archive.
-  const { cachePath } = await import("../binary-cache.js")
-  const version = config.versions.postgres
-  const { currentPlatform } = await import("../binary-cache.js")
+  const { cachePath, currentPlatform, resolveVersionFor } = await import("../binary-cache.js")
   const platform = currentPlatform()
+  const version = await resolveVersionFor("postgres", config)
 
   const pgCacheDir = cachePath("postgres", version)
   const extractedDir = join(pgCacheDir, `pg-${version}`)
@@ -915,9 +955,9 @@ const EXTENSION_FIELDS: Record<string, { ext: string; fallback: AstField }> = {
 }
 
 function adaptUnsupportedKinds(
-  ast: unknown,
+  ast: ExtractedSchemaAstV2,
   skipKinds: ReadonlySet<string>,
-): { filtered: unknown; adapted: string[] } {
+): { filtered: ExtractedSchemaAstV2; adapted: string[] } {
   const adapted: string[] = []
   if (!ast || typeof ast !== "object") return { filtered: ast, adapted }
   const schema = ast as AstSchema
@@ -937,7 +977,7 @@ function adaptUnsupportedKinds(
     return { ...model, fields }
   })
 
-  return { filtered: { ...schema, models }, adapted }
+  return { filtered: { ...schema, models } as ExtractedSchemaAstV2, adapted }
 }
 
 // ---------------------------------------------------------------------------

package/src/commands/diff.ts

@@ -1,63 +1,72 @@
 import type { Command } from "commander"
 import { loadConfig, loadSchemaAst } from "../config.js"
-import { connectionString, schemaPathFromProject } from "../project-config.js"
-import { ensureEngine, engineRequest, type DiffResult } from "../engine-client.js"
-import { printDiffWarnings } from "../diff-output.js"
+import { resolveRuntimeProvider, schemaPathFromProject } from "../project-config.js"
+import { printDiffOperations, printDiffWarnings } from "../diff-output.js"
+import { resolveTarget, targetSchemaDiff, schemaPgSchema } from "../resolve-target.js"
+import { loadProjectLink } from "../link.js"
+import { withSpinner } from "../ui/progress.js"
 
 export function registerDiff(program: Command): void {
   program
     .command("diff")
     .description("Show planned schema changes without applying them (dry run)")
     .option("--connection <url>", "Database connection URL (overrides config)")
-    .action(async (opts: { connection?: string }) => {
+    .option("--env <name>", "Target environment when linked")
+    .option("--direct", "Use local engine subprocess")
+    .action(async (opts: { connection?: string; env?: string; direct?: boolean }) => {
       const cwd = process.cwd()
       const config = loadConfig(cwd)
-      const connection = opts.connection ?? connectionString(config)
+      const pgSchema = schemaPgSchema(cwd)
 
-      await ensureEngine()
+      const ast = await withSpinner("Loading schema", async () =>
+        loadSchemaAst(schemaPathFromProject(config, cwd), cwd),
+      )
 
-      console.log("Loading schema...")
-      const ast = loadSchemaAst(schemaPathFromProject(config, cwd), cwd)
+      const linked = loadProjectLink(cwd)
+      const useDirect = opts.direct || Boolean(opts.connection)
 
-      const diff = await engineRequest<DiffResult>("/diff", {
-        ast,
-        database_url: connection,
-        schema: "public",
-      })
-
-      const ops = diff.operations ?? []
-      printDiffWarnings(diff)
-
-      if (ops.length === 0) {
-        console.log("No changes.")
+      if (linked && !useDirect && !opts.connection) {
+        const target = resolveTarget(cwd, { env: opts.env })
+        const diff = await withSpinner("Computing diff", () =>
+          targetSchemaDiff(target, ast, { schema: pgSchema }),
+        )
+        printDiffWarnings(diff)
+        printDiffOperations(diff)
         return
       }
 
-      const symbol: Record<NonNullable<DiffResult["operations"][number]["risk"]>, string> = {
-        safe: "+",
-        warn: "~",
-        cautious: "~",
-        danger: "!",
-        destructive: "!",
-      }
-      const legend: typeof symbol = {
-        safe: "safe",
-        warn: "caution",
-        cautious: "caution",
-        danger: "DANGER",
-        destructive: "DANGER",
-      }
-
-      console.log(`\n${ops.length} change(s):\n`)
-      for (const op of ops) {
-        const r = op.risk ?? "safe"
-        console.log(`  [${symbol[r]}] ${op.description}  (${legend[r]})`)
+      if (
+        !opts.connection &&
+        !useDirect &&
+        resolveRuntimeProvider(config) === "docker"
+      ) {
+        const localTarget = resolveTarget(cwd, { env: opts.env })
+        if (localTarget.mode === "local" && localTarget.token) {
+          const diff = await withSpinner("Computing diff", () =>
+            targetSchemaDiff(localTarget, ast, { schema: pgSchema }),
+          )
+          printDiffWarnings(diff)
+          printDiffOperations(diff)
+          return
+        }
+        const { diffSchemaDocker } = await import("../dev-compose.js")
+        const diff = await withSpinner("Computing diff via Docker Compose", () =>
+          diffSchemaDocker(cwd, config),
+        )
+        printDiffWarnings(diff)
+        printDiffOperations(diff)
+        return
       }
 
-      const dangerous = ops.filter((o) => o.risk === "danger").length
-      if (dangerous > 0) {
-        console.log(`\n  ${dangerous} dangerous operation(s). Review before pushing.`)
-      }
-      console.log()
+      const target = resolveTarget(cwd, {
+        env: opts.env,
+        direct: true,
+        connection: opts.connection,
+      })
+      const diff = await withSpinner("Computing diff", () =>
+        targetSchemaDiff(target, ast, { schema: pgSchema }),
+      )
+      printDiffWarnings(diff)
+      printDiffOperations(diff)
     })
 }

package/src/commands/doctor.ts

@@ -0,0 +1,103 @@
+import type { Command } from "commander"
+import { loadConfig, loadSchemaAst } from "../config.js"
+import { info, plain } from "../ui/messages.js"
+import { schemaPathFromProject } from "../project-config.js"
+import { resolveTarget, targetSchemaDoctor, schemaPgSchema } from "../resolve-target.js"
+import { loadProjectLink } from "../link.js"
+import { resolveHostEngineDatabaseUrl } from "../dev-compose.js"
+
+interface DoctorItem {
+  kind: string
+  table: string
+  name: string
+  fields: string[]
+  message: string
+}
+
+interface DoctorReport {
+  missing: DoctorItem[]
+  staleManaged: DoctorItem[]
+  unmanagedDrift: DoctorItem[]
+}
+
+function printSection(title: string, items: DoctorItem[]): void {
+  if (items.length === 0) return
+  plain(`\n${title} (${items.length}):\n`)
+  for (const item of items) {
+    const fields = item.fields.length > 0 ? ` (${item.fields.join(", ")})` : ""
+    plain(`  • ${item.table}.${item.name}${fields}`)
+    plain(`    ${item.message}`)
+  }
+}
+
+export function registerDoctor(program: Command): void {
+  program
+    .command("doctor")
+    .description("Report schema drift between schema/index.ts and the live database")
+    .option("--connection <url>", "Database connection URL (overrides config)")
+    .option("--env <name>", "Target environment when linked")
+    .option("--strict", "Exit non-zero when missing or stale managed drift exists")
+    .option("--no-cache", "Force full database introspection")
+    .option("--direct", "Use local engine subprocess")
+    .action(async (opts: {
+      connection?: string
+      env?: string
+      strict?: boolean
+      noCache?: boolean
+      direct?: boolean
+    }) => {
+      const cwd = process.cwd()
+      const config = loadConfig(cwd)
+      const pgSchema = schemaPgSchema(cwd)
+
+      info("Loading schema...")
+      const ast = loadSchemaAst(schemaPathFromProject(config, cwd), cwd)
+
+      let report: DoctorReport
+
+      const linked = loadProjectLink(cwd)
+      if (linked && !opts.direct && !opts.connection) {
+        const target = resolveTarget(cwd, { env: opts.env })
+        report = (await targetSchemaDoctor(target, ast, {
+          noCache: opts.noCache,
+          schema: pgSchema,
+        })) as DoctorReport
+      } else if (!opts.direct && !opts.connection) {
+        const connection = await resolveHostEngineDatabaseUrl(cwd, config, opts.connection)
+        const target = resolveTarget(cwd, { direct: true, connection })
+        report = (await targetSchemaDoctor(target, ast, {
+          noCache: opts.noCache,
+          schema: pgSchema,
+        })) as DoctorReport
+        void connection
+      } else {
+        const target = resolveTarget(cwd, {
+          env: opts.env,
+          direct: true,
+          connection: opts.connection,
+        })
+        report = (await targetSchemaDoctor(target, ast, {
+          noCache: opts.noCache,
+          schema: pgSchema,
+        })) as DoctorReport
+      }
+
+      printSection("Missing (in AST, not in DB)", report.missing ?? [])
+      printSection("Stale managed (stamped, not in AST)", report.staleManaged ?? [])
+      printSection("Unmanaged drift (manual decision)", report.unmanagedDrift ?? [])
+
+      const missing = report.missing?.length ?? 0
+      const stale = report.staleManaged?.length ?? 0
+      const unmanaged = report.unmanagedDrift?.length ?? 0
+
+      if (missing + stale + unmanaged === 0) {
+        info("No drift detected.")
+      } else {
+        plain(`\nSummary: ${missing} missing, ${stale} stale managed, ${unmanaged} unmanaged`)
+      }
+
+      if (opts.strict && (missing > 0 || stale > 0)) {
+        process.exit(1)
+      }
+    })
+}

package/src/commands/engine.ts

@@ -5,6 +5,7 @@
 
 import type { Command } from "commander"
 import { engineHealth } from "../engine-client.js"
+import { error, info } from "../ui/messages.js"
 
 export function registerEngine(program: Command): void {
   const engine = program
@@ -16,14 +17,14 @@ export function registerEngine(program: Command): void {
     .description("Check if the schema engine container is reachable")
     .action(async () => {
       const url = process.env["SUPATYPE_ENGINE_URL"] ?? "http://localhost:7500"
-      console.log(`Checking engine at ${url}...`)
+      info(`Checking engine at ${url}...`)
 
       const healthy = await engineHealth()
       if (healthy) {
-        console.log("Engine is reachable and healthy.")
+        info("Engine is reachable and healthy.")
       } else {
-        console.error("Engine is not reachable.")
-        console.error("Make sure the engine container is running (supatype dev or docker compose up).")
+        error("Engine is not reachable.")
+        error("Make sure the engine container is running (supatype dev or docker compose up).")
         process.exitCode = 1
       }
     })