create-payload-stack 0.1.0

package/README.md

@@ -0,0 +1,26 @@
+# create-payload-stack
+
+Scaffold a SaaS on Payload CMS in one command.
+
+```bash
+npx create-payload-stack@latest
+```
+
+Six prompts: project name, database (PostgreSQL, MongoDB, SQLite, Vercel Postgres), connection string, sign-in methods, organizations, billing. The CLI downloads [Payload Stack](https://www.payloadstack.com), writes your answers into `src/stack.config.ts`, swaps the Payload database adapter, generates `.env` with fresh secrets, installs dependencies and initializes git.
+
+```bash
+# non-interactive
+npx create-payload-stack@latest ridgeline -d postgres --auth email-password,magic-link,passkey --social github --billing organization -y
+```
+
+Run `npx create-payload-stack@latest --help` for every flag. Documentation: https://payload.solutions/docs/payload-stack
+
+## Development
+
+```bash
+pnpm --filter create-payload-stack build
+node packages/create-payload-stack/dist/index.js my-app --local-template templates/payload-stack --no-install
+pnpm --filter create-payload-stack test
+```
+
+MIT. A [payload.solutions](https://payload.solutions) project.

package/dist/index.js

@@ -0,0 +1,608 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { parseArgs } from "util";
+import { createRequire } from "module";
+import pc2 from "picocolors";
+
+// src/cli.ts
+import * as p from "@clack/prompts";
+import { execa as execa2 } from "execa";
+import { existsSync as existsSync3 } from "fs";
+import path3 from "path";
+import pc from "picocolors";
+
+// src/configure.ts
+import { readFile, writeFile } from "fs/promises";
+import path from "path";
+
+// src/databases.ts
+var DB_CHOICES = {
+  postgres: {
+    key: "postgres",
+    label: "PostgreSQL",
+    hint: "recommended",
+    packageName: "@payloadcms/db-postgres",
+    importName: "postgresAdapter",
+    connectionPrefix: "postgres://postgres:<password>@127.0.0.1:5432/",
+    connectionSuffix: "",
+    config: `db: postgresAdapter({
+    pool: {
+      connectionString: env.DATABASE_URL,
+    },
+  }),`
+  },
+  mongodb: {
+    key: "mongodb",
+    label: "MongoDB",
+    packageName: "@payloadcms/db-mongodb",
+    importName: "mongooseAdapter",
+    connectionPrefix: "mongodb://127.0.0.1/",
+    connectionSuffix: "",
+    config: `db: mongooseAdapter({
+    url: env.DATABASE_URL,
+  }),`
+  },
+  sqlite: {
+    key: "sqlite",
+    label: "SQLite",
+    hint: "zero setup, single file",
+    packageName: "@payloadcms/db-sqlite",
+    importName: "sqliteAdapter",
+    connectionPrefix: "file:./",
+    connectionSuffix: ".db",
+    config: `db: sqliteAdapter({
+    client: {
+      url: env.DATABASE_URL,
+    },
+  }),`
+  },
+  "vercel-postgres": {
+    key: "vercel-postgres",
+    label: "Vercel Postgres",
+    packageName: "@payloadcms/db-vercel-postgres",
+    importName: "vercelPostgresAdapter",
+    connectionPrefix: "postgres://postgres:<password>@127.0.0.1:5432/",
+    connectionSuffix: "",
+    config: `db: vercelPostgresAdapter({
+    pool: {
+      connectionString: env.DATABASE_URL,
+    },
+  }),`
+  }
+};
+var DB_KEYS = Object.keys(DB_CHOICES);
+function defaultConnectionString(db, projectSlug) {
+  return `${db.connectionPrefix}${projectSlug}${db.connectionSuffix}`;
+}
+
+// src/utils.ts
+import slugifyBase from "@sindresorhus/slugify";
+import { randomBytes } from "crypto";
+import { existsSync, readdirSync } from "fs";
+import { execa } from "execa";
+function slugify(input) {
+  return slugifyBase(input.trim()).replace(/^-+|-+$/g, "") || "my-saas";
+}
+function generateSecret(bytes = 32) {
+  return randomBytes(bytes).toString("base64url");
+}
+function isDirectoryEmpty(dir) {
+  if (!existsSync(dir)) return true;
+  const entries = readdirSync(dir).filter((e) => ![".git", ".DS_Store"].includes(e));
+  return entries.length === 0;
+}
+async function commandExists(cmd) {
+  try {
+    await execa(process.platform === "win32" ? "where" : "which", [cmd]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function detectPackageManager() {
+  const agent = process.env.npm_config_user_agent ?? "";
+  if (agent.startsWith("pnpm")) return "pnpm";
+  if (agent.startsWith("yarn")) return "yarn";
+  if (agent.startsWith("bun")) return "bun";
+  if (agent.startsWith("npm")) {
+    if (await commandExists("pnpm")) return "pnpm";
+    return "npm";
+  }
+  if (await commandExists("pnpm")) return "pnpm";
+  return "npm";
+}
+function installCommand(pm) {
+  return pm === "yarn" ? "yarn" : `${pm} install`;
+}
+function runCommand(pm, script) {
+  if (pm === "npm") return `npm run ${script}`;
+  return `${pm} ${script}`;
+}
+
+// src/configure.ts
+function renderStackConfig(o) {
+  const list = (items) => `[${items.map((i) => `'${i}'`).join(", ")}]`;
+  const billingBlock = o.billing === "none" ? `  billing: { provider: 'none' },` : `  billing: {
+    provider: 'stripe',
+    attachedTo: '${o.billing}', // or '${o.billing === "organization" ? "user" : "organization"}'
+    plans: [
+      {
+        id: 'starter',
+        name: 'Starter',
+        description: 'For small teams getting started.',
+        prices: [
+          { id: process.env.NEXT_PUBLIC_STRIPE_PRICE_STARTER_MONTHLY ?? 'price_starter_monthly', amount: 2900, currency: 'usd', interval: 'month' },
+          { id: process.env.NEXT_PUBLIC_STRIPE_PRICE_STARTER_YEARLY ?? 'price_starter_yearly', amount: 29000, currency: 'usd', interval: 'year' },
+        ],
+        features: ['Up to 3 members', '10 projects', 'Email support'],${o.billing === "organization" ? "\n        seats: 3," : ""}
+        limits: { projects: 10 },
+      },
+      {
+        id: 'team',
+        name: 'Team',
+        description: 'For growing teams that need room.',
+        prices: [
+          { id: process.env.NEXT_PUBLIC_STRIPE_PRICE_TEAM_MONTHLY ?? 'price_team_monthly', amount: 9900, currency: 'usd', interval: 'month' },
+          { id: process.env.NEXT_PUBLIC_STRIPE_PRICE_TEAM_YEARLY ?? 'price_team_yearly', amount: 99000, currency: 'usd', interval: 'year' },
+        ],
+        features: ['Up to 25 members', 'Unlimited projects', 'Priority support', '14-day free trial'],
+        highlighted: true,${o.billing === "organization" ? "\n        seats: 25," : ""}
+        trialDays: 14,
+        limits: { projects: -1 },
+      },
+    ],
+  },`;
+  return `import { defineStack } from '@/lib/stack'
+
+/**
+ * Your whole product, described in one file.
+ *
+ * Pricing page, checkout, entitlements, sign-in screens, navigation, legal pages and emails all
+ * read from here. Secrets never go in this file: they stay in .env and are read in src/lib/env.ts.
+ * Stripe price ids are public identifiers, so they may come from NEXT_PUBLIC_* variables.
+ */
+export default defineStack({
+  name: '${o.name.replace(/'/g, "\\'")}',
+  tagline: 'A new SaaS, built on Payload CMS.',
+  description:
+    'Authentication, organizations, subscriptions and an admin panel, wired together on Payload CMS and Next.js.',
+  url: process.env.NEXT_PUBLIC_APP_URL ?? 'http://localhost:3000',
+  support: { email: 'support@example.com' },
+
+  auth: {
+    methods: ${list(o.authMethods)},
+    social: ${list(o.social)},
+    twoFactor: ${o.authMethods.includes("email-password")},
+    requireEmailVerification: false,
+    allowSignUp: true,
+  },
+
+  organizations: {
+    enabled: ${o.organizations},
+    allowUserToCreate: true,
+    creatorRole: 'owner',
+    teams: false,
+  },
+
+${billingBlock}
+
+  legal: {
+    company: '${o.name.replace(/'/g, "\\'")} Ltd',
+    jurisdiction: 'Ireland',
+  },
+
+  nav: [${o.billing !== "none" ? "{ label: 'Pricing', href: '/pricing' }, " : ""}{ label: 'Docs', href: 'https://payload.solutions/docs/payload-stack' }],
+
+  social: {},
+})
+`;
+}
+var IMPORT_MARKER = "// database-adapter-import";
+var CONFIG_START = "// database-adapter-config-start";
+var CONFIG_END = "// database-adapter-config-end";
+function swapDatabaseAdapter(payloadConfigSource, db) {
+  const importLine = `${IMPORT_MARKER}
+import { ${db.importName} } from '${db.packageName}'`;
+  const withImport = payloadConfigSource.replace(
+    new RegExp(`${escapeRegExp(IMPORT_MARKER)}\\nimport [^\\n]+\\n`),
+    `${importLine}
+`
+  );
+  if (withImport === payloadConfigSource && !payloadConfigSource.includes(importLine)) {
+    throw new Error(`payload.config.ts is missing the "${IMPORT_MARKER}" marker`);
+  }
+  const start = withImport.indexOf(CONFIG_START);
+  const end = withImport.indexOf(CONFIG_END);
+  if (start === -1 || end === -1) throw new Error(`payload.config.ts is missing the database adapter markers`);
+  return `${withImport.slice(0, start)}${CONFIG_START}
+  ${db.config}
+  ${withImport.slice(end)}`;
+}
+function swapDatabasePackage(packageJson, db) {
+  const deps = { ...packageJson.dependencies };
+  const payloadVersion = deps.payload ?? "latest";
+  for (const other of Object.values(DB_CHOICES)) {
+    if (other.packageName !== db.packageName) delete deps[other.packageName];
+  }
+  deps[db.packageName] = payloadVersion;
+  return { ...packageJson, dependencies: sortKeys(deps) };
+}
+function renameProject(packageJson, slug) {
+  const next = { ...packageJson, name: slug, version: "0.1.0", private: true };
+  delete next.homepage;
+  delete next.repository;
+  delete next.description;
+  return next;
+}
+function renderEnv(example, o) {
+  const values = {
+    DATABASE_URL: o.connectionString,
+    PAYLOAD_SECRET: generateSecret(24),
+    BETTER_AUTH_SECRET: generateSecret(32),
+    NEXT_PUBLIC_APP_URL: o.appUrl ?? "http://localhost:3000"
+  };
+  const lines = example.split("\n").map((line) => {
+    const m = /^#?\s?([A-Z0-9_]+)=(.*)$/.exec(line);
+    if (!m) return line;
+    const key = m[1];
+    if (key in values) return `${key}=${values[key]}`;
+    return line;
+  });
+  return lines.join("\n");
+}
+function sortKeys(obj) {
+  return Object.fromEntries(Object.entries(obj).sort(([a], [b]) => a.localeCompare(b)));
+}
+function escapeRegExp(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+async function configureProject(o) {
+  const db = DB_CHOICES[o.db];
+  const read = (rel) => readFile(path.join(o.directory, rel), "utf8");
+  const write = (rel, content) => writeFile(path.join(o.directory, rel), content);
+  await write("src/stack.config.ts", renderStackConfig(o));
+  const payloadConfig = await read("src/payload.config.ts");
+  await write("src/payload.config.ts", swapDatabaseAdapter(payloadConfig, db));
+  const pkg = JSON.parse(await read("package.json"));
+  await write("package.json", JSON.stringify(renameProject(swapDatabasePackage(pkg, db), o.slug), null, 2) + "\n");
+  const example = await read(".env.example");
+  await write(".env", renderEnv(example, { connectionString: o.connectionString }));
+}
+
+// src/options.ts
+var AUTH_METHODS = ["email-password", "magic-link", "passkey"];
+var SOCIAL_PROVIDERS = ["google", "github"];
+
+// src/template.ts
+import { cp, mkdir, rm } from "fs/promises";
+import { existsSync as existsSync2 } from "fs";
+import path2 from "path";
+import { Readable } from "stream";
+import { pipeline } from "stream/promises";
+import * as tar from "tar";
+var REPO = "mpresecan/payload-solutions";
+var TEMPLATE_PATH = "templates/payload-stack";
+async function downloadTemplate({ dest, branch }) {
+  const url = `https://codeload.github.com/${REPO}/tar.gz/${encodeURIComponent(branch)}`;
+  const response = await fetch(url, { headers: { "User-Agent": "create-payload-stack" } });
+  if (!response.ok || !response.body) {
+    throw new Error(
+      `Could not download the template (${response.status} ${response.statusText}) from ${url}.
+Check your network, or pass --local-template <path> to scaffold from a local checkout.`
+    );
+  }
+  await mkdir(dest, { recursive: true });
+  const prefixDepth = 1 + TEMPLATE_PATH.split("/").length;
+  await pipeline(
+    Readable.fromWeb(response.body),
+    tar.x({
+      cwd: dest,
+      strip: prefixDepth,
+      filter: (entryPath) => {
+        const parts = entryPath.split("/");
+        return parts.slice(1, 1 + TEMPLATE_PATH.split("/").length).join("/") === TEMPLATE_PATH;
+      }
+    })
+  );
+  if (!existsSync2(path2.join(dest, "package.json"))) {
+    throw new Error(`The downloaded archive did not contain ${TEMPLATE_PATH}/package.json (branch "${branch}").`);
+  }
+}
+async function copyLocalTemplate({ from, dest }) {
+  const source = path2.resolve(from);
+  if (!existsSync2(path2.join(source, "package.json"))) {
+    throw new Error(`--local-template must point at a directory containing package.json (got ${source})`);
+  }
+  await mkdir(dest, { recursive: true });
+  await cp(source, dest, {
+    recursive: true,
+    filter: (src) => {
+      const rel = path2.relative(source, src);
+      const top = rel.split(path2.sep)[0];
+      return !["node_modules", ".next", ".turbo", ".env", "test-results", "playwright-report", "next-env.d.ts", "tsconfig.tsbuildinfo", "CLAUDE.md"].includes(top ?? "");
+    }
+  });
+  await rm(path2.join(dest, "CLAUDE.md"), { force: true });
+}
+
+// src/cli.ts
+var DOCS = "https://payload.solutions/docs/payload-stack";
+function bail(message = "Cancelled.") {
+  p.cancel(message);
+  process.exit(1);
+}
+function guard(value) {
+  if (p.isCancel(value)) bail();
+  return value;
+}
+function parseList(raw, allowed, flag) {
+  if (raw === void 0) return void 0;
+  const items = raw.split(",").map((s) => s.trim()).filter(Boolean);
+  for (const item of items) {
+    if (!allowed.includes(item)) bail(`Unknown value "${item}" for ${flag}. Allowed: ${allowed.join(", ")}`);
+  }
+  return items;
+}
+async function run(flags, positionalName) {
+  console.log();
+  p.intro(pc.bgWhite(pc.black(" create-payload-stack ")));
+  const providedName = flags.name ?? positionalName;
+  const name = flags.defaults && !providedName ? "my-saas" : providedName ?? guard(
+    await p.text({
+      message: "Project name",
+      placeholder: "my-saas",
+      defaultValue: "my-saas",
+      validate: (v) => v && v.trim().length < 2 ? "Use at least 2 characters" : void 0
+    })
+  );
+  const slug = slugify(name);
+  const directory = path3.resolve(process.cwd(), slug);
+  if (!isDirectoryEmpty(directory)) {
+    bail(`Directory ./${slug} already exists and is not empty.`);
+  }
+  const dbFlag = flags.db;
+  if (dbFlag && !DB_KEYS.includes(dbFlag)) bail(`Unknown database "${dbFlag}". Allowed: ${DB_KEYS.join(", ")}`);
+  const db = dbFlag ?? (flags.defaults ? "postgres" : guard(
+    await p.select({
+      message: "Database",
+      initialValue: "postgres",
+      options: DB_KEYS.map((key) => ({ value: key, label: DB_CHOICES[key].label, hint: DB_CHOICES[key].hint }))
+    })
+  ));
+  const dbChoice = DB_CHOICES[db];
+  const suggested = defaultConnectionString(dbChoice, slug);
+  const connectionString = flags.connectionString ?? (flags.defaults ? suggested : guard(
+    await p.text({
+      message: "Connection string",
+      placeholder: suggested,
+      defaultValue: suggested,
+      initialValue: suggested
+    })
+  ));
+  const authFlag = parseList(flags.auth, AUTH_METHODS, "--auth");
+  const socialFlag = parseList(flags.social, SOCIAL_PROVIDERS, "--social");
+  let authMethods;
+  let social;
+  if (authFlag || socialFlag || flags.defaults) {
+    authMethods = authFlag ?? ["email-password", "magic-link", "passkey"];
+    social = socialFlag ?? [];
+  } else {
+    const picked = guard(
+      await p.multiselect({
+        message: "Sign-in methods",
+        required: true,
+        initialValues: ["email-password", "magic-link", "passkey"],
+        options: [
+          { value: "email-password", label: "Email + password" },
+          { value: "magic-link", label: "Magic link" },
+          { value: "passkey", label: "Passkeys" },
+          { value: "google", label: "Google", hint: "needs GOOGLE_CLIENT_ID / _SECRET" },
+          { value: "github", label: "GitHub", hint: "needs GITHUB_CLIENT_ID / _SECRET" }
+        ]
+      })
+    );
+    authMethods = picked.filter((v) => AUTH_METHODS.includes(v));
+    social = picked.filter((v) => SOCIAL_PROVIDERS.includes(v));
+    if (authMethods.length === 0) {
+      p.log.warn("At least one non-social method is required for the Payload admin; adding email + password.");
+      authMethods = ["email-password"];
+    }
+  }
+  const organizations = flags.organizations ?? (flags.defaults ? true : guard(await p.confirm({ message: "Organizations (teams)", initialValue: true })));
+  let billing;
+  if (flags.billing !== void 0) {
+    if (!["organization", "user", "none"].includes(flags.billing)) bail(`Unknown value "${flags.billing}" for --billing. Allowed: organization, user, none`);
+    billing = flags.billing;
+    if (billing === "organization" && !organizations) bail("--billing organization requires organizations. Use --billing user or enable organizations.");
+  } else if (flags.defaults) {
+    billing = organizations ? "organization" : "user";
+  } else {
+    billing = guard(
+      await p.select({
+        message: "Billing",
+        initialValue: organizations ? "organization" : "user",
+        options: [
+          ...organizations ? [{ value: "organization", label: "Stripe subscriptions, per organization" }] : [],
+          { value: "user", label: "Stripe subscriptions, per user" },
+          { value: "none", label: "No billing yet" }
+        ]
+      })
+    );
+  }
+  const packageManager = flags.packageManager ?? await detectPackageManager();
+  const options = {
+    name,
+    slug,
+    directory,
+    db,
+    connectionString,
+    authMethods,
+    social,
+    organizations,
+    billing,
+    packageManager,
+    install: flags.install,
+    git: flags.git
+  };
+  if (flags.dryRun) {
+    p.note(JSON.stringify(options, null, 2), "Dry run: nothing written");
+    p.outro("Done.");
+    return;
+  }
+  const s = p.spinner();
+  s.start(flags.localTemplate ? "Copying local template" : "Downloading template");
+  try {
+    if (flags.localTemplate) await copyLocalTemplate({ from: flags.localTemplate, dest: directory });
+    else await downloadTemplate({ dest: directory, branch: flags.branch });
+    await configureProject(options);
+    s.stop("Project files written");
+  } catch (error) {
+    s.stop("Failed");
+    bail(error instanceof Error ? error.message : String(error));
+  }
+  if (options.install) {
+    const s2 = p.spinner();
+    s2.start(`Installing dependencies with ${packageManager}`);
+    try {
+      await execa2(installCommand(packageManager).split(" ")[0], installCommand(packageManager).split(" ").slice(1), {
+        cwd: directory,
+        env: { ...process.env, CI: "true" }
+      });
+      s2.stop(`Installed dependencies with ${packageManager}`);
+    } catch (error) {
+      s2.stop("Dependency installation failed");
+      p.log.warn(`Run ${pc.cyan(installCommand(packageManager))} inside ./${slug} to retry.
+${error instanceof Error ? error.message.split("\n")[0] : ""}`);
+    }
+  }
+  if (options.git && !existsSync3(path3.join(directory, ".git"))) {
+    try {
+      await execa2("git", ["init", "-b", "main"], { cwd: directory });
+      await execa2("git", ["add", "-A"], { cwd: directory });
+      await execa2("git", ["-c", "user.name=create-payload-stack", "-c", "user.email=cli@payloadstack.com", "commit", "-q", "-m", "feat: initial commit from create-payload-stack"], { cwd: directory });
+    } catch {
+      p.log.warn("Could not initialize a git repository. Run git init yourself.");
+    }
+  }
+  const steps = [
+    `cd ${slug}`,
+    ...options.install ? [] : [installCommand(packageManager)],
+    ...db === "sqlite" ? [] : ["# start your database, then check DATABASE_URL in .env"],
+    ...social.length ? [`# add ${social.map((sp) => `${sp.toUpperCase()}_CLIENT_ID / _SECRET`).join(" and ")} to .env`] : [],
+    ...billing !== "none" ? ["# add STRIPE_SECRET_KEY, STRIPE_WEBHOOK_SECRET and NEXT_PUBLIC_STRIPE_PRICE_* to .env when you are ready for billing"] : [],
+    runCommand(packageManager, "dev"),
+    "open http://localhost:3000/admin"
+  ];
+  p.note(steps.join("\n"), "Done. Next steps:");
+  p.outro(`Docs: ${pc.underline(DOCS)}`);
+}
+
+// src/index.ts
+var require2 = createRequire(import.meta.url);
+var { version } = require2("../package.json");
+var HELP = `
+  ${pc2.bold("create-payload-stack")} ${pc2.dim(`v${version}`)}
+  Scaffold a SaaS on Payload CMS: Better Auth, organizations, Stripe and a shadcn dashboard.
+
+  ${pc2.bold("Usage")}
+    $ npx create-payload-stack@latest [name] [options]
+
+  ${pc2.bold("Options")}
+    -n, --name <name>             Project name (also the directory)
+    -d, --db <db>                 ${DB_KEYS.join(" | ")}
+        --db-connection-string    Connection string written to .env
+        --auth <list>             Comma-separated: email-password, magic-link, passkey
+        --social <list>           Comma-separated: google, github
+        --organizations           Enable organizations (teams)
+        --no-organizations        Disable organizations
+        --billing <mode>          organization | user | none
+        --use-pnpm | --use-npm | --use-yarn | --use-bun
+        --no-install              Skip dependency installation
+        --no-git                  Skip git init
+    -y, --defaults                Accept defaults for every unanswered prompt
+        --branch <ref>            Git branch or tag of the template repo (default: main)
+        --local-template <path>   Scaffold from a local checkout of templates/payload-stack
+        --dry-run                 Print the resolved options and exit
+    -h, --help                    Show this help
+    -v, --version                 Show the version
+
+  ${pc2.bold("Examples")}
+    $ npx create-payload-stack@latest ridgeline
+    $ npx create-payload-stack@latest ridgeline -d sqlite --auth email-password,passkey --billing none -y
+
+  Docs: https://payload.solutions/docs/payload-stack
+`;
+function parse(argv) {
+  const { values, positionals } = parseArgs({
+    args: argv,
+    allowPositionals: true,
+    allowNegative: true,
+    options: {
+      name: { type: "string", short: "n" },
+      db: { type: "string", short: "d" },
+      "db-connection-string": { type: "string" },
+      auth: { type: "string" },
+      social: { type: "string" },
+      organizations: { type: "boolean" },
+      billing: { type: "string" },
+      "use-pnpm": { type: "boolean" },
+      "use-npm": { type: "boolean" },
+      "use-yarn": { type: "boolean" },
+      "use-bun": { type: "boolean" },
+      install: { type: "boolean", default: true },
+      git: { type: "boolean", default: true },
+      defaults: { type: "boolean", short: "y", default: false },
+      branch: { type: "string", default: "main" },
+      "local-template": { type: "string" },
+      "dry-run": { type: "boolean", default: false },
+      help: { type: "boolean", short: "h", default: false },
+      version: { type: "boolean", short: "v", default: false }
+    }
+  });
+  const packageManager = values["use-pnpm"] ? "pnpm" : values["use-npm"] ? "npm" : values["use-yarn"] ? "yarn" : values["use-bun"] ? "bun" : void 0;
+  return {
+    flags: {
+      name: values.name,
+      db: values.db,
+      connectionString: values["db-connection-string"],
+      auth: values.auth,
+      social: values.social,
+      organizations: values.organizations,
+      billing: values.billing,
+      packageManager,
+      install: values.install ?? true,
+      git: values.git ?? true,
+      defaults: values.defaults ?? false,
+      branch: values.branch ?? "main",
+      localTemplate: values["local-template"],
+      dryRun: values["dry-run"] ?? false,
+      help: values.help ?? false,
+      version: values.version ?? false
+    },
+    positional: positionals[0]
+  };
+}
+async function main() {
+  let parsed;
+  try {
+    parsed = parse(process.argv.slice(2));
+  } catch (error) {
+    console.error(pc2.red(error instanceof Error ? error.message : String(error)));
+    console.log(HELP);
+    process.exit(1);
+  }
+  if (parsed.flags.help) {
+    console.log(HELP);
+    return;
+  }
+  if (parsed.flags.version) {
+    console.log(version);
+    return;
+  }
+  await run(parsed.flags, parsed.positional);
+}
+main().catch((error) => {
+  console.error(pc2.red(error instanceof Error ? error.stack ?? error.message : String(error)));
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "create-payload-stack",
+  "version": "0.1.0",
+  "description": "Scaffold a SaaS on Payload CMS: Better Auth, organizations, Stripe subscriptions and a shadcn dashboard, in one command.",
+  "keywords": ["payload", "payloadcms", "saas", "boilerplate", "starter", "better-auth", "stripe", "shadcn", "nextjs", "create"],
+  "license": "MIT",
+  "homepage": "https://www.payloadstack.com",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mpresecan/payload-solutions.git",
+    "directory": "packages/create-payload-stack"
+  },
+  "bugs": "https://github.com/mpresecan/payload-solutions/issues",
+  "type": "module",
+  "bin": {
+    "create-payload-stack": "./dist/index.js"
+  },
+  "files": ["dist", "README.md"],
+  "engines": {
+    "node": ">=20.9.0"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "clean": "rm -rf dist .turbo",
+    "prepublishOnly": "pnpm build"
+  },
+  "dependencies": {
+    "@clack/prompts": "^1.7.0",
+    "@sindresorhus/slugify": "^3.0.1",
+    "execa": "^10.0.1",
+    "picocolors": "^1.1.1",
+    "tar": "^7.5.22"
+  },
+  "devDependencies": {
+    "@types/node": "^24.0.0",
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.18"
+  }
+}