@supatype/cli 0.1.2 → 0.1.4

package/dist/commands/init.js

@@ -2,7 +2,7 @@ import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { resolve, join, basename } from "node:path";
 import { spawnSync } from "node:child_process";
 import { p, runClackFlow } from "../ui/clack.js";
-import { ensureNotCancelled, printLogo } from "../ui/prompts.js";
+import { ensureNotCancelled } 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";
@@ -12,6 +12,7 @@ import { ensureComponentBinaries, reportComponentBinaryFailures, } from "../ensu
 import { mergeSupatypePackageJson } from "../init-package-json.js";
 import { cliPackageVersion } from "../cli-package-version.js";
 import { initDependencyVersionsFallback, resolveInitDependencyVersions, } from "../init-dependency-versions.js";
+import { detectProjectSetup } from "../init-project-detect.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)" },
@@ -67,8 +68,14 @@ export function registerInit(program) {
         const modeTarget = productionTargetFromMode(opts.mode);
         let result;
         if (interactive) {
-            printLogo();
-            result = await runWizard(defaultName, modeTarget);
+            await runInteractiveInit({
+                name,
+                dir,
+                defaultName,
+                modeTarget,
+                opts,
+            });
+            return;
         }
         else {
             result = {
@@ -106,12 +113,21 @@ export function registerInit(program) {
             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;
+        const installOk = doInstall ? runInstall(dir, result.packageManager) : false;
+        const keysGenerated = doKeys ? writeKeys(dir) : false;
+        const binariesReady = doInstall && installOk ? await ensureInitBinaries(dir) : false;
         if (doInstall && !installOk) {
-            warn("Skipping component binary check until dependencies install successfully.");
+            error(`Dependency install failed. Run "${result.packageManager} install" in the project directory, then "supatype update".`);
+            process.exit(1);
+        }
+        if (doKeys && !keysGenerated) {
+            error("Could not generate API keys. Check .env has JWT_SECRET, then run `supatype keys`.");
+            process.exit(1);
+        }
+        if (doInstall && installOk && !binariesReady) {
+            error("Component binaries could not be downloaded. Run `supatype update` in the project directory.");
+            process.exit(1);
         }
-        const keysGenerated = doKeys ? writeKeys(dir) : false;
         warnDockerUnavailableForProvider(result.provider);
         printNextSteps({
             name,
@@ -122,151 +138,218 @@ export function registerInit(program) {
         });
     });
 }
-// ─── Wizard ──────────────────────────────────────────────────────────────────
-async function runWizard(defaultName, defaultTarget) {
-    return runClackFlow(async () => {
+/** Interactive init — one Ink session for wizard + scaffold + install + finish. */
+async function runInteractiveInit(args) {
+    const { name, dir, defaultName, modeTarget, opts } = args;
+    await 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 detected = detectProjectSetup(dir);
+        if (detected.hasExistingFiles && detected.summaryLines.length > 0) {
+            p.note(["Existing project detected:", ...detected.summaryLines.map((line) => `  • ${line}`)].join("\n"));
+        }
+        let result = await collectWizardAnswers(defaultName, modeTarget, dir, detected);
+        if (opts.admin === false) {
+            delete result.adminEmail;
+            delete result.adminPassword;
         }
-        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();
+        else if (opts.adminEmail && opts.adminPassword) {
+            result.adminEmail = opts.adminEmail;
+            result.adminPassword = opts.adminPassword;
         }
-        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 =
+        const doInstall = opts.install !== false && result.install;
+        const doKeys = opts.keys !== false && result.generateKeys;
+        if (name)
+            mkdirSync(dir, { recursive: true });
+        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}`);
+        }
+        const setupSpinner = p.spinner();
+        setupSpinner.start("Setting up your project...");
+        scaffold(dir, result, deps);
+        let installOk = !doInstall;
+        if (doInstall) {
+            setupSpinner.start(`Installing dependencies with ${result.packageManager}...`);
+            installOk = runInstall(dir, result.packageManager);
+            setupSpinner.stop(installOk ? "Dependencies installed." : "Dependency install failed.");
+        }
+        let keysGenerated = !doKeys;
+        if (doKeys) {
+            setupSpinner.start("Generating API keys...");
+            keysGenerated = writeKeys(dir);
+            setupSpinner.stop(keysGenerated ? "API keys generated." : "Could not generate API keys.");
+        }
+        let binariesReady = false;
+        if (doInstall && installOk) {
+            setupSpinner.start("Preparing component binaries...");
+            binariesReady = await ensureInitBinaries(dir);
+            setupSpinner.stop(binariesReady ? "Component binaries ready." : "Some binaries are missing.");
+        }
+        if (doInstall && !installOk) {
+            error(`Dependency install failed. Run "${result.packageManager} install" in the project directory, then "supatype update".`);
+            process.exit(1);
+        }
+        if (doKeys && !keysGenerated) {
+            error("Could not generate API keys. Check .env has JWT_SECRET, then run `supatype keys`.");
+            process.exit(1);
+        }
+        if (doInstall && installOk && !binariesReady) {
+            error("Component binaries could not be downloaded. Run `supatype update` in the project directory.");
+            process.exit(1);
+        }
+        warnDockerUnavailableForProvider(result.provider);
+        p.outro(`Supatype project ready${name ? ` in ${name}/` : ""}.`);
+        printNextSteps({
+            name,
+            result,
+            installed: doInstall && installOk,
+            keysGenerated,
+            binariesReady,
+        });
+    });
+    process.exit(0);
+}
+// ─── Wizard ──────────────────────────────────────────────────────────────────
+async function collectWizardAnswers(defaultName, defaultTarget, dir, detected) {
+    const projectName = ensureNotCancelled(await p.text({
+        message: "Project name",
+        defaultValue: defaultName,
+        placeholder: defaultName,
+    })).trim() || defaultName;
+    const admin = await promptAdminUser();
+    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: "Admin email",
+                    message: "Email for Let's Encrypt (HTTPS) certificates",
                     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 } : {}),
-            schemaPath,
-            app,
-            email,
-            storageLocal,
-            storageProduction,
-            helloFunction,
-            packageManager,
-            install,
-            generateKeys,
-            ...(adminEmail && adminPassword ? { adminEmail, adminPassword } : {}),
-        };
-    });
+    }
+    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 defaultSchemaPath = existsSync(join(dir, "schema/index.ts"))
+        ? "schema/index.ts"
+        : "schema/index.ts";
+    const schemaPath = ensureNotCancelled(await p.text({
+        message: "Where should your schema live?",
+        defaultValue: defaultSchemaPath,
+        placeholder: "schema/index.ts",
+    })).trim() || defaultSchemaPath;
+    const app = await promptApp(detected, productionTarget);
+    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,
+    }));
+    return {
+        projectName,
+        provider,
+        ...(kongPort !== undefined ? { kongPort } : {}),
+        productionTarget,
+        ...(domain !== undefined ? { domain } : {}),
+        ...(tlsEmail !== undefined ? { tlsEmail } : {}),
+        schemaPath,
+        app,
+        email,
+        storageLocal,
+        storageProduction,
+        helloFunction,
+        packageManager,
+        install: true,
+        generateKeys: true,
+        ...admin,
+    };
+}
+async function promptAdminUser() {
+    const createAdmin = ensureNotCancelled(await p.confirm({
+        message: "Create an admin user for /admin?",
+        initialValue: true,
+    }));
+    if (!createAdmin)
+        return {};
+    p.note("First sign-in at /admin — created automatically on supatype dev or push.");
+    const adminEmail = ensureNotCancelled(await p.text({
+        message: "Admin email",
+        placeholder: "you@example.com",
+        validate: (value) => (value.trim() ? undefined : "Email is required"),
+    })).trim();
+    let adminPassword = "";
+    while (true) {
+        adminPassword = ensureNotCancelled(await p.password({ message: "Admin password (min 8 characters)" })).trim();
+        if (adminPassword.length >= 8)
+            break;
+        p.log.warn("Password must be at least 8 characters.");
+    }
+    return { adminEmail, adminPassword };
 }
-async function promptApp() {
+async function promptApp(detected, productionTarget) {
+    const initialMode = detected.hasVite && productionTarget !== "later"
+        ? "static"
+        : detected.hasVite
+            ? "proxy"
+            : "none";
     const mode = ensureNotCancelled(await p.select({
         message: "Host a frontend app at /?",
-        initialValue: "none",
+        initialValue: initialMode,
         options: [
             { value: "none", label: "No app", hint: "API only" },
             { value: "static", label: "Static site", hint: "serve a built directory" },
@@ -276,40 +359,44 @@ async function promptApp() {
     if (mode === "static") {
         const staticDir = ensureNotCancelled(await p.text({
             message: "Directory to serve",
-            defaultValue: "./public",
-            placeholder: "./public",
-        })).trim() || "./public";
-        const viteDevUrl = await promptViteDevUrl();
+            defaultValue: detected.staticDir,
+            placeholder: detected.staticDir,
+        })).trim() || detected.staticDir;
+        const viteDevUrl = await promptViteDevUrl(detected, productionTarget);
         return { mode, staticDir, ...(viteDevUrl ? { viteDevUrl } : {}) };
     }
     if (mode === "proxy") {
         const upstream = ensureNotCancelled(await p.text({
             message: "URL of your running dev server",
-            defaultValue: "http://localhost:3000",
-            placeholder: "http://localhost:3000",
-        })).trim() || "http://localhost:3000";
+            defaultValue: detected.hasVite ? detected.viteDevUrl : "http://localhost:3000",
+            placeholder: detected.hasVite ? detected.viteDevUrl : "http://localhost:3000",
+        })).trim() || (detected.hasVite ? detected.viteDevUrl : "http://localhost:3000");
         const start = ensureNotCancelled(await p.text({
             message: "package.json script that starts your dev server",
-            defaultValue: "dev",
-            placeholder: "dev",
-        })).trim() || "dev";
-        const viteDevUrl = await promptViteDevUrl();
+            defaultValue: detected.hasVite ? "vite" : "dev",
+            placeholder: detected.hasVite ? "vite" : "dev",
+        })).trim() || (detected.hasVite ? "vite" : "dev");
+        const viteDevUrl = await promptViteDevUrl(detected, productionTarget);
         return { mode, upstream, start, ...(viteDevUrl ? { viteDevUrl } : {}) };
     }
     return { mode: "none" };
 }
-async function promptViteDevUrl() {
+async function promptViteDevUrl(detected, productionTarget) {
+    const defaultYes = detected.hasVite || productionTarget !== "later";
     const useVite = ensureNotCancelled(await p.confirm({
-        message: "Enable live reload from a separate Vite dev server?",
-        initialValue: false,
+        message: detected.hasVite
+            ? "Use Vite for local development?"
+            : "Develop locally with Vite (live reload)?",
+        initialValue: defaultYes,
     }));
     if (!useVite)
         return undefined;
+    p.note(`Press Enter for ${detected.viteDevUrl}, or type a custom URL.`);
     return (ensureNotCancelled(await p.text({
         message: "Vite dev server URL",
-        defaultValue: "http://127.0.0.1:5173",
-        placeholder: "http://127.0.0.1:5173",
-    })).trim() || "http://127.0.0.1:5173");
+        defaultValue: detected.viteDevUrl,
+        placeholder: detected.viteDevUrl,
+    })).trim() || detected.viteDevUrl);
 }
 // ─── Package manager ───────────────────────────────────────────────────────--
 function detectInvokingPackageManager() {
@@ -323,14 +410,12 @@ function detectInvokingPackageManager() {
     return "npm";
 }
 function runInstall(dir, pm) {
-    info(`Installing dependencies with ${pm}...`);
     const res = spawnSync(pm, ["install"], {
         cwd: dir,
         stdio: "inherit",
         shell: process.platform === "win32",
     });
     if (res.status !== 0 || res.error) {
-        warn(`Dependency install did not complete (run "${pm} install" manually).`);
         return false;
     }
     return true;
@@ -398,7 +483,7 @@ export function scaffold(dir, optsOrName, deps = initDependencyVersionsFallback(
     write(".env", envTemplate(opts));
     write("seed.ts", seedTemplate(opts.projectName));
     write("seeds/.gitkeep", "");
-    scaffoldAppAssets(opts, write);
+    scaffoldAppAssets(dir, opts, write);
     if (opts.helloFunction)
         scaffoldHelloFunction(dir, write);
     const gitignorePath = join(dir, ".gitignore");
@@ -420,37 +505,50 @@ function staticDirRelative(staticDir) {
     const raw = (staticDir ?? "./public").trim();
     return raw.replace(/^\.\//, "").replace(/\/+$/, "") || "public";
 }
-function scaffoldAppAssets(opts, write) {
+function scaffoldAppAssets(dir, opts, write) {
+    const writeUnlessExists = (rel, content) => {
+        const full = join(dir, rel);
+        if (existsSync(full)) {
+            file("skipped", `${rel} (already exists)`);
+            return;
+        }
+        write(rel, content);
+    };
     const holding = holdingPageTemplate(opts.projectName);
     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);
+            writeUnlessExists("dist/index.html", holding);
+            scaffoldVite(dir, opts, writeUnlessExists, holding);
             return;
         }
-        write(`${staticRel}/index.html`, holding);
+        writeUnlessExists(`${staticRel}/index.html`, holding);
         if (opts.app.viteDevUrl)
-            scaffoldVite(opts, write, holding);
+            scaffoldVite(dir, opts, writeUnlessExists, holding);
         return;
     }
     if (opts.app.mode === "proxy" && opts.productionTarget !== "later") {
-        write("dist/index.html", holding);
+        writeUnlessExists("dist/index.html", holding);
         if (hasVite)
-            scaffoldVite(opts, write, holding);
+            scaffoldVite(dir, opts, writeUnlessExists, holding);
         return;
     }
     if (opts.app.mode === "proxy" && hasVite) {
-        scaffoldVite(opts, write, holding);
+        scaffoldVite(dir, opts, writeUnlessExists, holding);
         return;
     }
-    write("public/.gitkeep", "");
+    writeUnlessExists("public/.gitkeep", "");
 }
-function scaffoldVite(opts, write, holding) {
+function scaffoldVite(dir, opts, write, holding) {
     if (!opts.app.viteDevUrl)
         return;
     write("index.html", holding);
+    const viteConfigRel = ["vite.config.ts", "vite.config.js", "vite.config.mjs", "vite.config.cjs"].find((name) => existsSync(join(dir, name)));
+    if (viteConfigRel) {
+        file("skipped", `${viteConfigRel} (already exists)`);
+        return;
+    }
     write("vite.config.ts", viteConfigTemplate(opts.app.viteDevUrl));
 }
 function scaffoldHelloFunction(dir, write) {
@@ -1025,28 +1123,35 @@ function warnDockerUnavailableForProvider(provider) {
 }
 function printNextSteps(args) {
     const { name, result, installed, keysGenerated, binariesReady } = args;
+    const setupComplete = installed && keysGenerated && binariesReady;
     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");
     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 (setupComplete) {
+        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");
+        }
+    }
+    else {
+        if (!installed)
+            steps.push(`${result.packageManager} install`);
+        if (!binariesReady)
+            steps.push("supatype update        # download component binaries");
+        if (!keysGenerated)
+            steps.push("supatype keys");
+        steps.push(kongHint);
+        steps.push("supatype push         # apply schema + generate types");
     }
     if (result.helloFunction) {
         steps.push("supatype functions serve   # run edge functions locally");
     }
     info(`Supatype project ready${name ? ` in ${name}/` : ""}.`);
-    nextSteps("Next steps:", steps);
+    nextSteps(setupComplete ? "Next steps:" : "Finish setup:", steps);
     if (result.app.mode === "none") {
         nextSteps("Static frontend (self-host):", [
             "supatype app add --static ./public",