@supatype/cli 0.1.0-alpha.9 → 0.1.1

package/src/commands/self-host.ts

@@ -1,8 +1,8 @@
 /**
  * self-host commands — manage self-hosted deployments.
  *
- * Compose-based commands are the canonical path.
- * Native/systemd commands are kept temporarily for migration compatibility.
+ * Compose-based commands are the default path.
+ * Native/systemd commands remain available for bare-metal deployments.
  */
 
 import { Command } from "commander"
@@ -17,7 +17,10 @@ import { resolveBinary } from "../binary-cache.js"
 import { generateUnits } from "../systemd.js"
 import { readPid } from "../process-manager.js"
 import { localStorageEnv } from "../local-storage.js"
-import { runDockerCompose, writeSelfHostCompose } from "../self-host-compose.js"
+import { composeProjectName, exitComposeFailed, runDockerCompose, writeSelfHostCompose } from "../self-host-compose.js"
+import { file, error, info, plain, warn } from "../ui/messages.js"
+import { nextSteps } from "../ui/next-steps.js"
+import { withSpinner } from "../ui/progress.js"
 
 export function registerSelfHost(program: Command): void {
   const selfHostCmd = program
@@ -35,20 +38,27 @@ export function registerSelfHost(program: Command): void {
       const cwd = process.cwd()
       const config = loadConfig(cwd)
       const out = writeSelfHostCompose(cwd, config)
-      console.log(`Wrote ${out.composePath}`)
-      console.log(`Wrote ${out.kongPath}`)
+      file("wrote", out.composePath)
+      file("wrote", out.kongPath)
     })
 
   composeCmd
     .command("up")
     .description("Render and start compose services")
     .option("-d, --detach", "Start in detached mode", true)
-    .action((opts: { detach?: boolean }) => {
+    .action(async (opts: { detach?: boolean }) => {
       const cwd = process.cwd()
       const config = loadConfig(cwd)
-      const out = writeSelfHostCompose(cwd, config)
-      const status = runDockerCompose(out.composePath, opts.detach ? ["up", "-d"] : ["up"], cwd)
-      process.exitCode = status
+      const project = composeProjectName(config.project.name)
+      const args = opts.detach ? ["up", "-d"] : ["up"]
+      const brand = { intro: "Self-host deployment" }
+      const status = await withSpinner("Starting self-host Compose stack", async () => {
+        const out = writeSelfHostCompose(cwd, config)
+        return runDockerCompose(out.composePath, args, cwd, project, { brand })
+      })
+      if (status !== 0) {
+        exitComposeFailed(status, "Could not start the self-host Compose stack.", brand)
+      }
     })
 
   composeCmd
@@ -58,7 +68,17 @@ export function registerSelfHost(program: Command): void {
       const cwd = process.cwd()
       const config = loadConfig(cwd)
       const out = writeSelfHostCompose(cwd, config)
-      process.exitCode = runDockerCompose(out.composePath, ["down"], cwd)
+      const brand = { intro: "Self-host deployment" }
+      const status = runDockerCompose(
+        out.composePath,
+        ["down"],
+        cwd,
+        composeProjectName(config.project.name),
+        { brand },
+      )
+      if (status !== 0) {
+        exitComposeFailed(status, "Could not stop the self-host Compose stack.", brand)
+      }
     })
 
   composeCmd
@@ -68,7 +88,13 @@ export function registerSelfHost(program: Command): void {
       const cwd = process.cwd()
       const config = loadConfig(cwd)
       const out = writeSelfHostCompose(cwd, config)
-      process.exitCode = runDockerCompose(out.composePath, ["ps"], cwd)
+      process.exitCode = runDockerCompose(
+        out.composePath,
+        ["ps"],
+        cwd,
+        composeProjectName(config.project.name),
+        { brand: { intro: "Self-host deployment" } },
+      )
     })
 
   composeCmd
