@supatype/cli 0.1.0-alpha.9 → 0.1.1

package/src/commands/introspect.ts

@@ -0,0 +1,48 @@
+import type { Command } from "commander"
+import { writeFileSync } from "node:fs"
+import { loadProjectLink } from "../link.js"
+import { resolveTarget, targetSchemaIntrospect, schemaPgSchema } from "../resolve-target.js"
+import type { DatabaseStateJson } from "../pull-utils.js"
+import { printIntrospectSummary } from "../pull-utils.js"
+import { info, plain } from "../ui/messages.js"
+
+export function registerIntrospect(program: Command): void {
+  program
+    .command("introspect")
+    .description("Introspect the live Postgres database (JSON or summary)")
+    .option("--connection <url>", "Database connection URL (overrides config)")
+    .option("--env <name>", "Target environment when linked")
+    .option("--direct", "Use local engine subprocess")
+    .option("--json", "Output full DatabaseState JSON")
+    .option("--out <path>", "Write JSON output to a file")
+    .action(async (opts: {
+      connection?: string
+      env?: string
+      direct?: boolean
+      json?: boolean
+      out?: string
+    }) => {
+      const cwd = process.cwd()
+      const pgSchema = schemaPgSchema(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 state = (await targetSchemaIntrospect(target, { schema: pgSchema })) as DatabaseStateJson
+
+      if (opts.out) {
+        writeFileSync(opts.out, JSON.stringify(state, null, 2), "utf8")
+        info(`Wrote introspection to ${opts.out}`)
+        return
+      }
+
+      if (opts.json) {
+        plain(JSON.stringify(state, null, 2))
+        return
+      }
+
+      printIntrospectSummary(state)
+    })
+}

package/src/commands/keys.ts

@@ -1,7 +1,8 @@
 import type { Command } from "commander"
-import { readFileSync, existsSync } from "node:fs"
+import { readFileSync, existsSync, writeFileSync } from "node:fs"
 import { resolve } from "node:path"
 import { signJwt } from "../jwt.js"
+import { error, plain } from "../ui/messages.js"
 
 export function registerKeys(program: Command): void {
   program
@@ -12,15 +13,13 @@ export function registerKeys(program: Command): void {
     .action((opts: { secret?: string; expYears: string }) => {
       const secret = opts.secret ?? resolveSecret()
       if (!secret) {
-        console.error(
-          "Error: JWT_SECRET not found. Set it in .env or pass --secret <value>",
-        )
+        error("JWT_SECRET not found. Set it in .env or pass --secret <value>")
         process.exit(1)
       }
 
       const expYears = parseInt(opts.expYears, 10)
       if (isNaN(expYears) || expYears < 1) {
-        console.error("Error: --exp-years must be a positive integer")
+        error("--exp-years must be a positive integer")
         process.exit(1)
       }
 
@@ -30,24 +29,67 @@ export function registerKeys(program: Command): void {
       const anonKey = signJwt({ iss: "supatype", role: "anon", iat: now, exp }, secret)
       const serviceKey = signJwt({ iss: "supatype", role: "service_role", iat: now, exp }, secret)
 
-      console.log("\nGenerated keys (valid for", expYears, "years):\n")
-      console.log("ANON_KEY=" + anonKey)
-      console.log("SERVICE_ROLE_KEY=" + serviceKey)
-      console.log(
-        "\nAdd these to your .env file. Do not commit .env to source control.",
-      )
+      plain(`\nGenerated keys (valid for ${expYears} years):\n`)
+      plain("ANON_KEY=" + anonKey)
+      plain("SERVICE_ROLE_KEY=" + serviceKey)
+      plain("\nAdd these to your .env file. Do not commit .env to source control.")
     })
 }
 
 // ─── Helpers ─────────────────────────────────────────────────────────────────
 
-export function resolveSecret(): string | undefined {
+/** Mint a long-lived anon + service_role JWT pair from a secret. */
+export function signKeyPair(
+  secret: string,
+  expYears = 10,
+): { anonKey: string; serviceKey: string } {
+  const now = Math.floor(Date.now() / 1000)
+  const exp = now + expYears * 365 * 24 * 60 * 60
+  return {
+    anonKey: signJwt({ iss: "supatype", role: "anon", iat: now, exp }, secret),
+    serviceKey: signJwt({ iss: "supatype", role: "service_role", iat: now, exp }, secret),
+  }
+}
+
+/**
+ * Generate keys from the JWT_SECRET found in `dir`'s .env (or env var) and
+ * rewrite the ANON_KEY / SERVICE_ROLE_KEY lines in that .env file in place.
+ * Returns the minted pair, or null if no secret could be resolved.
+ */
+export function generateAndWriteKeys(
+  dir: string,
+  expYears = 10,
+): { anonKey: string; serviceKey: string } | null {
+  const secret = resolveSecret(dir)
+  if (!secret) return null
+
+  const { anonKey, serviceKey } = signKeyPair(secret, expYears)
+
+  const envPath = resolve(dir, ".env")
+  if (existsSync(envPath)) {
+    let content = readFileSync(envPath, "utf8")
+    content = upsertEnvVar(content, "ANON_KEY", anonKey)
+    content = upsertEnvVar(content, "SERVICE_ROLE_KEY", serviceKey)
+    writeFileSync(envPath, content, "utf8")
+  }
+
+  return { anonKey, serviceKey }
+}
+
+function upsertEnvVar(content: string, key: string, value: string): string {
+  const re = new RegExp(`^${key}=.*$`, "m")
+  if (re.test(content)) return content.replace(re, `${key}=${value}`)
+  const sep = content.endsWith("\n") || content.length === 0 ? "" : "\n"
+  return `${content}${sep}${key}=${value}\n`
+}
+
+export function resolveSecret(dir: string = process.cwd()): string | undefined {
   // 1. Check environment variable
   const fromEnv = process.env["JWT_SECRET"]
   if (fromEnv) return fromEnv
 
-  // 2. Parse .env file in cwd
-  const envPath = resolve(process.cwd(), ".env")
+  // 2. Parse .env file in the target directory
+  const envPath = resolve(dir, ".env")
   if (!existsSync(envPath)) return undefined
 
   try {

package/src/commands/link-helpers.ts

@@ -0,0 +1,273 @@
+import type { Command } from "commander"
+import { loadConfig } from "../config.js"
+import {
+  createCloudLink,
+  createSelfHostLink,
+  loadProjectLink,
+  saveProjectLink,
+  type ProjectLink,
+} from "../link.js"
+import { ensureSupatypeGitignore, warnIfLinkNotGitignored } from "../gitignore.js"
+import { targetFetch } from "../target-client.js"
+import { error, info, plain } from "../ui/messages.js"
+import { nextSteps } from "../ui/next-steps.js"
+import { isInteractive } from "../ui/interactive.js"
+import { ensureNotCancelled, printLogo, clack as p } from "../ui/prompts.js"
+
+function resolveLinkToken(opts: {
+  token?: string
+  serviceRoleKey?: string
+}): string | undefined {
+  return (
+    opts.token ??
+    opts.serviceRoleKey ??
+    process.env["SUPATYPE_ACCESS_TOKEN"] ??
+    process.env["SUPATYPE_TOKEN"] ??
+    process.env["SERVICE_ROLE_KEY"]
+  )
+}
+
+async function probeSelfHostLink(apiUrl: string, projectRef: string, token: string): Promise<void> {
+  await targetFetch(apiUrl, "/platform/v1", {
+    method: "GET",
+    path: `/projects/${projectRef}/status`,
+    token,
+  })
+}
+
+export function registerEnvs(program: Command): void {
+  const envs = program.command("envs").description("Manage linked deployment environments")
+
+  envs
+    .command("list")
+    .description("List linked environments")
+    .action(() => {
+      const cwd = process.cwd()
+      const link = loadProjectLink(cwd)
+      if (!link) {
+        info("Not linked. Run: supatype link")
+        return
+      }
+      plain(`\nProject: ${link.projectRef} (${link.kind})`)
+      plain(`Default: ${link.defaultEnvironment}\n`)
+      for (const [name, env] of Object.entries(link.environments)) {
+        const mark = name === link.defaultEnvironment ? " *" : "  "
+        plain(`${mark} ${name.padEnd(14)} ${env.apiUrl}`)
+      }
+      plain()
+    })
+
+  envs
+    .command("use <name>")
+    .description("Set the default environment")
+    .action((name: string) => {
+      const cwd = process.cwd()
+      const link = loadProjectLink(cwd)
+      if (!link?.environments[name]) {
+        error(`Environment "${name}" is not linked.`)
+        process.exit(1)
+      }
+      link.defaultEnvironment = name
+      saveProjectLink(cwd, link)
+      info(`Default environment set to "${name}".`)
+    })
+
+  envs
+    .command("create <name>")
+    .description("Create a cloud environment (staging/preview)")
+    .action(async (name: string) => {
+      const cwd = process.cwd()
+      const link = loadProjectLink(cwd)
+      if (!link || link.kind !== "cloud") {
+        error("Cloud link required. Run: supatype link --project <slug>")
+        process.exit(1)
+      }
+      if (!link.token || !link.cloudApiUrl) {
+        error("Missing cloud credentials in link.json")
+        process.exit(1)
+      }
+      const bodyName = name === "staging" || name === "preview" ? name : "staging"
+      await targetFetch(link.cloudApiUrl, "/api/v1", {
+        method: "POST",
+        path: `/projects/${link.projectRef}/environments`,
+        body: { name: bodyName },
+        token: link.token,
+        orgId: link.orgId,
+      })
+      const envsList = await targetFetch<Array<{ name: string; apiUrl: string }>>(
+        link.cloudApiUrl,
+        "/api/v1",
+        {
+          method: "GET",
+          path: `/projects/${link.projectRef}/environments`,
+          token: link.token,
+          orgId: link.orgId,
+        },
+      )
+      const updated = createCloudLink({
+        projectRef: link.projectRef,
+        cloudApiUrl: link.cloudApiUrl,
+        token: link.token,
+        environments: envsList.map((e) => ({ name: e.name, apiUrl: e.apiUrl })),
+        existing: link,
+        ...(link.orgId !== undefined ? { orgId: link.orgId } : {}),
+      })
+      saveProjectLink(cwd, updated)
+      info(`Environment "${bodyName}" created.`)
+    })
+}
+
+export function registerLinkOptions(linkCmd: Command): void {
+  linkCmd
+    .option("--project <slug>", "Cloud project slug")
+    .option("--url <url>", "Self-host or local Kong URL")
+    .option("--api-url <url>", "Cloud control plane API URL", "https://api.supatype.com")
+    .option("--token <token>", "Access token (cloud PAT or self-host SERVICE_ROLE_KEY)")
+    .option("--service-role-key <key>", "Deprecated alias for --token on self-host")
+    .option("--env <name>", "Environment name (default: production)", "production")
+    .option("--fix-gitignore", "Append .supatype/ to .gitignore if missing")
+}
+
+export async function runLinkAction(opts: {
+  project?: string
+  url?: string
+  apiUrl: string
+  token?: string
+  serviceRoleKey?: string
+  env?: string
+  fixGitignore?: boolean
+}): Promise<void> {
+  const cwd = process.cwd()
+  const config = loadConfig(cwd)
+  const projectRef = config.project?.name ?? "project"
+  const envName = opts.env ?? "production"
+  let project = opts.project
+  let url = opts.url
+
+  if (isInteractive() && !project && !url) {
+    printLogo()
+    p.intro("Link this project")
+    const targetKind = ensureNotCancelled(
+      await p.select<"cloud" | "self-host">({
+        message: "Link target",
+        options: [
+          { value: "cloud", label: "Supatype Cloud", hint: "managed project on supatype.com" },
+          { value: "self-host", label: "Self-host", hint: "your Kong gateway URL" },
+        ],
+      }),
+    )
+    if (targetKind === "cloud") {
+      project = ensureNotCancelled(
+        await p.text({
+          message: "Cloud project slug",
+          placeholder: projectRef,
+          defaultValue: projectRef,
+        }),
+      ).trim()
+    } else {
+      url = ensureNotCancelled(
+        await p.text({
+          message: "Kong gateway URL",
+          placeholder: "https://api.example.com",
+          defaultValue: "http://localhost:18473",
+        }),
+      ).trim()
+    }
+    p.outro("Linking...")
+  }
+
+  const token = resolveLinkToken(opts)
+
+  if (opts.fixGitignore) {
+    ensureSupatypeGitignore(cwd)
+  } else {
+    warnIfLinkNotGitignored(cwd)
+  }
+
+  const existing = loadProjectLink(cwd)
+
+  if (url) {
+    if (!token) {
+      error("Authentication required. Pass --token $SERVICE_ROLE_KEY")
+      process.exit(1)
+    }
+    const apiUrl = url.replace(/\/$/, "")
+    await probeSelfHostLink(apiUrl, projectRef, token)
+    const link = createSelfHostLink({
+      projectRef,
+      apiUrl,
+      token,
+      envName,
+      existing,
+    })
+    saveProjectLink(cwd, link)
+    info(`Linked to self-host environment "${envName}" at ${apiUrl}`)
+    nextSteps("Next steps:", [
+      "supatype push --env " + envName,
+      "supatype deploy",
+    ])
+    return
+  }
+
+  if (!token) {
+    error("Authentication required. Set SUPATYPE_ACCESS_TOKEN or pass --token.")
+    process.exit(1)
+  }
+
+  const cloudApiUrl = opts.apiUrl.replace(/\/$/, "")
+
+  if (project) {
+    const one = await targetFetch<{ slug: string; orgId: string }>(cloudApiUrl, "/api/v1", {
+      method: "GET",
+      path: `/projects/${project}`,
+      token,
+    })
+    let environments: Array<{ name: string; apiUrl: string }> = [
+      { name: "production", apiUrl: cloudApiUrl },
+    ]
+    try {
+      const listed = await targetFetch<Array<{ name: string; apiUrl: string }>>(
+        cloudApiUrl,
+        "/api/v1",
+        {
+          method: "GET",
+          path: `/projects/${project}/environments`,
+          token,
+          orgId: one.orgId,
+        },
+      )
+      if (listed.length > 0) {
+        environments = listed.map((e) => ({ name: e.name, apiUrl: e.apiUrl }))
+      }
+    } catch {
+      // environments optional on older control planes
+    }
+    const link = createCloudLink({
+      projectRef: project,
+      cloudApiUrl,
+      token,
+      orgId: one.orgId,
+      environments,
+      existing,
+    })
+    saveProjectLink(cwd, link)
+    info(`Linked to cloud project: ${project}`)
+    nextSteps("Next steps:", [
+      "supatype push --env production",
+      "supatype deploy",
+    ])
+    return
+  }
+
+  error("Specify --project <slug> for cloud or --url <kong-url> for self-host.")
+  process.exit(1)
+}
+
+export function getLinkOrExit(cwd: string): ProjectLink {
+  const link = loadProjectLink(cwd)
+  if (!link) {
+    error("Not linked. Run: supatype link")
+    process.exit(1)
+  }
+  return link
+}

package/src/commands/logs.ts

@@ -3,6 +3,7 @@
  */
 import type { Command } from "commander"
 import { spawn } from "node:child_process"
+import { error } from "../ui/messages.js"
 
 const SERVICES = ["postgres", "postgrest", "gotrue", "kong", "minio", "realtime", "studio"]
 
@@ -19,8 +20,8 @@ export function registerLogs(program: Command): void {
         : SERVICES.map((s) => `supatype-${s}`)
 
       if (opts.service && !SERVICES.includes(opts.service)) {
-        console.error(`Unknown service: ${opts.service}`)
-        console.error(`Available: ${SERVICES.join(", ")}`)
+        error(`Unknown service: ${opts.service}`)
+        error(`Available: ${SERVICES.join(", ")}`)
         process.exit(1)
       }
 
@@ -39,7 +40,7 @@ export function registerLogs(program: Command): void {
 
         const child = spawn("docker", containerArgs, { stdio: "inherit" })
         child.on("error", () => {
-          console.error("Docker not found. Ensure Docker is installed and running.")
+          error("Docker not found. Ensure Docker is installed and running.")
           process.exit(1)
         })
         return
@@ -51,7 +52,7 @@ export function registerLogs(program: Command): void {
         cwd: process.cwd(),
       })
       child.on("error", () => {
-        console.error("Docker not found. Ensure Docker is installed and running.")
+        error("Docker not found. Ensure Docker is installed and running.")
         process.exit(1)
       })
     })

package/src/commands/migrate-from-v1.ts

@@ -4,6 +4,7 @@ import { basename, dirname, extname, join, resolve } from "node:path"
 import ts from "typescript"
 import { loadConfig } from "../config.js"
 import { schemaPathFromProject } from "../project-config.js"
+import { info } from "../ui/messages.js"
 
 export function registerMigrateFromV1(program: Command): void {
   program
@@ -29,9 +30,9 @@ export function registerMigrateFromV1(program: Command): void {
         : join(dirname(schemaPath), basename(schemaPath).replace(extname(schemaPath), ".v2.ts"))
 
       writeFileSync(outPath, output, "utf8")
-      console.log(`v2 schema written to ${outPath}`)
+      info(`v2 schema written to ${outPath}`)
       if (!opts.write) {
-        console.log("Review TODO comments and replace unknown mappings before using this file in production.")
+        info("Review TODO comments and replace unknown mappings before using this file in production.")
       }
     })
 }