@supatype/cli 0.1.0-alpha.9 → 0.1.0

package/src/commands/adopt.ts

@@ -0,0 +1,82 @@
+import type { Command } from "commander"
+import { loadConfig, loadSchemaAst } from "../config.js"
+import { schemaPathFromProject } from "../project-config.js"
+import { loadProjectLink } from "../link.js"
+import { resolveTarget, targetSchemaAdopt, schemaPgSchema } from "../resolve-target.js"
+import { confirm } from "../ui/confirm.js"
+import { info, plain } from "../ui/messages.js"
+import { withSpinner } from "../ui/progress.js"
+
+interface AdoptPreview {
+  status: string
+  stampStatements?: string[]
+  doctor?: {
+    missing: unknown[]
+    staleManaged: unknown[]
+    unmanagedDrift: unknown[]
+  }
+}
+
+export function registerAdopt(program: Command): void {
+  program
+    .command("adopt")
+    .description("Stamp Supatype-managed comments on DB objects matching the schema (adoption ceremony)")
+    .option("--connection <url>", "Database connection URL (overrides config)")
+    .option("--env <name>", "Target environment when linked")
+    .option("--direct", "Use local engine subprocess")
+    .option("--yes", "Apply stamps without interactive confirmation")
+    .option("--no-cache", "Force full database introspection")
+    .action(async (opts: {
+      connection?: string
+      env?: string
+      direct?: boolean
+      yes?: boolean
+      noCache?: boolean
+    }) => {
+      const cwd = process.cwd()
+      const config = loadConfig(cwd)
+      const pgSchema = schemaPgSchema(cwd)
+
+      const ast = await withSpinner("Loading schema", async () =>
+        loadSchemaAst(schemaPathFromProject(config, cwd), cwd),
+      )
+
+      const linked = loadProjectLink(cwd)
+      const target = linked && !opts.direct && !opts.connection
+        ? resolveTarget(cwd, { env: opts.env })
+        : resolveTarget(cwd, { env: opts.env, direct: true, connection: opts.connection })
+
+      const preview = (await targetSchemaAdopt(target, ast, {
+        schema: pgSchema,
+        noCache: opts.noCache ?? false,
+        yes: false,
+      })) as AdoptPreview
+
+      const statements = preview.stampStatements ?? []
+      if (statements.length === 0) {
+        info("Nothing to stamp — matching objects are already managed or absent.")
+        return
+      }
+
+      plain(`\nWill stamp ${statements.length} object(s):\n`)
+      for (const sql of statements) {
+        plain(`  ${sql}`)
+      }
+
+      if (!opts.yes) {
+        const ok = await confirm("Apply adoption stamps?", { default: false })
+        if (!ok) {
+          plain("Adoption cancelled.")
+          return
+        }
+      }
+
+      const result = (await targetSchemaAdopt(target, ast, {
+        schema: pgSchema,
+        noCache: opts.noCache ?? false,
+        yes: true,
+      })) as { status: string; stamped?: number; name?: string }
+
+      info(`Adopted: ${result.stamped ?? 0} object(s) stamped (${result.name ?? "ok"}).`)
+    })
+}

package/src/commands/app.ts

@@ -3,6 +3,8 @@ import { existsSync, mkdirSync } from "node:fs"
 import { resolve } from "node:path"
 import { localKongBaseUrl } from "../local-gateway.js"
 import { updateAppConfigInProject } from "../app-config.js"