@@ -83,10 +109,16 @@ export function registerSelfHost(program: Command): void {
       const args = ["logs"]
       if (opts.follow) args.push("-f")
       if (opts.service) args.push(opts.service)
-      process.exitCode = runDockerCompose(out.composePath, args, cwd)
+      process.exitCode = runDockerCompose(
+        out.composePath,
+        args,
+        cwd,
+        composeProjectName(config.project.name),
+        { brand: { intro: "Self-host deployment" } },
+      )
     })
 
-  // ── Legacy native/systemd helpers (hidden; use compose for self-host) ─────
+  // ── Native/systemd helpers (hidden; compose is the default self-host path) ─────
 
   const legacyCmd = new Command("native")
   selfHostCmd.addCommand(legacyCmd, { hidden: true })
@@ -105,42 +137,41 @@ export function registerSelfHost(program: Command): void {
         user?: string
         enable: boolean
       }) => {
-        logLegacyWarning("install-service")
+        logNativeHint("install-service")
         const cwd = process.cwd()
         const config = loadConfig(cwd)
 
         const systemdDir = opts.outputDir ?? ".supatype/systemd"
         const absSystemdDir = resolve(cwd, systemdDir)
 
-        console.log("Generating systemd unit files...")
+        info("Generating systemd unit files...")
         const { postgres, server } = generateUnits(config, cwd, {
           outputDir: absSystemdDir,
           ...(opts.user !== undefined && { user: opts.user }),
         })
-        console.log(`  wrote ${postgres}`)
-        console.log(`  wrote ${server}`)
+        plain(`  wrote ${postgres}`)
+        plain(`  wrote ${server}`)
 
         if (!opts.enable) {
-          console.log(
-            `\nTo install manually:\n` +
-            `  sudo cp ${postgres} /etc/systemd/system/\n` +
-            `  sudo cp ${server} /etc/systemd/system/\n` +
-            `  sudo systemctl daemon-reload\n` +
-            `  sudo systemctl enable --now supatype-postgres supatype-server`,
-          )
+          nextSteps("To install manually:", [
+            `sudo cp ${postgres} /etc/systemd/system/`,
+            `sudo cp ${server} /etc/systemd/system/`,
+            "sudo systemctl daemon-reload",
+            "sudo systemctl enable --now supatype-postgres supatype-server",
+          ])
           return
         }
 
         if (process.platform !== "linux") {
-          console.log(
-            "\nNote: systemd unit installation is only supported on Linux.\n" +
+          info(
+            "systemd unit installation is only supported on Linux. " +
             `Unit files are at ${absSystemdDir}/`,
           )
           return
         }
 
         // Install to /etc/systemd/system/
-        console.log("\nInstalling to /etc/systemd/system/ (requires sudo)...")
+        info("Installing to /etc/systemd/system/ (requires sudo)...")
         const units = [
           { src: postgres, dest: "/etc/systemd/system/supatype-postgres.service" },
           { src: server, dest: "/etc/systemd/system/supatype-server.service" },
@@ -148,7 +179,7 @@ export function registerSelfHost(program: Command): void {
         for (const { src, dest } of units) {
           const cp = spawnSync("sudo", ["cp", src, dest], { stdio: "inherit" })
           if (cp.status !== 0) {
-            console.error(`Failed to copy ${src} to ${dest}`)
+            error(`Failed to copy ${src} to ${dest}`)
             process.exit(1)
           }
         }
@@ -163,9 +194,9 @@ export function registerSelfHost(program: Command): void {
         )
         if (enable.status !== 0) { process.exit(1) }
 
-        console.log("\nServices installed and started.")
-        console.log("  supatype-postgres.service")
-        console.log("  supatype-server.service")
+        info("Services installed and started.")
+        plain("  supatype-postgres.service")
+        plain("  supatype-server.service")
       },
     )
 
@@ -175,7 +206,7 @@ export function registerSelfHost(program: Command): void {
     .command("serve", "Start supatype-server in the foreground (for standalone mode)")
     .option("--port <port>", "Override port from config")
     .action(async (opts: { port?: string }) => {
-      logLegacyWarning("serve")
+      logNativeHint("serve")
       const cwd = process.cwd()
       const config = loadConfig(cwd)
 
@@ -191,7 +222,7 @@ export function registerSelfHost(program: Command): void {
       const stateDir = join(homedir(), ".supatype", "projects", config.project.name)
       const storageEnv = config.storage?.provider !== "s3" ? localStorageEnv(stateDir) : {}
 
-      console.log(`Starting supatype-server on port ${port}...`)
+      info(`Starting supatype-server on port ${port}...`)
       const result = spawnSync(serverBin, args, {
         stdio: "inherit",
         cwd,
@@ -205,7 +236,7 @@ export function registerSelfHost(program: Command): void {
   legacyCmd
     .command("reload", "Reload the running supatype-server (SIGHUP for config reload)")
     .action(() => {
-      logLegacyWarning("reload")
+      logNativeHint("reload")
       const cwd = process.cwd()
       const config = loadConfig(cwd)
       const stateDir = join(homedir(), ".supatype", "projects", config.project.name)
@@ -218,16 +249,16 @@ export function registerSelfHost(program: Command): void {
           process.exitCode = result.status ?? 1
           return
         }
-        console.error("Server does not appear to be running (no PID file found).")
+        error("Server does not appear to be running (no PID file found).")
         process.exitCode = 1
         return
       }
 
       try {
         process.kill(pid, "SIGHUP")
-        console.log(`Sent SIGHUP to supatype-server (pid ${pid}).`)
+        info(`Sent SIGHUP to supatype-server (pid ${pid}).`)
       } catch (err) {
-        console.error(`Failed to signal pid ${pid}:`, (err as Error).message)
+        error(`Failed to signal pid ${pid}: ${(err as Error).message}`)
         process.exitCode = 1
       }
     })
@@ -237,12 +268,12 @@ export function registerSelfHost(program: Command): void {
   legacyCmd
     .command("status", "Show running status of supatype services")
     .action(() => {
-      logLegacyWarning("status")
+      logNativeHint("status")
       const cwd = process.cwd()
       const config = loadConfig(cwd)
       const stateDir = join(homedir(), ".supatype", "projects", config.project.name)
 
-      console.log(`Project: ${config.project.name}\n`)
+      plain(`Project: ${config.project.name}\n`)
 
       if (process.platform === "linux" && existsSync("/run/systemd/system")) {
         // systemd is active
@@ -251,19 +282,19 @@ export function registerSelfHost(program: Command): void {
             encoding: "utf8",
           })
           const active = result.stdout?.includes("active (running)") ? "running" : "stopped"
-          console.log(`  ${svc}: ${active}`)
+          plain(`  ${svc}: ${active}`)
         }
       } else {
         // PID file check
         const serverPid = readPid(join(stateDir, "pid"), "server")
         const pgPid = readPid(join(stateDir, "pid"), "postgres")
-        console.log(`  postgres:          ${pgPid ? `running (pid ${pgPid})` : "stopped"}`)
-        console.log(`  supatype-server:   ${serverPid ? `running (pid ${serverPid})` : "stopped"}`)
+        plain(`  postgres:          ${pgPid ? `running (pid ${pgPid})` : "stopped"}`)
+        plain(`  supatype-server:   ${serverPid ? `running (pid ${serverPid})` : "stopped"}`)
       }
 
       const logDir = join(stateDir, "logs")
       if (existsSync(logDir)) {
-        console.log(`\nLogs: ${logDir}`)
+        plain(`\nLogs: ${logDir}`)
       }
     })
 
@@ -275,7 +306,7 @@ export function registerSelfHost(program: Command): void {
     .option("--lines <n>", "Number of lines to show", "50")
     .option("-f, --follow", "Follow log output")
     .action((opts: { service?: string; lines: string; follow?: boolean }) => {
-      logLegacyWarning("logs")
+      logNativeHint("logs")
       const cwd = process.cwd()
       const config = loadConfig(cwd)
       const stateDir = join(homedir(), ".supatype", "projects", config.project.name)
@@ -301,7 +332,7 @@ export function registerSelfHost(program: Command): void {
 
       for (const { label, file } of targets) {
         if (!existsSync(file)) {
-          console.log(`[${label}] log file not found: ${file}`)
+          plain(`[${label}] log file not found: ${file}`)
           continue
         }
         if (opts.follow) {
@@ -311,7 +342,7 @@ export function registerSelfHost(program: Command): void {
           const n = parseInt(opts.lines, 10)
           const content = readFileSync(file, "utf8")
           const lines = content.split("\n")
-          console.log(lines.slice(-n).join("\n"))
+          plain(lines.slice(-n).join("\n"))
         }
       }
     })
@@ -323,7 +354,7 @@ export function registerSelfHost(program: Command): void {
     .option("--output <path>", "Output file path (default: ./backups/backup-<timestamp>.sql.gz)")
     .option("--connection <url>", "Database connection URL (overrides config)")
     .action((opts: { output?: string; connection?: string }) => {
-      logLegacyWarning("backup")
+      logNativeHint("backup")
       const cwd = process.cwd()
       const config = loadConfig(cwd)
       const conn = opts.connection ?? connectionString(config)
@@ -335,7 +366,7 @@ export function registerSelfHost(program: Command): void {
 
       mkdirSync(resolve(outFile, ".."), { recursive: true })
 
-      console.log(`Backing up database to ${outFile}...`)
+      info(`Backing up database to ${outFile}...`)
       try {
         // Avoid shell interpolation of user-supplied values.
         const pgDump = spawnSync("pg_dump", [conn], {
@@ -348,17 +379,17 @@ export function registerSelfHost(program: Command): void {
 
         const compressed = gzipSync(pgDump.stdout)
         writeFileSync(outFile, compressed)
-        console.log("Backup complete.")
+        info("Backup complete.")
       } catch (err) {
-        console.error("Backup failed:", (err as Error).message)
+        error(`Backup failed: ${(err as Error).message}`)
         process.exit(1)
       }
     })
 }
 
-function logLegacyWarning(cmd: string): void {
-  console.warn(
-    `[supatype] self-host native ${cmd} is deprecated. ` +
-      "Use `supatype self-host compose` commands instead.",
+function logNativeHint(cmd: string): void {
+  warn(
+    `self-host native ${cmd}: Docker Compose is the default path. ` +
+      "Use `supatype self-host compose` unless you need bare-metal systemd/binaries.",
   )
 }

package/src/commands/self-update.ts

@@ -7,6 +7,7 @@
 
 import type { Command } from "commander"
 import { sep } from "node:path"
+import { error, plain } from "../ui/messages.js"
 
 function looksLikeNpmOrWorkspaceCLI(): boolean {
   const main = process.argv[1] ?? ""
@@ -27,7 +28,7 @@ export function registerSelfUpdate(program: Command): void {
     )
     .action(() => {
       if (looksLikeNpmOrWorkspaceCLI()) {
-        console.log(
+        plain(
           "This CLI was installed via npm (or runs from the package workspace).\n" +
             "Update with:\n\n  npm update -g @supatype/cli\n\n" +
             "To bump engine/server/postgres/deno pinned in supatype.config.ts, use:\n\n  supatype update\n",
@@ -35,7 +36,7 @@ export function registerSelfUpdate(program: Command): void {
         return
       }
 
-      console.error(
+      error(
         "Standalone CLI self-update (replace binary from CDN) is not published yet.\n\n" +
           "Install or upgrade via npm:\n  npm install -g @supatype/cli\n\n" +
           "Component binaries (engine, server, postgres, deno):\n  supatype update\n",

package/src/commands/status.ts

@@ -1,9 +1,14 @@
 /**
- * supatype status — show current state of local dev services.
+ * supatype status — show linked target or local dev 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 { 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
@@ -16,42 +21,106 @@ interface ServiceStatus {
 export function registerStatus(program: Command): void {
   program
     .command("status")
-    .description("Show current state of local dev services")
-    .action(() => {
-      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: LOCAL_KONG_HOST_PORT },
-        { 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 }) }
-      })
-
-      console.log("Supatype Local Development Stack\n")
-
-      const maxName = Math.max(...services.map((s) => s.name.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})` : ""
-        console.log(`  ${icon} ${svc.name.padEnd(maxName)}  ${status}  ${port}${uptime}`)
+    .description("Show linked target status or local dev services")
+    .option("--env <name>", "Target environment when linked")
+    .action(async (opts: { env?: string }) => {
+      const cwd = process.cwd()
+      const link = loadProjectLink(cwd)
+      const localEnv = loadLocalEnvironment(cwd)
+
+      if (link || localEnv) {
+        try {
+          const target = resolveTarget(cwd, { env: opts.env })
+          if (target.mode !== "direct") {
+            await printLinkedStatus(target)
+            return
+          }
+        } catch (err) {
+          error((err as Error).message)
+          process.exitCode = 1
+          return
+        }
       }
 
-      const running = services.filter((s) => s.status === "running")
-      console.log(`\n${running.length}/${services.length} services running`)
+      printLocalStackStatus(cwd)
+    })
+}
+
+async function printLinkedStatus(target: ReturnType<typeof resolveTarget>): Promise<void> {
+  info(`Target: ${target.mode} (${target.environment})`)
+  info(`Project: ${target.projectRef}`)
+  info(`API: ${target.apiBaseUrl}${target.apiPrefix}`)
+  plain()
 
-      if (running.length > 0) {
-        console.log(`\nAPI URL:    ${localKongBaseUrl()}`)
-        console.log(`Studio:     http://localhost:3100`)
-        console.log(`Database:   postgresql://supatype_admin:postgres@localhost:5432/postgres`)
+  try {
+    const data = (await targetStatus(target)) as Record<string, unknown>
+    if (data.functions && Array.isArray(data.functions)) {
+      plain(`Functions (${data.functions.length}):`)
+      for (const fn of data.functions as Array<{ name?: string } | string>) {
+        const name = typeof fn === "string" ? fn : fn.name
+        if (name) plain(`  • ${name}`)
       }
-    })
+      plain()
+    }
+    if (data.deploymentId) {
+      info(`Active deployment: ${data.deploymentId}`)
+    }
+    if (data.controlPlane) {
+      info(`Control plane: ${data.controlPlane}`)
+    }
+  } catch (err) {
+    warn(`Could not fetch remote status: ${(err as Error).message}`)
+  }
+}
+
+function printLocalStackStatus(cwd: string): void {
+  const localEnv = loadLocalEnvironment(cwd)
+  const kongPort = localEnv?.kongPort ?? LOCAL_KONG_HOST_PORT
+
+  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 }) }
+  })
+
+  plain("Supatype Local Development Stack\n")
+
+  const maxName = Math.max(...services.map((s) => s.name.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 running = services.filter((s) => s.status === "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`)
+    if (localEnv?.databaseUrl) {
+      plain(`Database:   ${localEnv.databaseUrl}`)
+    } else {
+      plain(`Database:   postgresql://supatype_admin:postgres@localhost:5432/postgres`)
+    }
+  }
+
+  if (existsSync(resolve(cwd, ".supatype/environment.json"))) {
+    plain("\nLocal environment file: .supatype/environment.json")
+    info("Link remote ops: supatype link --url <api> --token $SERVICE_ROLE_KEY")
+  }
 }
 
 function getContainerStatus(name: string): "running" | "stopped" | "error" {

package/src/commands/types.ts

@@ -3,6 +3,7 @@ import { existsSync, readFileSync } from "node:fs"
 import { resolve, relative } from "node:path"
 import ts from "typescript"
 import { loadConfig } from "../config.js"
+import { error, plain } from "../ui/messages.js"
 
 export function registerTypes(program: Command): void {
   const types = program.command("types").description("Type generation and validation utilities")
@@ -63,11 +64,11 @@ export function registerTypes(program: Command): void {
       }
 
       if (errors.length > 0) {
-        for (const err of errors) console.error(`- ${err}`)
+        for (const err of errors) error(err)
         process.exit(1)
       }
 
-      console.log("types check passed")
+      plain("types check passed")
     })
 }