@supatype/cli 0.1.0 → 0.1.2

package/dist/commands/init.js

@@ -1,27 +1,17 @@
 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() {
-    try {
-        const pkg = JSON.parse(readFileSync(CLI_PACKAGE_JSON, "utf8"));
-        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, } from "../init-dependency-versions.js";
 const STORAGE_PROVIDER_OPTIONS = [
     { value: "local", label: "Local", hint: "storage you host yourself (MinIO)" },
     { value: "s3", label: "S3", hint: "external bucket (AWS S3 or compatible)" },
@@ -63,6 +53,9 @@ export function registerInit(program) {
         .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, opts) => {
         const dir = name ? resolve(process.cwd(), name) : process.cwd();
         if (name && existsSync(dir)) {
@@ -84,132 +77,191 @@ export function registerInit(program) {
                 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.
         const doInstall = opts.install !== false && result.install;
         const doKeys = opts.keys !== false && result.generateKeys;
         if (name)
             mkdirSync(dir, { recursive: true });
-        scaffold(dir, result);
-        if (doInstall)
-            runInstall(dir, result.packageManager);
+        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.");
+        }
         const keysGenerated = doKeys ? writeKeys(dir) : false;
         warnDockerUnavailableForProvider(result.provider);
         printNextSteps({
             name,
             result,
-            installed: doInstall,
+            installed: doInstall && installOk,
             keysGenerated,
+            binariesReady,
         });
     });
 }
 // ─── Wizard ──────────────────────────────────────────────────────────────────
 async function runWizard(defaultName, defaultTarget) {
-    p.intro("Create a new Supatype project");
-    const projectName = ensureNotCancelled(await p.text({
-        message: "Project name",
-        defaultValue: defaultName,
-        placeholder: defaultName,
-    })).trim() || defaultName;
-    const packageManager = ensureNotCancelled(await p.select({
-        message: "Package manager",
-        initialValue: detectInvokingPackageManager(),
-        options: [
-            { value: "npm", label: "npm" },
-            { value: "pnpm", label: "pnpm" },
-            { value: "yarn", label: "yarn" },
-            { value: "bun", label: "bun" },
-        ],
-    }));
-    const productionTarget = ensureNotCancelled(await p.select({
-        message: "Where will this run in production?",
-        initialValue: defaultTarget,
-        options: [
-            { value: "cloud", label: "Supatype Cloud", hint: "managed; deploy via supatype link" },
-            { value: "self-host", label: "Self-host", hint: "your own server with TLS" },
-            { value: "later", label: "Decide later", hint: "local development only for now" },
-        ],
-    }));
-    let domain;
-    let tlsEmail;
-    if (productionTarget === "self-host") {
-        domain = ensureNotCancelled(await p.text({
-            message: "Production domain for ACME TLS (optional, can set later)",
-            placeholder: "api.example.com",
-            defaultValue: "",
-        })).trim();
-        if (domain) {
-            tlsEmail =
+    return runClackFlow(async () => {
+        p.intro("Create a new Supatype project");
+        const projectName = ensureNotCancelled(await p.text({
+            message: "Project name",
+            defaultValue: defaultName,
+            placeholder: defaultName,
+        })).trim() || defaultName;
+        const packageManager = ensureNotCancelled(await p.select({
+            message: "Package manager",
+            initialValue: detectInvokingPackageManager(),
+            options: [
+                { value: "npm", label: "npm" },
+                { value: "pnpm", label: "pnpm" },
+                { value: "yarn", label: "yarn" },
+                { value: "bun", label: "bun" },
+            ],
+        }));
+        const productionTarget = ensureNotCancelled(await p.select({
+            message: "Where will this run in production?",
+            initialValue: defaultTarget,
+            options: [
+                { value: "cloud", label: "Supatype Cloud", hint: "managed; deploy via supatype link" },
+                { value: "self-host", label: "Self-host", hint: "your own server with TLS" },
+                { value: "later", label: "Decide later", hint: "local development only for now" },
+            ],
+        }));
+        let domain;
+        let tlsEmail;
+        if (productionTarget === "self-host") {
+            domain = ensureNotCancelled(await p.text({
+                message: "Production domain for ACME TLS (optional, can set later)",
+                placeholder: "api.example.com",
+                defaultValue: "",
+            })).trim();
+            if (domain) {
+                tlsEmail =
+                    ensureNotCancelled(await p.text({
+                        message: "Email for Let's Encrypt (HTTPS) certificates",
+                        placeholder: "you@example.com",
+                        defaultValue: "",
+                    })).trim() || undefined;
+            }
+        }
+        const provider = ensureNotCancelled(await p.select({
+            message: "How should Postgres and the server run for local development?",
+            initialValue: "docker",
+            options: [
+                { value: "docker", label: "Docker", hint: "Docker Compose stack (recommended)" },
+                { value: "native", label: "Native", hint: "host Postgres + server binaries, no Docker" },
+            ],
+        }));
+        let kongPort;
+        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?",
+            defaultValue: "schema/index.ts",
+            placeholder: "schema/index.ts",
+        })).trim() || "schema/index.ts";
+        const app = await promptApp();
+        const email = ensureNotCancelled(await p.select({
+            message: "Email provider",
+            initialValue: "console",
+            options: [
+                { value: "console", label: "console", hint: "log emails to the terminal (dev)" },
+                { value: "smtp", label: "SMTP" },
+                { value: "resend", label: "Resend" },
+                { value: "ses", label: "Amazon SES" },
+            ],
+        }));
+        const storageLocal = ensureNotCancelled(await p.select({
+            message: "Local storage (for development)?",
+            initialValue: "local",
+            options: STORAGE_PROVIDER_OPTIONS,
+        }));
+        const storageProduction = ensureNotCancelled(await p.select({
+            message: "Production storage?",
+            initialValue: "local",
+            options: STORAGE_PROVIDER_OPTIONS,
+        }));
+        const helloFunction = ensureNotCancelled(await p.confirm({
+            message: "Create a hello-world edge function?",
+            initialValue: false,
+        }));
+        const install = ensureNotCancelled(await p.confirm({
+            message: `Install dependencies with ${packageManager} now?`,
+            initialValue: true,
+        }));
+        const generateKeys = ensureNotCancelled(await p.confirm({
+            message: "Generate ANON_KEY and SERVICE_ROLE_KEY now?",
+            initialValue: true,
+        }));
+        let adminEmail;
+        let adminPassword;
+        const createAdmin = ensureNotCancelled(await p.confirm({
+            message: "Create an admin user for /admin?",
+            initialValue: true,
+        }));
+        if (createAdmin) {
+            adminEmail =
                 ensureNotCancelled(await p.text({
-                    message: "Email for Let's Encrypt (HTTPS) certificates",
+                    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;
+                }
+            }
         }
-    }
-    const provider = ensureNotCancelled(await p.select({
-        message: "How should Postgres and the server run for local development?",
-        initialValue: "docker",
-        options: [
-            { value: "docker", label: "Docker", hint: "Docker Compose stack (recommended)" },
-            { value: "native", label: "Native", hint: "host Postgres + server binaries, no Docker" },
-        ],
-    }));
-    const schemaPath = ensureNotCancelled(await p.text({
-        message: "Where should your schema live?",
-        defaultValue: "schema/index.ts",
-        placeholder: "schema/index.ts",
-    })).trim() || "schema/index.ts";
-    const app = await promptApp();
-    const email = ensureNotCancelled(await p.select({
-        message: "Email provider",
-        initialValue: "console",
-        options: [
-            { value: "console", label: "console", hint: "log emails to the terminal (dev)" },
-            { value: "smtp", label: "SMTP" },
-            { value: "resend", label: "Resend" },
-            { value: "ses", label: "Amazon SES" },
-        ],
-    }));
-    const storageLocal = ensureNotCancelled(await p.select({
-        message: "Local storage (for development)?",
-        initialValue: "local",
-        options: STORAGE_PROVIDER_OPTIONS,
-    }));
-    const storageProduction = ensureNotCancelled(await p.select({
-        message: "Production storage?",
-        initialValue: "local",
-        options: STORAGE_PROVIDER_OPTIONS,
-    }));
-    const helloFunction = ensureNotCancelled(await p.confirm({
-        message: "Create a hello-world edge function?",
-        initialValue: false,
-    }));
-    const install = ensureNotCancelled(await p.confirm({
-        message: `Install dependencies with ${packageManager} now?`,
-        initialValue: true,
-    }));
-    const generateKeys = ensureNotCancelled(await p.confirm({
-        message: "Generate ANON_KEY and SERVICE_ROLE_KEY now?",
-        initialValue: true,
-    }));
-    p.outro("Setting up your project...");
-    return {
-        projectName,
-        provider,
-        productionTarget,
-        ...(domain !== undefined ? { domain } : {}),
-        ...(tlsEmail !== undefined ? { tlsEmail } : {}),
-        schemaPath,
-        app,
-        email,
-        storageLocal,
-        storageProduction,
-        helloFunction,
-        packageManager,
-        install,
-        generateKeys,
-    };
+        p.outro("Setting up your project...");
+        return {
+            projectName,
+            provider,
+            ...(kongPort !== undefined ? { kongPort } : {}),
+            productionTarget,
+            ...(domain !== undefined ? { domain } : {}),
+            ...(tlsEmail !== undefined ? { tlsEmail } : {}),
+            schemaPath,
+            app,
+            email,
+            storageLocal,
+            storageProduction,
+            helloFunction,
+            packageManager,
+            install,
+            generateKeys,
+            ...(adminEmail && adminPassword ? { adminEmail, adminPassword } : {}),
+        };
+    });
 }
 async function promptApp() {
     const mode = ensureNotCancelled(await p.select({
@@ -279,6 +331,30 @@ function runInstall(dir, pm) {
     });
     if (res.status !== 0 || res.error) {
         warn(`Dependency install did not complete (run "${pm} install" manually).`);
+        return false;
+    }
+    return true;
+}
+async function ensureInitBinaries(dir) {
+    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);
     }
 }
 function writeKeys(dir) {
@@ -290,7 +366,7 @@ function writeKeys(dir) {
     return true;
 }
 // ─── Scaffold ──────────────────────────────────────────────────────────────--
-function scaffold(dir, optsOrName) {
+export function scaffold(dir, optsOrName, deps = initDependencyVersionsFallback()) {
     const opts = typeof optsOrName === "string" ? defaultScaffoldOptions(optsOrName) : optsOrName;
     const write = (rel, content) => {
         const full = join(dir, rel);
@@ -300,10 +376,19 @@ function scaffold(dir, optsOrName) {
     };
     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"));
+            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));
     if (opts.productionTarget !== "later") {
@@ -340,8 +425,13 @@ function scaffoldAppAssets(opts, write) {
     const hasVite = Boolean(opts.app.viteDevUrl);
     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)
+        if (opts.app.viteDevUrl)
             scaffoldVite(opts, write, holding);
         return;
     }
@@ -373,7 +463,7 @@ function scaffoldHelloFunction(dir, write) {
     }
 }
 // ─── Templates ───────────────────────────────────────────────────────────────
-function packageJsonTemplate(opts, cliVersion) {
+function packageJsonTemplate(opts, deps) {
     const scripts = [
         `    "dev": "supatype dev"`,
         `    "push": "supatype push"`,
@@ -397,8 +487,8 @@ function packageJsonTemplate(opts, cliVersion) {
 ${scripts.join(",\n")}
   },
   "dependencies": {
-    "@supatype/cli": "^${cliVersion}",
-    "@supatype/types": "^${cliVersion}"
+    "@supatype/cli": "^${deps.cli}",
+    "@supatype/types": "^${deps.types}"
   },
   "devDependencies": {
 ${devDeps.join(",\n")}
@@ -460,20 +550,47 @@ function localConfigTemplate(app) {
         `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) {
+    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, productionTarget) {
     if (app.mode === "static") {
+        if (productionTarget !== "later" && app.viteDevUrl) {
+            return [
+                `  app: {`,
+                `    mode: "static",`,
+                `    static_dir: "./dist",  // production build output`,
+                `  },`,
+            ];
+        }
         const out = [
             `  app: {`,
             `    mode: "static",`,
@@ -532,7 +649,7 @@ function holdingPageTemplate(projectName) {
     <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" />
@@ -667,6 +784,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"],
   },
 })
 `;
@@ -728,8 +847,20 @@ ANON_KEY=
 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`);
     return sections.join("\n\n") + "\n";
 }
@@ -893,16 +1024,24 @@ function warnDockerUnavailableForProvider(provider) {
     plain();
 }
 function printNextSteps(args) {
-    const { name, result, installed, keysGenerated } = args;
+    const { name, result, installed, keysGenerated, binariesReady } = args;
     const steps = [];
     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");
     }