@supatype/cli 0.1.0 → 0.1.2

package/src/commands/init.ts

@@ -1,36 +1,25 @@
 import type { Command } from "commander"
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs"
-import { resolve, join, dirname, basename } from "node:path"
-import { fileURLToPath } from "node:url"
+import { resolve, join, basename } from "node:path"
 import { spawnSync } from "node:child_process"
-import * as p from "@clack/prompts"
+import { p, runClackFlow } from "../ui/clack.js"
 import { ensureNotCancelled, printLogo } from "../ui/prompts.js"
 import { generateAndWriteKeys } from "./keys.js"
 import { file, error, info, plain, warn } from "../ui/messages.js"
 import { nextSteps } from "../ui/next-steps.js"
 import { probeDockerDaemon, reportDockerUnavailable } from "../docker-runtime.js"
-
-export { scaffold }
-
-// ─── Markers used by `supatype app add / remove` (app.ts) ────────────────────
-export const APP_COMPOSE_MARKER = "  # ─── App service (run: supatype app add) ───"
-export const KONG_APP_MARKER = "  # ─── App fallback route (run: supatype app add) ───"
-
-const CLI_PACKAGE_JSON = join(
-  dirname(fileURLToPath(import.meta.url)),
-  "..",
-  "..",
-  "package.json",
-)
-
-function cliPackageVersion(): string {
-  try {
-    const pkg = JSON.parse(readFileSync(CLI_PACKAGE_JSON, "utf8")) as { version?: string }
-    return pkg.version ?? "0.1.0"
-  } catch {
-    return "0.1.0"
-  }
-}
+import { loadConfig } from "../config.js"
+import {
+  ensureComponentBinaries,
+  reportComponentBinaryFailures,
+} from "../ensure-component-binaries.js"
+import { mergeSupatypePackageJson } from "../init-package-json.js"
+import { cliPackageVersion } from "../cli-package-version.js"
+import {
+  initDependencyVersionsFallback,
+  resolveInitDependencyVersions,
+  type InitDependencyVersions,
+} from "../init-dependency-versions.js"
 
 // ─── Options model ─────────────────────────────────────────────────────────--
 
