create-whop-kit 0.1.0 → 0.3.0

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.3.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);
-});