create-macostack 0.1.1 → 0.2.1

package/bin/create-macostack.ts

@@ -20,52 +20,52 @@ import { tmpdir } from "node:os";
 import { join, resolve } from "node:path";
 import { parseArgs } from "node:util";
 
-const STACK_PART = {
-    SERVER: "server",
-    CLIENT: "client",
-} as const;
-
-type StackPart = (typeof STACK_PART)[keyof typeof STACK_PART];
-
-type TemplateConfig = {
-    part: StackPart;
-    directory: string;
+// create-macostack — start a new app from the macostack templates.
+//
+//   bun create macostack my-app
+//
+// It asks what your app needs (backend API, web app, or both), downloads each
+// template WITHOUT its git history, installs dependencies, and hands you over
+// to each template's own setup wizard. The orchestrator stays deliberately
+// dumb: it never knows what modules exist — each template owns its questions.
+
+//////////////////////////////////////////////////////////////////
+// CONFIG
+//////////////////////////////////////////////////////////////////
+
+const DEFAULT_OWNER = Bun.env.MACOSTACK_GITHUB_OWNER ?? "macobits";
+const DEFAULT_REF = Bun.env.MACOSTACK_REF ?? "main";
+
+type Part = {
+    id: "server" | "client";
+    folder: string;
     repo: string;
-};
-
-type ScaffoldConfig = {
-    owner: string;
-    ref: string;
-    token: string;
-    targetRoot: string;
-    targetName: string;
-    skipInstall: boolean;
-    skipSetup: boolean;
-};
-
-type DownloadTemplateProps = {
-    config: ScaffoldConfig;
-    template: TemplateConfig;
-    destination: string;
-};
-
-type RunCommandProps = {
-    command: string[];
-    cwd: string;
     label: string;
-    allowFailure?: boolean;
+    hint: string;
 };
 
-type PackageJson = {
-    scripts?: Record<string, string>;
-};
+const PARTS: Part[] = [
+    {
+        id: "server",
+        folder: "server",
+        repo: Bun.env.MACOSTACK_SERVER_REPO ?? "macostack-server",
+        label: "Backend API",
+        hint: "Bun + Hono + Postgres — auth included",
+    },
+    {
+        id: "client",
+        folder: "client",
+        repo: Bun.env.MACOSTACK_CLIENT_REPO ?? "macostack-client",
+        label: "Web app",
+        hint: "the frontend",
+    },
+];
 
-const DEFAULT_OWNER = "macobits";
-const DEFAULT_REF = "main";
-const DEFAULT_SERVER_REPO = "macostack-server";
-const DEFAULT_CLIENT_REPO = "macostack-client";
+//////////////////////////////////////////////////////////////////
+// FLAGS
+//////////////////////////////////////////////////////////////////
 
-const parsedArgs = parseArgs({
+const parsed = parseArgs({
     args: Bun.argv.slice(2),
     allowPositionals: true,
     options: {
@@ -81,36 +81,35 @@ const parsedArgs = parseArgs({
         "skip-setup": { type: "boolean", default: false },
     },
 });
+const flags = parsed.values;
 
-const flags = parsedArgs.values;
-
-const HELP_TEXT = `create-macostack
+if (flags.help) {
+    console.log(`create-macostack — start a new app from the macostack templates
 
 Usage:
-  bun create macostack <venture-folder>
-  bun run dev <venture-folder> [flags]
+  bun create macostack <app-name>
 
 Flags:
-  --server              scaffold only server
-  --client              scaffold only client
-  --owner <owner>       GitHub owner/org (default: macobits)
-  --ref <ref>           Git ref/tag/branch (default: main)
-  --server-repo <repo>  server template repo (default: macostack-server)
-  --client-repo <repo>  client template repo (default: macostack-client)
-  --skip-install        do not run bun install in generated halves
-  --skip-setup          do not run bun run setup in generated halves
-  --yes                 skip create-macostack prompts; selects server + client
-  --help                show this help
-
-Auth:
-  Set GITHUB_TOKEN or run gh auth login for private template tarballs.
-`;
-
-if (flags.help === true) {
-    console.log(HELP_TEXT);
+  --server / --client   scaffold only that part (default: it asks)
+  --yes                 no questions: both parts, template defaults
+  --owner <org>         GitHub owner (default: ${DEFAULT_OWNER})
+  --ref <ref>           branch or tag to pull (default: ${DEFAULT_REF})
+  --server-repo <name>  server template repo
+  --client-repo <name>  client template repo
+  --skip-install        don't run bun install
+  --skip-setup          don't run each template's setup wizard
+
+Auth (templates are private):
+  export GITHUB_TOKEN=github_pat_…   or   gh auth login
+  (fine-grained token, Contents: Read-only is enough)
+`);
     process.exit(0);
 }
 
+//////////////////////////////////////////////////////////////////
+// HELPERS
+//////////////////////////////////////////////////////////////////
+
 const bail = (message: string): never => {
     cancel(message);
     process.exit(1);
@@ -118,393 +117,250 @@ const bail = (message: string): never => {
 
 const answered = <T>(value: T | symbol): T => {
     if (isCancel(value)) {
-        cancel("Scaffold aborted — nothing else will be touched.");
+        cancel("No problem — nothing was created.");
         process.exit(0);
     }
-
     return value as T;
 };
 
-const getStringFlag = (
-    value: string | boolean | undefined,
-    fallback: string,
-) => {
-    if (typeof value === "string" && value.length > 0) {
-        return value;
-    }
-
-    return fallback;
+const githubToken = (): string | null => {
+    const fromEnv = Bun.env.GITHUB_TOKEN ?? Bun.env.GH_TOKEN;
+    if (fromEnv) return fromEnv;
+    const gh = Bun.spawnSync(["gh", "auth", "token"], { stdout: "pipe", stderr: "pipe" });
+    const token = gh.exitCode === 0 ? gh.stdout.toString().trim() : "";
+    return token || null;
 };
 
-const getBooleanFlag = (value: string | boolean | undefined) => value === true;
-
-const isRecord = (value: unknown): value is Record<string, unknown> =>
-    typeof value === "object" && value !== null;
+const isEmptyDir = (dir: string) =>
+    !existsSync(dir) ||
+    readdirSync(dir).filter((e) => e !== ".DS_Store").length === 0;
 
-const isValidDirectoryName = (value: string) =>
-    /^[a-z0-9][a-z0-9-]*$/.test(value);
+//////////////////////////////////////////////////////////////////
+// WIZARD
+//////////////////////////////////////////////////////////////////
 
-const isStackPart = (value: string): value is StackPart =>
-    value === STACK_PART.SERVER || value === STACK_PART.CLIENT;
+intro("create-macostack");
 
-const readPackageJson = async (directory: string): Promise<PackageJson | null> => {
-    const packagePath = resolve(directory, "package.json");
-    if (!existsSync(packagePath)) {
-        return null;
+// 1. App name (positional arg or prompt).
+const positional = parsed.positionals[0];
+const validName = (v: string) => /^[a-z0-9][a-z0-9-]*$/.test(v);
+let appName: string;
+if (positional) {
+    if (!validName(positional)) {
+        bail("App names use lowercase letters, digits and dashes — e.g. soccer-app");
     }
-
-    const value: unknown = await Bun.file(packagePath).json();
-    if (!isRecord(value)) {
-        return null;
-    }
-
-    const scriptsValue = value.scripts;
-    if (!isRecord(scriptsValue)) {
-        return {};
-    }
-
-    const scripts = Object.fromEntries(
-        Object.entries(scriptsValue).filter(
-            (entry): entry is [string, string] => typeof entry[1] === "string",
-        ),
+    appName = positional;
+} else if (flags.yes) {
+    bail("Tell me the app name: bun create macostack my-app --yes");
+    throw ""; // unreachable
+} else {
+    appName = answered(
+        await text({
+            message: "What should we call your app?",
+            placeholder: "soccer-app",
+            validate: (v) =>
+                validName(v ?? "") ? undefined : "lowercase letters, digits and dashes — e.g. soccer-app",
+        }),
     );
+}
 
-    return { scripts };
-};
-
-const getGhToken = (): string | null => {
-    const result = Bun.spawnSync(["gh", "auth", "token"], {
-        stdout: "pipe",
-        stderr: "pipe",
-    });
-
-    if (result.exitCode !== 0) {
-        return null;
-    }
-
-    const token = result.stdout.toString().trim();
-    return token.length > 0 ? token : null;
-};
-
-const getGithubToken = (): string | null => {
-    const envToken = Bun.env.GITHUB_TOKEN ?? Bun.env.GH_TOKEN;
-    if (envToken && envToken.length > 0) {
-        return envToken;
-    }
-
-    return getGhToken();
-};
-
-const requireGithubToken = (): string => {
-    const token = getGithubToken();
-    if (typeof token === "string" && token.length > 0) {
-        return token;
-    }
+const targetRoot = resolve(process.cwd(), appName);
+if (!isEmptyDir(targetRoot)) {
+    bail(`The folder ./${appName} already exists and isn't empty — pick another name or clear it first.`);
+}
 
-    return bail(
-        "Private templates require GitHub auth. Set GITHUB_TOKEN or run `gh auth login`. " +
-            "Use a fine-grained token with Contents: Read-only.",
+// 2. Which parts?
+let selected: Part[];
+if (flags.server || flags.client) {
+    selected = PARTS.filter((p) => flags[p.id]);
+} else if (flags.yes) {
+    selected = PARTS;
+} else {
+    const picked = answered(
+        await multiselect({
+            message: `What does ${appName} need? (space to pick, enter to continue)`,
+            options: PARTS.map((p) => ({ value: p.id, label: p.label, hint: p.hint })),
+            initialValues: PARTS.map((p) => p.id),
+            required: true,
+        }),
     );
-};
-
-const ensureEmptyDirectory = (directory: string, label: string) => {
-    if (!existsSync(directory)) {
-        mkdirSync(directory, { recursive: true });
-        return;
-    }
+    selected = PARTS.filter((p) => picked.includes(p.id));
+}
 
-    const entries = readdirSync(directory).filter((entry) => entry !== ".DS_Store");
-    if (entries.length > 0) {
-        bail(`${label} already exists and is not empty: ${directory}`);
-    }
-};
+// 3. GitHub access — checked before anything is created.
+const owner = flags.owner ?? DEFAULT_OWNER;
+const ref = flags.ref ?? DEFAULT_REF;
+const token = githubToken();
+if (!token) {
+    bail(
+        "I need GitHub access to download the templates (they're private).\n" +
+            "   Easiest: gh auth login\n" +
+            "   Or:      export GITHUB_TOKEN=github_pat_…  (Contents: Read-only)",
+    );
+    throw ""; // unreachable
+}
+for (const p of selected) {
+    p.repo = (p.id === "server" ? flags["server-repo"] : flags["client-repo"]) ?? p.repo;
+}
 
-const runCommand = ({
-    command,
-    cwd,
-    label,
-    allowFailure = false,
-}: RunCommandProps) => {
-    const result = Bun.spawnSync(command, {
-        cwd,
-        stdin: "inherit",
-        stdout: "inherit",
-        stderr: "inherit",
+// Preflight every selected template so a typo'd repo or missing access fails
+// BEFORE any folders exist.
+const gh = (path: string) =>
+    fetch(`https://api.github.com${path}`, {
+        headers: {
+            Accept: "application/vnd.github+json",
+            Authorization: `Bearer ${token}`,
+            "User-Agent": "create-macostack",
+            "X-GitHub-Api-Version": "2022-11-28",
+        },
     });
-
-    if (result.exitCode === 0 || allowFailure) {
-        return result.exitCode;
+for (const p of selected) {
+    const res = await gh(`/repos/${owner}/${p.repo}`);
+    if (!res.ok) {
+        bail(
+            `Can't reach ${owner}/${p.repo} (HTTP ${res.status}).\n` +
+                "   Does the repo exist, and does your token have read access to it?",
+        );
     }
+}
 
-    bail(`${label} failed with exit code ${result.exitCode}.`);
-};
+//////////////////////////////////////////////////////////////////
+// SCAFFOLD
+//////////////////////////////////////////////////////////////////
 
-const downloadTemplate = async ({
-    config,
-    template,
-    destination,
-}: DownloadTemplateProps) => {
-    const temporaryDirectory = mkdtempSync(join(tmpdir(), "create-macostack-"));
-    const archivePath = join(temporaryDirectory, `${template.part}.tar.gz`);
-    const tarballUrl = `https://api.github.com/repos/${config.owner}/${template.repo}/tarball/${config.ref}`;
+mkdirSync(targetRoot, { recursive: true });
+const ready: Part[] = [];
+
+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 {
-        const response = await fetch(tarballUrl, {
-            headers: {
-                Accept: "application/vnd.github+json",
-                Authorization: `Bearer ${config.token}`,
-                "User-Agent": "create-macostack",
-                "X-GitHub-Api-Version": "2022-11-28",
-            },
-        });
-
-        if (!response.ok) {
-            const details = await response.text();
-            bail(
-                `GitHub refused ${config.owner}/${template.repo}@${config.ref} (${response.status}). ` +
-                    `Check GITHUB_TOKEN permissions. ${details.slice(0, 240)}`,
-            );
+        const res = await gh(`/repos/${owner}/${p.repo}/tarball/${ref}`);
+        if (!res.ok) {
+            s.stop(`${p.label} — download failed`);
+            bail(`GitHub refused the download (HTTP ${res.status}). Try again, or check --ref ${ref}.`);
+        }
+        const archive = join(tmp, "template.tar.gz");
+        await Bun.write(archive, await res.arrayBuffer());
+        mkdirSync(dest, { recursive: true });
+        const tar = Bun.spawnSync(
+            ["tar", "-xzf", archive, "-C", dest, "--strip-components=1"],
+            { stdout: "pipe", stderr: "pipe" },
+        );
+        if (tar.exitCode !== 0) {
+            s.stop(`${p.label} — extract failed`);
+            bail(`Couldn't unpack the template: ${tar.stderr.toString().slice(0, 200)}`);
         }
-
-        await Bun.write(archivePath, await response.arrayBuffer());
-        ensureEmptyDirectory(destination, template.directory);
-        runCommand({
-            command: [
-                "tar",
-                "-xzf",
-                archivePath,
-                "-C",
-                destination,
-                "--strip-components=1",
-            ],
-            cwd: destination,
-            label: `Extract ${template.part}`,
-        });
     } finally {
-        rmSync(temporaryDirectory, { recursive: true, force: true });
-    }
-};
-
-const runInstall = (directory: string, template: TemplateConfig) => {
-    runCommand({
-        command: ["bun", "install"],
-        cwd: directory,
-        label: `bun install in ${template.part}`,
-    });
-};
-
-const runSetup = async (directory: string, template: TemplateConfig) => {
-    const packageJson = await readPackageJson(directory);
-    if (!packageJson?.scripts?.setup) {
-        note(`No setup script found in ${template.directory}; skipping delegation.`, template.part);
-        return;
+        rmSync(tmp, { recursive: true, force: true });
     }
-
-    runCommand({
-        command: ["bun", "run", "setup"],
-        cwd: directory,
-        label: `setup in ${template.part}`,
-    });
-};
-
-const ensureGitRepository = (directory: string, template: TemplateConfig) => {
-    if (existsSync(resolve(directory, ".git"))) {
-        return;
-    }
-
-    runCommand({
-        command: ["git", "init", "-b", "main"],
-        cwd: directory,
-        label: `git init in ${template.part}`,
-    });
-    runCommand({
-        command: ["git", "add", "-A"],
-        cwd: directory,
-        label: `git add in ${template.part}`,
-    });
-
-    const commitExitCode = runCommand({
-        command: ["git", "commit", "-m", "init from template"],
-        cwd: directory,
-        label: `git commit in ${template.part}`,
-        allowFailure: true,
-    });
-
-    if (commitExitCode !== 0) {
-        note(
-            `Fresh ${template.part} repo created, but initial commit failed. ` +
-                `Run: cd ${template.directory} && git add -A && git commit -m "init"`,
-            "Git",
+    s.stop(`${p.label} — downloaded into ${appName}/${p.folder}`);
+
+    if (!flags["skip-install"]) {
+        const s2 = spinner();
+        s2.start(`${p.label} — installing dependencies`);
+        const code = Bun.spawnSync(["bun", "install"], { cwd: dest, stdout: "pipe", stderr: "pipe" }).exitCode;
+        s2.stop(
+            code === 0
+                ? `${p.label} — dependencies installed`
+                : `${p.label} — bun install had issues (run it again inside ${appName}/${p.folder})`,
         );
     }
-};
-
-const getSelectedPartsFromFlags = () => {
-    const selected: StackPart[] = [];
-
-    if (getBooleanFlag(flags.server)) {
-        selected.push(STACK_PART.SERVER);
-    }
 
-    if (getBooleanFlag(flags.client)) {
-        selected.push(STACK_PART.CLIENT);
-    }
-
-    return selected;
-};
-
-const resolveTargetName = async () => {
-    const positionalTarget = parsedArgs.positionals[0];
-    if (positionalTarget) {
-        if (!isValidDirectoryName(positionalTarget)) {
-            bail("Project folder must use lowercase letters, digits and dashes only.");
+    // 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 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 {}
+            }
         }
 
-        return positionalTarget;
-    }
-
-    if (getBooleanFlag(flags.yes)) {
-        bail("Missing project folder. Usage: bun create macostack my-venture");
-    }
-
-    const value = answered(
-        await text({
-            message: "Venture folder",
-            placeholder: "mi-tienda",
-            validate: (input) =>
-                isValidDirectoryName(input ?? "")
-                    ? undefined
-                    : "lowercase letters, digits and dashes only",
-        }),
-    );
-
-    return value;
-};
-
-const resolveSelectedParts = async () => {
-    const selectedFromFlags = getSelectedPartsFromFlags();
-    if (selectedFromFlags.length > 0) {
-        return selectedFromFlags;
-    }
-
-    if (getBooleanFlag(flags.yes)) {
-        return [STACK_PART.SERVER, STACK_PART.CLIENT];
-    }
-
-    const selected = answered(
-        await multiselect({
-            message: "¿Qué incluye este venture?",
-            options: [
-                { value: STACK_PART.SERVER, label: "server" },
-                { value: STACK_PART.CLIENT, label: "client" },
-            ],
-            initialValues: [STACK_PART.SERVER, STACK_PART.CLIENT],
-            required: true,
-        }),
-    );
-
-    const validSelected = selected.filter(isStackPart);
-    if (validSelected.length === 0) {
-        bail("Select at least one half.");
-    }
-
-    return validSelected;
-};
-
-const buildTemplates = (selectedParts: StackPart[]) => {
-    const serverRepo = getStringFlag(
-        flags["server-repo"],
-        Bun.env.MACOSTACK_SERVER_REPO ?? DEFAULT_SERVER_REPO,
-    );
-    const clientRepo = getStringFlag(
-        flags["client-repo"],
-        Bun.env.MACOSTACK_CLIENT_REPO ?? DEFAULT_CLIENT_REPO,
-    );
-
-    const templates = {
-        [STACK_PART.SERVER]: {
-            part: STACK_PART.SERVER,
-            directory: "server",
-            repo: serverRepo,
-        },
-        [STACK_PART.CLIENT]: {
-            part: STACK_PART.CLIENT,
-            directory: "client",
-            repo: clientRepo,
-        },
-    } satisfies Record<StackPart, TemplateConfig>;
-
-    return [STACK_PART.SERVER, STACK_PART.CLIENT]
-        .filter((part) => selectedParts.includes(part))
-        .map((part) => templates[part]);
-};
-
-const scaffoldTemplate = async (config: ScaffoldConfig, template: TemplateConfig) => {
-    const destination = resolve(config.targetRoot, template.directory);
-    const s = spinner();
-
-    s.start(`Downloading ${config.owner}/${template.repo}@${config.ref} → ${template.directory}`);
-    await downloadTemplate({ config, template, destination });
-    s.stop(`${template.directory} downloaded`);
+        const setupArgs = ["run", "setup", "--yes", "--name", appName];
+
+        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,
+                    }),
+                );
+                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(","));
+        }
 
-    if (!config.skipInstall) {
-        runInstall(destination, template);
+        const s3 = spinner();
+        s3.start(`${p.label} — applying your setup (modules, fresh secrets, git)`);
+        const setup = Bun.spawnSync(["bun", ...setupArgs], { cwd: dest, stdout: "pipe", stderr: "pipe" });
+        if (setup.exitCode === 0) {
+            s3.stop(`${p.label} — configured`);
+        } else {
+            s3.stop(`${p.label} — setup didn't finish`);
+            note(
+                `Everything downloaded fine — just finish it yourself:\n  cd ${appName}/${p.folder} && bun run setup`,
+                "Heads up",
+            );
+        }
     }
 
-    if (!config.skipSetup) {
-        await runSetup(destination, template);
+    // Safety net: whatever happened above, each part ends up as its own fresh
+    // git repo (the wizard usually did this already).
+    if (!existsSync(resolve(dest, ".git"))) {
+        Bun.spawnSync(["git", "init", "-b", "main"], { cwd: dest, stdout: "pipe", stderr: "pipe" });
+        Bun.spawnSync(["git", "add", "-A"], { cwd: dest, stdout: "pipe", stderr: "pipe" });
+        Bun.spawnSync(["git", "commit", "-m", "init from template"], { cwd: dest, stdout: "pipe", stderr: "pipe" });
     }
 
-    ensureGitRepository(destination, template);
-};
-
-const main = async () => {
-    intro("create-macostack");
+    ready.push(p);
+}
 
-    const targetName = await resolveTargetName();
-    const selectedParts = await resolveSelectedParts();
-    const owner = getStringFlag(
-        flags.owner,
-        Bun.env.MACOSTACK_GITHUB_OWNER ?? DEFAULT_OWNER,
-    );
-    const ref = getStringFlag(flags.ref, Bun.env.MACOSTACK_REF ?? DEFAULT_REF);
-    const githubToken = requireGithubToken();
-
-    const config: ScaffoldConfig = {
-        owner,
-        ref,
-        token: githubToken,
-        targetRoot: resolve(process.cwd(), targetName),
-        targetName,
-        skipInstall: getBooleanFlag(flags["skip-install"]),
-        skipSetup: getBooleanFlag(flags["skip-setup"]),
-    };
-    const templates = buildTemplates(selectedParts);
-
-    ensureEmptyDirectory(config.targetRoot, "Target root");
-
-    for (const template of templates) {
-        await scaffoldTemplate(config, template);
-    }
+//////////////////////////////////////////////////////////////////
+// DONE
+//////////////////////////////////////////////////////////////////
 
-    const remoteSteps = templates
-        .map(
-            (template) =>
-                `  cd ${config.targetName}/${template.directory}\n` +
-                `  git remote add origin <${template.part}-repo-url>\n` +
-                "  git push -u origin main",
-        )
-        .join("\n\n");
-
-    const devSteps = templates
-        .map((template) => `  cd ${config.targetName}/${template.directory} && bun dev`)
-        .join("\n");
-
-    outro(
-        `Done. Root folder is intentionally not a git repo.\n\n` +
-            `Next remotes:\n${remoteSteps}\n\n` +
-            `Dev:\n${devSteps}`,
+const steps: string[] = [];
+const server = ready.find((p) => p.id === "server");
+const client = ready.find((p) => p.id === "client");
+if (server) {
+    steps.push(
+        `Start the backend:\n  cd ${appName}/server\n  docker compose up -d && bun run db:migrate && bun dev`,
     );
-};
-
-await main();
+}
+if (client) {
+    steps.push(`Start the web app:\n  cd ${appName}/client\n  bun dev`);
+}
+steps.push(
+    `When you're ready to publish (each part is its own repo):\n` +
+        ready
+            .map((p) => `  cd ${appName}/${p.folder} && git remote add origin <your-repo> && git push -u origin main`)
+            .join("\n"),
+);
+
+outro(`${appName} is ready 🎉\n\n${steps.join("\n\n")}`);

package/package.json

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