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

package/README.md

@@ -1,3 +1,114 @@
-# 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. One command, full source code, ready to ship.
+
+## Quick Start
+
+```bash
+npx create-supersaas-app my-saas
+cd my-saas
+pnpm dev
+# Open http://localhost:3000/setup to configure
+```
+
+## What You Get
+
+- **Next.js 15** App Router + React 19 + TypeScript (strict mode)
+- **Authentication** — Better Auth: email/password, magic links, 2FA, Google/GitHub/Twitter OAuth
+- **4 Payment Providers** — Stripe, Polar, LemonSqueezy, DodoPayments (switch with one env var)
+- **5 Email Providers** — Resend, Postmark, SendGrid, Mailgun, Nodemailer/SMTP
+- **Database** — Drizzle ORM on PostgreSQL (Neon, Supabase, or local Docker)
+- **Teams** — multi-tenant orgs with invites, owner/admin/member roles
+- **Admin Dashboard** — user management, analytics, subscriptions, leads, feature flags
+- **13 Themes** — complete UI vibes, switch with one line in globals.css
+- **Blog + Changelog** — MDX with syntax highlighting, RSS, reading time
+- **Rate Limiting** — Upstash Redis middleware
+- **i18n** — locale detection, server + client translations
+- **Setup Wizard** — browser-based `/setup` generates your .env in 2 minutes
+- **AI-Ready** — ships with CLAUDE.md + AGENTS.md for Claude Code, Cursor, Copilot, Windsurf
+
+## Usage
+
+### Interactive Mode
+
+```bash
+npx create-supersaas-app
+```
+
+You'll be prompted for:
+1. License key (from your purchase email)
+2. App name
+3. Database provider (Neon, Supabase, or local Docker Postgres)
+4. Optional features (blog, admin dashboard)
+5. Install dependencies (yes/no)
+
+### Non-Interactive Mode
+
+For CI/CD, automation, or AI agents:
+
+```bash
+npx create-supersaas-app my-saas \
+  --key YOUR_LICENSE_KEY \
+  --db neon \
+  --features blog,admin \
+  --install \
+  --yes
+```
+
+### Dev Mode
+
+For local development without a license:
+
+```bash
+npx create-supersaas-app my-saas --key dev
+```
+
+## CLI Options
+
+| Flag | Description | Values |
+|------|-------------|--------|
+| `--key <key>` | License key | Your key from purchase email |
+| `--db <provider>` | Database provider | `neon`, `supabase`, `local` |
+| `--features <list>` | Optional features | `blog`, `admin` (comma-separated) |
+| `--install` | Install dependencies after scaffolding | — |
+| `--no-git` | Skip git repository initialization | — |
+| `--yes` / `--defaults` | Skip prompts, use defaults | — |
+
+## Deactivate License
+
+Free up a machine activation slot:
+
+```bash
+npx create-supersaas-app deactivate
+```
+
+## After Scaffolding
+
+```bash
+cd my-saas
+pnpm dev   # deps already installed if you said yes during setup
+# Open http://localhost:3000/setup — the setup wizard walks you through everything
+```
+
+The setup wizard configures:
+- Database connection
+- Auth secrets
+- Payment provider
+- Email provider
+- App identity
+
+After setup, manage runtime config at `/admin/settings`.
+
+## License
+
+Requires a valid SuperSaaS Kit license. One purchase ($129), unlimited projects, 3 machine activations.
+
+Get yours at [supersaas-kit.superbuilds.fun](https://supersaas-kit.superbuilds.fun)
+
+## Support
+
+- **Docs:** [supersaas-kit.superbuilds.fun/docs](https://supersaas-kit.superbuilds.fun/docs)
+- **Discord:** [discord.gg/bM3w3RZYYH](https://discord.gg/bM3w3RZYYH)
+- **Email:** hi@superbuilds.fun

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,562 @@
+#!/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 be invalid. 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);
+    try {
+      execSync(`tar -xzf "${archivePath}" -C "${targetDir}"`, {
+        stdio: "pipe"
+      });
+    } catch (tarErr) {
+      spinner.fail(chalk.red("Extraction failed"));
+      const isWindows = process.platform === "win32";
+      if (isWindows) {
+        p3.log.error(chalk.red("tar is not available on this system."));
+        p3.log.info(chalk.dim("Install tar via Windows Build Tools, or use WSL."));
+      } else {
+        p3.log.error(chalk.red(`tar extraction failed: ${tarErr.message}`));
+      }
+      await fs.remove(tmpDir);
+      return false;
+    }
+    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) {
+    if (await fs.pathExists(targetDir)) {
+      await fs.remove(targetDir);
+    }
+    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"));
+    p3.log.info(chalk.dim("Created .env from template \u2014 configure via /setup after first run"));
+  }
+  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(", ")}`));
+  if (config.install) {
+    const pm = detectPackageManager();
+    const spinner = ora(`Installing dependencies with ${pm}...`).start();
+    try {
+      execSync(`${pm} install`, { cwd: targetDir, stdio: "pipe" });
+      spinner.succeed(chalk.green("Dependencies installed"));
+    } catch {
+      spinner.fail(chalk.yellow("Install failed \u2014 run it manually after setup"));
+    }
+  }
+  if (!config.skipGit && hasGit()) {
+    try {
+      execSync("git init", { cwd: targetDir, stdio: "pipe" });
+      execSync("git add -A", { cwd: targetDir, stdio: "pipe" });
+      execSync('git commit -m "Initial commit from create-supersaas-app"', {
+        cwd: targetDir,
+        stdio: "pipe"
+      });
+      p3.log.info(chalk.dim("Initialized git repository"));
+    } catch {
+    }
+  }
+}
+function detectPackageManager() {
+  const userAgent = process.env.npm_config_user_agent || "";
+  if (userAgent.startsWith("pnpm")) return "pnpm";
+  if (userAgent.startsWith("yarn")) return "yarn";
+  if (userAgent.startsWith("bun")) return "bun";
+  return "pnpm";
+}
+function hasGit() {
+  try {
+    execSync("git --version", { stdio: "pipe" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+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);
+    }
+  }
+}
+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.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*name:\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";
+async function loadLocalLicense() {
+  try {
+    if (await fs.pathExists(LICENSE_PATH)) {
+      const data = await fs.readJson(LICENSE_PATH);
+      if (data.key && 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 license = {
+      key,
+      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 \u2014 ${existing.key.slice(0, 12)}...`)
+      );
+      return existing;
+    }
+    await fs.remove(LICENSE_PATH);
+    if (!nonInteractive) {
+      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("License activated!"));
+    return license;
+  }
+  return null;
+}
+async function deactivate() {
+  const existing = await loadLocalLicense();
+  if (!existing) {
+    p3.log.warning(chalk.yellow("No active license found on this machine."));
+    return false;
+  }
+  try {
+    const res = await fetch(`${DODO_BASE_URL}/licenses/deactivate`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        license_key: existing.key,
+        license_key_instance_id: existing.instance_id
+      })
+    });
+    if (res.ok) {
+      await fs.remove(LICENSE_PATH);
+      p3.log.success(chalk.green("License deactivated. Machine slot freed."));
+      return true;
+    }
+    const body = await res.json().catch(() => ({}));
+    p3.log.error(chalk.red(`Deactivation failed: ${body.message || "Unknown error"}`));
+    return false;
+  } catch {
+    p3.log.error(chalk.red("Could not reach license server."));
+    return false;
+  }
+}
+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)").option("--install", "Install dependencies after scaffolding").option("--no-git", "Skip git repository initialization").action(async (name, options) => {
+  const nonInteractive = options.defaults || options.yes || !process.stdin.isTTY;
+  if (!nonInteractive) {
+    p3.intro(
+      `${chalk.bold("supersaas-kit")} ${chalk.dim(`v${version}`)}
+` + chalk.dim("  Production-ready SaaS in one command")
+    );
+  }
+  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-ready with RSS feed" },
+        { value: "admin", label: "Admin Dashboard", hint: "user management, analytics" }
+      ],
+      required: false
+    });
+    if (p3.isCancel(features)) {
+      p3.cancel("Cancelled.");
+      process.exit(0);
+    }
+  }
+  let shouldInstall = options.install || false;
+  if (!nonInteractive && !options.install) {
+    shouldInstall = await p3.confirm({
+      message: "Install dependencies?",
+      initialValue: true
+    });
+    if (p3.isCancel(shouldInstall)) {
+      p3.cancel("Cancelled.");
+      process.exit(0);
+    }
+  }
+  await createApp({
+    name: appName,
+    database: dbChoice,
+    features: features || [],
+    licenseKey: licenseResult.key,
+    install: shouldInstall,
+    skipGit: options.git === false
+  });
+  if (!nonInteractive) {
+    const steps = [
+      chalk.green("Your app is ready!"),
+      "",
+      `  ${chalk.cyan("cd")} ${appName}`
+    ];
+    if (!shouldInstall) {
+      steps.push(`  ${chalk.cyan("pnpm install")}`);
+    }
+    steps.push(
+      `  ${chalk.cyan("pnpm dev")}`,
+      "",
+      chalk.dim("  Then visit /setup to configure your services."),
+      chalk.dim("  Docs: https://supersaas-kit.superbuilds.fun/docs")
+    );
+    p3.outro(steps.join("\n"));
+  } else {
+    const installCmd = shouldInstall ? "" : "pnpm install && ";
+    console.log(`\u2714 Created ${appName}. Run: cd ${appName} && ${installCmd}pnpm dev`);
+  }
+});
+program.command("deactivate").description("Deactivate your license on this machine (frees a machine slot)").action(async () => {
+  p3.intro(chalk.bold("supersaas-kit \u2014 deactivate"));
+  const confirmed = await p3.confirm({
+    message: "This will free one of your 3 machine activation slots. Continue?",
+    initialValue: false
+  });
+  if (p3.isCancel(confirmed) || !confirmed) {
+    p3.outro(chalk.dim("Deactivation cancelled."));
+    return;
+  }
+  const success = await deactivate();
+  if (success) {
+    p3.outro(chalk.green("License deactivated. You can activate on another machine now."));
+  } else {
+    p3.outro(chalk.red("Deactivation failed. Run again or contact hi@superbuilds.fun"));
+    process.exit(1);
+  }
+});
+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.1",
+  "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"
+  }
+}