create-whop-kit 0.5.1 → 0.6.1

package/dist/chunk-42L7PRMT.js

@@ -0,0 +1,62 @@
+#!/usr/bin/env node
+
+// src/utils/exec.ts
+import { execSync } from "child_process";
+function exec(cmd, cwd, timeoutMs = 12e4) {
+  try {
+    const stdout = execSync(cmd, {
+      cwd,
+      stdio: "pipe",
+      encoding: "utf-8",
+      timeout: timeoutMs
+    }).trim();
+    return { stdout, stderr: "", success: true };
+  } catch (err) {
+    const e = err;
+    return {
+      stdout: e.stdout?.toString?.().trim() ?? "",
+      stderr: e.stderr?.toString?.().trim() ?? "",
+      success: false
+    };
+  }
+}
+function execInteractive(cmd, cwd) {
+  try {
+    execSync(cmd, { cwd, stdio: "inherit", timeout: 3e5 });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function execWithStdin(cmd, input, cwd) {
+  try {
+    const stdout = execSync(cmd, {
+      cwd,
+      input,
+      stdio: ["pipe", "pipe", "pipe"],
+      encoding: "utf-8",
+      timeout: 12e4
+    }).trim();
+    return { stdout, stderr: "", success: true };
+  } catch (err) {
+    const e = err;
+    return { stdout: "", stderr: e.stderr?.toString?.().trim() ?? "", 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";
+}
+
+export {
+  exec,
+  execInteractive,
+  execWithStdin,
+  hasCommand,
+  detectPackageManager
+};

package/dist/{chunk-BR467LBM.js → chunk-HOQ5QQ2M.js}

@@ -1,4 +1,7 @@
 #!/usr/bin/env node
+import {
+  exec
+} from "./chunk-42L7PRMT.js";
 
 // src/templates.ts
 var FRAMEWORKS = {
@@ -69,39 +72,6 @@ var APP_TYPES = {
   }
 };
 
-// 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 execInteractive(cmd, cwd) {
-  try {
-    execSync(cmd, { cwd, stdio: "inherit", timeout: 3e5 });
-    return true;
-  } catch {
-    return 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";
@@ -357,10 +327,6 @@ export {
   TEMPLATES,
   getTemplate,
   APP_TYPES,
-  exec,
-  execInteractive,
-  hasCommand,
-  detectPackageManager,
   createManifest,
   readManifest,
   addFeatureToManifest,

package/dist/chunk-NRG6LIOM.js

@@ -0,0 +1,327 @@
+#!/usr/bin/env node
+import {
+  exec,
+  execInteractive,
+  execWithStdin,
+  hasCommand
+} from "./chunk-42L7PRMT.js";
+
+// src/deploy/index.ts
+import * as p2 from "@clack/prompts";
+import pc2 from "picocolors";
+
+// src/deploy/vercel.ts
+import * as p from "@clack/prompts";
+import pc from "picocolors";
+function isVercelInstalled() {
+  return hasCommand("vercel");
+}
+async function installVercel() {
+  const s = p.spinner();
+  s.start("Installing Vercel CLI...");
+  const result = exec("npm install -g vercel");
+  if (result.success) {
+    s.stop("Vercel CLI installed");
+    return true;
+  }
+  s.stop("Failed to install Vercel CLI");
+  p.log.error(`Install manually: ${pc.bold("npm install -g vercel")}`);
+  return false;
+}
+function isVercelAuthenticated() {
+  const result = exec("vercel whoami");
+  return result.success;
+}
+async function vercelLogin() {
+  p.log.step("Vercel: authenticating (opening browser)...");
+  console.log("");
+  const ok = execInteractive("vercel login");
+  console.log("");
+  return ok;
+}
+async function vercelDeploy(projectDir) {
+  p.log.step("Vercel: deploying to production (this may take a few minutes)...");
+  console.log("");
+  const ok = execInteractive("vercel deploy --prod --yes", projectDir);
+  console.log("");
+  if (!ok) {
+    p.log.error("Vercel deployment failed. Check the output above for details.");
+    return null;
+  }
+  const inspect = exec("vercel inspect --json", projectDir);
+  if (inspect.success) {
+    try {
+      const data = JSON.parse(inspect.stdout);
+      if (data.url) {
+        const url = data.url.startsWith("https://") ? data.url : `https://${data.url}`;
+        p.log.success(`Deployed to ${pc.cyan(url)}`);
+        return url;
+      }
+    } catch {
+    }
+  }
+  const ls = exec("vercel ls --json 2>/dev/null | head -1", projectDir);
+  if (ls.success) {
+    const urlMatch = ls.stdout.match(/https:\/\/[^\s"]+\.vercel\.app/);
+    if (urlMatch) {
+      p.log.success(`Deployed to ${pc.cyan(urlMatch[0])}`);
+      return urlMatch[0];
+    }
+  }
+  p.log.warning("Could not determine deployment URL automatically.");
+  const manual = await p.text({
+    message: "Paste your Vercel deployment URL",
+    placeholder: "https://your-app.vercel.app",
+    validate: (v) => {
+      if (!v?.startsWith("https://")) return "Must be a https:// URL";
+    }
+  });
+  if (p.isCancel(manual)) return null;
+  return manual;
+}
+function vercelEnvSet(key, value, environment = "production", projectDir) {
+  const result = execWithStdin(
+    `vercel env add ${key} ${environment} --force`,
+    value,
+    projectDir
+  );
+  return result.success;
+}
+function vercelEnvSetBatch(vars, projectDir) {
+  const success = [];
+  const failed = [];
+  for (const [key, value] of Object.entries(vars)) {
+    if (!value) continue;
+    const ok = vercelEnvSet(key, value, "production", projectDir) && vercelEnvSet(key, value, "preview", projectDir) && vercelEnvSet(key, value, "development", projectDir);
+    if (ok) success.push(key);
+    else failed.push(key);
+  }
+  return { success, failed };
+}
+
+// src/deploy/whop-api.ts
+var WHOP_API = "https://api.whop.com/api/v1";
+function headers(apiKey) {
+  return {
+    Authorization: `Bearer ${apiKey}`,
+    "Content-Type": "application/json"
+  };
+}
+async function validateApiKey(apiKey) {
+  try {
+    const res = await fetch(`${WHOP_API}/apps`, {
+      headers: headers(apiKey)
+    });
+    return res.ok;
+  } catch {
+    return false;
+  }
+}
+async function createWhopApp(apiKey, name, redirectUris) {
+  try {
+    const res = await fetch(`${WHOP_API}/apps`, {
+      method: "POST",
+      headers: headers(apiKey),
+      body: JSON.stringify({
+        name,
+        redirect_uris: redirectUris
+      })
+    });
+    if (!res.ok) {
+      const err = await res.text().catch(() => "");
+      console.error(`[Whop API] Create app failed (${res.status}): ${err}`);
+      return null;
+    }
+    const data = await res.json();
+    return {
+      id: data.id,
+      client_secret: data.client_secret
+    };
+  } catch (err) {
+    console.error("[Whop API] Create app error:", err);
+    return null;
+  }
+}
+async function createWhopWebhook(apiKey, url, events) {
+  try {
+    const res = await fetch(`${WHOP_API}/webhooks`, {
+      method: "POST",
+      headers: headers(apiKey),
+      body: JSON.stringify({
+        url,
+        events
+      })
+    });
+    if (!res.ok) {
+      const err = await res.text().catch(() => "");
+      console.error(`[Whop API] Create webhook failed (${res.status}): ${err}`);
+      return null;
+    }
+    const data = await res.json();
+    return {
+      id: data.id,
+      secret: data.secret || data.signing_secret || data.webhook_secret || ""
+    };
+  } catch (err) {
+    console.error("[Whop API] Create webhook error:", err);
+    return null;
+  }
+}
+
+// src/deploy/index.ts
+var WEBHOOK_EVENTS = [
+  "membership.activated",
+  "membership.deactivated",
+  "membership.cancel_at_period_end_changed",
+  "payment.succeeded",
+  "payment.failed",
+  "refund.created"
+];
+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}"`);
+}
+async function runDeployPipeline(options) {
+  const { projectDir, projectName, databaseUrl, framework } = options;
+  if (!isVercelInstalled()) {
+    const install = await p2.confirm({
+      message: "Vercel CLI not found. Install it now?",
+      initialValue: true
+    });
+    if (p2.isCancel(install) || !install) return null;
+    const ok = await installVercel();
+    if (!ok) return null;
+  }
+  if (!isVercelAuthenticated()) {
+    const ok = await vercelLogin();
+    if (!ok) {
+      p2.log.error("Vercel authentication failed. Deploy later with: " + pc2.bold("whop-kit deploy"));
+      return null;
+    }
+  }
+  p2.log.success("Vercel authenticated");
+  if (databaseUrl) {
+    const s2 = p2.spinner();
+    s2.start("Setting DATABASE_URL on Vercel...");
+    vercelEnvSet("DATABASE_URL", databaseUrl, "production", projectDir);
+    vercelEnvSet("DATABASE_URL", databaseUrl, "preview", projectDir);
+    vercelEnvSet("DATABASE_URL", databaseUrl, "development", projectDir);
+    s2.stop("DATABASE_URL configured");
+  }
+  const productionUrl = await vercelDeploy(projectDir);
+  if (!productionUrl) {
+    p2.log.error("Vercel deployment failed. Try deploying manually:");
+    p2.log.info(pc2.bold(`  cd ${projectName} && vercel deploy --prod`));
+    return null;
+  }
+  p2.log.success(`Live at ${pc2.cyan(productionUrl)}`);
+  const connectWhop = await p2.confirm({
+    message: "Connect to Whop? (creates OAuth app + webhooks automatically)",
+    initialValue: true
+  });
+  if (p2.isCancel(connectWhop) || !connectWhop) {
+    return { productionUrl };
+  }
+  p2.log.info("");
+  p2.note(
+    [
+      `${pc2.bold("1.")} Go to the Whop Developer Dashboard`,
+      `   ${pc2.cyan("https://whop.com/dashboard/developer")}`,
+      "",
+      `${pc2.bold("2.")} Click ${pc2.bold('"Create"')} under "Company API Keys"`,
+      "",
+      `${pc2.bold("3.")} Name it anything (e.g. "${projectName}")`,
+      "",
+      `${pc2.bold("4.")} Select these permissions:`,
+      `   ${pc2.green("\u2022")} developer:create_app`,
+      `   ${pc2.green("\u2022")} developer:manage_api_key`,
+      `   ${pc2.green("\u2022")} developer:manage_webhook`,
+      "",
+      `${pc2.bold("5.")} Create the key and paste it below`
+    ].join("\n"),
+    "Create a Company API Key"
+  );
+  openUrl("https://whop.com/dashboard/developer");
+  let apiKey = options.whopCompanyKey ?? "";
+  if (!apiKey) {
+    const result = await p2.text({
+      message: "Paste your Company API key",
+      placeholder: "paste the key here...",
+      validate: (v) => !v ? "API key is required" : void 0
+    });
+    if (p2.isCancel(result)) return { productionUrl };
+    apiKey = result;
+  }
+  const s = p2.spinner();
+  s.start("Validating API key...");
+  const keyValid = await validateApiKey(apiKey);
+  if (!keyValid) {
+    s.stop("Invalid API key");
+    p2.log.error("The key was rejected. Check that it has the required permissions:");
+    p2.log.info("  developer:create_app, developer:manage_api_key, developer:manage_webhook");
+    p2.log.info(`  Dashboard: ${pc2.cyan("https://whop.com/dashboard/developer")}`);
+    return { productionUrl };
+  }
+  s.stop("API key valid");
+  const callbackPath = framework === "astro" ? "/api/auth/callback" : "/api/auth/callback";
+  const redirectUris = [
+    `http://localhost:3000${callbackPath}`,
+    `${productionUrl}${callbackPath}`
+  ];
+  s.start("Creating Whop OAuth app...");
+  const app = await createWhopApp(apiKey, projectName, redirectUris);
+  if (!app) {
+    s.stop("Failed to create Whop app");
+    p2.log.error("Create it manually in the Whop dashboard.");
+    return { productionUrl };
+  }
+  s.stop(`Whop app created: ${pc2.bold(app.id)}`);
+  const webhookUrl = `${productionUrl}/api/webhooks/whop`;
+  s.start("Creating webhook endpoint...");
+  const webhook = await createWhopWebhook(apiKey, webhookUrl, WEBHOOK_EVENTS);
+  if (!webhook) {
+    s.stop("Failed to create webhook");
+    p2.log.warning("Create it manually in the Whop dashboard.");
+  } else {
+    s.stop("Webhook endpoint created");
+  }
+  const envVars = {};
+  if (framework === "nextjs") {
+    envVars["NEXT_PUBLIC_WHOP_APP_ID"] = app.id;
+  } else {
+    envVars["WHOP_APP_ID"] = app.id;
+  }
+  envVars["WHOP_API_KEY"] = app.client_secret;
+  if (webhook?.secret) {
+    envVars["WHOP_WEBHOOK_SECRET"] = webhook.secret;
+  }
+  s.start("Pushing credentials to Vercel...");
+  const { success, failed } = vercelEnvSetBatch(envVars, projectDir);
+  if (failed.length > 0) {
+    s.stop(`Pushed ${success.length} vars, ${failed.length} failed`);
+    p2.log.warning(`Failed to push: ${failed.join(", ")}. Add them manually in Vercel dashboard.`);
+  } else {
+    s.stop(`${success.length} environment variables pushed`);
+  }
+  p2.log.step("Vercel: redeploying with full configuration...");
+  console.log("");
+  const redeployOk = execInteractive("vercel deploy --prod --yes", projectDir);
+  console.log("");
+  if (redeployOk) {
+    p2.log.success("Redeployed with full configuration");
+  } else {
+    p2.log.warning("Redeploy failed \u2014 env vars will apply on next deploy/push");
+  }
+  return {
+    productionUrl,
+    whopAppId: app.id,
+    whopApiKey: app.client_secret,
+    webhookSecret: webhook?.secret
+  };
+}
+
+export {
+  runDeployPipeline
+};

package/dist/cli-create.js

@@ -3,14 +3,16 @@ import {
   APP_TYPES,
   FRAMEWORKS,
   createManifest,
-  detectPackageManager,
-  exec,
-  execInteractive,
   getTemplate,
-  hasCommand,
   installProviderSkills,
   writeProjectContext
-} from "./chunk-BR467LBM.js";
+} from "./chunk-HOQ5QQ2M.js";
+import {
+  detectPackageManager,
+  exec,
+  execInteractive,
+  hasCommand
+} from "./chunk-42L7PRMT.js";
 
 // src/cli-create.ts
 import { runMain } from "citty";
@@ -45,70 +47,50 @@ var neonProvider = {
   },
   async provision(projectName) {
     const cli = hasCommand("neonctl") ? "neonctl" : "neon";
+    p.log.step("Neon: checking authentication...");
     const whoami = exec(`${cli} me --output json`);
     if (!whoami.success) {
-      p.log.info("You need to authenticate with Neon. This will open your browser.");
+      p.log.info("Opening browser for Neon authentication...");
       console.log("");
       const authOk = execInteractive(`${cli} auth`);
       if (!authOk) {
-        p.log.error("Neon authentication failed. Try running manually:");
-        p.log.info(pc.bold(`  ${cli} auth`));
+        p.log.error("Authentication failed. Run manually: " + pc.bold(`${cli} auth`));
         return null;
       }
       console.log("");
     }
-    p.log.info(`Creating Neon project "${projectName}"...`);
+    p.log.step(`Neon: creating project "${projectName}"...`);
     console.log("");
     const createOk = execInteractive(
       `${cli} projects create --name "${projectName}" --set-context`
     );
+    console.log("");
     if (!createOk) {
-      p.log.error("Failed to create Neon project. Try manually at https://console.neon.tech");
+      p.log.error("Failed to create project. Try: https://console.neon.tech");
       return null;
     }
-    console.log("");
-    p.log.success("Neon project created");
+    p.log.step("Neon: getting connection string...");
     let connString = "";
-    const connResult = exec(`${cli} connection-string --prisma --output json`);
-    if (connResult.success) {
-      try {
-        const parsed = JSON.parse(connResult.stdout);
-        connString = parsed.connection_string || parsed.connectionString || connResult.stdout;
-      } catch {
-        connString = connResult.stdout.trim();
-      }
-    }
-    if (!connString) {
-      const fallback = exec(`${cli} connection-string --prisma`);
-      if (fallback.success && fallback.stdout.startsWith("postgres")) {
-        connString = fallback.stdout.trim();
+    for (const flags of ["--prisma", ""]) {
+      if (connString) break;
+      const result = exec(`${cli} connection-string ${flags}`.trim(), void 0, 3e4);
+      if (result.success && result.stdout.startsWith("postgres")) {
+        connString = result.stdout.trim();
       }
     }
     if (!connString) {
-      const raw = exec(`${cli} connection-string`);
-      if (raw.success && raw.stdout.startsWith("postgres")) {
-        connString = raw.stdout.trim();
-      }
-    }
-    if (!connString) {
-      p.log.warning("Could not extract connection string automatically.");
-      console.log("");
-      execInteractive(`${cli} connection-string`);
-      console.log("");
+      p.log.warning("Could not retrieve connection string automatically.");
+      p.log.info("The connection URI was shown in the table above.");
       const manual = await p.text({
-        message: "Paste the connection string shown above",
+        message: "Paste the connection string from the output above",
         placeholder: "postgresql://...",
         validate: (v) => {
-          if (!v?.startsWith("postgres")) return "Must be a PostgreSQL connection string";
+          if (!v?.startsWith("postgres")) return "Must start with postgresql://";
         }
       });
       if (p.isCancel(manual)) return null;
       connString = manual;
     }
-    if (!connString) {
-      p.log.error("Could not get connection string. Get it from: https://console.neon.tech");
-      return null;
-    }
     return {
       connectionString: connString,
       provider: "neon"
@@ -456,6 +438,15 @@ var init_default = defineCommand({
       description: "Show what would be created without doing it",
       default: false
     },
+    "skip-deploy": {
+      type: "boolean",
+      description: "Skip Vercel deployment",
+      default: false
+    },
+    "whop-company-key": {
+      type: "string",
+      description: "Whop Company API key for automatic app creation"
+    },
     verbose: {
       type: "boolean",
       description: "Show detailed output",
@@ -672,40 +663,70 @@ var init_default = defineCommand({
       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 deployResult = null;
+    if (!args["skip-deploy"] && !args["dry-run"]) {
+      const shouldDeploy = isNonInteractive ? false : await (async () => {
+        const result = await p5.confirm({
+          message: "Deploy to Vercel and connect to Whop?",
+          initialValue: true
+        });
+        return !isCancelled(result) && result;
+      })();
+      if (shouldDeploy) {
+        const { runDeployPipeline } = await import("./deploy-RKVUZYCU.js");
+        deployResult = await runDeployPipeline({
+          projectDir,
+          projectName,
+          databaseUrl: dbUrl || void 0,
+          framework,
+          whopCompanyKey: args["whop-company-key"]
+        });
+      }
+    }
     let summary = "";
-    if (configured.length > 0) {
-      summary += `${pc5.green("\u2713")} ${configured.join(", ")}
+    if (deployResult?.productionUrl) {
+      summary += `${pc5.green("\u2713")} Deployed to ${pc5.cyan(deployResult.productionUrl)}
 `;
-    }
-    if (dbNote) {
-      summary += `${pc5.yellow("!")} ${dbNote}
+      if (deployResult.whopAppId) summary += `${pc5.green("\u2713")} Whop app: ${deployResult.whopAppId}
 `;
-    }
-    summary += `
+      if (deployResult.webhookSecret) summary += `${pc5.green("\u2713")} Webhooks configured
 `;
-    summary += `  ${pc5.bold("cd")} ${basename2(projectName)}
+      if (dbUrl) summary += `${pc5.green("\u2713")} Database connected
 `;
-    if (dbUrl) {
-      summary += `  ${pc5.bold(`${pm} run db:push`)}   ${pc5.dim("# push schema to database")}
+      summary += `
 `;
-    }
-    summary += `  ${pc5.bold(`${pm} run dev`)}      ${pc5.dim("# start dev server")}
+      summary += `  ${pc5.bold("cd")} ${basename2(projectName)}
+`;
+      summary += `  ${pc5.bold(`${pm} run dev`)}      ${pc5.dim("# local development")}
+`;
+      summary += `
 `;
-    summary += `
+      summary += `  ${pc5.dim(`Production: ${deployResult.productionUrl}`)}`;
+    } else {
+      if (dbUrl) summary += `${pc5.green("\u2713")} Database configured
+`;
+      if (dbNote) summary += `${pc5.yellow("!")} ${dbNote}
+`;
+      summary += `
 `;
-    summary += `  ${pc5.dim("Open http://localhost:3000 \u2014 the setup wizard will")}
+      summary += `  ${pc5.bold("cd")} ${basename2(projectName)}
+`;
+      if (dbUrl) {
+        summary += `  ${pc5.bold(`${pm} run db:push`)}   ${pc5.dim("# push schema to database")}
+`;
+      }
+      summary += `  ${pc5.bold(`${pm} run dev`)}      ${pc5.dim("# start dev server")}
 `;
-    summary += `  ${pc5.dim("walk you through connecting your Whop app.")}`;
+      summary += `
+`;
+      summary += `  ${pc5.dim("Open http://localhost:3000 \u2014 the setup wizard will")}
+`;
+      summary += `  ${pc5.dim("walk you through connecting your Whop app.")}
+`;
+      summary += `
+`;
+      summary += `  ${pc5.dim(`Or run ${pc5.bold("whop-kit deploy")} to deploy + auto-configure.`)}`;
+    }
     p5.note(summary, "Your app is ready");
     p5.outro(`${pc5.green("Happy building!")} ${pc5.dim("\u2014 whop-kit")}`);
   }

package/dist/cli-kit.js

@@ -4,14 +4,19 @@ import {
   FRAMEWORKS,
   TEMPLATES,
   addFeatureToManifest,
-  detectPackageManager,
-  exec,
   readManifest,
   writeFeatureSkill
-} from "./chunk-BR467LBM.js";
+} from "./chunk-HOQ5QQ2M.js";
+import {
+  runDeployPipeline
+} from "./chunk-NRG6LIOM.js";
+import {
+  detectPackageManager,
+  exec
+} from "./chunk-42L7PRMT.js";
 
 // src/cli-kit.ts
-import { defineCommand as defineCommand7, runMain } from "citty";
+import { defineCommand as defineCommand8, runMain } from "citty";
 
 // src/commands/add.ts
 import * as p4 from "@clack/prompts";
@@ -452,10 +457,59 @@ var catalog_default = defineCommand4({
   }
 });
 
-// src/commands/open.ts
+// src/commands/deploy.ts
 import * as p8 from "@clack/prompts";
 import pc6 from "picocolors";
 import { defineCommand as defineCommand5 } from "citty";
+import { basename } from "path";
+var deploy_default = defineCommand5({
+  meta: {
+    name: "deploy",
+    description: "Deploy your project to Vercel and connect to Whop"
+  },
+  args: {
+    "whop-company-key": {
+      type: "string",
+      description: "Whop Company API key (skips interactive prompt)"
+    },
+    "skip-whop": {
+      type: "boolean",
+      description: "Deploy without Whop configuration",
+      default: false
+    }
+  },
+  async run({ args }) {
+    console.log("");
+    p8.intro(`${pc6.bgCyan(pc6.black(" whop-kit deploy "))}`);
+    const manifest = readManifest(".");
+    if (!manifest) {
+      p8.log.error("No .whop/config.json found. Are you in a whop-kit project?");
+      process.exit(1);
+    }
+    const projectName = basename(process.cwd());
+    const result = await runDeployPipeline({
+      projectDir: ".",
+      projectName,
+      framework: manifest.framework,
+      whopCompanyKey: args["whop-company-key"]
+    });
+    if (result) {
+      let summary = `${pc6.green("\u2713")} Live at ${pc6.cyan(result.productionUrl)}
+`;
+      if (result.whopAppId) summary += `${pc6.green("\u2713")} Whop app: ${result.whopAppId}
+`;
+      if (result.webhookSecret) summary += `${pc6.green("\u2713")} Webhook configured
+`;
+      p8.note(summary, "Deployment complete");
+    }
+    p8.outro("Done");
+  }
+});
+
+// src/commands/open.ts
+import * as p9 from "@clack/prompts";
+import pc7 from "picocolors";
+import { defineCommand as defineCommand6 } from "citty";
 var DASHBOARDS = {
   whop: { name: "Whop Developer Dashboard", url: "https://whop.com/dashboard/developer" },
   neon: { name: "Neon Console", url: "https://console.neon.tech" },
@@ -468,7 +522,7 @@ function openUrl(url) {
   else if (platform === "win32") exec(`start "${url}"`);
   else exec(`xdg-open "${url}"`);
 }
-var open_default = defineCommand5({
+var open_default = defineCommand6({
   meta: {
     name: "open",
     description: "Open a provider dashboard in your browser"
@@ -483,7 +537,7 @@ var open_default = defineCommand5({
   async run({ args }) {
     let target = args.target;
     if (!target) {
-      const result = await p8.select({
+      const result = await p9.select({
         message: "Which dashboard?",
         options: Object.entries(DASHBOARDS).map(([value, d]) => ({
           value,
@@ -491,43 +545,43 @@ var open_default = defineCommand5({
           hint: d.url
         }))
       });
-      if (p8.isCancel(result)) {
-        p8.cancel("Cancelled.");
+      if (p9.isCancel(result)) {
+        p9.cancel("Cancelled.");
         process.exit(0);
       }
       target = result;
     }
     const dashboard = DASHBOARDS[target];
     if (!dashboard) {
-      p8.log.error(`Unknown dashboard "${target}". Options: ${Object.keys(DASHBOARDS).join(", ")}`);
+      p9.log.error(`Unknown dashboard "${target}". Options: ${Object.keys(DASHBOARDS).join(", ")}`);
       process.exit(1);
     }
     openUrl(dashboard.url);
     console.log(`
-  Opening ${pc6.bold(dashboard.name)} \u2192 ${pc6.cyan(dashboard.url)}
+  Opening ${pc7.bold(dashboard.name)} \u2192 ${pc7.cyan(dashboard.url)}
 `);
   }
 });
 
 // src/commands/upgrade.ts
-import * as p9 from "@clack/prompts";
-import pc7 from "picocolors";
-import { defineCommand as defineCommand6 } from "citty";
-var upgrade_default = defineCommand6({
+import * as p10 from "@clack/prompts";
+import pc8 from "picocolors";
+import { defineCommand as defineCommand7 } from "citty";
+var upgrade_default = defineCommand7({
   meta: {
     name: "upgrade",
     description: "Update whop-kit to the latest version in your project"
   },
   async run() {
     console.log("");
-    p9.intro(`${pc7.bgCyan(pc7.black(" whop-kit upgrade "))}`);
+    p10.intro(`${pc8.bgCyan(pc8.black(" whop-kit upgrade "))}`);
     const manifest = readManifest(".");
     if (!manifest) {
-      p9.log.error("No .whop/config.json found. Are you in a whop-kit project?");
+      p10.log.error("No .whop/config.json found. Are you in a whop-kit project?");
       process.exit(1);
     }
     const pm = detectPackageManager();
-    const s = p9.spinner();
+    const s = p10.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");
@@ -535,20 +589,20 @@ var upgrade_default = defineCommand6({
     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(pc7.green("whop-kit upgraded"));
+      s.stop(pc8.green("whop-kit upgraded"));
     } else {
-      s.stop(pc7.red("Upgrade failed"));
-      p9.log.error("Try running manually: " + pc7.bold(cmd));
+      s.stop(pc8.red("Upgrade failed"));
+      p10.log.error("Try running manually: " + pc8.bold(cmd));
     }
-    p9.outro("Done");
+    p10.outro("Done");
   }
 });
 
 // src/cli-kit.ts
-var main = defineCommand7({
+var main = defineCommand8({
   meta: {
     name: "whop-kit",
-    version: "0.5.0",
+    version: "0.6.0",
     description: "Manage your Whop project"
   },
   subCommands: {
@@ -556,6 +610,7 @@ var main = defineCommand7({
     status: status_default,
     env: env_default,
     catalog: catalog_default,
+    deploy: deploy_default,
     open: open_default,
     upgrade: upgrade_default
   }

package/dist/deploy-RKVUZYCU.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+import {
+  runDeployPipeline
+} from "./chunk-NRG6LIOM.js";
+import "./chunk-42L7PRMT.js";
+export {
+  runDeployPipeline
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-whop-kit",
-  "version": "0.5.1",
+  "version": "0.6.1",
   "description": "Scaffold and manage Whop-powered apps with whop-kit",
   "type": "module",
   "license": "MIT",