@@ -52,6 +41,8 @@ export interface ScaffoldOptions {
   projectName: string
   /** Local development runtime (docker recommended). */
   provider: "docker" | "native"
+  /** Host Kong port when provider is docker (unique per project). */
+  kongPort?: number
   productionTarget: ProductionTarget
   domain?: string
   /** ACME contact email for Let's Encrypt HTTPS (self-host + domain). */
@@ -64,6 +55,9 @@ export interface ScaffoldOptions {
   /** Object storage when deployed to production. */
   storageProduction: "local" | "s3"
   helloFunction: boolean
+  /** When set, written to .env for first dev/push to create the admin panel user. */
+  adminEmail?: string
+  adminPassword?: string
 }
 
 type StorageProvider = ScaffoldOptions["storageLocal"]
@@ -126,6 +120,9 @@ interface InitCliOptions {
   defaults?: boolean
   install: boolean
   keys: boolean
+  adminEmail?: string
+  adminPassword?: string
+  admin?: boolean
 }
 
 export function registerInit(program: Command): void {
@@ -140,6 +137,9 @@ export function registerInit(program: Command): void {
     .option("-y, --defaults", "Skip all prompts and use sensible defaults")
     .option("--no-install", "Do not run the package manager install step")
     .option("--no-keys", "Do not generate ANON_KEY / SERVICE_ROLE_KEY")
+    .option("--admin-email <email>", "First admin panel user email (written to .env)")
+    .option("--admin-password <password>", "First admin panel user password (written to .env)")
+    .option("--no-admin", "Do not configure a first admin user")
     .action(async (name: string | undefined, opts: InitCliOptions) => {
       const dir = name ? resolve(process.cwd(), name) : process.cwd()
 
@@ -164,6 +164,23 @@ export function registerInit(program: Command): void {
           install: true,
           generateKeys: true,
         }
+        if (result.provider === "docker") {
+          const { findNextFreePort } = await import("../dev-ports.js")
+          const { COMPOSE_DEV_KONG_PORT } = await import("../project-config.js")
+          result.kongPort = await findNextFreePort(COMPOSE_DEV_KONG_PORT)
+        }
+        if (!opts.admin && opts.adminEmail && opts.adminPassword) {
+          result.adminEmail = opts.adminEmail
+          result.adminPassword = opts.adminPassword
+        }
+      }
+
+      if (opts.admin === false) {
+        delete result.adminEmail
+        delete result.adminPassword
+      } else if (opts.adminEmail && opts.adminPassword) {
+        result.adminEmail = opts.adminEmail
+        result.adminPassword = opts.adminPassword
       }
 
       // CLI flags override wizard / default action choices.
@@ -172,9 +189,23 @@ export function registerInit(program: Command): void {
 
       if (name) mkdirSync(dir, { recursive: true })
 
-      scaffold(dir, result)
+      const deps = await resolveInitDependencyVersions()
+      const runningCli = cliPackageVersion()
+      if (deps.cli !== runningCli || deps.types !== runningCli) {
+        info(
+          `Using published npm versions: @supatype/cli ^${deps.cli}, @supatype/types ^${deps.types}`,
+        )
+      }
+
+      scaffold(dir, result, deps)
+
+      const installOk = doInstall ? runInstall(dir, result.packageManager) : true
+
+      const binariesReady = installOk ? await ensureInitBinaries(dir) : false
+      if (doInstall && !installOk) {
+        warn("Skipping component binary check until dependencies install successfully.")
+      }
 
-      if (doInstall) runInstall(dir, result.packageManager)
       const keysGenerated = doKeys ? writeKeys(dir) : false
 
       warnDockerUnavailableForProvider(result.provider)
@@ -182,8 +213,9 @@ export function registerInit(program: Command): void {
       printNextSteps({
         name,
         result,
-        installed: doInstall,
+        installed: doInstall && installOk,
         keysGenerated,
+        binariesReady,
       })
     })
 }
@@ -194,6 +226,7 @@ async function runWizard(
   defaultName: string,
   defaultTarget: ProductionTarget,
 ): Promise<WizardResult> {
+  return runClackFlow(async () => {
   p.intro("Create a new Supatype project")
 
   const projectName = ensureNotCancelled(
@@ -262,6 +295,12 @@ async function runWizard(
     }),
   )
 
+  let kongPort: number | undefined
+  if (provider === "docker") {
+    const { promptKongPortChoice } = await import("../dev-ports.js")
+    kongPort = await promptKongPortChoice()
+  }
+
   const schemaPath = ensureNotCancelled(
     await p.text({
       message: "Where should your schema live?",
@@ -322,11 +361,43 @@ async function runWizard(
     }),
   )
 
+  let adminEmail: string | undefined
+  let adminPassword: string | undefined
+  const createAdmin = ensureNotCancelled(
+    await p.confirm({
+      message: "Create an admin user for /admin?",
+      initialValue: true,
+    }),
+  )
+  if (createAdmin) {
+    adminEmail =
+      ensureNotCancelled(
+        await p.text({
+          message: "Admin email",
+          placeholder: "you@example.com",
+          defaultValue: "",
+        }),
+      ).trim() || undefined
+    if (adminEmail) {
+      adminPassword =
+        ensureNotCancelled(
+          await p.text({
+            message: "Admin password (min 8 chars)",
+            defaultValue: "",
+          }),
+        ).trim() || undefined
+      if (adminPassword && adminPassword.length < 8) {
+        adminPassword = undefined
+      }
+    }
+  }
+
   p.outro("Setting up your project...")
 
   return {
     projectName,
     provider,
+    ...(kongPort !== undefined ? { kongPort } : {}),
     productionTarget,
     ...(domain !== undefined ? { domain } : {}),
     ...(tlsEmail !== undefined ? { tlsEmail } : {}),
@@ -339,7 +410,9 @@ async function runWizard(
     packageManager,
     install,
     generateKeys,
+    ...(adminEmail && adminPassword ? { adminEmail, adminPassword } : {}),
   }
+  })
 }
 
 async function promptApp(): Promise<ScaffoldAppOptions> {
@@ -418,7 +491,7 @@ function detectInvokingPackageManager(): PackageManager {
   return "npm"
 }
 
-function runInstall(dir: string, pm: PackageManager): void {
+function runInstall(dir: string, pm: PackageManager): boolean {
   info(`Installing dependencies with ${pm}...`)
   const res = spawnSync(pm, ["install"], {
     cwd: dir,
@@ -427,6 +500,29 @@ function runInstall(dir: string, pm: PackageManager): void {
   })
   if (res.status !== 0 || res.error) {
     warn(`Dependency install did not complete (run "${pm} install" manually).`)
+    return false
+  }
+  return true
+}
+
+async function ensureInitBinaries(dir: string): Promise<boolean> {
+  const previousCwd = process.cwd()
+  try {
+    process.chdir(dir)
+    const config = loadConfig(dir)
+    const result = await ensureComponentBinaries(config, dir)
+    if (!result.ok) {
+      reportComponentBinaryFailures(result.failures)
+      return false
+    }
+    return true
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err)
+    warn(`Could not verify component binaries: ${message}`)
+    warn("Run manually from your project directory: supatype update")
+    return false
+  } finally {
+    process.chdir(previousCwd)
   }
 }
 
@@ -441,7 +537,11 @@ function writeKeys(dir: string): boolean {
 
 // ─── Scaffold ──────────────────────────────────────────────────────────────--
 
-function scaffold(dir: string, optsOrName: ScaffoldOptions | string): void {
+export function scaffold(
+  dir: string,
+  optsOrName: ScaffoldOptions | string,
+  deps: InitDependencyVersions = initDependencyVersionsFallback(),
+): void {
   const opts =
     typeof optsOrName === "string" ? defaultScaffoldOptions(optsOrName) : optsOrName
   const write = (rel: string, content: string) => {
@@ -453,9 +553,17 @@ function scaffold(dir: string, optsOrName: ScaffoldOptions | string): void {
 
   const pkgPath = join(dir, "package.json")
   if (!existsSync(pkgPath)) {
-    write("package.json", packageJsonTemplate(opts, cliPackageVersion()))
+    write("package.json", packageJsonTemplate(opts, deps))
   } else {
-    file("skipped", "package.json (already exists)")
+    try {
+      const existing = JSON.parse(readFileSync(pkgPath, "utf8")) as Record<string, unknown>
+      const merged = mergeSupatypePackageJson(existing, opts, deps)
+      writeFileSync(pkgPath, `${JSON.stringify(merged, null, 2)}\n`, "utf8")
+      file("updated", "package.json (added Supatype dependencies)")
+    } catch {
+      warn("Could not merge into package.json — add @supatype/cli and @supatype/types manually.")
+      file("skipped", "package.json (invalid JSON)")
+    }
   }
 
   write("supatype.config.ts", tsConfigTemplate(opts))
@@ -498,8 +606,13 @@ function scaffoldAppAssets(
 
   if (opts.app.mode === "static") {
     const staticRel = staticDirRelative(opts.app.staticDir)
+    if (opts.app.viteDevUrl && opts.productionTarget !== "later") {
+      write("dist/index.html", holding)
+      scaffoldVite(opts, write, holding)
+      return
+    }
     write(`${staticRel}/index.html`, holding)
-    if (hasVite) scaffoldVite(opts, write, holding)
+    if (opts.app.viteDevUrl) scaffoldVite(opts, write, holding)
     return
   }
 
@@ -542,7 +655,7 @@ function scaffoldHelloFunction(
 
 // ─── Templates ───────────────────────────────────────────────────────────────
 
-function packageJsonTemplate(opts: ScaffoldOptions, cliVersion: string): string {
+function packageJsonTemplate(opts: ScaffoldOptions, deps: InitDependencyVersions): string {
   const scripts: string[] = [
     `    "dev": "supatype dev"`,
     `    "push": "supatype push"`,
@@ -566,8 +679,8 @@ function packageJsonTemplate(opts: ScaffoldOptions, cliVersion: string): string
 ${scripts.join(",\n")}
   },
   "dependencies": {
-    "@supatype/cli": "^${cliVersion}",
-    "@supatype/types": "^${cliVersion}"
+    "@supatype/cli": "^${deps.cli}",
+    "@supatype/types": "^${deps.types}"
   },
   "devDependencies": {
 ${devDeps.join(",\n")}
@@ -634,20 +747,49 @@ function localConfigTemplate(app: ScaffoldAppOptions): string {
     `const localConfig: Partial<SupatypeConfig> = {`,
     `  server: { mode: "dev" },`,
   ]
-  if (app.mode === "proxy") {
-    lines.push(`  app: {`)
-    lines.push(`    mode: "proxy",`)
-    lines.push(`    upstream: "${app.upstream ?? "http://localhost:3000"}",`)
-    lines.push(`    start: "${app.start ?? "dev"}",`)
-    if (app.viteDevUrl) lines.push(`    vite_dev_url: "${app.viteDevUrl}",`)
-    lines.push(`  },`)
+  const localApp = localDevAppConfigLines(app)
+  if (localApp.length > 0) {
+    lines.push(...localApp)
   }
   lines.push(`}`, ``, `export default localConfig`, ``)
   return lines.join("\n")
 }
 
+/** App block for supatype.local.config.ts (proxy + Vite during local dev). */
+function localDevAppConfigLines(app: ScaffoldAppOptions): string[] {
+  if (app.mode === "proxy") {
+    return [
+      `  app: {`,
+      `    mode: "proxy",`,
+      `    upstream: "${app.upstream ?? "http://localhost:3000"}",`,
+      `    start: "${app.start ?? "dev"}",`,
+      ...(app.viteDevUrl ? [`    vite_dev_url: "${app.viteDevUrl}",`] : []),
+      `  },`,
+    ]
+  }
+  if (app.viteDevUrl) {
+    return [
+      `  app: {`,
+      `    mode: "proxy",`,
+      `    upstream: "${app.viteDevUrl}",`,
+      `    start: "vite",`,
+      `    vite_dev_url: "${app.viteDevUrl}",`,
+      `  },`,
+    ]
+  }
+  return []
+}
+
 function appConfigLines(app: ScaffoldAppOptions, productionTarget: ProductionTarget): string[] {
   if (app.mode === "static") {
+    if (productionTarget !== "later" && app.viteDevUrl) {
+      return [
+        `  app: {`,
+        `    mode: "static",`,
+        `    static_dir: "./dist",  // production build output`,
+        `  },`,
+      ]
+    }
     const out = [
       `  app: {`,
       `    mode: "static",`,
@@ -707,7 +849,7 @@ function holdingPageTemplate(projectName: string): string {
     <meta charset="UTF-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>${name} — Supatype</title>
-    <meta name="description" content="A Supatype project. Define your types — we generate your backend." />
+    <meta name="description" content="A Supatype project. Define your types — we generate your platform." />
     <link rel="preconnect" href="https://fonts.googleapis.com" />
     <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
     <link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&display=swap" rel="stylesheet" />
@@ -842,6 +984,8 @@ export default defineConfig({
     host: "127.0.0.1",
     port: ${port},
     strictPort: true,
+    // Docker Compose app proxy reaches the host as host.docker.internal.
+    allowedHosts: ["127.0.0.1", "localhost", "host.docker.internal"],
   },
 })
 `
@@ -910,9 +1054,27 @@ SERVICE_ROLE_KEY=`)
   sections.push(`# Site URL (used by GoTrue for email redirects)
 SITE_URL=http://localhost:3000`)
 
+  if (opts.provider === "docker" && opts.kongPort !== undefined) {
+    const apiUrl = `http://localhost:${opts.kongPort}`
+    sections.push(
+      `# Local API gateway (Kong) — unique per project so multiple stacks can run concurrently
+SUPATYPE_KONG_PORT=${opts.kongPort}
+PUBLIC_SUPATYPE_URL=${apiUrl}
+API_EXTERNAL_URL=${apiUrl}`,
+    )
+  }
+
   sections.push(emailEnvSection(opts.email, opts.projectName))
   sections.push(storageEnvSections(opts.storageLocal, opts.storageProduction))
 
+  if (opts.adminEmail && opts.adminPassword) {
+    sections.push(
+      `# First admin for /admin — consumed on first supatype dev or push (password removed after use)
+SUPATYPE_ADMIN_EMAIL=${opts.adminEmail}
+SUPATYPE_ADMIN_PASSWORD=${opts.adminPassword}`,
+    )
+  }
+
   sections.push(
     `# Self-host compose uses the same DATABASE_URL when Postgres is published on localhost:5432`,
   )
@@ -1100,14 +1262,23 @@ function printNextSteps(args: {
   result: WizardResult
   installed: boolean
   keysGenerated: boolean
+  binariesReady: boolean
 }): void {
-  const { name, result, installed, keysGenerated } = args
+  const { name, result, installed, keysGenerated, binariesReady } = args
   const steps: string[] = []
   if (name) steps.push(`cd ${name}`)
   if (!installed) steps.push(`${result.packageManager} install`)
+  if (!binariesReady) steps.push("supatype update        # download component binaries")
   if (!keysGenerated) steps.push("supatype keys")
-  steps.push("supatype dev          # Docker Compose stack (Kong :18473)")
+  const kongHint =
+    result.provider === "docker" && result.kongPort !== undefined
+      ? `supatype dev          # Docker Compose stack (Kong :${result.kongPort})`
+      : "supatype dev          # Docker Compose stack (Kong :18473)"
+  steps.push(kongHint)
   steps.push("supatype push         # apply schema + generate types")
+  if (result.adminEmail) {
+    steps.push("                      # first admin user is created on dev or push")
+  }
   if (result.helloFunction) {
     steps.push("supatype functions serve   # run edge functions locally")
   }

package/src/commands/link-helpers.ts

@@ -12,7 +12,7 @@ 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"
+import { ensureNotCancelled, p, runClackFlow } from "../ui/prompts.js"
 
 function resolveLinkToken(opts: {
   token?: string
@@ -145,35 +145,36 @@ export async function runLinkAction(opts: {
   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,
+    await runClackFlow(async () => {
+      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" },
+          ],
         }),
-      ).trim()
-    } else {
-      url = ensureNotCancelled(
-        await p.text({
-          message: "Kong gateway URL",
-          placeholder: "https://api.example.com",
-          defaultValue: "http://localhost:18473",
-        }),
-      ).trim()
-    }
-    p.outro("Linking...")
+      )
+      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)

package/src/commands/push.ts

@@ -8,7 +8,7 @@ import { printDiffOperations, printDiffWarnings } from "../diff-output.js"
 import { signJwt } from "../jwt.js"
 import { provisionBucketsFromAst } from "../storage-provision.js"
 import type { ExtractedSchemaAstV2 } from "../schema-ast-v2.js"
-import { promptFirstAdminUser } from "./admin.js"
+import { ensureFirstAdminUser } from "./admin.js"
 import { withAdminRoles } from "../studio-admin-roles.js"
 import { restoreSystemRelationTargets } from "../restore-system-relation-targets.js"
 import type { SupatypeProjectConfig } from "../project-config.js"
@@ -145,8 +145,8 @@ async function pushViaTarget(
 
   if (target.mode === "direct" || target.mode === "local") {
     await writeLocalAdminConfig(ast, config)
-    if (ops.length > 0 && target.databaseUrl) {
-      await promptFirstAdminUser(target.databaseUrl)
+    if (target.databaseUrl) {
+      await ensureFirstAdminUser(target.databaseUrl, { cwd })
     }
     await generateTypesLocal(ast, config)
     await provisionLocalStorage(ast, config)

package/src/compose-local-server-image.ts

@@ -0,0 +1,68 @@
+import { existsSync } from "node:fs"
+import { dirname, isAbsolute, join, resolve } from "node:path"
+import { spawnSync } from "node:child_process"
+import { VERSION_PIN_LOCAL } from "./binary-cache.js"
+import { appendStackOutput, getActiveDevSession } from "./dev-session.js"
+import { requireDockerDaemon } from "./docker-runtime.js"
+import type { SupatypeProjectConfig } from "./project-config.js"
+
+/** Docker tag for compose dev when `versions.server` is `local`. */
+export const LOCAL_SERVER_DOCKER_IMAGE = "supatype/server:local-dev"
+
+/** Find the server repo root (directory containing `Dockerfile`) from an overrides.server binary path. */
+export function resolveServerSourceRoot(serverOverride: string, cwd: string): string | null {
+  const binaryPath = isAbsolute(serverOverride) ? serverOverride : resolve(cwd, serverOverride)
+  let dir = dirname(binaryPath)
+  for (let depth = 0; depth < 5; depth++) {
+    if (existsSync(join(dir, "Dockerfile"))) return dir
+    const parent = dirname(dir)
+    if (parent === dir) break
+    dir = parent
+  }
+  return null
+}
+
+/**
+ * When `versions.server` is `local`, build a Linux server image from the source tree
+ * next to `overrides.server` so compose dev matches the contributor's binary.
+ */
+export async function ensureLocalServerDockerImage(
+  cwd: string,
+  config: SupatypeProjectConfig,
+  brand?: { intro?: string },
+): Promise<string | undefined> {
+  if (config.versions?.server !== VERSION_PIN_LOCAL) return undefined
+
+  const override = config.overrides?.server?.trim()
+  if (!override) return undefined
+
+  const root = resolveServerSourceRoot(override, cwd)
+  if (!root) {
+    console.warn(
+      `[supatype] ⚠  versions.server is "local" but no Dockerfile found near ${override}. ` +
+        "Compose will use the default supatype/server:latest image.",
+    )
+    return undefined
+  }
+
+  requireDockerDaemon(brand?.intro ? { brand: { intro: brand.intro } } : undefined)
+  const dockerfile = join(root, "Dockerfile")
+  console.log(`[supatype] Building local server Docker image from ${root}…`)
+  const result = spawnSync(
+    "docker",
+    ["build", "--progress=plain", "-t", LOCAL_SERVER_DOCKER_IMAGE, "-f", dockerfile, root],
+    { encoding: "utf8", stdio: "pipe" },
+  )
+  const tui = getActiveDevSession()?.isTui() ?? false
+  if (!tui) {
+    appendStackOutput(result.stdout, "log")
+    appendStackOutput(result.stderr, result.status === 0 ? "log" : "error")
+  } else if (result.status !== 0) {
+    appendStackOutput(result.stderr || result.stdout || "docker build failed", "error")
+  }
+  if (result.status !== 0) {
+    throw new Error(`docker build failed for local server (exit ${result.status ?? "unknown"})`)
+  }
+  console.log(`[supatype] Local server image ready: ${LOCAL_SERVER_DOCKER_IMAGE}`)
+  return LOCAL_SERVER_DOCKER_IMAGE
+}