@superbuilds/create-supersaas-app 0.0.0-stage → 2.0.0

package/README.md

@@ -1,3 +1,139 @@
-# Temporary Holding Version
+# create-supersaas-app
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+> Scaffold production-ready SaaS apps in seconds
+
+The fastest way to get your indie SaaS off the ground. Built for serious builders who ship.
+
+## Quick Start
+
+```bash
+npx create-supersaas-app my-saas --key YOUR_LICENSE_KEY
+cd my-saas
+npm run dev
+```
+
+## What You Get
+
+- **Next.js 15** + React 19 + TypeScript
+- **Authentication** (Better Auth) - email, OAuth, magic links
+- **Payments** (Stripe) - subscriptions, one-time, webhooks
+- **Database** (Drizzle ORM) - type-safe, migrations included
+- **Email** (Resend) - transactional + newsletter
+- **Teams** - multi-tenant with invites
+- **Admin Dashboard** - user management, analytics
+- **Beautiful UI** - Tailwind CSS v4, dark mode, responsive
+- **API Routes** - rate limiting, validation, error handling
+
+## Usage
+
+### Interactive Mode (Recommended)
+
+```bash
+npx create-supersaas-app
+```
+
+You'll be prompted for:
+- App name
+- Database provider (Neon, Supabase, PlanetScale, SQLite)
+- Optional features (blog, AI routes, admin, waitlist)
+
+### Non-Interactive Mode
+
+Perfect for CI/CD or automation:
+
+```bash
+npx create-supersaas-app my-saas \
+  --key YOUR_LICENSE_KEY \
+  --db neon \
+  --features blog,ai,admin \
+  --yes
+```
+
+## Options
+
+| Flag | Description | Example |
+|------|-------------|---------|
+| `--key` | License key (required) | `--key lic_abc123` |
+| `--db` | Database provider | `--db neon` |
+| `--features` | Comma-separated features | `--features blog,ai` |
+| `--yes` | Skip prompts, use defaults | `--yes` |
+
+## Features
+
+### Core (All Tiers)
+
+- Authentication (email + OAuth)
+- Database with migrations
+- Payment processing
+- Email delivery
+- Team management
+- API routes
+
+### Pro Tier
+
+- AI routes (OpenAI/Anthropic)
+- Admin dashboard
+- Advanced themes
+- Priority support
+
+### Bundle Tier
+
+- Everything in Pro
+- Lifetime updates
+- Team licenses
+- Early access to new features
+
+## Database Options
+
+- **Neon** (Postgres) - Recommended, generous free tier
+- **Supabase** (Postgres) - Auth + DB + Storage
+- **PlanetScale** (MySQL) - Serverless MySQL
+- **SQLite** - Local development
+
+## After Installation
+
+```bash
+cd your-app
+
+# 1. Set up environment variables
+cp .env.example .env.local
+# Edit .env.local with your keys
+
+# 2. Run migrations
+npm run db:push
+
+# 3. Start dev server
+npm run dev
+```
+
+Visit `http://localhost:3000`
+
+## CLI Commands (built-in)
+
+Once your app is created, use the built-in CLI from your project directory:
+
+```bash
+npx supersaas setup stripe
+npx supersaas add blog
+npx supersaas deploy
+```
+
+## License
+
+You need a valid supersaas-kit license to use this. Get yours at [supersaas-kit.superbuilds.fun](https://supersaas-kit.superbuilds.fun)
+
+## Support
+
+- **Docs:** https://supersaas-kit.superbuilds.fun/docs
+- **Issues:** https://github.com/bixblues/supersaas-kit/issues
+- **Email:** hi@superbuilds.fun
+
+## What's Next?
+
+1. Read the docs: https://supersaas-kit.superbuilds.fun/docs
+2. Join Discord: https://supersaas-kit.superbuilds.fun/discord
+3. Follow updates: https://x.com/superbuilds
+
+---
+
+Built with ❤️ by indie hackers, for indie hackers.

package/dist/index.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/index.js

@@ -0,0 +1,446 @@
+#!/usr/bin/env node
+import { program } from 'commander';
+import * as p3 from '@clack/prompts';
+import chalk from 'chalk';
+import path from 'path';
+import fs from 'fs-extra';
+import ora from 'ora';
+import { execSync } from 'child_process';
+import os2 from 'os';
+import { createRequire } from 'module';
+
+var API_BASE = process.env.SUPERSAAS_API_URL || "https://supersaas-kit.superbuilds.fun";
+var SUBSTITUTIONS = {
+  __APP_NAME__: (c) => c.name
+};
+var FEATURE_PATHS = {
+  blog: [
+    "src/app/(marketing)/blog",
+    "src/app/blog",
+    "src/lib/blog.ts",
+    "content/blog",
+    "src/components/blog"
+  ],
+  admin: [
+    "src/app/(app)/admin",
+    "src/lib/admin"
+  ]
+};
+var DATABASE_CONFIGS = {
+  neon: { hint: "# Get your connection string from https://console.neon.tech" },
+  supabase: { hint: "# Get your connection string from Supabase Dashboard > Settings > Database" },
+  local: { hint: "# Local Docker Postgres: docker compose up -d" }
+};
+async function downloadTemplate(licenseKey, targetDir) {
+  const spinner = ora("Downloading template...").start();
+  try {
+    const res = await fetch(`${API_BASE}/api/download`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        license_key: licenseKey
+      })
+    });
+    if (!res.ok) {
+      spinner.fail(chalk.red("Download failed"));
+      const errorBody = await res.json().catch(() => ({}));
+      const msg = errorBody.error || `HTTP ${res.status}`;
+      p3.log.error(chalk.red(msg));
+      if (res.status === 403) {
+        p3.log.info(chalk.dim("Your license may not include this tier. Check https://supersaas-kit.superbuilds.fun"));
+      }
+      if (res.status === 429) {
+        p3.log.info(chalk.dim("Too many downloads. Wait an hour and try again."));
+      }
+      return false;
+    }
+    const tmpDir = path.join(os2.tmpdir(), `supersaas-kit-${Date.now()}`);
+    await fs.ensureDir(tmpDir);
+    const archivePath = path.join(tmpDir, "template.tar.gz");
+    const arrayBuffer = await res.arrayBuffer();
+    await fs.writeFile(archivePath, Buffer.from(arrayBuffer));
+    spinner.text = "Extracting template...";
+    await fs.ensureDir(targetDir);
+    execSync(`tar -xzf "${archivePath}" -C "${targetDir}"`, {
+      stdio: "pipe"
+    });
+    await fs.remove(tmpDir);
+    spinner.succeed(chalk.green("Template downloaded and extracted"));
+    return true;
+  } catch (err) {
+    spinner.fail(chalk.red("Download failed"));
+    p3.log.error(
+      chalk.red(
+        `Could not download template: ${err.message}`
+      )
+    );
+    p3.log.info(chalk.dim("Check your internet connection and try again."));
+    return false;
+  }
+}
+async function createApp(config) {
+  const targetDir = path.resolve(process.cwd(), config.name);
+  if (await fs.pathExists(targetDir)) {
+    p3.log.error(chalk.red(`Directory "${config.name}" already exists.`));
+    process.exit(1);
+  }
+  const downloaded = await downloadTemplate(config.licenseKey, targetDir);
+  if (!downloaded) {
+    process.exit(1);
+  }
+  const excludePaths = /* @__PURE__ */ new Set();
+  for (const [feature, paths] of Object.entries(FEATURE_PATHS)) {
+    if (!config.features.includes(feature)) {
+      for (const p4 of paths) {
+        excludePaths.add(p4);
+      }
+    }
+  }
+  for (const excludePath of excludePaths) {
+    const fullPath = path.join(targetDir, excludePath);
+    if (await fs.pathExists(fullPath)) {
+      await fs.remove(fullPath);
+    }
+  }
+  const pkgTemplatePath = path.join(targetDir, "package.json.template");
+  if (await fs.pathExists(pkgTemplatePath)) {
+    await fs.move(pkgTemplatePath, path.join(targetDir, "package.json"));
+  }
+  await substituteVars(targetDir, config);
+  await configureDatabase(targetDir, config);
+  await updateManifest(targetDir, config);
+  const envExample = path.join(targetDir, ".env.example");
+  if (await fs.pathExists(envExample)) {
+    await fs.copy(envExample, path.join(targetDir, ".env"));
+  }
+  await cleanupFeatureImports(targetDir, config);
+  const activeFeatures = ["auth", "payments", "email", "seo", ...config.features];
+  p3.log.info(chalk.dim(`Database: ${config.database}`));
+  p3.log.info(chalk.dim(`Features: ${activeFeatures.join(", ")}`));
+}
+async function configureDatabase(targetDir, config) {
+  const dbConfig = DATABASE_CONFIGS[config.database];
+  if (!dbConfig) return;
+  const envPath = path.join(targetDir, ".env.example");
+  if (await fs.pathExists(envPath)) {
+    let content = await fs.readFile(envPath, "utf-8");
+    const hint = dbConfig.hint;
+    if (hint && !content.includes(hint)) {
+      content = content.replace(/DATABASE_URL=/, `${hint}
+DATABASE_URL=`);
+      await fs.writeFile(envPath, content);
+    }
+  }
+  if (config.database === "local") {
+    const envPath2 = path.join(targetDir, ".env.example");
+    if (await fs.pathExists(envPath2)) {
+      let content = await fs.readFile(envPath2, "utf-8");
+      if (content.includes("DATABASE_URL=postgres://postgres:postgres@localhost:5432/app")) ;
+      await fs.writeFile(envPath2, content);
+    }
+  }
+}
+async function updateManifest(targetDir, config) {
+  const manifestPath = path.join(targetDir, ".supersaas", "manifest.json");
+  if (await fs.pathExists(manifestPath)) {
+    const manifest = await fs.readJson(manifestPath);
+    manifest.database = config.database;
+    manifest.features = config.features;
+    manifest.tier = config.tier;
+    manifest.createdAt = (/* @__PURE__ */ new Date()).toISOString();
+    if (manifest.providers) {
+      if (manifest.providers.db) manifest.providers.db = "postgres";
+    }
+    await fs.writeJson(manifestPath, manifest, { spaces: 2 });
+  }
+}
+async function cleanupFeatureImports(targetDir, config) {
+  if (!config.features.includes("blog")) {
+    const sitemapPath = path.join(targetDir, "src/app/sitemap.ts");
+    if (await fs.pathExists(sitemapPath)) {
+      await fs.writeFile(sitemapPath, `import { MetadataRoute } from "next";
+import { appConfig } from "@/config/app";
+
+const baseUrl = appConfig.url;
+
+export default function sitemap(): MetadataRoute.Sitemap {
+  const now = new Date();
+
+  return [
+    { url: baseUrl, lastModified: now, changeFrequency: "weekly", priority: 1.0 },
+    { url: \`\${baseUrl}/sign-up\`, lastModified: now, changeFrequency: "yearly", priority: 0.5 },
+  ];
+}
+`);
+    }
+    const configPath = path.join(targetDir, "src/config/app.ts");
+    if (await fs.pathExists(configPath)) {
+      let content = await fs.readFile(configPath, "utf-8");
+      content = content.replace(/\s*\{\s*label:\s*["']Blog["'],\s*href:\s*["']\/blog["']\s*\},?\n?/g, "");
+      await fs.writeFile(configPath, content);
+    }
+  }
+  if (!config.features.includes("admin")) {
+    const sidebarPath = path.join(targetDir, "src/components/layout/sidebar.tsx");
+    if (await fs.pathExists(sidebarPath)) {
+      let content = await fs.readFile(sidebarPath, "utf-8");
+      content = content.replace(/\s*\{\s*label:\s*["']Admin["'].*?\},?\n?/gs, "");
+      await fs.writeFile(sidebarPath, content);
+    }
+  }
+}
+async function substituteVars(dir, config) {
+  const textExtensions = [
+    ".ts",
+    ".tsx",
+    ".js",
+    ".jsx",
+    ".json",
+    ".md",
+    ".mdx",
+    ".css",
+    ".env",
+    ".example"
+  ];
+  const files = await getAllFiles(dir);
+  for (const file of files) {
+    const ext = path.extname(file);
+    const basename = path.basename(file);
+    if (!textExtensions.includes(ext) && !basename.startsWith(".env")) continue;
+    let content = await fs.readFile(file, "utf-8");
+    let changed = false;
+    for (const [placeholder, resolver] of Object.entries(SUBSTITUTIONS)) {
+      if (content.includes(placeholder)) {
+        content = content.replaceAll(placeholder, resolver(config));
+        changed = true;
+      }
+    }
+    if (changed) {
+      await fs.writeFile(file, content);
+    }
+  }
+}
+async function getAllFiles(dir) {
+  const entries = await fs.readdir(dir, { withFileTypes: true });
+  const files = [];
+  for (const entry of entries) {
+    const full = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      if (entry.name === "node_modules" || entry.name === ".next") continue;
+      files.push(...await getAllFiles(full));
+    } else {
+      files.push(full);
+    }
+  }
+  return files;
+}
+var SUPERSAAS_DIR = path.join(os2.homedir(), ".supersaas");
+var LICENSE_PATH = path.join(SUPERSAAS_DIR, "license.json");
+var DODO_BASE_URL = process.env.SUPERSAAS_DODO_URL || "https://test.dodopayments.com";
+function inferTierFromActivation(_data) {
+  return "bundle";
+}
+async function loadLocalLicense() {
+  try {
+    if (await fs.pathExists(LICENSE_PATH)) {
+      const data = await fs.readJson(LICENSE_PATH);
+      if (data.key && data.tier && data.instance_id) {
+        return data;
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+async function validateKey(key) {
+  try {
+    const res = await fetch(`${DODO_BASE_URL}/licenses/validate`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ license_key: key })
+    });
+    if (!res.ok) {
+      return { valid: false };
+    }
+    const data = await res.json();
+    return { valid: data.valid !== false, data };
+  } catch {
+    return { valid: false };
+  }
+}
+async function activateOnline(key) {
+  const machineName = `${os2.hostname()} (${os2.platform()})`;
+  try {
+    const validation = await validateKey(key);
+    if (!validation.valid) {
+      p3.log.error(chalk.red("Invalid or expired license key."));
+      return null;
+    }
+    const res = await fetch(`${DODO_BASE_URL}/licenses/activate`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        license_key: key,
+        name: machineName
+      })
+    });
+    if (!res.ok) {
+      const body = await res.json().catch(() => ({}));
+      const msg = body.message || body.error || `HTTP ${res.status}`;
+      p3.log.error(chalk.red(`Activation failed: ${msg}`));
+      return null;
+    }
+    const result = await res.json();
+    const tier = inferTierFromActivation(result);
+    const license = {
+      key,
+      tier,
+      instance_id: result.id || result.license_key_instance_id || "",
+      activated_at: (/* @__PURE__ */ new Date()).toISOString(),
+      valid: true
+    };
+    await fs.ensureDir(SUPERSAAS_DIR);
+    await fs.writeJson(LICENSE_PATH, license, { spaces: 2 });
+    return license;
+  } catch {
+    p3.log.error(
+      chalk.red("Could not reach license server. Check your connection.")
+    );
+    return null;
+  }
+}
+async function activate(keyArg, nonInteractive) {
+  const existing = await loadLocalLicense();
+  if (existing) {
+    const check = await validateKey(existing.key).catch(() => ({ valid: true }));
+    if (check.valid) {
+      p3.log.success(
+        chalk.dim(
+          `Licensed (${existing.tier}) - ${existing.key.slice(0, 12)}...`
+        )
+      );
+      return existing;
+    }
+    await fs.remove(LICENSE_PATH);
+    p3.log.warning(chalk.yellow("License expired or revoked. Please re-activate."));
+  }
+  if (!keyArg && nonInteractive) {
+    return null;
+  }
+  const key = keyArg || await p3.text({
+    message: "Enter your license key:",
+    placeholder: "Paste your license key from the purchase email",
+    validate: (v) => {
+      if (!v) return "License key is required";
+      if (v.length < 8) return "Invalid key format";
+    }
+  });
+  if (p3.isCancel(key)) return null;
+  p3.log.step("Activating license...");
+  const license = await activateOnline(key);
+  if (license) {
+    p3.log.success(chalk.green(`Activated! Tier: ${license.tier}`));
+    return license;
+  }
+  return null;
+}
+var require2 = createRequire(import.meta.url);
+var { version } = require2("../package.json");
+var VALID_DBS = ["neon", "supabase", "local"];
+var VALID_FEATURES = ["blog", "admin"];
+program.name("create-supersaas-app").description("Scaffold production-ready SaaS apps in seconds").version(version).argument("[name]", "Name of your app").option("--key <license-key>", "License key for activation").option("--defaults", "Skip prompts, use default settings (for agents)").option("--yes", "Alias for --defaults (non-interactive mode)").option("--db <provider>", "Database provider (neon|supabase|local)").option("--features <list>", "Comma-separated features (blog,admin)").action(async (name, options) => {
+  const nonInteractive = options.defaults || options.yes || !process.stdin.isTTY;
+  if (!nonInteractive) p3.intro(chalk.bold("supersaas-kit"));
+  let licenseResult = await activate(options.key, nonInteractive);
+  if (!licenseResult) {
+    if (!nonInteractive) p3.cancel("License activation failed.");
+    else console.error("License activation failed.");
+    process.exit(1);
+  }
+  let appName = name;
+  if (!appName && nonInteractive) {
+    console.error("Error: app name is required in non-interactive mode. Pass it as the first argument: create-supersaas-app <name>");
+    process.exit(1);
+  }
+  if (!appName) {
+    appName = await p3.text({
+      message: "What's your app called?",
+      placeholder: "my-saas",
+      validate: (v) => {
+        if (!v) return "App name is required";
+        if (!/^[a-z0-9-]+$/.test(v))
+          return "Use lowercase letters, numbers, and hyphens only";
+      }
+    });
+    if (p3.isCancel(appName)) {
+      p3.cancel("Cancelled.");
+      process.exit(0);
+    }
+  }
+  let dbChoice = options.db || (nonInteractive ? "neon" : null);
+  if (dbChoice && !VALID_DBS.includes(dbChoice)) {
+    const msg = `Invalid --db value "${dbChoice}". Valid options: ${VALID_DBS.join(", ")}`;
+    if (nonInteractive) {
+      console.error(`Error: ${msg}`);
+      process.exit(1);
+    }
+    p3.log.warn(chalk.yellow(msg));
+    dbChoice = null;
+  }
+  if (!dbChoice) {
+    dbChoice = await p3.select({
+      message: "Database provider?",
+      options: [
+        { value: "neon", label: "Neon (Postgres)", hint: "serverless, recommended" },
+        { value: "supabase", label: "Supabase (Postgres)" },
+        { value: "local", label: "Local Docker Postgres", hint: "docker compose up -d" }
+      ]
+    });
+    if (p3.isCancel(dbChoice)) {
+      p3.cancel("Cancelled.");
+      process.exit(0);
+    }
+  }
+  let features = options.features ? options.features.split(",").map((f) => f.trim()).filter(Boolean) : [];
+  if (features.length > 0) {
+    const invalid = features.filter((f) => !VALID_FEATURES.includes(f));
+    if (invalid.length > 0) {
+      const msg = `Unknown features: ${invalid.join(", ")}. Valid options: ${VALID_FEATURES.join(", ")}`;
+      if (nonInteractive) {
+        console.error(`Error: ${msg}`);
+        process.exit(1);
+      }
+      p3.log.warn(chalk.yellow(msg));
+      features = features.filter((f) => VALID_FEATURES.includes(f));
+    }
+  }
+  if (!nonInteractive && !options.features) {
+    features = await p3.multiselect({
+      message: "Include optional modules?",
+      options: [
+        { value: "blog", label: "Blog (MDX)", hint: "SEO boost" },
+        { value: "admin", label: "Admin Dashboard", hint: "Pro" }
+      ],
+      required: false
+    });
+    if (p3.isCancel(features)) {
+      p3.cancel("Cancelled.");
+      process.exit(0);
+    }
+  }
+  await createApp({
+    name: appName,
+    database: dbChoice,
+    features: features || [],
+    tier: licenseResult.tier,
+    licenseKey: licenseResult.key
+  });
+  if (!nonInteractive) {
+    p3.outro(
+      chalk.green("Done!") + ` Run ${chalk.cyan(`cd ${appName} && npm install && npm run dev`)} to start.`
+    );
+  } else {
+    console.log(`\u2714 Created ${appName}. Run: cd ${appName} && npm install && npm run dev`);
+  }
+});
+program.parse();

package/package.json

@@ -1,6 +1,60 @@
 {
   "name": "@superbuilds/create-supersaas-app",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "2.0.0",
+  "description": "Scaffold production-ready SaaS apps in seconds — SuperSaaS Kit CLI",
+  "author": "superbuilds",
+  "license": "MIT",
+  "homepage": "https://supersaas-kit.superbuilds.fun",
+  "bugs": {
+    "url": "https://github.com/bixblues/supersaas-kit/issues"
+  },
+  "bin": {
+    "create-supersaas-app": "./dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --treeshake --define.__DEV_MODE__=false",
+    "build:dev": "tsup src/index.ts --format esm --dts --define.__DEV_MODE__=true",
+    "dev": "tsup src/index.ts --format esm --watch --define.__DEV_MODE__=true"
+  },
+  "dependencies": {
+    "@clack/prompts": "^0.9.1",
+    "chalk": "^5.4.1",
+    "commander": "^13.1.0",
+    "fs-extra": "^11.3.0",
+    "ora": "^8.2.0"
+  },
+  "devDependencies": {
+    "@types/fs-extra": "^11.0.4",
+    "@types/node": "^22.15.0",
+    "tsup": "^8.4.0",
+    "typescript": "^5.8.0"
+  },
+  "type": "module",
+  "engines": {
+    "node": ">=18.17.0"
+  },
+  "keywords": [
+    "supersaas-kit",
+    "superbuilds",
+    "saas",
+    "saas-boilerplate",
+    "nextjs",
+    "nextjs-starter",
+    "indie-hacker",
+    "create-app",
+    "starter",
+    "boilerplate"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/bixblues/supersaas-kit",
+    "directory": "packages/create-supersaas-app"
+  }
+}