create-whop-kit 0.1.0 → 0.3.0

package/dist/cli-create.js

@@ -0,0 +1,761 @@
+#!/usr/bin/env node
+import {
+  createManifest,
+  detectPackageManager,
+  exec,
+  hasCommand
+} from "./chunk-M4AXERQP.js";
+
+// src/cli-create.ts
+import { runMain } from "citty";
+
+// src/commands/init.ts
+import { resolve, basename as basename2 } from "path";
+import { existsSync as existsSync5 } from "fs";
+import * as p5 from "@clack/prompts";
+import pc5 from "picocolors";
+import { defineCommand } from "citty";
+
+// src/templates.ts
+var TEMPLATES = {
+  nextjs: {
+    name: "Next.js",
+    description: "Full-stack React with App Router, SSR, and API routes",
+    repo: "colinmcdermott/whop-saas-starter-v2",
+    available: true
+  },
+  astro: {
+    name: "Astro",
+    description: "Content-focused with islands architecture",
+    repo: "colinmcdermott/whop-astro-starter",
+    available: true
+  },
+  tanstack: {
+    name: "TanStack Start",
+    description: "Full-stack React with TanStack Router",
+    repo: "",
+    available: false
+  },
+  vite: {
+    name: "Vite + React",
+    description: "Lightweight SPA with Vite bundler",
+    repo: "",
+    available: false
+  }
+};
+var APP_TYPES = {
+  saas: {
+    name: "SaaS",
+    description: "Subscription tiers, dashboard, billing portal",
+    available: true
+  },
+  course: {
+    name: "Course",
+    description: "Lessons, progress tracking, drip content",
+    available: false
+  },
+  community: {
+    name: "Community",
+    description: "Member feeds, gated content, roles",
+    available: false
+  },
+  blank: {
+    name: "Blank",
+    description: "Just auth + payments, you build the rest",
+    available: false
+  }
+};
+var DB_OPTIONS = {
+  neon: {
+    name: "Neon",
+    description: "Serverless Postgres (recommended)",
+    envVarHint: "postgresql://user:pass@ep-xxx.us-east-2.aws.neon.tech/dbname?sslmode=require"
+  },
+  supabase: {
+    name: "Supabase",
+    description: "Open-source Firebase alternative",
+    envVarHint: "postgresql://postgres.xxx:pass@aws-0-us-east-1.pooler.supabase.com:6543/postgres"
+  },
+  local: {
+    name: "Local PostgreSQL",
+    description: "Your own Postgres instance",
+    envVarHint: "postgresql://postgres:postgres@localhost:5432/myapp"
+  },
+  later: {
+    name: "Configure later",
+    description: "Skip database setup for now",
+    envVarHint: ""
+  }
+};
+
+// src/providers/neon.ts
+import * as p from "@clack/prompts";
+import pc from "picocolors";
+var neonProvider = {
+  name: "Neon",
+  description: "Serverless Postgres \u2014 free tier, scales to zero",
+  isInstalled() {
+    return hasCommand("neonctl") || hasCommand("neon");
+  },
+  async install() {
+    const s = p.spinner();
+    s.start("Installing neonctl...");
+    const result = exec("npm install -g neonctl");
+    if (result.success) {
+      s.stop("neonctl installed");
+      return true;
+    }
+    s.stop("Failed to install neonctl");
+    p.log.error(`Install manually: ${pc.bold("npm install -g neonctl")}`);
+    return false;
+  },
+  async provision(projectName) {
+    const cli = hasCommand("neonctl") ? "neonctl" : "neon";
+    const whoami = exec(`${cli} me`);
+    if (!whoami.success) {
+      p.log.info("You need to authenticate with Neon.");
+      p.log.info(`Running ${pc.bold(`${cli} auth`)} \u2014 this will open your browser.`);
+      const authResult = exec(`${cli} auth`);
+      if (!authResult.success) {
+        p.log.error("Neon authentication failed. Try running manually:");
+        p.log.info(pc.bold(`  ${cli} auth`));
+        return null;
+      }
+    }
+    const s = p.spinner();
+    s.start(`Creating Neon project "${projectName}"...`);
+    const createResult = exec(
+      `${cli} projects create --name "${projectName}" --set-context --output json`
+    );
+    if (!createResult.success) {
+      s.stop("Failed to create Neon project");
+      p.log.error("Try creating manually at https://console.neon.tech");
+      return null;
+    }
+    s.stop("Neon project created");
+    s.start("Getting connection string...");
+    const connResult = exec(`${cli} connection-string --prisma`);
+    if (!connResult.success) {
+      s.stop("Could not retrieve connection string");
+      p.log.error("Get it from: https://console.neon.tech");
+      return null;
+    }
+    s.stop("Connection string retrieved");
+    return {
+      connectionString: connResult.stdout,
+      provider: "neon"
+    };
+  }
+};
+
+// src/providers/supabase.ts
+import * as p2 from "@clack/prompts";
+import pc2 from "picocolors";
+var supabaseProvider = {
+  name: "Supabase",
+  description: "Open-source Firebase alternative with Postgres",
+  isInstalled() {
+    return hasCommand("supabase");
+  },
+  async install() {
+    const s = p2.spinner();
+    s.start("Checking Supabase CLI...");
+    if (hasCommand("brew")) {
+      s.message("Installing via Homebrew...");
+      const result = exec("brew install supabase/tap/supabase");
+      if (result.success) {
+        s.stop("Supabase CLI installed");
+        return true;
+      }
+    }
+    s.stop("Supabase CLI not found");
+    p2.log.info("Install the Supabase CLI:");
+    p2.log.info(pc2.bold("  brew install supabase/tap/supabase"));
+    p2.log.info(pc2.dim("  or use npx supabase <command>"));
+    const useNpx = await p2.confirm({
+      message: "Continue with npx supabase? (slower but works without install)",
+      initialValue: true
+    });
+    if (p2.isCancel(useNpx) || !useNpx) return false;
+    return true;
+  },
+  async provision(projectName) {
+    const cli = hasCommand("supabase") ? "supabase" : "npx supabase";
+    const projectsList = exec(`${cli} projects list`);
+    if (!projectsList.success) {
+      p2.log.info("You need to authenticate with Supabase.");
+      p2.log.info(`Running ${pc2.bold(`${cli} login`)} \u2014 this will open your browser.`);
+      const authResult = exec(`${cli} login`);
+      if (!authResult.success) {
+        p2.log.error("Supabase authentication failed. Try:");
+        p2.log.info(pc2.bold(`  ${cli} login`));
+        return null;
+      }
+    }
+    const orgsResult = exec(`${cli} orgs list`);
+    let orgId = "";
+    if (orgsResult.success && orgsResult.stdout) {
+      const lines = orgsResult.stdout.split("\n").filter((l) => l.trim());
+      if (lines.length > 1) {
+        const orgInput = await p2.text({
+          message: "Supabase Organization ID",
+          placeholder: "Find in dashboard: supabase.com/dashboard",
+          validate: (v) => !v ? "Required" : void 0
+        });
+        if (p2.isCancel(orgInput)) return null;
+        orgId = orgInput;
+      }
+    }
+    const password = Array.from(crypto.getRandomValues(new Uint8Array(16))).map((b) => b.toString(16).padStart(2, "0")).join("");
+    const s = p2.spinner();
+    s.start(`Creating Supabase project "${projectName}"...`);
+    const createCmd = orgId ? `${cli} projects create "${projectName}" --org-id "${orgId}" --db-password "${password}" --region us-east-1` : `${cli} projects create "${projectName}" --db-password "${password}" --region us-east-1`;
+    const createResult = exec(createCmd);
+    if (!createResult.success) {
+      s.stop("Failed to create Supabase project");
+      p2.log.error("Create manually at: https://supabase.com/dashboard");
+      return null;
+    }
+    s.stop("Supabase project created");
+    p2.log.info("");
+    p2.log.info(pc2.bold("Get your connection string:"));
+    p2.log.info("  1. Go to https://supabase.com/dashboard");
+    p2.log.info("  2. Select your new project");
+    p2.log.info('  3. Click "Connect" \u2192 "Session pooler"');
+    p2.log.info("  4. Copy the connection string");
+    p2.log.info("");
+    const connString = await p2.text({
+      message: "Paste your Supabase connection string",
+      placeholder: "postgresql://postgres.[ref]:[password]@...",
+      validate: (v) => {
+        if (!v) return "Required";
+        if (!v.startsWith("postgres")) return "Must be a PostgreSQL connection string";
+      }
+    });
+    if (p2.isCancel(connString)) return null;
+    return {
+      connectionString: connString,
+      provider: "supabase"
+    };
+  }
+};
+
+// src/providers/prisma-postgres.ts
+import * as p3 from "@clack/prompts";
+import pc3 from "picocolors";
+import { readFileSync, existsSync } from "fs";
+var prismaPostgresProvider = {
+  name: "Prisma Postgres",
+  description: "Instant Postgres \u2014 no auth needed, free tier",
+  isInstalled() {
+    return true;
+  },
+  async install() {
+    return true;
+  },
+  async provision(projectName) {
+    const region = await p3.select({
+      message: "Prisma Postgres region",
+      options: [
+        { value: "us-east-1", label: "US East (Virginia)", hint: "default" },
+        { value: "us-west-1", label: "US West (Oregon)" },
+        { value: "eu-central-1", label: "EU Central (Frankfurt)" },
+        { value: "eu-west-3", label: "EU West (Paris)" },
+        { value: "ap-southeast-1", label: "Asia Pacific (Singapore)" },
+        { value: "ap-northeast-1", label: "Asia Pacific (Tokyo)" }
+      ]
+    });
+    if (p3.isCancel(region)) return null;
+    const s = p3.spinner();
+    s.start("Creating Prisma Postgres database...");
+    const result = exec(`npx create-db@latest --region ${region} --json`);
+    if (!result.success) {
+      const fallback = exec(`npx -y create-db@latest --region ${region}`);
+      if (!fallback.success) {
+        s.stop("Failed to create database");
+        p3.log.error("Try manually: " + pc3.bold("npx create-db@latest"));
+        return null;
+      }
+      const match = fallback.stdout.match(/postgresql:\/\/[^\s"]+/);
+      if (match) {
+        s.stop("Prisma Postgres database created");
+        return {
+          connectionString: match[0],
+          provider: "prisma-postgres",
+          note: "This is a temporary database (24h). Claim it via the link in the output to make it permanent."
+        };
+      }
+    }
+    try {
+      const data = JSON.parse(result.stdout);
+      if (data.connectionString || data.url) {
+        s.stop("Prisma Postgres database created");
+        return {
+          connectionString: data.connectionString || data.url,
+          provider: "prisma-postgres",
+          note: "This is a temporary database (24h). Claim it to make it permanent."
+        };
+      }
+    } catch {
+      const match = result.stdout.match(/postgresql:\/\/[^\s"]+/);
+      if (match) {
+        s.stop("Prisma Postgres database created");
+        return {
+          connectionString: match[0],
+          provider: "prisma-postgres",
+          note: "This is a temporary database (24h). Claim it to make it permanent."
+        };
+      }
+    }
+    if (existsSync(".env")) {
+      const envContent = readFileSync(".env", "utf-8");
+      const match = envContent.match(/DATABASE_URL="?(postgresql:\/\/[^\s"]+)"?/);
+      if (match) {
+        s.stop("Prisma Postgres database created");
+        return {
+          connectionString: match[1],
+          provider: "prisma-postgres",
+          note: "This is a temporary database (24h). Claim it to make it permanent."
+        };
+      }
+    }
+    s.stop("Database created but could not extract connection string");
+    p3.log.warning("Check the output above for your DATABASE_URL, or visit https://console.prisma.io");
+    return null;
+  }
+};
+
+// src/providers/index.ts
+var DB_PROVIDERS = {
+  neon: neonProvider,
+  supabase: supabaseProvider,
+  "prisma-postgres": prismaPostgresProvider
+};
+
+// src/utils/checks.ts
+import * as p4 from "@clack/prompts";
+import pc4 from "picocolors";
+function checkNodeVersion(minimum = 18) {
+  const major = parseInt(process.versions.node.split(".")[0], 10);
+  if (major < minimum) {
+    p4.log.error(
+      `Node.js ${pc4.bold(`v${minimum}+`)} is required. You have ${pc4.bold(`v${process.versions.node}`)}.`
+    );
+    process.exit(1);
+  }
+}
+function checkGit() {
+  if (!hasCommand("git")) {
+    p4.log.error(
+      `${pc4.bold("git")} is required but not found. Install it from ${pc4.cyan("https://git-scm.com")}`
+    );
+    process.exit(1);
+  }
+}
+function validateDatabaseUrl(url) {
+  if (!url.startsWith("postgres://") && !url.startsWith("postgresql://")) {
+    return "Must be a PostgreSQL connection string (starts with postgres:// or postgresql://)";
+  }
+  return void 0;
+}
+function validateWhopAppId(id) {
+  if (id && !id.startsWith("app_")) {
+    return 'Whop App IDs start with "app_"';
+  }
+  return void 0;
+}
+
+// src/utils/cleanup.ts
+import { rmSync, existsSync as existsSync2 } from "fs";
+function cleanupDir(dir) {
+  if (existsSync2(dir)) {
+    try {
+      rmSync(dir, { recursive: true, force: true });
+    } catch {
+    }
+  }
+}
+
+// src/scaffolding/clone.ts
+import { existsSync as existsSync3, readFileSync as readFileSync2, writeFileSync, rmSync as rmSync2 } from "fs";
+import { join, basename } from "path";
+function cloneTemplate(repo, projectDir) {
+  const result = exec(
+    `git clone --depth 1 https://github.com/${repo}.git "${projectDir}"`
+  );
+  if (!result.success || !existsSync3(projectDir)) {
+    return false;
+  }
+  const gitDir = join(projectDir, ".git");
+  if (existsSync3(gitDir)) {
+    rmSync2(gitDir, { recursive: true, force: true });
+  }
+  return true;
+}
+function updatePackageName(projectDir, name) {
+  const pkgPath = join(projectDir, "package.json");
+  if (existsSync3(pkgPath)) {
+    const pkg = JSON.parse(readFileSync2(pkgPath, "utf-8"));
+    pkg.name = basename(name);
+    writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
+  }
+}
+function initGit(projectDir) {
+  exec("git init", projectDir);
+  exec("git add -A", projectDir);
+  exec('git commit -m "initial: scaffolded with create-whop-kit"', projectDir);
+}
+
+// src/scaffolding/env-file.ts
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync2, existsSync as existsSync4 } from "fs";
+import { join as join2 } from "path";
+function writeEnvFile(projectDir, values) {
+  const examplePath = join2(projectDir, ".env.example");
+  const envPath = join2(projectDir, ".env.local");
+  const filled = Object.fromEntries(
+    Object.entries(values).filter(([, v]) => v)
+  );
+  if (existsSync4(examplePath)) {
+    let content = readFileSync3(examplePath, "utf-8");
+    for (const [key, value] of Object.entries(filled)) {
+      const pattern = new RegExp(
+        `^(#\\s*)?${escapeRegex(key)}=.*$`,
+        "m"
+      );
+      if (pattern.test(content)) {
+        content = content.replace(pattern, `${key}="${value}"`);
+      }
+    }
+    writeFileSync2(envPath, content);
+  } else {
+    const lines = Object.entries(filled).map(
+      ([key, value]) => `${key}="${value}"`
+    );
+    writeFileSync2(envPath, lines.join("\n") + "\n");
+  }
+}
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// src/commands/init.ts
+function isCancelled(value) {
+  return p5.isCancel(value);
+}
+var init_default = defineCommand({
+  meta: {
+    name: "create-whop-kit",
+    version: "0.2.0",
+    description: "Scaffold a new Whop-powered app with whop-kit"
+  },
+  args: {
+    name: {
+      type: "positional",
+      description: "Project name",
+      required: false
+    },
+    framework: {
+      type: "string",
+      description: "Framework: nextjs, astro"
+    },
+    type: {
+      type: "string",
+      description: "App type: saas",
+      default: "saas"
+    },
+    db: {
+      type: "string",
+      description: "Database: neon, supabase, local, later"
+    },
+    "db-url": {
+      type: "string",
+      description: "Database connection URL"
+    },
+    "app-id": {
+      type: "string",
+      description: "Whop App ID"
+    },
+    "api-key": {
+      type: "string",
+      description: "Whop API Key"
+    },
+    "webhook-secret": {
+      type: "string",
+      description: "Whop webhook secret"
+    },
+    yes: {
+      type: "boolean",
+      alias: "y",
+      description: "Skip optional prompts, use defaults",
+      default: false
+    },
+    "dry-run": {
+      type: "boolean",
+      description: "Show what would be created without doing it",
+      default: false
+    },
+    verbose: {
+      type: "boolean",
+      description: "Show detailed output",
+      default: false
+    }
+  },
+  async run({ args }) {
+    checkNodeVersion(18);
+    checkGit();
+    console.log("");
+    p5.intro(`${pc5.bgCyan(pc5.black(" create-whop-kit "))} Create a Whop-powered app`);
+    const isNonInteractive = !!(args.framework && args.db);
+    let projectName = args.name;
+    if (!projectName) {
+      const result = await p5.text({
+        message: "Project name",
+        placeholder: "my-whop-app",
+        validate: (v) => {
+          if (!v) return "Project name is required";
+          if (existsSync5(resolve(v))) return `Directory "${v}" already exists`;
+        }
+      });
+      if (isCancelled(result)) {
+        p5.cancel("Cancelled.");
+        process.exit(0);
+      }
+      projectName = result;
+    } else if (existsSync5(resolve(projectName))) {
+      p5.log.error(`Directory "${projectName}" already exists`);
+      process.exit(1);
+    }
+    let appType = args.type;
+    if (!isNonInteractive && !args.yes) {
+      const result = await p5.select({
+        message: "What are you building?",
+        options: Object.entries(APP_TYPES).map(([value, t]) => ({
+          value,
+          label: t.available ? t.name : `${t.name} ${pc5.dim("(coming soon)")}`,
+          hint: t.description,
+          disabled: !t.available
+        }))
+      });
+      if (isCancelled(result)) {
+        p5.cancel("Cancelled.");
+        process.exit(0);
+      }
+      appType = result;
+    }
+    let framework = args.framework;
+    if (!framework) {
+      const result = await p5.select({
+        message: "Which framework?",
+        options: Object.entries(TEMPLATES).map(([value, t]) => ({
+          value,
+          label: t.available ? t.name : `${t.name} ${pc5.dim("(coming soon)")}`,
+          hint: t.description,
+          disabled: !t.available
+        }))
+      });
+      if (isCancelled(result)) {
+        p5.cancel("Cancelled.");
+        process.exit(0);
+      }
+      framework = result;
+    }
+    const template = TEMPLATES[framework];
+    if (!template || !template.available) {
+      p5.log.error(`Framework "${framework}" is not available. Options: ${Object.keys(TEMPLATES).filter((k) => TEMPLATES[k].available).join(", ")}`);
+      process.exit(1);
+    }
+    let database = args.db;
+    if (!database) {
+      const result = await p5.select({
+        message: "Which database?",
+        options: [
+          { value: "neon", label: "Neon", hint: "Serverless Postgres \u2014 auto-provisioned (recommended)" },
+          { value: "prisma-postgres", label: "Prisma Postgres", hint: "Instant database \u2014 no account needed" },
+          { value: "supabase", label: "Supabase", hint: "Open-source Firebase alternative" },
+          { value: "manual", label: "I have a connection string", hint: "Paste an existing PostgreSQL URL" },
+          { value: "later", label: "Configure later", hint: "Skip database setup for now" }
+        ]
+      });
+      if (isCancelled(result)) {
+        p5.cancel("Cancelled.");
+        process.exit(0);
+      }
+      database = result;
+    }
+    let dbUrl = args["db-url"] ?? "";
+    let dbNote = "";
+    if (database !== "later" && database !== "manual" && !dbUrl) {
+      const provider = DB_PROVIDERS[database];
+      if (provider) {
+        if (!provider.isInstalled()) {
+          const install = await p5.confirm({
+            message: `${provider.name} CLI not found. Install it now?`,
+            initialValue: true
+          });
+          if (isCancelled(install) || !install) {
+            p5.log.warning("Skipping database provisioning. You can configure it later.");
+            database = "later";
+          } else {
+            const installed = await provider.install();
+            if (!installed) {
+              p5.log.warning("Skipping database provisioning.");
+              database = "later";
+            }
+          }
+        }
+        if (database !== "later") {
+          const result = await provider.provision(projectName);
+          if (result) {
+            dbUrl = result.connectionString;
+            if (result.note) dbNote = result.note;
+            p5.log.success(`${pc5.bold(provider.name)} database ready`);
+          } else {
+            p5.log.warning("Database provisioning skipped. Configure manually later.");
+          }
+        }
+      }
+    } else if (database === "manual" && !dbUrl) {
+      const result = await p5.text({
+        message: "Database URL",
+        placeholder: "postgresql://user:pass@host:5432/dbname",
+        validate: (v) => {
+          if (!v) return "Required (choose 'Configure later' to skip)";
+          return validateDatabaseUrl(v);
+        }
+      });
+      if (isCancelled(result)) {
+        p5.cancel("Cancelled.");
+        process.exit(0);
+      }
+      dbUrl = result;
+    }
+    let appId = args["app-id"] ?? "";
+    let apiKey = args["api-key"] ?? "";
+    let webhookSecret = args["webhook-secret"] ?? "";
+    if (!isNonInteractive && !args.yes) {
+      const setupWhop = await p5.confirm({
+        message: "Configure Whop credentials now? (you can do this later via the setup wizard)",
+        initialValue: false
+      });
+      if (!isCancelled(setupWhop) && setupWhop) {
+        if (!appId) {
+          const result = await p5.text({
+            message: "Whop App ID",
+            placeholder: "app_xxxxxxxxx",
+            validate: (v) => v ? validateWhopAppId(v) : void 0
+          });
+          if (!isCancelled(result)) appId = result ?? "";
+        }
+        if (!apiKey) {
+          const result = await p5.text({
+            message: "Whop API Key",
+            placeholder: "apik_xxxxxxxxx (optional, press Enter to skip)"
+          });
+          if (!isCancelled(result)) apiKey = result ?? "";
+        }
+        if (!webhookSecret) {
+          const result = await p5.text({
+            message: "Whop Webhook Secret",
+            placeholder: "optional, press Enter to skip"
+          });
+          if (!isCancelled(result)) webhookSecret = result ?? "";
+        }
+      }
+    }
+    if (args["dry-run"]) {
+      p5.log.info(pc5.dim("Dry run \u2014 showing what would be created:\n"));
+      console.log(`  ${pc5.bold("Project:")}     ${projectName}`);
+      console.log(`  ${pc5.bold("Framework:")}   ${template.name}`);
+      console.log(`  ${pc5.bold("App type:")}    ${APP_TYPES[appType]?.name ?? appType}`);
+      console.log(`  ${pc5.bold("Database:")}    ${DB_OPTIONS[database]?.name ?? database}`);
+      console.log(`  ${pc5.bold("Template:")}    github.com/${template.repo}`);
+      if (dbUrl) console.log(`  ${pc5.bold("DB URL:")}      ${dbUrl.substring(0, 30)}...`);
+      if (appId) console.log(`  ${pc5.bold("Whop App:")}    ${appId}`);
+      console.log("");
+      p5.outro("No files were created.");
+      return;
+    }
+    const projectDir = resolve(projectName);
+    const s = p5.spinner();
+    s.start(`Cloning ${template.name} template...`);
+    const cloned = cloneTemplate(template.repo, projectDir);
+    if (!cloned) {
+      s.stop("Failed to clone template");
+      p5.log.error(`Could not clone github.com/${template.repo}. Check your internet connection.`);
+      cleanupDir(projectDir);
+      process.exit(1);
+    }
+    updatePackageName(projectDir, projectName);
+    s.stop(`${template.name} template cloned`);
+    const envVars = {};
+    if (dbUrl) envVars["DATABASE_URL"] = dbUrl;
+    if (framework === "nextjs") {
+      if (appId) envVars["NEXT_PUBLIC_WHOP_APP_ID"] = appId;
+    } else {
+      if (appId) envVars["WHOP_APP_ID"] = appId;
+    }
+    if (apiKey) envVars["WHOP_API_KEY"] = apiKey;
+    if (webhookSecret) envVars["WHOP_WEBHOOK_SECRET"] = webhookSecret;
+    if (Object.keys(envVars).length > 0) {
+      s.start("Configuring environment...");
+      writeEnvFile(projectDir, envVars);
+      s.stop("Environment configured");
+    }
+    createManifest(projectDir, {
+      framework,
+      appType,
+      database,
+      features: [],
+      templateVersion: "0.2.0"
+    });
+    const pm = detectPackageManager();
+    s.start(`Installing dependencies with ${pm}...`);
+    const installResult = exec(`${pm} install`, projectDir);
+    if (!installResult.success) {
+      s.stop(`${pm} install failed`);
+      p5.log.warning("Dependency installation failed. Run it manually after setup.");
+    } else {
+      s.stop("Dependencies installed");
+    }
+    initGit(projectDir);
+    const configured = [];
+    const missing = [];
+    if (dbUrl) configured.push("Database");
+    else missing.push("Database URL");
+    if (appId) configured.push("Whop App ID");
+    else missing.push("Whop App ID");
+    if (apiKey) configured.push("Whop API Key");
+    else missing.push("Whop API Key");
+    if (webhookSecret) configured.push("Webhook Secret");
+    else missing.push("Webhook Secret");
+    let summary = "";
+    if (configured.length > 0) {
+      summary += `${pc5.green("\u2713")} ${configured.join(", ")}
+`;
+    }
+    if (missing.length > 0) {
+      summary += `${pc5.yellow("\u25CB")} Missing: ${missing.join(", ")}
+`;
+      summary += `  ${pc5.dim("Configure via the setup wizard or .env.local")}
+`;
+    }
+    if (dbNote) {
+      summary += `${pc5.yellow("!")} ${dbNote}
+`;
+    }
+    summary += `
+`;
+    summary += `  ${pc5.bold("cd")} ${basename2(projectName)}
+`;
+    if (dbUrl) {
+      summary += `  ${pc5.bold(`${pm} run db:push`)}
+`;
+    }
+    summary += `  ${pc5.bold(`${pm} run dev`)}`;
+    p5.note(summary, "Your app is ready");
+    p5.outro(`${pc5.green("Happy building!")} ${pc5.dim("\u2014 whop-kit")}`);
+  }
+});
+
+// src/cli-create.ts
+runMain(init_default);