+import { error, file, info, warn } from "../ui/messages.js"
+import { nextSteps } from "../ui/next-steps.js"
 
 export function registerApp(program: Command): void {
   const appCmd = program
@@ -14,7 +16,7 @@ export function registerApp(program: Command): void {
     .description("Configure app routing: --static for a built site, or proxy to a dev server")
     .option("--static", "Serve a static directory at / (default: ./public, or [dir] argument)")
     .option("--port <port>", "Port your app listens on (proxy mode)", "3000")
-    .option("--upstream <url>", "Explicit upstream URL (proxy mode; defaults to localhost:<port>)")
+    .option("--upstream <url>", "URL of your running dev server (proxy mode; defaults to localhost:<port>)")
     .option("--dockerfile <path>", "(deprecated) ignored — use supatype.config.ts")
     .action(
       (
@@ -31,7 +33,7 @@ export function registerApp(program: Command): void {
           return
         }
         if (opts.dockerfile) {
-          console.warn("[supatype] --dockerfile is deprecated and ignored.")
+          warn("--dockerfile is deprecated and ignored.")
         }
         addProxyApp(process.cwd(), opts.port, opts.upstream)
       },
@@ -56,18 +58,19 @@ function addStaticApp(cwd: string, staticDir: string): void {
   const abs = resolve(cwd, staticDir)
   if (!existsSync(abs)) {
     mkdirSync(abs, { recursive: true })
-    console.log(`  created  ${staticDir}/`)
+    file("created", `${staticDir}/`)
   }
   try {
     const configPath = updateAppConfigInProject(cwd, { mode: "static", staticDir })
-    console.log(`  updated  ${configPath}`)
-    console.log(`\nStatic app directory: ${staticDir}`)
-    console.log(`Build your frontend into ${staticDir}/, then:`)
-    console.log(`  supatype self-host compose render`)
-    console.log(`  supatype self-host compose up -d`)
-    console.log(`\nYour app will be served at ${localKongBaseUrl()}/\n`)
+    file("updated", configPath)
+    info(`Static app directory: ${staticDir}`)
+    nextSteps("Build your frontend, then:", [
+      "supatype self-host compose render",
+      "supatype self-host compose up -d",
+      `App URL: ${localKongBaseUrl()}/`,
+    ])
   } catch (err) {
-    console.error((err as Error).message)
+    error((err as Error).message)
     process.exit(1)
   }
 }
@@ -76,11 +79,11 @@ function addProxyApp(cwd: string, port: string, upstream?: string): void {
   const upstreamUrl = upstream?.trim() || `http://localhost:${port}`
   try {
     const configPath = updateAppConfigInProject(cwd, { mode: "proxy", upstream: upstreamUrl })
-    console.log(`  updated  ${configPath}`)
-    console.log(`\nApp upstream set to ${upstreamUrl}. The app will be available at ${localKongBaseUrl()}/\n`)
-    console.log("Run: supatype self-host compose render")
+    file("updated", configPath)
+    info(`Forwarding to ${upstreamUrl} — app at ${localKongBaseUrl()}/`)
+    nextSteps("Next:", ["supatype self-host compose render"])
   } catch (err) {
-    console.error((err as Error).message)
+    error((err as Error).message)
     process.exit(1)
   }
 }
@@ -88,10 +91,10 @@ function addProxyApp(cwd: string, port: string, upstream?: string): void {
 function removeApp(cwd: string): void {
   try {
     const configPath = updateAppConfigInProject(cwd, { mode: "none" })
-    console.log(`  updated  ${configPath}`)
-    console.log("\nApp routing disabled (app.mode=none).\n")
+    file("updated", configPath)
+    info("App routing disabled (app.mode=none).")
   } catch (err) {
-    console.error((err as Error).message)
+    error((err as Error).message)
     process.exit(1)
   }
 }

package/src/commands/cache.ts

@@ -6,6 +6,7 @@ import type { Command } from "commander"
 import { existsSync, readdirSync, rmSync, statSync } from "node:fs"
 import { join } from "node:path"
 import { cacheRoot, type Component } from "../binary-cache.js"
+import { info, plain } from "../ui/messages.js"
 
 const COMPONENTS: Component[] = ["engine", "server", "postgres", "deno"]
 
@@ -20,7 +21,7 @@ export function registerCache(program: Command): void {
     .action(() => {
       const root = cacheRoot()
       if (!existsSync(root)) {
-        console.log("Cache is empty.")
+        info("Cache is empty.")
         return
       }
 
@@ -39,17 +40,17 @@ export function registerCache(program: Command): void {
           const size = dirSize(vDir)
           totalBytes += size
           found = true
-          console.log(`  ${component}@${version}  ${formatBytes(size)}`)
+          plain(`  ${component}@${version}  ${formatBytes(size)}`)
         }
       }
 
       if (!found) {
-        console.log("Cache is empty.")
+        info("Cache is empty.")
         return
       }
 
-      console.log(`\nTotal: ${formatBytes(totalBytes)}`)
-      console.log(`Cache root: ${root}`)
+      plain(`\nTotal: ${formatBytes(totalBytes)}`)
+      info(`Cache root: ${root}`)
     })
 
   cache
@@ -64,7 +65,7 @@ export function registerCache(program: Command): void {
     .action((component?: string, version?: string) => {
       const root = cacheRoot()
       if (!existsSync(root)) {
-        console.log("Cache is already empty.")
+        info("Cache is already empty.")
         return
       }
 
@@ -77,18 +78,18 @@ export function registerCache(program: Command): void {
         if (version) {
           const vDir = join(compDir, version)
           if (!existsSync(vDir)) {
-            console.log(`  ${comp}@${version} not cached.`)
+            info(`${comp}@${version} not cached.`)
             continue
           }
           rmSync(vDir, { recursive: true, force: true })
-          console.log(`  removed  ${comp}@${version}`)
+          plain(`  removed  ${comp}@${version}`)
         } else {
           rmSync(compDir, { recursive: true, force: true })
-          console.log(`  removed  ${comp} (all versions)`)
+          plain(`  removed  ${comp} (all versions)`)
         }
       }
 
-      console.log("Done.")
+      info("Done.")
     })
 }
 

package/src/commands/cloud.ts

@@ -1,20 +1,37 @@
 import type { Command } from "commander"
 import { readFileSync, writeFileSync, existsSync } from "node:fs"
 import { resolve } from "node:path"
-import { createInterface } from "node:readline"
+import { loadProjectLink, migrateLegacyLinkFiles } from "../link.js"
+import { targetFetch } from "../target-client.js"
+import { registerEnvs, registerLinkOptions, runLinkAction } from "./link-helpers.js"
+import { resolveTarget, targetSchemaPush, schemaPgSchema } from "../resolve-target.js"
+import { loadConfig, loadSchemaAst } from "../config.js"
+import { schemaPathFromProject } from "../project-config.js"
+import { error, info, plain } from "../ui/messages.js"
+import { nextSteps } from "../ui/next-steps.js"
 
 interface CloudConfig {
   apiUrl: string
   token: string
   projectSlug?: string
-  /** Organisation UUID — required for schema routes (`X-Org-Id`). */
-  orgId?: string
+  orgId?: string | undefined
 }
 
+/** @deprecated Prefer loadProjectLink */
 export function loadCloudConfig(cwd: string): CloudConfig | null {
-  const configPath = resolve(cwd, ".supatype/cloud.json")
-  if (!existsSync(configPath)) return null
-  return JSON.parse(readFileSync(configPath, "utf8")) as CloudConfig
+  migrateLegacyLinkFiles(cwd)
+  const link = loadProjectLink(cwd)
+  if (!link || link.kind !== "cloud") return null
+  const legacyPath = resolve(cwd, ".supatype/cloud.json")
+  if (existsSync(legacyPath)) {
+    return JSON.parse(readFileSync(legacyPath, "utf8")) as CloudConfig
+  }
+  return {
+    apiUrl: link.cloudApiUrl ?? "https://api.supatype.com",
+    token: link.token ?? "",
+    projectSlug: link.projectRef,
+    ...(link.orgId !== undefined ? { orgId: link.orgId } : {}),
+  }
 }
 
 function saveCloudConfig(cwd: string, config: CloudConfig): void {
@@ -27,135 +44,66 @@ function saveCloudConfig(cwd: string, config: CloudConfig): void {
 }
 
 async function cloudFetch<T>(config: CloudConfig, method: string, path: string, body?: unknown): Promise<T> {
-  const headers: Record<string, string> = {
-    "Content-Type": "application/json",
-    Authorization: `Bearer ${config.token}`,
-  }
-  if (config.orgId) {
-    headers["X-Org-Id"] = config.orgId
-  }
-  const res = await fetch(`${config.apiUrl}/api/v1${path}`, {
+  return targetFetch<T>(config.apiUrl, "/api/v1", {
     method,
-    headers,
-    ...(body !== undefined ? { body: JSON.stringify(body) } : {}),
+    path,
+    body,
+    token: config.token,
+    orgId: config.orgId,
   })
-
-  const json = await res.json() as { data?: T; error?: string; message?: string }
-  if (!res.ok) {
-    throw new Error(json.message ?? json.error ?? `API error: ${res.status}`)
-  }
-  return json.data as T
 }
 
-/** True when `.supatype/cloud.json` exists with a linked project slug. */
 export function isCloudLinked(cwd: string): boolean {
-  const cfg = loadCloudConfig(cwd)
-  return Boolean(cfg?.projectSlug && cfg.token)
+  migrateLegacyLinkFiles(cwd)
+  const link = loadProjectLink(cwd)
+  return Boolean(link?.kind === "cloud" && link.projectRef && link.token)
 }
 
-/**
- * Push schema AST to the linked cloud project (`POST /api/v1/projects/:ref/schema/push`).
- * Credentials stay server-side; only AST is sent.
- */
-export async function pushSchemaToLinkedProject(cwd: string, opts?: { force?: boolean }): Promise<void> {
-  const config = loadCloudConfig(cwd)
-  if (!config?.projectSlug) {
-    console.error("Not linked to a cloud project. Run: supatype link")
+export async function pushSchemaToLinkedProject(
+  cwd: string,
+  opts?: { force?: boolean; env?: string },
+): Promise<void> {
+  const config = loadConfig(cwd)
+  const target = resolveTarget(cwd, { env: opts?.env })
+  if (target.mode !== "cloud") {
+    error("Not linked to a cloud project. Run: supatype link --project <slug>")
     process.exit(1)
   }
-  if (!config.orgId) {
-    console.error(
-      "Missing orgId in .supatype/cloud.json. Re-run: supatype link --project <slug> (after cloud login).",
-    )
-    process.exit(1)
-  }
-
-  const { loadConfig: loadAppConfig, loadSchemaAst } = await import("../config.js")
-  const { schemaPathFromProject } = await import("../project-config.js")
-
-  const appConfig = loadAppConfig(cwd)
-  const ast = loadSchemaAst(schemaPathFromProject(appConfig, cwd), cwd)
 
-  console.log(`Pushing schema to cloud project ${config.projectSlug}...`)
+  const ast = loadSchemaAst(schemaPathFromProject(config, cwd), cwd)
+  info(`Pushing schema to ${target.mode} project ${target.projectRef} (${target.environment})...`)
 
-  const result = await cloudFetch<{ message?: string }>(config, "POST", `/projects/${config.projectSlug}/schema/push`, {
-    ast,
+  const result = await targetSchemaPush(target, ast, {
     force: opts?.force ?? true,
+    schema: schemaPgSchema(cwd),
   })
 
-  console.log(result.message ?? "Schema push completed.")
+  info((result as { message?: string }).message ?? "Schema push completed.")
 }
 
-/** @deprecated Use pushSchemaToLinkedProject — kept for deploy command alias */
-export async function deploySchemaToLinkedProject(cwd: string, _environment: string): Promise<void> {
-  await pushSchemaToLinkedProject(cwd)
+export async function deploySchemaToLinkedProject(cwd: string, environment: string): Promise<void> {
+  await pushSchemaToLinkedProject(cwd, { force: true, env: environment })
 }
 
-function prompt(question: string): Promise<string> {
-  const rl = createInterface({ input: process.stdin, output: process.stdout })
-  return new Promise((resolve) => {
-    rl.question(question, (answer) => {
-      rl.close()
-      resolve(answer.trim())
-    })
-  })
-}
-
-// ─── Registration ──────────────────────────────────────────────────────────────
-
 export function registerCloud(program: Command): void {
-  // ── Link ───────────────────────────────────────────────────────────────────
-  program
-    .command("link")
-    .description("Link this local project to a Supatype cloud project")
-    .option("--project <slug>", "Project slug to link to")
-    .option("--api-url <url>", "Control plane API URL", "https://api.supatype.com")
-    .option("--token <token>", "Authentication token")
-    .action(async (opts: { project?: string; apiUrl: string; token?: string }) => {
-      const cwd = process.cwd()
-      const token = opts.token ?? process.env["SUPATYPE_TOKEN"]
-      if (!token) {
-        console.error("Authentication required. Set SUPATYPE_TOKEN or pass --token.")
-        process.exit(1)
-      }
-
-      const config: CloudConfig = { apiUrl: opts.apiUrl, token }
+  registerEnvs(program)
 
-      if (opts.project) {
-        config.projectSlug = opts.project
-        const one = await cloudFetch<{ slug: string; orgId: string }>(config, "GET", `/projects/${opts.project}`)
-        config.orgId = one.orgId
-      } else {
-        const projects = await cloudFetch<Array<{ slug: string; name: string; status: string; tier: string; orgId: string }>>(
-          config, "GET", "/projects",
-        )
-        if (projects.length === 0) {
-          console.error("No projects found. Create one with: supatype projects create <name>")
-          process.exit(1)
-        }
-
-        console.log("\nAvailable projects:\n")
-        projects.forEach((p, i) => {
-          console.log(`  ${i + 1}. ${p.name} (${p.slug}) [${p.tier}] — ${p.status}`)
-        })
-
-        const answer = await prompt(`\nSelect project (1-${projects.length}): `)
-        const idx = parseInt(answer, 10) - 1
-        if (isNaN(idx) || idx < 0 || idx >= projects.length) {
-          console.error("Invalid selection.")
-          process.exit(1)
-        }
-        const picked = projects[idx]!
-        config.projectSlug = picked.slug
-        config.orgId = picked.orgId
-      }
-
-      saveCloudConfig(cwd, config)
-      console.log(`\nLinked to project: ${config.projectSlug}`)
-      console.log(`Config saved to .supatype/cloud.json\n`)
-    })
+  const linkCmd = program
+    .command("link")
+    .description("Link this project to cloud or self-host (unified .supatype/link.json)")
+  registerLinkOptions(linkCmd)
+  linkCmd.action(async (opts: {
+    project?: string
+    url?: string
+    apiUrl: string
+    token?: string
+    serviceRoleKey?: string
+    env?: string
+    fixGitignore?: boolean
+  }) => {
+    await runLinkAction(opts)
+  })
 
-  // ── Projects ───────────────────────────────────────────────────────────────
   const projectsCmd = program
     .command("projects")
     .description("Manage cloud projects")
@@ -171,18 +119,18 @@ export function registerCloud(program: Command): void {
       }>>(config, "GET", "/projects")
 
       if (projects.length === 0) {
-        console.log("No projects. Create one with: supatype projects create <name>")
+        info("No projects. Create one with: supatype projects create <name>")
         return
       }
 
-      console.log("\n  Name                    Slug                     Tier    Region    Status")
-      console.log("  " + "─".repeat(80))
+      plain("\n  Name                    Slug                     Tier    Region    Status")
+      plain("  " + "─".repeat(80))
       for (const p of projects) {
-        console.log(
+        plain(
           `  ${p.name.padEnd(24)}${p.slug.padEnd(25)}${p.tier.padEnd(8)}${p.region.padEnd(10)}${p.status}`,
         )
       }
-      console.log()
+      plain()
     })
 
   projectsCmd
@@ -193,16 +141,16 @@ export function registerCloud(program: Command): void {
     .action(async (name: string, opts: { tier: string; region: string }) => {
       const config = getCloudConfigOrExit()
 
-      console.log(`Creating project "${name}" (${opts.tier}, ${opts.region})...`)
+      info(`Creating project "${name}" (${opts.tier}, ${opts.region})...`)
 
       const project = await cloudFetch<{ slug: string; name: string; status: string }>(
         config, "POST", "/projects",
         { name, tier: opts.tier, region: opts.region },
       )
 
-      console.log(`\nProject created: ${project.name} (${project.slug})`)
-      console.log(`Status: ${project.status}`)
-      console.log(`\nTo link this project: supatype link --project ${project.slug}\n`)
+      info(`Project created: ${project.name} (${project.slug})`)
+      info(`Status: ${project.status}`)
+      nextSteps("To link this project:", [`supatype link --project ${project.slug}`])
     })
 
   projectsCmd
@@ -211,7 +159,7 @@ export function registerCloud(program: Command): void {
     .action(async (slug: string) => {
       const config = getCloudConfigOrExit()
       await cloudFetch(config, "POST", `/projects/${slug}/pause`)
-      console.log(`Project ${slug} paused.`)
+      info(`Project ${slug} paused.`)
     })
 
   projectsCmd
@@ -220,10 +168,9 @@ export function registerCloud(program: Command): void {
     .action(async (slug: string) => {
       const config = getCloudConfigOrExit()
       await cloudFetch(config, "POST", `/projects/${slug}/resume`)
-      console.log(`Project ${slug} resumed.`)
+      info(`Project ${slug} resumed.`)
     })
 
-  // ── Domains ────────────────────────────────────────────────────────────────
   const domainsCmd = program
     .command("domains")
     .description("Manage custom domains for a project")
@@ -234,7 +181,7 @@ export function registerCloud(program: Command): void {
     .action(async () => {
       const config = getCloudConfigOrExit()
       if (!config.projectSlug) {
-        console.error("Not linked to a project. Run: supatype link")
+        error("Not linked to a project. Run: supatype link")
         process.exit(1)
       }
 
@@ -243,18 +190,18 @@ export function registerCloud(program: Command): void {
       }>>(config, "GET", `/projects/${config.projectSlug}/domains`)
 
       if (domains.length === 0) {
-        console.log("No custom domains configured.")
+        info("No custom domains configured.")
         return
       }
 
-      console.log("\n  Domain                          Status               CNAME Target")
-      console.log("  " + "─".repeat(80))
+      plain("\n  Domain                          Status               CNAME Target")
+      plain("  " + "─".repeat(80))
       for (const d of domains) {
-        console.log(
+        plain(
           `  ${d.domain.padEnd(34)}${d.status.padEnd(21)}${d.cnameTarget}`,
         )
       }
-      console.log()
+      plain()
     })
 
   domainsCmd
@@ -263,7 +210,7 @@ export function registerCloud(program: Command): void {
     .action(async (domain: string) => {
       const config = getCloudConfigOrExit()
       if (!config.projectSlug) {
-        console.error("Not linked to a project. Run: supatype link")
+        error("Not linked to a project. Run: supatype link")
         process.exit(1)
       }
 
@@ -272,9 +219,9 @@ export function registerCloud(program: Command): void {
         { domain },
       )
 
-      console.log(`\nDomain added: ${result.domain}`)
-      console.log(`\n${result.instructions}`)
-      console.log(`\nAfter adding the CNAME record, verify with: supatype domains verify ${domain}\n`)
+      info(`Domain added: ${result.domain}`)
+      plain(`\n${result.instructions}`)
+      info(`After adding the CNAME record, verify with: supatype domains verify ${domain}`)
     })
 
   domainsCmd
@@ -283,12 +230,12 @@ export function registerCloud(program: Command): void {
     .action(async (domainId: string) => {
       const config = getCloudConfigOrExit()
       if (!config.projectSlug) {
-        console.error("Not linked to a project. Run: supatype link")
+        error("Not linked to a project. Run: supatype link")
         process.exit(1)
       }
 
       await cloudFetch(config, "DELETE", `/projects/${config.projectSlug}/domains/${domainId}`)
-      console.log("Domain removed.")
+      info("Domain removed.")
     })
 
   domainsCmd
@@ -297,7 +244,7 @@ export function registerCloud(program: Command): void {
     .action(async (domainId: string) => {
       const config = getCloudConfigOrExit()
       if (!config.projectSlug) {
-        console.error("Not linked to a project. Run: supatype link")
+        error("Not linked to a project. Run: supatype link")
         process.exit(1)
       }
 
@@ -305,7 +252,7 @@ export function registerCloud(program: Command): void {
         config, "POST", `/projects/${config.projectSlug}/domains/${domainId}/verify`,
       )
 
-      console.log(`Domain ${result.domain}: ${result.status}`)
+      info(`Domain ${result.domain}: ${result.status}`)
     })
 }
 
@@ -313,10 +260,12 @@ function getCloudConfigOrExit(): CloudConfig {
   const cwd = process.cwd()
   let config = loadCloudConfig(cwd)
   if (!config) {
-    const token = process.env["SUPATYPE_TOKEN"]
+    const token =
+      process.env["SUPATYPE_ACCESS_TOKEN"] ??
+      process.env["SUPATYPE_TOKEN"]
     const apiUrl = process.env["SUPATYPE_API_URL"] ?? "https://api.supatype.com"
     if (!token) {
-      console.error("Not connected to Supatype Cloud. Run: supatype link, or set SUPATYPE_TOKEN.")
+      error("Not connected to Supatype Cloud. Run: supatype link, or set SUPATYPE_ACCESS_TOKEN.")
       process.exit(1)
     }
     config = { apiUrl, token }