create-macostack 0.3.0 → 0.5.0

package/bin/create-macostack.ts

@@ -45,6 +45,24 @@ type Part = {
     hint: string;
 };
 
+// The module question a template exposes via `setup --questions`. The CLI stays
+// dumb: it renders whatever the template declares (options + optional one-line
+// descriptions), never hardcoding which modules exist.
+type ModuleSpec = {
+    options: string[];
+    initial: string[];
+    descriptions?: Record<string, string>;
+    exclusive?: string[][];
+};
+
+// Optional deploy-target question a template may expose (e.g. vps vs cloudflare
+// workers). Same dumb-CLI contract as modules: rendered from what setup declares.
+type RuntimeSpec = {
+    options: string[];
+    initial: string;
+    descriptions?: Record<string, string>;
+};
+
 const PARTS: Part[] = [
     {
         id: "server",
@@ -204,7 +222,7 @@ const adjustModules = async (part: Part) => {
         stdout: "pipe",
         stderr: "pipe",
     });
-    let spec: { modules?: { options: string[]; initial: string[]; exclusive?: string[][] } } | null = null;
+    let spec: { modules?: ModuleSpec } | null = null;
     if (q.exitCode === 0) {
         try {
             spec = JSON.parse(q.stdout.toString().trim().split("\n").at(-1) ?? "");
@@ -221,7 +239,7 @@ const adjustModules = async (part: Part) => {
         chosen = answered(
             await multiselect({
                 message: `${part.label} — which modules should be ON? (your current setup is preselected)`,
-                options: mods.options.map((m) => ({ value: m, label: m })),
+                options: mods.options.map((m) => ({ value: m, label: m, hint: mods.descriptions?.[m] })),
                 initialValues: mods.initial,
                 required: false,
             }),
@@ -346,14 +364,12 @@ for (const p of selected) {
 //////////////////////////////////////////////////////////////////
 
 mkdirSync(targetRoot, { recursive: true });
-const ready: Part[] = [];
 
+// Phase 1 — download every selected template (no git history) and install.
+// Nothing is asked yet: the questions come ONCE, after everything is on disk.
 for (const p of selected) {
     const dest = resolve(targetRoot, p.folder);
     const s = spinner();
-
-    // Download the tarball — no git history comes with it, so each part starts
-    // life fully detached from the template.
     s.start(`${p.label} — downloading ${owner}/${p.repo}@${ref}`);
     const tmp = mkdtempSync(join(tmpdir(), "create-macostack-"));
     try {
@@ -388,53 +404,147 @@ for (const p of selected) {
                 : `${p.label} — bun install had issues (run it again inside ${displayRoot}/${p.folder})`,
         );
     }
+}
+
+// Phase 2 — ONE round of questions for the whole app. Each template still owns
+// what it can be asked (`setup --questions`); we MERGE those declarations so the
+// same feature is asked once and dispatched to every part that supports it. The
+// meaning of a pick differs by design and lives in the templates, not here: the
+// backend toggles it (code stays, dormant), the web app strips what you omit.
+type PartSetup = {
+    part: Part;
+    dest: string;
+    hasSetup: boolean;
+    modules?: ModuleSpec;
+    runtime?: RuntimeSpec;
+};
 
-    // Configure the template. It OWNS its questions — we fetch them as data
-    // (`setup --questions`), ask them in THIS wizard (nested interactive
-    // prompts don't get keyboard control under `bun create`), and apply the
-    // answers non-interactively (`setup --yes`).
+const setups: PartSetup[] = [];
+for (const p of selected) {
+    const dest = resolve(targetRoot, p.folder);
     const pkg = existsSync(resolve(dest, "package.json"))
         ? await Bun.file(resolve(dest, "package.json")).json()
         : null;
-    if (!flags["skip-setup"] && pkg?.scripts?.setup) {
-        let questions: { modules?: { options: string[]; initial: string[]; exclusive?: string[][] } } | null = null;
-        if (!flags.yes) {
-            const q = Bun.spawnSync(["bun", "run", "setup", "--questions"], {
-                cwd: dest,
-                stdout: "pipe",
-                stderr: "pipe",
-            });
-            if (q.exitCode === 0) {
-                try {
-                    questions = JSON.parse(q.stdout.toString().trim().split("\n").at(-1) ?? "");
-                } catch {}
-            }
+    const hasSetup = Boolean(pkg?.scripts?.setup);
+    let modules: ModuleSpec | undefined;
+    let runtime: RuntimeSpec | undefined;
+    if (hasSetup && !flags.yes && !flags["skip-setup"]) {
+        const q = Bun.spawnSync(["bun", "run", "setup", "--questions"], {
+            cwd: dest,
+            stdout: "pipe",
+            stderr: "pipe",
+        });
+        if (q.exitCode === 0) {
+            try {
+                const spec = JSON.parse(q.stdout.toString().trim().split("\n").at(-1) ?? "");
+                modules = spec.modules;
+                runtime = spec.runtime;
+            } catch {}
         }
+    }
+    setups.push({ part: p, dest, hasSetup, modules, runtime });
+}
 
-        const setupArgs = ["run", "setup", "--yes", "--name", appName];
+// Deploy target — only the backend declares one; asked once, before features
+// (the stack is a bigger commitment than which features ship).
+let runtimeChoice: string | null = null;
+const runtimeSpec = setups.find((s) => s.runtime && s.runtime.options.length > 1)?.runtime;
+if (runtimeSpec) {
+    runtimeChoice = answered(
+        await select({
+            message: "Backend — where will you deploy?",
+            options: runtimeSpec.options.map((o) => ({
+                value: o,
+                label: o,
+                hint: runtimeSpec.descriptions?.[o],
+            })),
+            initialValue: runtimeSpec.initial,
+        }),
+    ) as string;
+}
+
+// Features — the single, merged question (union of what each part declares).
+let chosenModules: string[] | null = null;
+const moduleOptions: string[] = [];
+const moduleDescriptions: Record<string, string> = {};
+const exclusivePairs: string[][] = [];
+const moduleInitial = new Set<string>();
+for (const s of setups) {
+    if (!s.modules) continue;
+    for (const o of s.modules.options) if (!moduleOptions.includes(o)) moduleOptions.push(o);
+    for (const [k, v] of Object.entries(s.modules.descriptions ?? {}))
+        if (!(k in moduleDescriptions)) moduleDescriptions[k] = v;
+    for (const pair of s.modules.exclusive ?? []) exclusivePairs.push(pair);
+    for (const m of s.modules.initial) moduleInitial.add(m);
+}
+if (moduleOptions.length > 0) {
+    for (;;) {
+        chosenModules = answered(
+            await multiselect({
+                message:
+                    "Features (one pick for the whole app — the backend keeps them as dormant code you can flip on; the web app drops the ones you leave out)",
+                options: moduleOptions.map((m) => ({ value: m, label: m, hint: moduleDescriptions[m] })),
+                initialValues: [...moduleInitial],
+                required: false,
+            }),
+        );
+        const clash = exclusivePairs.find((pair) => pair.every((m) => chosenModules!.includes(m)));
+        if (!clash) break;
+        note(`${clash.join(" and ")} can't both be on — keep one of the two.`, "One thing");
+    }
+}
 
-        if (questions?.modules) {
-            let chosen: string[];
-            for (;;) {
-                chosen = answered(
-                    await multiselect({
-                        message: `${p.label} — which modules should start ON? (everything stays in the code; off = dormant, ready when you need it)`,
-                        options: questions.modules.options.map((m) => ({ value: m, label: m })),
-                        initialValues: questions.modules.initial,
-                        required: false,
+// Optional .env prefill — asked once, injected into whichever part uses it.
+let domain: string | null = null;
+let resendKey: string | null = null;
+if (!flags.yes && !flags["skip-setup"]) {
+    const wantsServer = setups.some((s) => s.part.id === "server" && s.hasSetup);
+    domain =
+        (
+            answered(
+                await text({
+                    message: "Primary domain? (optional — sets CORS + cookie scope and the web app's API URL; blank to skip)",
+                    placeholder: "midominio.com",
+                    validate: (v) =>
+                        !v || /^([a-z0-9-]+\.)+[a-z]{2,}$/i.test(v)
+                            ? undefined
+                            : "a bare domain like midominio.com (no https://)",
+                }),
+            ) as string
+        ).trim() || null;
+    if (wantsServer) {
+        resendKey =
+            (
+                answered(
+                    await text({
+                        message: "Resend API key? (optional — backend transactional email; blank to fill in .env later)",
+                        placeholder: "re_…",
                     }),
-                );
-                const clash = (questions.modules.exclusive ?? []).find((pair) =>
-                    pair.every((m) => chosen.includes(m)),
-                );
-                if (!clash) break;
-                note(`${clash.join(" and ")} can't both be on — keep one of the two.`, "One thing");
-            }
-            setupArgs.push("--modules", chosen.join(","));
+                ) as string
+            ).trim() || null;
+    }
+}
+
+// Phase 3 — apply. Each part gets ONLY the features it declared; the same click
+// means "toggle" on the backend and "keep vs strip" on the web app.
+const ready: Part[] = [];
+for (const s of setups) {
+    const { part: p, dest, hasSetup } = s;
+
+    if (hasSetup && !flags["skip-setup"]) {
+        const setupArgs = ["run", "setup", "--yes", "--name", appName];
+        if (s.modules && chosenModules) {
+            const forPart = chosenModules.filter((m) => s.modules!.options.includes(m));
+            setupArgs.push("--modules", forPart.join(","));
+        }
+        if (s.runtime && s.runtime.options.length > 1 && runtimeChoice) {
+            setupArgs.push("--runtime", runtimeChoice);
         }
+        if (domain) setupArgs.push("--domain", domain);
+        if (resendKey && p.id === "server") setupArgs.push("--resend", resendKey);
 
         const s3 = spinner();
-        s3.start(`${p.label} — applying your setup (modules, fresh secrets, git)`);
+        s3.start(`${p.label} — applying your setup (features, fresh secrets, git)`);
         const setup = Bun.spawnSync(["bun", ...setupArgs], { cwd: dest, stdout: "pipe", stderr: "pipe" });
         if (setup.exitCode === 0) {
             s3.stop(`${p.label} — configured`);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "create-macostack",
-    "version": "0.3.0",
+    "version": "0.5.0",
     "description": "Private macostack scaffold orchestrator for detached server/client repos.",
     "type": "module",
     "bin": {