@supatype/cli 0.1.0-alpha.6

package/src/commands/app.ts

@@ -0,0 +1,261 @@
+import type { Command } from "commander"
+import { readFileSync, writeFileSync, existsSync } from "node:fs"
+import { resolve } from "node:path"
+import { APP_COMPOSE_MARKER, KONG_APP_MARKER } from "./init.js"
+
+export function registerApp(program: Command): void {
+  const appCmd = program
+    .command("app")
+    .description("Manage your application container in the Supatype stack")
+
+  appCmd
+    .command("add")
+    .description("Add your application to the docker-compose stack at /")
+    .option("--dockerfile <path>", "Path to your Dockerfile", "./Dockerfile")
+    .option("--port <port>", "Port your app listens on", "3000")
+    .action((opts: { dockerfile: string; port: string }) => {
+      addApp(process.cwd(), opts.dockerfile, opts.port)
+    })
+
+  appCmd
+    .command("remove")
+    .description("Remove your application from the docker-compose stack")
+    .action(() => {
+      removeApp(process.cwd())
+    })
+}
+
+// ─── Implementation ───────────────────────────────────────────────────────────
+
+function addApp(cwd: string, dockerfile: string, port: string): void {
+  const composePath = resolve(cwd, "docker-compose.yml")
+  if (!existsSync(composePath)) {
+    console.error("docker-compose.yml not found. Run: supatype init")
+    process.exit(1)
+  }
+
+  let compose = readFileSync(composePath, "utf8")
+  if (!compose.includes(APP_COMPOSE_MARKER)) {
+    console.error("App service slot not found in docker-compose.yml. Is this a supatype project?")
+    process.exit(1)
+  }
+
+  if (isAppActive(compose)) {
+    console.error("App service is already configured. Run: supatype app remove first.")
+    process.exit(1)
+  }
+
+  compose = uncommentServiceBlock(compose, APP_COMPOSE_MARKER, { dockerfile, port })
+  writeFileSync(composePath, compose, "utf8")
+  console.log("  updated  docker-compose.yml")
+
+  const kongPath = resolve(cwd, ".supatype/kong.yml")
+  if (existsSync(kongPath)) {
+    let kong = readFileSync(kongPath, "utf8")
+    if (kong.includes(KONG_APP_MARKER)) {
+      kong = uncommentKongBlock(kong, KONG_APP_MARKER, port)
+      writeFileSync(kongPath, kong, "utf8")
+      console.log("  updated  .supatype/kong.yml")
+    }
+  }
+
+  console.log(`\nApp service added (port ${port}). Your app will be available at http://localhost:8000/\n`)
+  console.log("Run: supatype dev")
+}
+
+function removeApp(cwd: string): void {
+  const composePath = resolve(cwd, "docker-compose.yml")
+  if (!existsSync(composePath)) {
+    console.error("docker-compose.yml not found.")
+    process.exit(1)
+  }
+
+  let compose = readFileSync(composePath, "utf8")
+  if (!isAppActive(compose)) {
+    console.error("No active app service found.")
+    process.exit(1)
+  }
+
+  compose = recommentServiceBlock(compose, APP_COMPOSE_MARKER)
+  writeFileSync(composePath, compose, "utf8")
+  console.log("  updated  docker-compose.yml")
+
+  const kongPath = resolve(cwd, ".supatype/kong.yml")
+  if (existsSync(kongPath)) {
+    let kong = readFileSync(kongPath, "utf8")
+    if (!kong.includes(KONG_APP_MARKER)) {
+      // Active route — re-comment it
+      kong = recommentKongBlock(kong)
+    }
+    writeFileSync(kongPath, kong, "utf8")
+    console.log("  updated  .supatype/kong.yml")
+  }
+
+  console.log("\nApp service removed.\n")
+}
+
+// ─── Block manipulation helpers ───────────────────────────────────────────────
+
+/** Returns true if the docker-compose has an active (uncommented) app: service. */
+function isAppActive(compose: string): boolean {
+  return /^  app:/m.test(compose)
+}
+
+/**
+ * Finds the commented app service block after the marker line and uncomments it,
+ * substituting the dockerfile path and port.
+ */
+function uncommentServiceBlock(
+  compose: string,
+  marker: string,
+  opts: { dockerfile: string; port: string },
+): string {
+  const lines = compose.split("\n")
+  const markerIdx = lines.findIndex((l) => l === marker)
+  if (markerIdx === -1) return compose
+
+  const result: string[] = []
+  let i = 0
+
+  while (i < lines.length) {
+    if (i === markerIdx) {
+      // Skip the marker line itself, then uncomment the block
+      i++
+      while (i < lines.length) {
+        const line = lines[i]!
+        // End of block: empty line followed by a non-commented service-level line
+        if (line === "" && i + 1 < lines.length && !/^  #/.test(lines[i + 1]!)) {
+          result.push(line)
+          i++
+          break
+        }
+        if (/^  # /.test(line)) {
+          // Uncomment: replace "  # " prefix with "  "
+          let uncommented = line.replace(/^  # /, "  ")
+          // Substitute placeholders
+          uncommented = uncommented.replace("./Dockerfile", opts.dockerfile)
+          uncommented = uncommented.replace(/- "3000:3000"/, `- "${opts.port}:${opts.port}"`)
+          result.push(uncommented)
+        } else if (line === "" || /^  #─/.test(line)) {
+          // Skip remaining marker-style comment lines
+        } else {
+          result.push(line)
+        }
+        i++
+      }
+    } else {
+      result.push(lines[i]!)
+      i++
+    }
+  }
+
+  return result.join("\n")
+}
+
+/**
+ * Finds the active app: service block and re-comments it, restoring the marker.
+ */
+function recommentServiceBlock(compose: string, marker: string): string {
+  const lines = compose.split("\n")
+  const appIdx = lines.findIndex((l) => l === "  app:")
+  if (appIdx === -1) return compose
+
+  const result: string[] = []
+  let i = 0
+
+  while (i < lines.length) {
+    if (i === appIdx) {
+      result.push(marker)
+      // Re-comment lines until we hit an empty line or the volumes: section
+      while (i < lines.length) {
+        const line = lines[i]!
+        if (line === "" || /^volumes:/.test(line) || /^  \w/.test(line)) {
+          result.push(line)
+          i++
+          break
+        }
+        // Re-comment: "  X..." → "  # X..."
+        result.push(line.replace(/^  /, "  # "))
+        i++
+      }
+    } else {
+      result.push(lines[i]!)
+      i++
+    }
+  }
+
+  return result.join("\n")
+}
+
+/**
+ * Uncomments the Kong app route block after the marker.
+ */
+function uncommentKongBlock(kong: string, marker: string, port: string): string {
+  const lines = kong.split("\n")
+  const markerIdx = lines.findIndex((l) => l === marker)
+  if (markerIdx === -1) return kong
+
+  const result: string[] = []
+  let i = 0
+
+  while (i < lines.length) {
+    if (i === markerIdx) {
+      i++ // skip marker
+      while (i < lines.length) {
+        const line = lines[i]!
+        if (line === "" && (i + 1 >= lines.length || !/^  #/.test(lines[i + 1]!))) {
+          result.push(line)
+          i++
+          break
+        }
+        if (/^  # /.test(line)) {
+          let uncommented = line.replace(/^  # /, "  ")
+          uncommented = uncommented.replace(":3000", `:${port}`)
+          result.push(uncommented)
+        } else {
+          result.push(line)
+        }
+        i++
+      }
+    } else {
+      result.push(lines[i]!)
+      i++
+    }
+  }
+
+  return result.join("\n")
+}
+
+/**
+ * Finds the active Kong app route and re-comments it, restoring the marker.
+ */
+function recommentKongBlock(kong: string): string {
+  const lines = kong.split("\n")
+  // Find "  - name: app" (the active route)
+  const appIdx = lines.findIndex((l) => /^  - name: app$/.test(l))
+  if (appIdx === -1) return kong
+
+  const result: string[] = []
+  let i = 0
+
+  while (i < lines.length) {
+    if (i === appIdx) {
+      result.push(KONG_APP_MARKER)
+      while (i < lines.length) {
+        const line = lines[i]!
+        if (line === "" || (i > appIdx && /^  - /.test(line))) {
+          result.push(line)
+          i++
+          break
+        }
+        result.push(line.replace(/^  /, "  # "))
+        i++
+      }
+    } else {
+      result.push(lines[i]!)
+      i++
+    }
+  }
+
+  return result.join("\n")
+}

package/src/commands/cloud.ts

@@ -0,0 +1,326 @@
+import type { Command } from "commander"
+import { readFileSync, writeFileSync, existsSync } from "node:fs"
+import { resolve } from "node:path"
+import { createInterface } from "node:readline"
+
+interface CloudConfig {
+  apiUrl: string
+  token: string
+  projectSlug?: string
+}
+
+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
+}
+
+function saveCloudConfig(cwd: string, config: CloudConfig): void {
+  const dir = resolve(cwd, ".supatype")
+  if (!existsSync(dir)) {
+    const { mkdirSync } = require("node:fs") as typeof import("node:fs")
+    mkdirSync(dir, { recursive: true })
+  }
+  writeFileSync(resolve(cwd, ".supatype/cloud.json"), JSON.stringify(config, null, 2) + "\n", "utf8")
+}
+
+async function cloudFetch<T>(config: CloudConfig, method: string, path: string, body?: unknown): Promise<T> {
+  const res = await fetch(`${config.apiUrl}/api/v1${path}`, {
+    method,
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${config.token}`,
+    },
+    ...(body !== undefined ? { body: JSON.stringify(body) } : {}),
+  })
+
+  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
+}
+
+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.io")
+    .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 }
+
+      if (opts.project) {
+        config.projectSlug = opts.project
+      } else {
+        // List projects and let user choose
+        const projects = await cloudFetch<Array<{ slug: string; name: string; status: string; tier: 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)
+        }
+        config.projectSlug = projects[idx]!.slug
+      }
+
+      saveCloudConfig(cwd, config)
+      console.log(`\nLinked to project: ${config.projectSlug}`)
+      console.log(`Config saved to .supatype/cloud.json\n`)
+    })
+
+  // ── Deploy ─────────────────────────────────────────────────────────────────
+  program
+    .command("deploy")
+    .description("Deploy schema to the linked cloud project")
+    .option("--environment <name>", "Target environment", "production")
+    .action(async (opts: { environment: string }) => {
+      const cwd = process.cwd()
+      const config = loadCloudConfig(cwd)
+      if (!config?.projectSlug) {
+        console.error("Not linked to a cloud project. Run: supatype link")
+        process.exit(1)
+      }
+
+      console.log(`Deploying to ${config.projectSlug} (${opts.environment})...`)
+
+      // Load schema AST
+      const { loadConfig: loadAppConfig, loadSchemaAst } = await import("../config.js")
+      const { ensureEngine, invokeEngine } = await import("../engine.js")
+
+      const appConfig = loadAppConfig(cwd)
+      const ast = loadSchemaAst(appConfig.schema, cwd)
+
+      // Generate migration SQL locally using the engine
+      await ensureEngine()
+      const migrateResult = invokeEngine(
+        ["migrate", "--format", "sql"],
+        JSON.stringify(ast),
+      )
+      if (migrateResult.exitCode !== 0) {
+        console.error("Failed to generate migration:", migrateResult.stderr || migrateResult.stdout)
+        process.exit(1)
+      }
+
+      const { createHash } = await import("node:crypto")
+      const schemaHash = createHash("sha256").update(JSON.stringify(ast)).digest("hex").slice(0, 16)
+
+      const deployment = await cloudFetch<{
+        id: string; status: string; errorMessage?: string
+      }>(config, "POST", `/projects/${config.projectSlug}/deploy`, {
+        environment: opts.environment,
+        schemaHash,
+        migrationSql: migrateResult.stdout,
+      })
+
+      if (deployment.status === "success") {
+        console.log(`\nDeployment successful (${deployment.id})`)
+      } else if (deployment.status === "failed") {
+        console.error(`\nDeployment failed: ${deployment.errorMessage}`)
+        process.exit(1)
+      } else {
+        console.log(`\nDeployment ${deployment.status} (${deployment.id})`)
+      }
+    })
+
+  // ── Projects ───────────────────────────────────────────────────────────────
+  const projectsCmd = program
+    .command("projects")
+    .description("Manage cloud projects")
+
+  projectsCmd
+    .command("list")
+    .description("List all projects in your organisation")
+    .action(async () => {
+      const config = getCloudConfigOrExit()
+
+      const projects = await cloudFetch<Array<{
+        name: string; slug: string; tier: string; region: string; status: string
+      }>>(config, "GET", "/projects")
+
+      if (projects.length === 0) {
+        console.log("No projects. Create one with: supatype projects create <name>")
+        return
+      }
+
+      console.log("\n  Name                    Slug                     Tier    Region    Status")
+      console.log("  " + "─".repeat(80))
+      for (const p of projects) {
+        console.log(
+          `  ${p.name.padEnd(24)}${p.slug.padEnd(25)}${p.tier.padEnd(8)}${p.region.padEnd(10)}${p.status}`,
+        )
+      }
+      console.log()
+    })
+
+  projectsCmd
+    .command("create <name>")
+    .description("Create a new project")
+    .option("--tier <tier>", "Project tier (free, pro, team)", "free")
+    .option("--region <region>", "Region (eu-fsn, eu-nbg, eu-hel)", "eu-fsn")
+    .action(async (name: string, opts: { tier: string; region: string }) => {
+      const config = getCloudConfigOrExit()
+
+      console.log(`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`)
+    })
+
+  projectsCmd
+    .command("pause <slug>")
+    .description("Pause a project")
+    .action(async (slug: string) => {
+      const config = getCloudConfigOrExit()
+      await cloudFetch(config, "POST", `/projects/${slug}/pause`)
+      console.log(`Project ${slug} paused.`)
+    })
+
+  projectsCmd
+    .command("resume <slug>")
+    .description("Resume a paused project")
+    .action(async (slug: string) => {
+      const config = getCloudConfigOrExit()
+      await cloudFetch(config, "POST", `/projects/${slug}/resume`)
+      console.log(`Project ${slug} resumed.`)
+    })
+
+  // ── Domains ────────────────────────────────────────────────────────────────
+  const domainsCmd = program
+    .command("domains")
+    .description("Manage custom domains for a project")
+
+  domainsCmd
+    .command("list")
+    .description("List domains for the linked project")
+    .action(async () => {
+      const config = getCloudConfigOrExit()
+      if (!config.projectSlug) {
+        console.error("Not linked to a project. Run: supatype link")
+        process.exit(1)
+      }
+
+      const domains = await cloudFetch<Array<{
+        domain: string; status: string; cnameTarget: string; sslExpiresAt: string | null
+      }>>(config, "GET", `/projects/${config.projectSlug}/domains`)
+
+      if (domains.length === 0) {
+        console.log("No custom domains configured.")
+        return
+      }
+
+      console.log("\n  Domain                          Status               CNAME Target")
+      console.log("  " + "─".repeat(80))
+      for (const d of domains) {
+        console.log(
+          `  ${d.domain.padEnd(34)}${d.status.padEnd(21)}${d.cnameTarget}`,
+        )
+      }
+      console.log()
+    })
+
+  domainsCmd
+    .command("add <domain>")
+    .description("Add a custom domain")
+    .action(async (domain: string) => {
+      const config = getCloudConfigOrExit()
+      if (!config.projectSlug) {
+        console.error("Not linked to a project. Run: supatype link")
+        process.exit(1)
+      }
+
+      const result = await cloudFetch<{ domain: string; cnameTarget: string; instructions: string }>(
+        config, "POST", `/projects/${config.projectSlug}/domains`,
+        { 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`)
+    })
+
+  domainsCmd
+    .command("remove <domainId>")
+    .description("Remove a custom domain")
+    .action(async (domainId: string) => {
+      const config = getCloudConfigOrExit()
+      if (!config.projectSlug) {
+        console.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.")
+    })
+
+  domainsCmd
+    .command("verify <domainId>")
+    .description("Verify CNAME and provision SSL for a domain")
+    .action(async (domainId: string) => {
+      const config = getCloudConfigOrExit()
+      if (!config.projectSlug) {
+        console.error("Not linked to a project. Run: supatype link")
+        process.exit(1)
+      }
+
+      const result = await cloudFetch<{ domain: string; status: string }>(
+        config, "POST", `/projects/${config.projectSlug}/domains/${domainId}/verify`,
+      )
+
+      console.log(`Domain ${result.domain}: ${result.status}`)
+    })
+}
+
+function getCloudConfigOrExit(): CloudConfig {
+  const cwd = process.cwd()
+  let config = loadCloudConfig(cwd)
+  if (!config) {
+    const token = process.env["SUPATYPE_TOKEN"]
+    const apiUrl = process.env["SUPATYPE_API_URL"] ?? "https://api.supatype.io"
+    if (!token) {
+      console.error("Not connected to Supatype Cloud. Run: supatype link, or set SUPATYPE_TOKEN.")
+      process.exit(1)
+    }
+    config = { apiUrl, token }
+  }
+  return config
+}