create-whop-kit 0.1.0 → 0.2.0

package/dist/chunk-M4AXERQP.js

@@ -0,0 +1,73 @@
+#!/usr/bin/env node
+
+// src/utils/exec.ts
+import { execSync } from "child_process";
+function exec(cmd, cwd) {
+  try {
+    const stdout = execSync(cmd, {
+      cwd,
+      stdio: "pipe",
+      encoding: "utf-8",
+      timeout: 12e4
+    }).trim();
+    return { stdout, success: true };
+  } catch {
+    return { stdout: "", success: false };
+  }
+}
+function hasCommand(cmd) {
+  return exec(`which ${cmd}`).success;
+}
+function detectPackageManager() {
+  if (hasCommand("pnpm")) return "pnpm";
+  if (hasCommand("yarn")) return "yarn";
+  if (hasCommand("bun")) return "bun";
+  return "npm";
+}
+
+// src/scaffolding/manifest.ts
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { join } from "path";
+var MANIFEST_DIR = ".whop";
+var MANIFEST_FILE = "config.json";
+function getManifestPath(projectDir) {
+  return join(projectDir, MANIFEST_DIR, MANIFEST_FILE);
+}
+function createManifest(projectDir, data) {
+  const dir = join(projectDir, MANIFEST_DIR);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  const manifest = {
+    version: 1,
+    ...data,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  writeFileSync(getManifestPath(projectDir), JSON.stringify(manifest, null, 2) + "\n");
+}
+function readManifest(projectDir) {
+  const path = getManifestPath(projectDir);
+  if (!existsSync(path)) return null;
+  try {
+    return JSON.parse(readFileSync(path, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function addFeatureToManifest(projectDir, feature) {
+  const manifest = readManifest(projectDir);
+  if (!manifest) return;
+  if (!manifest.features.includes(feature)) {
+    manifest.features.push(feature);
+  }
+  writeFileSync(getManifestPath(projectDir), JSON.stringify(manifest, null, 2) + "\n");
+}
+
+export {
+  exec,
+  hasCommand,
+  detectPackageManager,
+  createManifest,
+  readManifest,
+  addFeatureToManifest
+};

package/dist/cli-create.js

@@ -0,0 +1,480 @@
+#!/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 existsSync4 } from "fs";
+import * as p2 from "@clack/prompts";
+import pc2 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/utils/checks.ts
+import * as p from "@clack/prompts";
+import pc from "picocolors";
+function checkNodeVersion(minimum = 18) {
+  const major = parseInt(process.versions.node.split(".")[0], 10);
+  if (major < minimum) {
+    p.log.error(
+      `Node.js ${pc.bold(`v${minimum}+`)} is required. You have ${pc.bold(`v${process.versions.node}`)}.`
+    );
+    process.exit(1);
+  }
+}
+function checkGit() {
+  if (!hasCommand("git")) {
+    p.log.error(
+      `${pc.bold("git")} is required but not found. Install it from ${pc.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 } from "fs";
+function cleanupDir(dir) {
+  if (existsSync(dir)) {
+    try {
+      rmSync(dir, { recursive: true, force: true });
+    } catch {
+    }
+  }
+}
+
+// src/scaffolding/clone.ts
+import { existsSync as existsSync2, readFileSync, 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 || !existsSync2(projectDir)) {
+    return false;
+  }
+  const gitDir = join(projectDir, ".git");
+  if (existsSync2(gitDir)) {
+    rmSync2(gitDir, { recursive: true, force: true });
+  }
+  return true;
+}
+function updatePackageName(projectDir, name) {
+  const pkgPath = join(projectDir, "package.json");
+  if (existsSync2(pkgPath)) {
+    const pkg = JSON.parse(readFileSync(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 readFileSync2, writeFileSync as writeFileSync2, existsSync as existsSync3 } 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 (existsSync3(examplePath)) {
+    let content = readFileSync2(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 p2.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("");
+    p2.intro(`${pc2.bgCyan(pc2.black(" create-whop-kit "))} Create a Whop-powered app`);
+    const isNonInteractive = !!(args.framework && args.db);
+    let projectName = args.name;
+    if (!projectName) {
+      const result = await p2.text({
+        message: "Project name",
+        placeholder: "my-whop-app",
+        validate: (v) => {
+          if (!v) return "Project name is required";
+          if (existsSync4(resolve(v))) return `Directory "${v}" already exists`;
+        }
+      });
+      if (isCancelled(result)) {
+        p2.cancel("Cancelled.");
+        process.exit(0);
+      }
+      projectName = result;
+    } else if (existsSync4(resolve(projectName))) {
+      p2.log.error(`Directory "${projectName}" already exists`);
+      process.exit(1);
+    }
+    let appType = args.type;
+    if (!isNonInteractive && !args.yes) {
+      const result = await p2.select({
+        message: "What are you building?",
+        options: Object.entries(APP_TYPES).map(([value, t]) => ({
+          value,
+          label: t.available ? t.name : `${t.name} ${pc2.dim("(coming soon)")}`,
+          hint: t.description,
+          disabled: !t.available
+        }))
+      });
+      if (isCancelled(result)) {
+        p2.cancel("Cancelled.");
+        process.exit(0);
+      }
+      appType = result;
+    }
+    let framework = args.framework;
+    if (!framework) {
+      const result = await p2.select({
+        message: "Which framework?",
+        options: Object.entries(TEMPLATES).map(([value, t]) => ({
+          value,
+          label: t.available ? t.name : `${t.name} ${pc2.dim("(coming soon)")}`,
+          hint: t.description,
+          disabled: !t.available
+        }))
+      });
+      if (isCancelled(result)) {
+        p2.cancel("Cancelled.");
+        process.exit(0);
+      }
+      framework = result;
+    }
+    const template = TEMPLATES[framework];
+    if (!template || !template.available) {
+      p2.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 p2.select({
+        message: "Which database?",
+        options: Object.entries(DB_OPTIONS).map(([value, d]) => ({
+          value,
+          label: d.name,
+          hint: d.description
+        }))
+      });
+      if (isCancelled(result)) {
+        p2.cancel("Cancelled.");
+        process.exit(0);
+      }
+      database = result;
+    }
+    let dbUrl = args["db-url"] ?? "";
+    if (database !== "later" && !dbUrl) {
+      const result = await p2.text({
+        message: "Database URL",
+        placeholder: DB_OPTIONS[database]?.envVarHint ?? "postgresql://...",
+        validate: (v) => {
+          if (!v) return "Required (choose 'Configure later' to skip)";
+          return validateDatabaseUrl(v);
+        }
+      });
+      if (isCancelled(result)) {
+        p2.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 p2.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 p2.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 p2.text({
+            message: "Whop API Key",
+            placeholder: "apik_xxxxxxxxx (optional, press Enter to skip)"
+          });
+          if (!isCancelled(result)) apiKey = result ?? "";
+        }
+        if (!webhookSecret) {
+          const result = await p2.text({
+            message: "Whop Webhook Secret",
+            placeholder: "optional, press Enter to skip"
+          });
+          if (!isCancelled(result)) webhookSecret = result ?? "";
+        }
+      }
+    }
+    if (args["dry-run"]) {
+      p2.log.info(pc2.dim("Dry run \u2014 showing what would be created:\n"));
+      console.log(`  ${pc2.bold("Project:")}     ${projectName}`);
+      console.log(`  ${pc2.bold("Framework:")}   ${template.name}`);
+      console.log(`  ${pc2.bold("App type:")}    ${APP_TYPES[appType]?.name ?? appType}`);
+      console.log(`  ${pc2.bold("Database:")}    ${DB_OPTIONS[database]?.name ?? database}`);
+      console.log(`  ${pc2.bold("Template:")}    github.com/${template.repo}`);
+      if (dbUrl) console.log(`  ${pc2.bold("DB URL:")}      ${dbUrl.substring(0, 30)}...`);
+      if (appId) console.log(`  ${pc2.bold("Whop App:")}    ${appId}`);
+      console.log("");
+      p2.outro("No files were created.");
+      return;
+    }
+    const projectDir = resolve(projectName);
+    const s = p2.spinner();
+    s.start(`Cloning ${template.name} template...`);
+    const cloned = cloneTemplate(template.repo, projectDir);
+    if (!cloned) {
+      s.stop("Failed to clone template");
+      p2.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`);
+      p2.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 += `${pc2.green("\u2713")} ${configured.join(", ")}
+`;
+    }
+    if (missing.length > 0) {
+      summary += `${pc2.yellow("\u25CB")} Missing: ${missing.join(", ")}
+`;
+      summary += `  ${pc2.dim("Configure via the setup wizard or .env.local")}
+`;
+    }
+    summary += `
+`;
+    summary += `  ${pc2.bold("cd")} ${basename2(projectName)}
+`;
+    if (dbUrl) {
+      summary += `  ${pc2.bold(`${pm} run db:push`)}
+`;
+    }
+    summary += `  ${pc2.bold(`${pm} run dev`)}`;
+    p2.note(summary, "Your app is ready");
+    p2.outro(`${pc2.green("Happy building!")} ${pc2.dim("\u2014 whop-kit")}`);
+  }
+});
+
+// src/cli-create.ts
+runMain(init_default);

package/dist/cli-kit.js

@@ -0,0 +1,413 @@
+#!/usr/bin/env node
+import {
+  addFeatureToManifest,
+  detectPackageManager,
+  exec,
+  readManifest
+} from "./chunk-M4AXERQP.js";
+
+// src/cli-kit.ts
+import { defineCommand as defineCommand5, runMain } from "citty";
+
+// src/commands/add.ts
+import * as p4 from "@clack/prompts";
+import pc2 from "picocolors";
+import { defineCommand } from "citty";
+
+// src/features/email.ts
+import * as p from "@clack/prompts";
+
+// src/features/helpers.ts
+import { readFileSync, writeFileSync, existsSync } from "fs";
+import { join } from "path";
+function appendEnvVar(projectDir, key, value) {
+  const envPath = join(projectDir, ".env.local");
+  if (!existsSync(envPath)) {
+    writeFileSync(envPath, `${key}="${value}"
+`);
+    return;
+  }
+  let content = readFileSync(envPath, "utf-8");
+  const pattern = new RegExp(`^(#\\s*)?${key}=.*$`, "m");
+  if (pattern.test(content)) {
+    content = content.replace(pattern, `${key}="${value}"`);
+  } else {
+    content = content.trimEnd() + `
+${key}="${value}"
+`;
+  }
+  writeFileSync(envPath, content);
+}
+
+// src/features/email.ts
+var emailFeature = {
+  name: "Email",
+  description: "Transactional email via Resend or SendGrid",
+  configKey: "email",
+  async run(projectDir) {
+    const provider = await p.select({
+      message: "Email provider",
+      options: [
+        { value: "resend", label: "Resend", hint: "Modern email API" },
+        { value: "sendgrid", label: "SendGrid", hint: "Established platform" }
+      ]
+    });
+    if (p.isCancel(provider)) {
+      p.cancel("Cancelled.");
+      process.exit(0);
+    }
+    const apiKey = await p.text({
+      message: `${provider === "resend" ? "Resend" : "SendGrid"} API key`,
+      placeholder: provider === "resend" ? "re_xxxxxxxxx" : "SG.xxxxxxxxx",
+      validate: (v) => !v ? "API key is required" : void 0
+    });
+    if (p.isCancel(apiKey)) {
+      p.cancel("Cancelled.");
+      process.exit(0);
+    }
+    const fromAddress = await p.text({
+      message: "From email address",
+      placeholder: "noreply@yourdomain.com"
+    });
+    if (p.isCancel(fromAddress)) {
+      p.cancel("Cancelled.");
+      process.exit(0);
+    }
+    appendEnvVar(projectDir, "EMAIL_PROVIDER", provider);
+    appendEnvVar(projectDir, "EMAIL_API_KEY", apiKey);
+    if (fromAddress) {
+      appendEnvVar(projectDir, "EMAIL_FROM_ADDRESS", fromAddress);
+    }
+  }
+};
+
+// src/features/analytics.ts
+import * as p2 from "@clack/prompts";
+var analyticsFeature = {
+  name: "Analytics",
+  description: "Product analytics via PostHog, Google Analytics, or Plausible",
+  configKey: "analytics",
+  async run(projectDir) {
+    const provider = await p2.select({
+      message: "Analytics provider",
+      options: [
+        { value: "posthog", label: "PostHog", hint: "Open-source product analytics" },
+        { value: "google", label: "Google Analytics", hint: "GA4" },
+        { value: "plausible", label: "Plausible", hint: "Privacy-friendly analytics" }
+      ]
+    });
+    if (p2.isCancel(provider)) {
+      p2.cancel("Cancelled.");
+      process.exit(0);
+    }
+    const placeholders = {
+      posthog: "phc_xxxxxxxxx",
+      google: "G-XXXXXXXXXX",
+      plausible: "yourdomain.com"
+    };
+    const id = await p2.text({
+      message: `${provider === "google" ? "Measurement" : provider === "posthog" ? "Project API" : "Site"} ID`,
+      placeholder: placeholders[provider] ?? "",
+      validate: (v) => !v ? "ID is required" : void 0
+    });
+    if (p2.isCancel(id)) {
+      p2.cancel("Cancelled.");
+      process.exit(0);
+    }
+    appendEnvVar(projectDir, "ANALYTICS_PROVIDER", provider);
+    appendEnvVar(projectDir, "ANALYTICS_ID", id);
+  }
+};
+
+// src/features/webhook-event.ts
+import * as p3 from "@clack/prompts";
+import pc from "picocolors";
+var webhookEventFeature = {
+  name: "Webhook Event",
+  description: "Add a new webhook event handler",
+  configKey: "webhook-event",
+  async run() {
+    const eventName = await p3.text({
+      message: "Event name",
+      placeholder: "payment_succeeded",
+      validate: (v) => !v ? "Event name is required" : void 0
+    });
+    if (p3.isCancel(eventName)) {
+      p3.cancel("Cancelled.");
+      process.exit(0);
+    }
+    const code = `
+    ${eventName}: async (data) => {
+      const userId = data.user_id as string | undefined;
+      if (!userId) return;
+      // TODO: Handle ${eventName}
+      console.log(\`[Webhook] ${eventName} for \${userId}\`);
+    },`;
+    p3.note(
+      `Add this to the ${pc.bold("on")} object in your webhook route:
+
+${pc.cyan(code)}`,
+      "Add to your webhook handler"
+    );
+    p3.log.info(
+      `File: ${pc.dim("app/api/webhooks/whop/route.ts")} (Next.js) or ${pc.dim("src/pages/api/webhooks/whop.ts")} (Astro)`
+    );
+  }
+};
+
+// src/commands/add.ts
+var FEATURES = {
+  email: emailFeature,
+  analytics: analyticsFeature,
+  "webhook-event": webhookEventFeature
+};
+var add_default = defineCommand({
+  meta: {
+    name: "add",
+    description: "Add a feature to your Whop project"
+  },
+  args: {
+    feature: {
+      type: "positional",
+      description: `Feature to add: ${Object.keys(FEATURES).join(", ")}`,
+      required: false
+    }
+  },
+  async run({ args }) {
+    console.log("");
+    p4.intro(`${pc2.bgCyan(pc2.black(" whop-kit add "))} Add a feature`);
+    const manifest = readManifest(".");
+    if (!manifest) {
+      p4.log.error(
+        "No .whop/config.json found. Run this command from a project created with create-whop-kit."
+      );
+      process.exit(1);
+    }
+    let featureKey = args.feature;
+    if (!featureKey) {
+      const result = await p4.select({
+        message: "What would you like to add?",
+        options: Object.entries(FEATURES).map(([value, f]) => {
+          const installed = manifest.features.includes(f.configKey);
+          return {
+            value,
+            label: installed ? `${f.name} ${pc2.green("\u2713 configured")}` : f.name,
+            hint: f.description
+          };
+        })
+      });
+      if (p4.isCancel(result)) {
+        p4.cancel("Cancelled.");
+        process.exit(0);
+      }
+      featureKey = result;
+    }
+    const feature = FEATURES[featureKey];
+    if (!feature) {
+      p4.log.error(
+        `Unknown feature "${featureKey}". Available: ${Object.keys(FEATURES).join(", ")}`
+      );
+      process.exit(1);
+    }
+    if (manifest.features.includes(feature.configKey)) {
+      const proceed = await p4.confirm({
+        message: `${feature.name} is already configured. Reconfigure?`,
+        initialValue: false
+      });
+      if (p4.isCancel(proceed) || !proceed) {
+        p4.cancel("Cancelled.");
+        process.exit(0);
+      }
+    }
+    await feature.run(".");
+    addFeatureToManifest(".", feature.configKey);
+    p4.outro(`${pc2.green("\u2713")} ${feature.name} configured`);
+  }
+});
+
+// src/commands/status.ts
+import { readFileSync as readFileSync2, existsSync as existsSync2 } from "fs";
+import { join as join2 } from "path";
+import * as p5 from "@clack/prompts";
+import pc3 from "picocolors";
+import { defineCommand as defineCommand2 } from "citty";
+var ENV_CHECKS = [
+  { key: "DATABASE_URL", label: "Database", required: true },
+  { key: "NEXT_PUBLIC_WHOP_APP_ID", label: "Whop App ID", required: true },
+  { key: "WHOP_API_KEY", label: "Whop API Key", required: true },
+  { key: "WHOP_WEBHOOK_SECRET", label: "Webhook Secret", required: true },
+  { key: "EMAIL_PROVIDER", label: "Email Provider", required: false },
+  { key: "EMAIL_API_KEY", label: "Email API Key", required: false },
+  { key: "ANALYTICS_PROVIDER", label: "Analytics Provider", required: false },
+  { key: "ANALYTICS_ID", label: "Analytics ID", required: false }
+];
+function readEnvFile(projectDir) {
+  const envPath = join2(projectDir, ".env.local");
+  if (!existsSync2(envPath)) return {};
+  const content = readFileSync2(envPath, "utf-8");
+  const vars = {};
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const match = trimmed.match(/^([A-Z_][A-Z0-9_]*)=["']?(.*)["']?$/);
+    if (match) {
+      vars[match[1]] = match[2].replace(/["']$/, "");
+    }
+  }
+  return vars;
+}
+var status_default = defineCommand2({
+  meta: {
+    name: "status",
+    description: "Show your project's configuration status"
+  },
+  async run() {
+    console.log("");
+    p5.intro(`${pc3.bgCyan(pc3.black(" whop-kit status "))} Project health`);
+    const manifest = readManifest(".");
+    if (!manifest) {
+      p5.log.error(
+        "No .whop/config.json found. Are you in a project created with create-whop-kit?"
+      );
+      process.exit(1);
+    }
+    const envVars = readEnvFile(".");
+    if (!envVars["NEXT_PUBLIC_WHOP_APP_ID"] && envVars["WHOP_APP_ID"]) {
+      envVars["NEXT_PUBLIC_WHOP_APP_ID"] = envVars["WHOP_APP_ID"];
+    }
+    console.log(`  ${pc3.bold("Framework:")}  ${manifest.framework}`);
+    console.log(`  ${pc3.bold("App type:")}   ${manifest.appType}`);
+    console.log(`  ${pc3.bold("Database:")}   ${manifest.database}`);
+    console.log(`  ${pc3.bold("Created:")}    ${new Date(manifest.createdAt).toLocaleDateString()}`);
+    console.log("");
+    console.log(`  ${pc3.bold("Configuration:")}`);
+    let allRequired = true;
+    for (const check of ENV_CHECKS) {
+      const value = envVars[check.key];
+      const isSet = !!value;
+      if (check.required && !isSet) allRequired = false;
+      const icon = isSet ? pc3.green("\u2713") : check.required ? pc3.red("\u2717") : pc3.yellow("\u25CB");
+      const maskedValue = isSet ? pc3.dim(value.substring(0, 8) + "...") : check.required ? pc3.red("not set") : pc3.dim("not set (optional)");
+      console.log(`    ${icon} ${check.label.padEnd(20)} ${maskedValue}`);
+    }
+    console.log("");
+    if (manifest.features.length > 0) {
+      console.log(`  ${pc3.bold("Features:")} ${manifest.features.join(", ")}`);
+    }
+    if (allRequired) {
+      p5.outro(pc3.green("All required configuration is set. Ready to run!"));
+    } else {
+      p5.outro(
+        `${pc3.yellow("Some required config is missing.")} Run ${pc3.bold("whop-kit add")} or edit ${pc3.dim(".env.local")}`
+      );
+    }
+  }
+});
+
+// src/commands/open.ts
+import * as p6 from "@clack/prompts";
+import pc4 from "picocolors";
+import { defineCommand as defineCommand3 } from "citty";
+var DASHBOARDS = {
+  whop: { name: "Whop Developer Dashboard", url: "https://whop.com/dashboard/developer" },
+  neon: { name: "Neon Console", url: "https://console.neon.tech" },
+  supabase: { name: "Supabase Dashboard", url: "https://supabase.com/dashboard" },
+  vercel: { name: "Vercel Dashboard", url: "https://vercel.com/dashboard" }
+};
+function openUrl(url) {
+  const platform = process.platform;
+  if (platform === "darwin") exec(`open "${url}"`);
+  else if (platform === "win32") exec(`start "${url}"`);
+  else exec(`xdg-open "${url}"`);
+}
+var open_default = defineCommand3({
+  meta: {
+    name: "open",
+    description: "Open a provider dashboard in your browser"
+  },
+  args: {
+    target: {
+      type: "positional",
+      description: `Dashboard to open: ${Object.keys(DASHBOARDS).join(", ")}`,
+      required: false
+    }
+  },
+  async run({ args }) {
+    let target = args.target;
+    if (!target) {
+      const result = await p6.select({
+        message: "Which dashboard?",
+        options: Object.entries(DASHBOARDS).map(([value, d]) => ({
+          value,
+          label: d.name,
+          hint: d.url
+        }))
+      });
+      if (p6.isCancel(result)) {
+        p6.cancel("Cancelled.");
+        process.exit(0);
+      }
+      target = result;
+    }
+    const dashboard = DASHBOARDS[target];
+    if (!dashboard) {
+      p6.log.error(`Unknown dashboard "${target}". Options: ${Object.keys(DASHBOARDS).join(", ")}`);
+      process.exit(1);
+    }
+    openUrl(dashboard.url);
+    console.log(`
+  Opening ${pc4.bold(dashboard.name)} \u2192 ${pc4.cyan(dashboard.url)}
+`);
+  }
+});
+
+// src/commands/upgrade.ts
+import * as p7 from "@clack/prompts";
+import pc5 from "picocolors";
+import { defineCommand as defineCommand4 } from "citty";
+var upgrade_default = defineCommand4({
+  meta: {
+    name: "upgrade",
+    description: "Update whop-kit to the latest version in your project"
+  },
+  async run() {
+    console.log("");
+    p7.intro(`${pc5.bgCyan(pc5.black(" whop-kit upgrade "))}`);
+    const manifest = readManifest(".");
+    if (!manifest) {
+      p7.log.error("No .whop/config.json found. Are you in a whop-kit project?");
+      process.exit(1);
+    }
+    const pm = detectPackageManager();
+    const s = p7.spinner();
+    s.start("Checking for updates...");
+    const latest = exec("npm view whop-kit version");
+    s.stop(latest.success ? `Latest: whop-kit@${latest.stdout}` : "Could not check latest version");
+    s.start(`Upgrading whop-kit with ${pm}...`);
+    const cmd = pm === "npm" ? "npm install whop-kit@latest" : pm === "yarn" ? "yarn add whop-kit@latest" : pm === "bun" ? "bun add whop-kit@latest" : "pnpm add whop-kit@latest";
+    const result = exec(cmd);
+    if (result.success) {
+      s.stop(pc5.green("whop-kit upgraded"));
+    } else {
+      s.stop(pc5.red("Upgrade failed"));
+      p7.log.error("Try running manually: " + pc5.bold(cmd));
+    }
+    p7.outro("Done");
+  }
+});
+
+// src/cli-kit.ts
+var main = defineCommand5({
+  meta: {
+    name: "whop-kit",
+    version: "0.2.0",
+    description: "Manage your Whop project"
+  },
+  subCommands: {
+    add: add_default,
+    status: status_default,
+    open: open_default,
+    upgrade: upgrade_default
+  }
+});
+runMain(main);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "create-whop-kit",
-  "version": "0.1.0",
-  "description": "Scaffold a new Whop-powered app with whop-kit",
+  "version": "0.2.0",
+  "description": "Scaffold and manage Whop-powered apps with whop-kit",
   "type": "module",
   "license": "MIT",
   "author": "Colin McDermott",
@@ -10,22 +10,22 @@
     "url": "https://github.com/colinmcdermott/create-whop-kit"
   },
   "bin": {
-    "create-whop-kit": "./dist/index.js"
+    "create-whop-kit": "./dist/cli-create.js",
+    "whop-kit": "./dist/cli-kit.js"
   },
   "files": [
     "dist",
-    "templates",
-    "README.md",
-    "LICENSE"
+    "README.md"
   ],
   "scripts": {
     "build": "tsup",
     "dev": "tsup --watch",
-    "start": "node dist/index.js",
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "@clack/prompts": "^0.10.0"
+    "@clack/prompts": "^0.10.0",
+    "citty": "^0.2.2",
+    "picocolors": "^1.1.1"
   },
   "devDependencies": {
     "tsup": "^8.4.0",

package/dist/index.js

@@ -1,209 +0,0 @@
-#!/usr/bin/env node
-
-// src/index.ts
-import * as p from "@clack/prompts";
-import { execSync } from "child_process";
-import { existsSync, readFileSync, writeFileSync } from "fs";
-import { resolve, join, basename } from "path";
-import { fileURLToPath } from "url";
-var __dirname = fileURLToPath(new URL(".", import.meta.url));
-var TEMPLATES_DIR = resolve(__dirname, "..", "templates");
-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: "",
-    available: false
-  },
-  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: ""
-  }
-};
-function run(cmd, cwd) {
-  try {
-    return execSync(cmd, { cwd, stdio: "pipe", encoding: "utf-8" }).trim();
-  } catch {
-    return "";
-  }
-}
-function hasCommand(cmd) {
-  return run(`which ${cmd}`) !== "";
-}
-async function main() {
-  const args = process.argv.slice(2);
-  const projectName = args[0];
-  console.log("");
-  p.intro("Create Whop Kit App");
-  const name = projectName ?? await p.text({
-    message: "Project name",
-    placeholder: "my-whop-app",
-    validate: (v) => {
-      if (!v) return "Project name is required";
-      if (existsSync(resolve(v))) return `Directory "${v}" already exists`;
-    }
-  });
-  if (p.isCancel(name)) {
-    p.cancel("Cancelled.");
-    process.exit(0);
-  }
-  const appType = await p.select({
-    message: "What are you building?",
-    options: Object.entries(APP_TYPES).map(([value, { name: name2, description, available }]) => ({
-      value,
-      label: available ? name2 : `${name2} (coming soon)`,
-      hint: description,
-      disabled: !available
-    }))
-  });
-  if (p.isCancel(appType)) {
-    p.cancel("Cancelled.");
-    process.exit(0);
-  }
-  const framework = await p.select({
-    message: "Which framework?",
-    options: Object.entries(TEMPLATES).map(([value, { name: name2, description, available }]) => ({
-      value,
-      label: available ? name2 : `${name2} (coming soon)`,
-      hint: description,
-      disabled: !available
-    }))
-  });
-  if (p.isCancel(framework)) {
-    p.cancel("Cancelled.");
-    process.exit(0);
-  }
-  const database = await p.select({
-    message: "Which database?",
-    options: Object.entries(DB_OPTIONS).map(([value, { name: name2, description }]) => ({
-      value,
-      label: name2,
-      hint: description
-    }))
-  });
-  if (p.isCancel(database)) {
-    p.cancel("Cancelled.");
-    process.exit(0);
-  }
-  let databaseUrl = "";
-  if (database !== "later") {
-    const dbUrl = await p.text({
-      message: "Database URL",
-      placeholder: DB_OPTIONS[database].envVarHint,
-      validate: (v) => {
-        if (!v) return "Database URL is required (or go back and choose 'Configure later')";
-      }
-    });
-    if (p.isCancel(dbUrl)) {
-      p.cancel("Cancelled.");
-      process.exit(0);
-    }
-    databaseUrl = dbUrl;
-  }
-  const template = TEMPLATES[framework];
-  const projectDir = resolve(name);
-  const s = p.spinner();
-  s.start("Cloning template...");
-  const cloneResult = run(
-    `git clone --depth 1 https://github.com/${template.repo}.git "${projectDir}" 2>&1`
-  );
-  if (!existsSync(projectDir)) {
-    s.stop("Failed to clone template");
-    p.log.error(cloneResult || "Git clone failed. Make sure git is installed.");
-    process.exit(1);
-  }
-  run(`rm -rf "${join(projectDir, ".git")}"`);
-  const pkgPath = join(projectDir, "package.json");
-  if (existsSync(pkgPath)) {
-    const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
-    pkg.name = basename(name);
-    writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
-  }
-  s.stop("Template cloned");
-  if (databaseUrl) {
-    s.start("Configuring environment...");
-    const envContent = `DATABASE_URL="${databaseUrl}"
-`;
-    writeFileSync(join(projectDir, ".env.local"), envContent);
-    s.stop("Environment configured");
-  }
-  const packageManager = hasCommand("pnpm") ? "pnpm" : hasCommand("yarn") ? "yarn" : "npm";
-  s.start(`Installing dependencies with ${packageManager}...`);
-  run(`${packageManager} install`, projectDir);
-  s.stop("Dependencies installed");
-  run("git init", projectDir);
-  run("git add -A", projectDir);
-  run('git commit -m "initial: scaffolded with create-whop-kit"', projectDir);
-  const relativePath = name;
-  p.note(
-    [
-      `cd ${relativePath}`,
-      databaseUrl ? `${packageManager} run db:push` : `# Add DATABASE_URL to .env.local first`,
-      `${packageManager} run dev`
-    ].join("\n"),
-    "Next steps"
-  );
-  p.outro("Happy building!");
-}
-main().catch((err) => {
-  console.error(err);
-  process.exit(1);
-});