@whop/cli 0.2.0 → 0.3.0

package/dist/index.js

@@ -9,6 +9,7 @@ import {
   PromptCancelledError,
   apiBaseUrl,
   buildTarget,
+  buildVersion,
   chooseAuthMethod,
   configDir,
   createWhopFetch,
@@ -32,7 +33,7 @@ import {
   switchProfile,
   upsertProfile,
   validateApiKey
-} from "./chunk-2Y4EKBOD.js";
+} from "./chunk-4WNH276N.js";
 import {
   external_exports
 } from "./chunk-KFCNNWPI.js";
@@ -311,7 +312,7 @@ async function loginAdapter(c2) {
   const accountId = getActiveProfile()?.accountId ?? "";
   if (accountId) {
     try {
-      const { createWhopFetch: createWhopFetch2 } = await import("./api-U7WU3JXH.js");
+      const { createWhopFetch: createWhopFetch2 } = await import("./api-A6NYSDKW.js");
       const fetch3 = createWhopFetch2();
       const res = await fetch3(
         new Request(
@@ -590,10 +591,15 @@ function buildAuthGroup() {
   return auth;
 }
 
-// src/commerce/products.ts
-import { text, isCancel } from "@clack/prompts";
+// src/apps/commands.ts
+import { isCancel, select, text } from "@clack/prompts";
+import { spawnSync as spawnSync2 } from "child_process";
+import { createHash } from "crypto";
+import { existsSync as existsSync3, readFileSync as readFileSync3, readdirSync } from "fs";
+import { join as join3, resolve as resolve2 } from "path";
+import chalk from "chalk";
 
-// src/commerce/client.ts
+// src/journey/client.ts
 var PLACEHOLDER = "https://api.whop.com";
 var whopFetch = createWhopFetch();
 async function makeWhopRequest(method, path3, body) {
@@ -608,473 +614,1145 @@ async function makeWhopRequest(method, path3, body) {
   return text3 ? JSON.parse(text3) : { success: true };
 }
 
-// src/commerce/crud.ts
-function buildBody(options) {
-  const body = {};
-  for (const [key, value] of Object.entries(options)) {
-    if (value !== void 0) body[key] = value;
-  }
-  return body;
-}
-function registerListCommand(group, config) {
-  const shape = {
-    first: external_exports.coerce.number().optional().describe("Number of results"),
-    after: external_exports.string().optional().describe("Pagination cursor")
-  };
-  if (config.filter) {
-    shape[config.filter.option] = external_exports.string().optional().describe(config.filter.describe);
-  }
-  group.command("list", {
-    description: config.description,
-    options: external_exports.object(shape),
-    run: (c2) => {
-      const options = c2.options;
-      const params = new URLSearchParams();
-      if (config.filter && options[config.filter.option]) {
-        params.set(config.filter.param, String(options[config.filter.option]));
-      }
-      if (options.first) params.set("first", String(options.first));
-      if (options.after) params.set("after", String(options.after));
-      const qs = params.toString() ? `?${params}` : "";
-      return makeWhopRequest("GET", `${config.path}${qs}`);
-    }
+// src/apps/api.ts
+async function createApp(input) {
+  const company_id = input.company_id ?? await resolveActiveAccountId();
+  return makeWhopRequest("POST", "/apps", { ...input, company_id });
+}
+var DEV_TOKEN_TTL_MS = (3 * 60 - 1) * 60 * 1e3;
+async function createDevAccessToken() {
+  const company_id = await resolveActiveAccountId();
+  return makeWhopRequest("POST", "/access_tokens", {
+    ...company_id ? { company_id } : {},
+    expires_at: new Date(Date.now() + DEV_TOKEN_TTL_MS).toISOString()
   });
 }
-function registerItemCommands(group, config) {
-  const { path: path3, noun, idLabel, schema, updateOptions, transformBody } = config;
-  const idArg = external_exports.object({ id: external_exports.string().describe(idLabel) });
-  group.command("get", {
-    description: `Get a ${noun} by ID`,
-    args: idArg,
-    output: schema,
-    run: (c2) => makeWhopRequest(`GET`, `${path3}/${c2.args.id}`)
+async function listApps() {
+  const companyId = await resolveActiveAccountId();
+  const query = companyId ? `?company_id=${encodeURIComponent(companyId)}` : "";
+  const response = await makeWhopRequest(
+    "GET",
+    `/apps${query}`
+  );
+  return response.data ?? [];
+}
+async function getApp(appId) {
+  return makeWhopRequest("GET", `/apps/${appId}`);
+}
+async function updateAppRoute(appId, route) {
+  return makeWhopRequest("PATCH", `/apps/${appId}`, { route });
+}
+async function createAppBuild(input) {
+  return makeWhopRequest("POST", "/app_builds", {
+    app_id: input.app_id,
+    platform: "web",
+    checksum: input.checksum,
+    attachment: { id: input.file_id }
   });
-  if (updateOptions) {
-    group.command("update", {
-      description: `Update a ${noun}`,
-      args: idArg,
-      options: updateOptions,
-      output: schema,
-      run: (c2) => {
-        const body = buildBody(c2.options);
-        return makeWhopRequest("PATCH", `${path3}/${c2.args.id}`, transformBody ? transformBody(body) : body);
-      }
-    });
-  }
-  group.command("delete", {
-    description: `Delete a ${noun}`,
-    args: idArg,
-    run: (c2) => makeWhopRequest("DELETE", `${path3}/${c2.args.id}`)
+}
+async function getAppBuild(buildId) {
+  return makeWhopRequest("GET", `/app_builds/${buildId}`);
+}
+async function listAppBuilds(appId) {
+  const response = await makeWhopRequest(
+    "GET",
+    `/app_builds?app_id=${encodeURIComponent(appId)}&platform=web`
+  );
+  return response.data ?? [];
+}
+async function promoteAppBuild(buildId) {
+  return makeWhopRequest(
+    "POST",
+    `/app_builds/${buildId}/promote`,
+    {}
+  );
+}
+async function uploadBuildArchive(zip, filename) {
+  const file = await makeWhopRequest("POST", "/files", {
+    filename,
+    visibility: "public"
+  });
+  if (!file.upload_url) {
+    throw new Error("File creation did not return an upload URL.");
+  }
+  const body = new Uint8Array(zip).buffer;
+  const uploadResponse = await fetch(file.upload_url, {
+    method: "PUT",
+    headers: file.upload_headers ?? { "Content-Type": "application/zip" },
+    body
   });
+  if (!uploadResponse.ok) {
+    throw new Error(
+      `Archive upload failed: ${uploadResponse.status} ${await uploadResponse.text()}`
+    );
+  }
+  return file.id;
+}
+async function waitForFileReady(fileId, timeoutMs = 6e4) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const file = await makeWhopRequest("GET", `/files/${fileId}`);
+    if (file.upload_status === "ready") return;
+    await sleep(1e3);
+  }
+  throw new Error(
+    "Timed out waiting for the build archive to finish processing."
+  );
+}
+async function waitForBuildPromotion(buildId, timeoutMs = 3e4) {
+  const deadline = Date.now() + timeoutMs;
+  let latest = await getAppBuild(buildId);
+  while (Date.now() < deadline) {
+    if (latest.is_production) return latest;
+    if (latest.status === "rejected") {
+      throw new Error("Build was rejected and cannot be promoted.");
+    }
+    await sleep(750);
+    latest = await getAppBuild(buildId);
+  }
+  return latest;
+}
+function sleep(ms) {
+  return new Promise((resolve3) => setTimeout(resolve3, ms));
 }
 
-// src/commerce/output.ts
-import chalk from "chalk";
-function printCreateSuccess(c2, opts) {
-  if (c2.agent || c2.formatExplicit) return;
-  const lines = ["", chalk.green.bold(`\u2713 ${opts.title}`)];
-  if (opts.id) lines.push(`  ${chalk.dim(opts.id)}`);
-  if (opts.checkoutUrl) {
-    lines.push("", chalk.bold("\u{1F389} You can sell now. Share your checkout link:"));
-    lines.push(`   ${chalk.cyan.underline(opts.checkoutUrl)}`);
-  }
-  if (opts.next) {
-    lines.push("", `${chalk.bold("Next")}  ${chalk.cyan.bold(`whop ${opts.next.command}`)}`);
-    if (opts.next.hint) lines.push(`  ${chalk.dim(`\u2192 ${opts.next.hint}`)}`);
+// src/apps/config.ts
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { join, resolve } from "path";
+var APP_CONFIG_FILENAME = "whop.app.json";
+function findProjectDir(startDir) {
+  let dir = resolve(startDir ?? process.cwd());
+  for (let i = 0; i < 25; i++) {
+    if (existsSync(join(dir, APP_CONFIG_FILENAME))) return dir;
+    const parent = resolve(dir, "..");
+    if (parent === dir) break;
+    dir = parent;
   }
-  lines.push("");
-  console.log(lines.join("\n"));
+  return null;
+}
+function readAppConfig(projectDir) {
+  const path3 = join(projectDir, APP_CONFIG_FILENAME);
+  if (!existsSync(path3)) return null;
+  try {
+    const parsed = JSON.parse(
+      readFileSync(path3, "utf-8")
+    );
+    if (typeof parsed.app_id === "string" && typeof parsed.name === "string" && typeof parsed.route === "string") {
+      return { app_id: parsed.app_id, name: parsed.name, route: parsed.route };
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function writeAppConfig(projectDir, config) {
+  writeFileSync(
+    join(projectDir, APP_CONFIG_FILENAME),
+    `${JSON.stringify(config, null, "	")}
+`
+  );
+}
+function slugify(name) {
+  return name.toLowerCase().normalize("NFKD").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 63);
 }
 
-// src/commerce/products.ts
-var ProductSchema = external_exports.object({
+// src/apps/scaffold.ts
+import { spawnSync } from "child_process";
+import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { basename, join as join2 } from "path";
+var SPAWN_VIA_SHELL = process.platform === "win32";
+var DLX_RUNNERS = {
+  npm: ["npx", "-y"],
+  pnpm: ["pnpm", "dlx"],
+  bun: ["bunx"],
+  yarn: ["yarn", "dlx"]
+};
+var PM_PRIORITY = ["bun", "pnpm", "npm"];
+function isPmInstalled(pm) {
+  const result = spawnSync(pm, ["--version"], {
+    stdio: "ignore",
+    shell: SPAWN_VIA_SHELL
+  });
+  return !result.error && result.status === 0;
+}
+function detectPackageManager() {
+  return PM_PRIORITY.find(isPmInstalled) ?? null;
+}
+function pmInstallHint(pm) {
+  const win = process.platform === "win32";
+  switch (pm) {
+    case "bun":
+      return win ? 'powershell -c "irm bun.sh/install.ps1 | iex"' : "curl -fsSL https://bun.sh/install | bash";
+    case "pnpm":
+      return win ? 'powershell -c "irm get.pnpm.io/install.ps1 | iex"' : "curl -fsSL https://get.pnpm.io/install.sh | sh -";
+    case "npm":
+      return "install Node.js (includes npm): https://nodejs.org";
+    case "yarn":
+      return "npm install -g yarn";
+  }
+}
+function runTanstackCreate(options) {
+  const [runner, ...runnerArgs] = DLX_RUNNERS[options.pm];
+  const result = spawnSync(
+    runner,
+    [
+      ...runnerArgs,
+      "@tanstack/cli@latest",
+      "create",
+      options.projectName,
+      "--target-dir",
+      options.targetDir,
+      "--framework",
+      "React",
+      "--deployment",
+      "cloudflare",
+      "--no-git",
+      "--no-install",
+      "--no-intent",
+      "--no-toolchain",
+      "--no-examples",
+      "--non-interactive"
+    ],
+    {
+      stdio: options.quiet ? "ignore" : "inherit",
+      shell: SPAWN_VIA_SHELL
+    }
+  );
+  if (result.error) throw result.error;
+  if (result.status !== 0) {
+    throw new Error(
+      `\`${options.pm === "npm" ? "npx" : options.pm} @tanstack/cli create\` failed (exit ${result.status}). Check your network connection and try again.`
+    );
+  }
+}
+var VITE_CONFIG_NAMES = [
+  "vite.config.ts",
+  "vite.config.mts",
+  "vite.config.js",
+  "vite.config.mjs"
+];
+var WRANGLER_CONFIG_NAMES = ["wrangler.jsonc", "wrangler.json"];
+function cliDependencyVersion() {
+  return buildVersion ? `^${buildVersion}` : "latest";
+}
+function whopifyProject(options) {
+  const manualSteps = [];
+  patchPackageJson(options.targetDir, manualSteps);
+  patchViteConfig(options.targetDir, manualSteps);
+  patchWranglerConfig(options.targetDir, options.route, manualSteps);
+  return { manualSteps };
+}
+function patchPackageJson(dir, manualSteps) {
+  const file = join2(dir, "package.json");
+  let pkg;
+  try {
+    pkg = JSON.parse(readFileSync2(file, "utf-8"));
+  } catch {
+    manualSteps.push(
+      `package.json could not be parsed. Add a "deploy": "whop apps deploy" script, a "typecheck" script, and a devDependency "@whop/cli": "${cliDependencyVersion()}".`
+    );
+    return;
+  }
+  pkg.scripts = {
+    ...pkg.scripts,
+    deploy: "whop apps deploy",
+    typecheck: pkg.scripts?.typecheck ?? "tsc --noEmit"
+  };
+  pkg.devDependencies = {
+    ...pkg.devDependencies,
+    // The project imports the whop() vite plugin from @whop/cli/vite.
+    "@whop/cli": pkg.devDependencies?.["@whop/cli"] ?? cliDependencyVersion()
+  };
+  writeFileSync2(file, `${JSON.stringify(pkg, null, 2)}
+`);
+}
+function patchViteConfig(dir, manualSteps) {
+  const file = VITE_CONFIG_NAMES.map((name) => join2(dir, name)).find(
+    (path3) => existsSync2(path3)
+  );
+  if (!file) {
+    manualSteps.push(
+      "No vite config found (looked for vite.config.ts/.mts/.js/.mjs). Whop hosting serves Vite builds \u2014 create a vite config that builds with @cloudflare/vite-plugin (emitting dist/client and, for SSR, dist/server) and includes the whop() plugin from @whop/cli/vite in its plugins array."
+    );
+    return;
+  }
+  let content = readFileSync2(file, "utf-8");
+  const hasWhopPlugin = content.includes("@whop/cli/vite");
+  if (!hasWhopPlugin) {
+    const pluginsOpen = /plugins:\s*\[/;
+    if (!pluginsOpen.test(content)) {
+      manualSteps.push(
+        `Could not find a \`plugins: [...]\` array in ${basename(file)}. Add \`import { whop } from '@whop/cli/vite'\` and include \`whop()\` in the config's plugins so builds pack dist/whop-build.zip.`
+      );
+    } else {
+      content = `import { whop } from '@whop/cli/vite'
+${content}`;
+      content = content.replace(
+        pluginsOpen,
+        (match) => `${match}
+    whop(),`
+      );
+      writeFileSync2(file, content);
+    }
+  }
+  if (!content.includes("@cloudflare/vite-plugin")) {
+    manualSteps.push(
+      `${basename(file)} does not use @cloudflare/vite-plugin. Whop hosting runs builds on Cloudflare Workers: install @cloudflare/vite-plugin and wrangler, add \`cloudflare({ viteEnvironment: { name: 'ssr' } })\` to the plugins array (before your framework plugin), and make sure \`vite build\` emits dist/client (static assets) and dist/server (worker modules with an index.js entry).`
+    );
+  }
+}
+function patchWranglerConfig(dir, route, manualSteps) {
+  const file = WRANGLER_CONFIG_NAMES.map((name) => join2(dir, name)).find(
+    (path3) => existsSync2(path3)
+  );
+  if (!file) {
+    manualSteps.push(
+      `No wrangler config found. Create wrangler.jsonc with: { "name": "${route}", "compatibility_date": "<today>", "compatibility_flags": ["nodejs_compat"], "main": "<your framework's server entry>" } (for TanStack Start the main is "@tanstack/react-start/server-entry").`
+    );
+    return;
+  }
+  const content = readFileSync2(file, "utf-8");
+  const updated = replaceTopLevelName(content, route);
+  if (updated) {
+    writeFileSync2(file, updated);
+  } else {
+    manualSteps.push(
+      `Set the top-level "name" in ${basename(file)} to "${route}" so the worker is named after the app's route.`
+    );
+  }
+}
+function replaceTopLevelName(content, route) {
+  let depth = 0;
+  let i = 0;
+  while (i < content.length) {
+    const ch = content[i];
+    if (ch === '"') {
+      let j = i + 1;
+      while (j < content.length && content[j] !== '"') {
+        j += content[j] === "\\" ? 2 : 1;
+      }
+      if (depth === 1 && content.slice(i + 1, j) === "name") {
+        const after = content.slice(j + 1);
+        const value = after.match(/^(\s*:\s*)"(?:[^"\\]|\\.)*"/);
+        if (value) {
+          const start = j + 1 + value[1].length;
+          const end = j + 1 + value[0].length;
+          return `${content.slice(0, start)}"${route}"${content.slice(end)}`;
+        }
+      }
+      i = j + 1;
+      continue;
+    }
+    if (ch === "/" && content[i + 1] === "/") {
+      const newline = content.indexOf("\n", i);
+      i = newline === -1 ? content.length : newline + 1;
+      continue;
+    }
+    if (ch === "/" && content[i + 1] === "*") {
+      const close = content.indexOf("*/", i + 2);
+      i = close === -1 ? content.length : close + 2;
+      continue;
+    }
+    if (ch === "{" || ch === "[") depth++;
+    if (ch === "}" || ch === "]") depth--;
+    i++;
+  }
+  return null;
+}
+
+// src/apps/commands.ts
+var BUILD_ARCHIVE = "dist/whop-build.zip";
+var AppSchema = external_exports.object({
   id: external_exports.string(),
-  title: external_exports.string(),
-  visibility: external_exports.string().optional(),
-  route: external_exports.string().optional(),
-  headline: external_exports.string().nullable().optional(),
-  description: external_exports.string().nullable().optional(),
-  member_count: external_exports.number().optional(),
-  created_at: external_exports.number().optional()
+  name: external_exports.string(),
+  route: external_exports.string().nullable().optional(),
+  url: external_exports.string().optional(),
+  directory: external_exports.string().optional(),
+  install_failed: external_exports.boolean().optional()
 });
-var createOptions = external_exports.object({
-  title: external_exports.string().optional().describe("Product display name (max 80 characters)"),
-  company_id: external_exports.string().optional().describe(
-    "Business account to create under (defaults to your active account)"
-  ),
-  visibility: external_exports.enum(["visible", "hidden", "archived"]).optional().describe("Who can see this product"),
-  headline: external_exports.string().optional().describe("Short tagline shown on the store page"),
-  description: external_exports.string().optional().describe("Full description"),
-  route: external_exports.string().optional().describe("Custom URL slug (e.g. my-course)"),
-  redirect_purchase_url: external_exports.string().optional().describe("Redirect buyers here after purchase")
+var BuildSchema = external_exports.object({
+  id: external_exports.string(),
+  status: external_exports.string(),
+  is_production: external_exports.boolean().optional(),
+  url: external_exports.string().optional()
 });
-function buildProductsGroup() {
-  const products = Cli_exports.create("products", {
-    description: "Products \u2014 what you're selling on Whop"
+function detectPackageManager2(projectDir) {
+  if (existsSync3(join3(projectDir, "bun.lock")) || existsSync3(join3(projectDir, "bun.lockb")))
+    return "bun";
+  if (existsSync3(join3(projectDir, "pnpm-lock.yaml"))) return "pnpm";
+  if (existsSync3(join3(projectDir, "yarn.lock"))) return "yarn";
+  return "npm";
+}
+function hasScript(projectDir, script) {
+  try {
+    const pkg = JSON.parse(
+      readFileSync3(join3(projectDir, "package.json"), "utf-8")
+    );
+    return Boolean(pkg.scripts?.[script]);
+  } catch {
+    return false;
+  }
+}
+var SPAWN_VIA_SHELL2 = process.platform === "win32";
+function runScript(projectDir, script, extraEnv = {}) {
+  const pm = detectPackageManager2(projectDir);
+  const result = spawnSync2(pm, ["run", script], {
+    cwd: projectDir,
+    stdio: "inherit",
+    shell: SPAWN_VIA_SHELL2,
+    env: { ...process.env, ...extraEnv }
+  });
+  if (result.error) {
+    throw new Error(
+      `Could not run \`${pm} run ${script}\`: ${result.error.message}`
+    );
+  }
+  if (result.status !== 0) {
+    throw new Error(
+      `\`${pm} run ${script}\` failed with exit code ${result.status ?? "unknown"}`
+    );
+  }
+}
+function log(c2, message) {
+  if (!c2.agent) console.log(message);
+}
+function loadProject(dir) {
+  const projectDir = dir ? resolve2(dir) : findProjectDir();
+  if (!projectDir) {
+    return {
+      ok: false,
+      error: {
+        code: "NO_PROJECT",
+        message: `No ${APP_CONFIG_FILENAME} found in this directory or any parent. Run \`whop apps create --existing\` to link this project to a Whop app.`,
+        cta: {
+          commands: [
+            {
+              command: "apps create --existing",
+              description: "Link this project to a Whop app"
+            }
+          ]
+        }
+      }
+    };
+  }
+  const config = readAppConfig(projectDir);
+  if (!config) {
+    return {
+      ok: false,
+      error: {
+        code: "INVALID_CONFIG",
+        message: `${join3(projectDir, APP_CONFIG_FILENAME)} is missing or malformed. Run \`whop apps create --existing\` to regenerate it.`
+      }
+    };
+  }
+  return { ok: true, projectDir, config };
+}
+async function promptText(message, placeholder, initialValue) {
+  const value = await text({ message, placeholder, initialValue });
+  if (isCancel(value)) return null;
+  return String(value);
+}
+function formatManualSteps(steps) {
+  return steps.map((step, i) => `  ${i + 1}. ${step}`).join("\n");
+}
+async function runRegisterFlow(c2, options) {
+  const projectDir = resolve2(options.dir ?? ".");
+  if (!existsSync3(join3(projectDir, "package.json"))) {
+    return c2.error({
+      code: "NO_PACKAGE_JSON",
+      message: `No package.json in ${projectDir} \u2014 --existing wires up a project that's already here. Drop --existing to scaffold a new one.`
+    });
+  }
+  const existing = readAppConfig(projectDir);
+  if (existing) {
+    const { manualSteps: manualSteps2 } = whopifyProject({
+      targetDir: projectDir,
+      route: existing.route
+    });
+    if (manualSteps2.length > 0) {
+      return c2.error({
+        code: "WHOPIFY_INCOMPLETE",
+        message: `This project is already linked to ${existing.app_id} (${existing.route}), but it isn't fully wired for Whop hosting yet. Complete these steps:
+
+${formatManualSteps(manualSteps2)}
+
+Then run \`whop apps deploy\`. Re-running \`whop apps create --existing\` re-checks the wiring.`
+      });
+    }
+    if (!c2.agent && !c2.formatExplicit) {
+      console.log(
+        `${chalk.green.bold(`\u2713 Already linked to ${existing.name}`)} ${chalk.dim(`(${existing.app_id})`)} \u2014 wiring verified. Delete ${APP_CONFIG_FILENAME} to relink.`
+      );
+    }
+    return c2.ok({
+      id: existing.app_id,
+      name: existing.name,
+      route: existing.route,
+      directory: projectDir
+    });
+  }
+  let linked = null;
+  if (options.link) {
+    const apps = await listApps();
+    linked = apps.find((a) => a.id === options.link) ?? null;
+    if (!linked) {
+      return c2.error({
+        code: "APP_NOT_FOUND",
+        message: `No app ${options.link} found on your account.`
+      });
+    }
+  }
+  let name = options.name ?? linked?.name;
+  if (!name) {
+    if (c2.agent) {
+      return c2.error({
+        code: "NAME_REQUIRED",
+        message: 'Pass a name: `whop apps create "My Site"`.',
+        retryable: true
+      });
+    }
+    const value = await promptText("What is your app called?", "My Site");
+    if (value === null)
+      return c2.error({
+        code: "CANCELLED",
+        message: "Cancelled.",
+        exitCode: 130
+      });
+    name = value;
+  }
+  if (!linked) {
+    const apps = await listApps();
+    const slug = slugify(name);
+    const similar = apps.filter(
+      (a) => slugify(a.name) === slug || a.route === (options.route ?? slug)
+    );
+    if (similar.length > 0 && !c2.agent) {
+      const choice = await select({
+        message: `Found existing app${similar.length > 1 ? "s" : ""} with a similar name \u2014 link one or create new?`,
+        options: [
+          ...similar.map((a) => ({
+            value: a.id,
+            label: `Link ${a.name} (${a.id}${a.route ? `, ${a.route}` : ""})`
+          })),
+          { value: "__new__", label: `Create a new app called "${name}"` }
+        ]
+      });
+      if (isCancel(choice))
+        return c2.error({
+          code: "CANCELLED",
+          message: "Cancelled.",
+          exitCode: 130
+        });
+      if (choice !== "__new__") {
+        linked = similar.find((a) => a.id === choice) ?? null;
+      }
+    } else if (similar.length > 0 && c2.agent) {
+      return c2.error({
+        code: "SIMILAR_APPS_FOUND",
+        message: `Existing app(s) with a similar name: ${similar.map((a) => `${a.name} (${a.id})`).join(
+          ", "
+        )}. Pass --link <app_id> to link one, or --name with a distinct name to create new.`,
+        retryable: true
+      });
+    }
+  }
+  let route = options.route ?? slugify(name);
+  if (!options.route && !linked && !c2.agent) {
+    const value = await promptText(
+      "Which route should it live at? (your-route.whop.app)",
+      slugify(name),
+      slugify(name)
+    );
+    if (value === null)
+      return c2.error({
+        code: "CANCELLED",
+        message: "Cancelled.",
+        exitCode: 130
+      });
+    route = slugify(value);
+  }
+  if (!route && !linked?.route) {
+    return c2.error({
+      code: "ROUTE_REQUIRED",
+      message: `Couldn't derive a route from "${name}" \u2014 pass --route with letters and numbers (e.g. --route my-site).`,
+      retryable: true
+    });
+  }
+  let whopApp;
+  try {
+    if (linked) {
+      whopApp = linked;
+      route = options.route ?? linked.route ?? slugify(name);
+      if (!linked.route || options.route && options.route !== linked.route) {
+        whopApp = await updateAppRoute(linked.id, route);
+      }
+    } else {
+      whopApp = await createApp({
+        name,
+        route,
+        ...options.companyId ? { company_id: options.companyId } : {}
+      });
+    }
+  } catch (err) {
+    return c2.error({
+      code: "CREATE_FAILED",
+      message: err instanceof Error ? err.message : "Failed to register the app",
+      retryable: true
+    });
+  }
+  writeAppConfig(projectDir, { app_id: whopApp.id, name, route });
+  const { manualSteps } = whopifyProject({ targetDir: projectDir, route });
+  if (manualSteps.length > 0) {
+    return c2.error({
+      code: "WHOPIFY_INCOMPLETE",
+      message: `${name} is registered on Whop (${whopApp.id}) and ${APP_CONFIG_FILENAME} is written, but the project isn't fully wired for hosting yet. Complete these steps:
+
+${formatManualSteps(manualSteps)}
+
+Then run \`whop apps deploy\`. Re-running \`whop apps create --existing\` re-checks the wiring and applies anything it can.`
+    });
+  }
+  const url = whopApp.hosted_url ?? void 0;
+  if (!c2.agent && !c2.formatExplicit) {
+    console.log(
+      [
+        "",
+        chalk.green.bold(`\u2713 ${linked ? "Linked" : "Created"} ${name}`),
+        `  ${chalk.dim(whopApp.id)}${url ? ` \u2192 ${chalk.cyan.underline(url)}` : ""}`,
+        "",
+        `${chalk.bold("Next")}  ${chalk.cyan.bold("whop apps deploy")}`,
+        ""
+      ].join("\n")
+    );
+  }
+  return c2.ok({ id: whopApp.id, name, route, url, directory: projectDir });
+}
+function buildAppGroup() {
+  const app = Cli_exports.create("apps", {
+    description: "Build and deploy fully-hosted web apps on Whop (*.whop.app)"
   });
-  products.command("create", {
-    description: "Create a product",
-    hint: "A product is the top-level container for what you sell. Add a pricing plan next.",
-    options: createOptions,
-    output: ProductSchema,
+  app.command("create", {
+    description: "Create a Whop app: scaffold a new project (default) or wire up an existing one",
+    hint: "Registers the app on Whop, writes whop.app.json, and wires the whop() deploy plugin into the vite config. By default it scaffolds the latest TanStack Start template into ./<route>. Pass --existing to register + whopify the Vite project in the current directory (or --dir) instead \u2014 safe to re-run, already-linked projects just get their wiring re-checked. --link reuses an existing app record in either mode.",
+    args: external_exports.object({
+      name: external_exports.string().optional().describe("App name (e.g. 'My Site'; when linking, defaults to the linked app's name)")
+    }),
+    options: external_exports.object({
+      route: external_exports.string().optional().describe("Subdomain route to claim (e.g. my-site \u2192 my-site.whop.app)"),
+      dir: external_exports.string().optional().describe(
+        "Directory to scaffold into (defaults to ./<route>); with --existing, the project directory (defaults to the current directory)"
+      ),
+      existing: external_exports.boolean().optional().describe(
+        "Wire up the existing Vite project here instead of scaffolding a new one"
+      ),
+      link: external_exports.string().optional().describe(
+        "Reuse an existing app by id (app_xxx) instead of creating a new one \u2014 works when scaffolding and with --existing"
+      ),
+      company_id: external_exports.string().optional().describe(
+        "Business account to create the app under (defaults to your active account)"
+      ),
+      install: external_exports.boolean().optional().describe(
+        "Install dependencies after scaffolding fresh (default: true)"
+      ),
+      pm: external_exports.enum(["npm", "pnpm", "bun", "yarn"]).optional().describe(
+        "Package manager to use (default: first of bun, pnpm, npm found on your PATH)"
+      )
+    }),
+    output: AppSchema,
     outputPolicy: "agent-only",
     examples: [
       {
-        options: { title: "My Online Course" },
-        description: "Create a product"
+        args: { name: "My Site" },
+        options: { route: "my-site" },
+        description: "Scaffold 'My Site' into ./my-site, live at my-site.whop.app"
       },
       {
-        options: { title: "My Course", visibility: "hidden" },
-        description: "Create a hidden product"
+        args: { name: "My Site" },
+        options: { existing: true },
+        description: "Register + wire up the Vite project in the current directory"
       }
     ],
     run: async (c2) => {
-      let title = c2.options.title;
-      if (!title) {
+      const explicitDir = c2.options.dir ? resolve2(c2.options.dir) : void 0;
+      if (c2.options.existing) {
+        const linkedDir = explicitDir ?? findProjectDir();
+        const projectDir = linkedDir && readAppConfig(linkedDir) ? linkedDir : explicitDir ?? process.cwd();
+        return runRegisterFlow(c2, {
+          dir: projectDir,
+          name: c2.args.name,
+          route: c2.options.route,
+          link: c2.options.link,
+          companyId: c2.options.company_id
+        });
+      }
+      if (!explicitDir && existsSync3(join3(process.cwd(), "package.json"))) {
+        log(
+          c2,
+          chalk.dim(
+            "Detected an existing project here \u2014 scaffolding a new app in a subdirectory. Pass --existing to wire up this project instead."
+          )
+        );
+      }
+      let linked = null;
+      if (c2.options.link) {
+        const apps = await listApps();
+        linked = apps.find((a) => a.id === c2.options.link) ?? null;
+        if (!linked) {
+          return c2.error({
+            code: "APP_NOT_FOUND",
+            message: `No app ${c2.options.link} found on your account.`
+          });
+        }
+      }
+      let name = c2.args.name ?? linked?.name;
+      if (!name) {
         if (c2.agent) {
           return c2.error({
-            code: "TITLE_REQUIRED",
-            message: "Pass --title to set the product name.",
+            code: "NAME_REQUIRED",
+            message: 'Pass a name: `whop apps create "My Site"`.',
             retryable: true
           });
         }
-        const t = await text({
-          message: "What are you selling?",
-          placeholder: "e.g. My Online Course, Trading Community, Fitness Program"
-        });
-        if (isCancel(t))
+        const value = await promptText("What is your app called?", "My Site");
+        if (value === null)
           return c2.error({
             code: "CANCELLED",
             message: "Cancelled.",
             exitCode: 130
           });
-        title = t;
+        name = value;
       }
-      const body = { ...buildBody(c2.options), title };
-      let product;
-      try {
-        product = await makeWhopRequest(
-          "POST",
-          "/products",
-          body
+      let route = c2.options.route ?? linked?.route ?? slugify(name);
+      if (!c2.options.route && !linked?.route && !c2.agent) {
+        const value = await promptText(
+          "Which route should it live at? (your-route.whop.app)",
+          slugify(name),
+          slugify(name)
         );
-      } catch (err) {
+        if (value === null)
+          return c2.error({
+            code: "CANCELLED",
+            message: "Cancelled.",
+            exitCode: 130
+          });
+        route = slugify(value);
+      }
+      if (!route) {
         return c2.error({
-          code: "API_ERROR",
-          message: err instanceof Error ? err.message : "Failed to create product",
+          code: "ROUTE_REQUIRED",
+          message: `Couldn't derive a route from "${name}" \u2014 pass --route with letters and numbers (e.g. --route my-site).`,
           retryable: true
         });
       }
-      printCreateSuccess(c2, {
-        title: `Product "${product.title}" created`,
-        id: product.id,
-        next: {
-          command: `plans create --product_id ${product.id}`,
-          hint: "Add pricing \u2014 required before you can take a checkout"
+      let pm = c2.options.pm;
+      if (pm && !isPmInstalled(pm)) {
+        return c2.error({
+          code: "PM_NOT_INSTALLED",
+          message: `${pm} is not installed (or not on your PATH). Install it: ${pmInstallHint(pm)}`
+        });
+      }
+      if (!pm) pm = detectPackageManager() ?? void 0;
+      if (!pm) {
+        if (c2.agent) {
+          return c2.error({
+            code: "NO_PACKAGE_MANAGER",
+            message: `No package manager found (looked for bun, pnpm, npm). Install bun (recommended): ${pmInstallHint("bun")} \u2014 then re-run \`whop apps create\`.`
+          });
         }
-      });
-      return c2.ok(product, {
-        cta: {
-          description: "Add pricing to your product:",
-          commands: [
-            {
-              command: "plans create",
-              options: { product_id: product.id },
-              description: "Create a pricing plan (required before checkout)"
-            }
+        const choice = await select({
+          message: "No package manager found (bun, pnpm, or npm). Which one do you want to install?",
+          options: [
+            { value: "bun", label: "bun", hint: "recommended" },
+            { value: "pnpm", label: "pnpm" },
+            { value: "npm", label: "npm", hint: "comes with Node.js" }
           ]
+        });
+        if (isCancel(choice)) {
+          return c2.error({
+            code: "CANCELLED",
+            message: "Cancelled.",
+            exitCode: 130
+          });
         }
-      });
-    }
-  });
-  registerListCommand(products, {
-    path: "/products",
-    description: "List products"
-  });
-  registerItemCommands(products, {
-    path: "/products",
-    noun: "product",
-    idLabel: "Product ID (prod_xxx)",
-    schema: ProductSchema,
-    updateOptions: createOptions.partial()
-  });
-  return products;
-}
+        return c2.error({
+          code: "NO_PACKAGE_MANAGER",
+          message: `Install ${String(choice)} with:
 
-// src/commerce/plans.ts
-import { select, isCancel as isCancel2, spinner } from "@clack/prompts";
+  ${pmInstallHint(choice)}
 
-// src/commerce/billing.ts
-var BILLING_PERIOD_DAYS = {
-  daily: 1,
-  weekly: 7,
-  monthly: 30,
-  quarterly: 90,
-  annually: 365,
-  every_two_years: 730
-};
-
-// src/commerce/plans.ts
-var PlanSchema = external_exports.object({
-  id: external_exports.string(),
-  title: external_exports.string().nullable().optional(),
-  plan_type: external_exports.string().optional(),
-  billing_period: external_exports.string().nullable().optional(),
-  initial_price: external_exports.number().nullable().optional(),
-  renewal_price: external_exports.number().nullable().optional(),
-  currency: external_exports.string().optional(),
-  purchase_url: external_exports.string().nullable().optional(),
-  visibility: external_exports.string().optional(),
-  created_at: external_exports.number().optional()
-});
-var createOptions2 = external_exports.object({
-  product_id: external_exports.string().optional().describe("Product this plan belongs to (prod_xxx)"),
-  title: external_exports.string().optional().describe("Display name for this plan"),
-  plan_type: external_exports.enum(["one_time", "renewal", "free"]).optional().describe("Billing model \u2014 one_time, renewal, or free"),
-  billing_period: external_exports.enum(["daily", "weekly", "monthly", "quarterly", "annually", "every_two_years"]).optional().describe("How often to charge (for renewal plans)"),
-  initial_price: external_exports.coerce.number().optional().describe("Price in the plan's currency (e.g. 9.99 for $9.99)"),
-  renewal_price: external_exports.coerce.number().optional().describe("Recurring price for renewal plans (defaults to initial_price)"),
-  currency: external_exports.string().optional().describe("3-letter currency code (default: USD)"),
-  trial_period_days: external_exports.coerce.number().optional().describe("Free trial length in days"),
-  visibility: external_exports.enum(["visible", "hidden", "archived"]).optional().describe("Who can see this plan")
-});
-function normalizePlanBody(body) {
-  if (typeof body.billing_period === "string") {
-    body.billing_period = BILLING_PERIOD_DAYS[body.billing_period];
-  }
-  if (body.plan_type === "renewal" && body.renewal_price == null && body.initial_price != null) {
-    body.renewal_price = body.initial_price;
-  }
-  return body;
-}
-async function resolveProductId(providedId, isAgent) {
-  if (providedId) return { ok: true, productId: providedId, autoResolved: false };
-  const profile = getActiveProfile();
-  const params = new URLSearchParams({ first: "100" });
-  if (profile?.accountId) params.set("company_id", profile.accountId);
-  let data;
-  try {
-    const res = await makeWhopRequest("GET", `/products?${params}`);
-    data = res.data ?? [];
-  } catch {
-    return { ok: false, code: "API_ERROR", message: "Failed to fetch products" };
-  }
-  if (data.length === 0) {
-    return {
-      ok: false,
-      code: "NO_PRODUCTS",
-      message: "No products found. Create one first."
-    };
-  }
-  if (data.length === 1) {
-    return { ok: true, productId: data[0].id, autoResolved: true };
-  }
-  if (isAgent) {
-    return { ok: false, code: "PRODUCT_REQUIRED", message: "Multiple products found. Pass --product_id.", candidates: data };
-  }
-  const chosen = await select({
-    message: "Which product is this plan for?",
-    options: data.map((p) => ({ value: p.id, label: p.title, hint: p.id }))
-  });
-  if (isCancel2(chosen)) return { ok: false, code: "CANCELLED", message: "Cancelled." };
-  return { ok: true, productId: chosen, autoResolved: false };
-}
-function buildPlansGroup() {
-  const plans = Cli_exports.create("plans", {
-    description: "Plans \u2014 pricing for your products"
-  });
-  plans.command("create", {
-    description: "Create a pricing plan",
-    hint: "A plan sets the price and billing interval. After creating a plan, your checkout link is ready to share.",
-    options: createOptions2,
-    output: PlanSchema,
-    outputPolicy: "agent-only",
-    examples: [
-      {
-        options: { product_id: "prod_xxx", initial_price: 9.99, plan_type: "one_time" },
-        description: "One-time payment of $9.99"
-      },
-      {
-        options: {
-          product_id: "prod_xxx",
-          initial_price: 19.99,
-          plan_type: "renewal",
-          billing_period: "monthly"
-        },
-        description: "Monthly subscription at $19.99"
+then re-run \`whop apps create\`.`
+        });
       }
-    ],
-    run: async (c2) => {
-      const s = c2.agent ? null : spinner();
-      if (s) s.start("Resolving product\u2026");
-      const resolved = await resolveProductId(c2.options.product_id, c2.agent);
-      if (s) s.stop("");
-      if (!resolved.ok) {
+      const targetDir = resolve2(c2.options.dir ?? `./${route}`);
+      if (existsSync3(targetDir) && readdirSync(targetDir).length > 0) {
         return c2.error({
-          code: resolved.code,
-          message: resolved.message,
-          retryable: resolved.code !== "CANCELLED",
-          cta: resolved.code === "NO_PRODUCTS" ? {
-            description: "Create a product first:",
-            commands: [{ command: "products create", description: "Create a product" }]
-          } : resolved.candidates ? {
-            description: "Available products:",
-            commands: resolved.candidates.map((p) => ({
-              command: "plans create",
-              options: { product_id: p.id },
-              description: p.title
-            }))
-          } : void 0
+          code: "TARGET_NOT_EMPTY",
+          message: `Target directory is not empty: ${targetDir}. Choose an empty directory with --dir, or a different route.`
         });
       }
-      if (resolved.autoResolved && !c2.agent) {
-        console.error(
-          `Note: using product ${resolved.productId} \u2014 pass --product_id to override`
-        );
-      }
-      const body = normalizePlanBody({
-        ...buildBody(c2.options),
-        product_id: resolved.productId
-      });
-      let plan;
+      let whopApp;
       try {
-        plan = await makeWhopRequest("POST", "/plans", body);
+        if (linked) {
+          whopApp = linked;
+          if (!linked.route || c2.options.route && c2.options.route !== linked.route) {
+            whopApp = await updateAppRoute(linked.id, route);
+          }
+        } else {
+          whopApp = await createApp({
+            name,
+            route,
+            ...c2.options.company_id ? { company_id: c2.options.company_id } : {}
+          });
+        }
       } catch (err) {
         return c2.error({
-          code: "API_ERROR",
-          message: err instanceof Error ? err.message : "Failed to create plan",
+          code: "CREATE_FAILED",
+          message: err instanceof Error ? err.message : "Failed to create the app on Whop",
           retryable: true
         });
       }
-      const purchaseUrl = plan.purchase_url;
-      const ctaDescription = purchaseUrl ? `\u{1F389} You can sell now. Share your checkout link: ${purchaseUrl}` : "Plan created.";
-      printCreateSuccess(c2, {
-        title: purchaseUrl ? "Plan created \u2014 you can sell now" : "Plan created",
-        id: plan.id,
-        checkoutUrl: purchaseUrl,
-        next: {
-          command: "checkout-configurations create",
-          hint: "Optional: customize the checkout page (currency, redirect, payment mode)"
-        }
-      });
-      return c2.ok(plan, {
-        cta: {
-          description: ctaDescription,
-          commands: [
-            { command: "quickstart", description: "See your setup status and what's next" },
-            {
-              command: "checkout-configurations create",
-              options: { plan_id: plan.id },
-              description: "Optional: customize the checkout page"
-            }
-          ]
+      let whopifySteps = [];
+      try {
+        log(
+          c2,
+          chalk.dim("\nScaffolding with the latest TanStack Start template...")
+        );
+        runTanstackCreate({
+          targetDir,
+          projectName: route,
+          pm,
+          quiet: Boolean(c2.agent)
+        });
+        whopifySteps = whopifyProject({ targetDir, route }).manualSteps;
+      } catch (err) {
+        return c2.error({
+          code: "SCAFFOLD_FAILED",
+          message: err instanceof Error ? err.message : "Failed to scaffold the project"
+        });
+      }
+      writeAppConfig(targetDir, { app_id: whopApp.id, name, route });
+      if (whopifySteps.length > 0) {
+        return c2.error({
+          code: "WHOPIFY_INCOMPLETE",
+          message: `Scaffolded ${targetDir} and registered ${whopApp.id}, but the project needs manual wiring:
+
+${formatManualSteps(whopifySteps)}
+
+Then run \`whop apps deploy\`. Re-running \`whop apps create --existing\` in the project re-checks the wiring.`
+        });
+      }
+      let installFailed = false;
+      if (c2.options.install !== false) {
+        log(c2, chalk.dim(`
+Installing dependencies with ${pm}...`));
+        const result = spawnSync2(pm, ["install"], {
+          cwd: targetDir,
+          stdio: c2.agent ? "ignore" : "inherit",
+          shell: SPAWN_VIA_SHELL2
+        });
+        installFailed = Boolean(result.error) || result.status !== 0;
+        if (installFailed) {
+          log(
+            c2,
+            chalk.yellow(
+              `
+${pm} install failed \u2014 run it manually inside ${targetDir}.`
+            )
+          );
         }
+      }
+      const url = whopApp.hosted_url ?? void 0;
+      if (!c2.agent && !c2.formatExplicit) {
+        console.log(
+          [
+            "",
+            chalk.green.bold(`\u2713 ${name} is ready`),
+            `  ${chalk.dim(whopApp.id)}`,
+            "",
+            `  ${chalk.bold("Directory")}  ${targetDir}`,
+            ...url ? [
+              `  ${chalk.bold("URL")}        ${chalk.cyan.underline(url)} ${chalk.dim("(after first deploy)")}`
+            ] : [],
+            "",
+            `${chalk.bold("Next")}`,
+            `  cd ${targetDir}`,
+            `  ${chalk.cyan.bold("whop apps dev")}      ${chalk.dim("\u2192 local dev server")}`,
+            `  ${chalk.cyan.bold("whop apps deploy")}   ${chalk.dim("\u2192 ship it live")}`,
+            ""
+          ].join("\n")
+        );
+      }
+      return c2.ok({
+        id: whopApp.id,
+        name,
+        route,
+        url,
+        directory: targetDir,
+        install_failed: installFailed
       });
     }
   });
-  registerListCommand(plans, {
-    path: "/plans",
-    description: "List plans",
-    filter: { option: "product_id", param: "product_ids", describe: "Filter by product" }
-  });
-  registerItemCommands(plans, {
-    path: "/plans",
-    noun: "plan",
-    idLabel: "Plan ID (plan_xxx)",
-    schema: PlanSchema,
-    updateOptions: createOptions2.omit({ product_id: true }).partial(),
-    transformBody: normalizePlanBody
+  app.command("list", {
+    description: "List the apps on your business account",
+    output: external_exports.array(AppSchema),
+    outputPolicy: "agent-only",
+    run: async (c2) => {
+      const apps = await listApps();
+      return c2.ok(
+        apps.map((a) => ({
+          id: a.id,
+          name: a.name,
+          route: a.route,
+          url: a.hosted_url ?? void 0
+        }))
+      );
+    }
   });
-  return plans;
-}
-
-// src/commerce/checkout.ts
-var CheckoutConfigSchema = external_exports.object({
-  id: external_exports.string(),
-  mode: external_exports.enum(["payment", "setup"]).optional(),
-  currency: external_exports.string().nullable().optional(),
-  purchase_url: external_exports.string().nullable().optional(),
-  redirect_url: external_exports.string().nullable().optional(),
-  company_id: external_exports.string().optional(),
-  created_at: external_exports.number().optional()
-});
-var createOptions3 = external_exports.object({
-  plan_id: external_exports.string().optional().describe("Plan to attach this checkout to (plan_xxx)"),
-  mode: external_exports.enum(["payment", "setup"]).optional().describe("payment = charge immediately; setup = save payment method only"),
-  currency: external_exports.string().optional().describe("3-letter currency code override"),
-  redirect_url: external_exports.string().optional().describe("URL to redirect after successful checkout"),
-  affiliate_code: external_exports.string().optional().describe("Affiliate code to apply")
-});
-function buildCheckoutGroup() {
-  const checkout = Cli_exports.create("checkout-configurations", {
-    description: "Checkout configurations \u2014 customize your checkout page"
+  app.command("dev", {
+    description: "Run the local dev server for this app",
+    hint: "Starts the project's dev script with WHOP_APP_ID set and a short-lived access token injected as WHOP_API_KEY (minted from your CLI credential), so server-side SDK calls work locally without env setup. An explicitly exported WHOP_API_KEY is used as-is.",
+    options: external_exports.object({
+      dir: external_exports.string().optional().describe("Project directory (defaults to the current directory)")
+    }),
+    run: async (c2) => {
+      const project = loadProject(c2.options.dir);
+      if (!project.ok) return c2.error(project.error);
+      const injected = {
+        WHOP_APP_ID: project.config.app_id
+      };
+      if (process.env.WHOP_API_KEY) {
+        log(
+          c2,
+          chalk.dim(
+            "Using the WHOP_API_KEY from your environment for server-side calls."
+          )
+        );
+      } else {
+        try {
+          const minted = await createDevAccessToken();
+          injected.WHOP_API_KEY = minted.token;
+          const expiresAt = typeof minted.expires_at === "number" ? new Date(minted.expires_at * 1e3) : minted.expires_at ? new Date(minted.expires_at) : null;
+          const expiry = expiresAt ? ` (expires ${expiresAt.toLocaleTimeString()})` : "";
+          log(
+            c2,
+            chalk.dim(
+              `Injected a temporary access token as WHOP_API_KEY${expiry} \u2014 server-side SDK calls just work. Restart \`whop apps dev\` to refresh it.`
+            )
+          );
+        } catch (err) {
+          log(
+            c2,
+            chalk.yellow(
+              `Couldn't mint a temporary access token (${err instanceof Error ? err.message : "unknown error"}) \u2014 set WHOP_API_KEY manually for server-side calls.`
+            )
+          );
+        }
+      }
+      log(c2, chalk.dim(`Starting dev server for ${project.config.name}...`));
+      try {
+        runScript(project.projectDir, "dev", injected);
+      } catch (err) {
+        return c2.error({
+          code: "DEV_FAILED",
+          message: err instanceof Error ? err.message : "Dev server exited with an error"
+        });
+      }
+      return c2.ok({ success: true });
+    }
   });
-  checkout.command("create", {
-    description: "Create a checkout configuration",
-    hint: "Customize the currency, redirect URL, and payment mode for a plan's checkout page.",
-    options: createOptions3,
-    output: CheckoutConfigSchema,
+  app.command("deploy", {
+    description: "Build, upload and ship this app live",
+    hint: "Typechecks, builds with Vite, uploads the build to Whop, and promotes it to production. Use --no-promote to upload a preview-only build.",
+    options: external_exports.object({
+      dir: external_exports.string().optional().describe("Project directory (defaults to the current directory)"),
+      promote: external_exports.boolean().optional().describe(
+        "Promote this build to production after upload (default: true)"
+      ),
+      skip_typecheck: external_exports.boolean().optional().describe("Skip the typecheck step"),
+      skip_build: external_exports.boolean().optional().describe("Skip the build step and upload the existing dist/ output")
+    }),
+    output: BuildSchema,
     outputPolicy: "agent-only",
     examples: [
+      { description: "Build and ship to production" },
       {
-        options: { plan_id: "plan_xxx" },
-        description: "Basic checkout configuration for a plan"
-      },
-      {
-        options: { plan_id: "plan_xxx", redirect_url: "https://mysite.com/thank-you" },
-        description: "Redirect buyers to a custom thank-you page"
+        options: { promote: false },
+        description: "Upload a preview build without promoting"
       }
     ],
     run: async (c2) => {
-      const body = buildBody(c2.options);
-      let config;
+      const project = loadProject(c2.options.dir);
+      if (!project.ok) return c2.error(project.error);
+      const { projectDir, config } = project;
       try {
-        config = await makeWhopRequest(
-          "POST",
-          "/checkout_configurations",
-          body
+        if (!c2.options.skip_build) {
+          log(c2, chalk.dim("[1/3] Building..."));
+          runScript(projectDir, "build", { WHOP_APP_ID: config.app_id });
+          if (!c2.options.skip_typecheck && hasScript(projectDir, "typecheck")) {
+            log(c2, chalk.dim("[2/3] Typechecking..."));
+            runScript(projectDir, "typecheck");
+          }
+        }
+        const archivePath = join3(projectDir, BUILD_ARCHIVE);
+        if (!existsSync3(archivePath)) {
+          return c2.error({
+            code: "NO_BUILD_ARCHIVE",
+            message: `No build archive at ${BUILD_ARCHIVE}. Add the whop() plugin from @whop/cli/vite to your vite config, then build. See https://whop.com/docs/apps/hosting.`
+          });
+        }
+        log(c2, chalk.dim("[3/3] Uploading + creating build..."));
+        const zip = readFileSync3(archivePath);
+        const checksum = createHash("sha256").update(zip).digest("hex");
+        const fileId = await uploadBuildArchive(
+          new Uint8Array(zip),
+          `${config.route}-build.zip`
         );
+        await waitForFileReady(fileId);
+        let build = await createAppBuild({
+          app_id: config.app_id,
+          checksum,
+          file_id: fileId
+        });
+        if (c2.options.promote !== false) {
+          await promoteAppBuild(build.id);
+          build = await waitForBuildPromotion(build.id);
+        }
+        const promoted = build.is_production === true;
+        const productionUrl = promoted ? (await getApp(config.app_id)).hosted_url ?? void 0 : void 0;
+        if (!c2.agent && !c2.formatExplicit) {
+          console.log(
+            [
+              "",
+              chalk.green.bold(
+                promoted ? "\u2713 Deployed to production" : "\u2713 Build uploaded"
+              ),
+              `  ${chalk.dim(build.id)}`,
+              "",
+              ...promoted && productionUrl ? [
+                `  ${chalk.bold("Live")}  ${chalk.cyan.underline(productionUrl)}`
+              ] : [
+                `${chalk.bold("Promote when ready")}  ${chalk.cyan.bold(`whop apps promote ${build.id}`)}`
+              ],
+              ""
+            ].join("\n")
+          );
+        }
+        return c2.ok({
+          id: build.id,
+          status: build.status,
+          is_production: promoted,
+          url: productionUrl
+        });
       } catch (err) {
         return c2.error({
-          code: "API_ERROR",
-          message: err instanceof Error ? err.message : "Failed to create checkout configuration",
+          code: "DEPLOY_FAILED",
+          message: err instanceof Error ? err.message : "Deploy failed",
           retryable: true
         });
       }
-      const purchaseUrl = config.purchase_url;
-      printCreateSuccess(c2, {
-        title: "Checkout configured",
-        id: config.id,
-        checkoutUrl: purchaseUrl,
-        next: { command: "quickstart", hint: "See your full setup status" }
-      });
-      return c2.ok(config, {
-        cta: {
-          description: purchaseUrl ? `Checkout configured. Share your link: ${purchaseUrl}` : "Checkout configured.",
-          commands: [
-            { command: "quickstart", description: "See your full setup status" }
-          ]
-        }
-      });
     }
   });
-  registerListCommand(checkout, {
-    path: "/checkout_configurations",
-    description: "List checkout configurations",
-    filter: { option: "plan_id", param: "plan_id", describe: "Filter by plan" }
+  app.command("promote", {
+    description: "Promote a previously uploaded build to production",
+    args: external_exports.object({
+      build_id: external_exports.string().describe("The build to promote (apbu_xxx)")
+    }),
+    options: external_exports.object({
+      dir: external_exports.string().optional().describe("Project directory (defaults to the current directory)")
+    }),
+    output: BuildSchema,
+    outputPolicy: "agent-only",
+    run: async (c2) => {
+      const project = loadProject(c2.options.dir);
+      if (!project.ok) return c2.error(project.error);
+      try {
+        await promoteAppBuild(c2.args.build_id);
+        const build = await waitForBuildPromotion(c2.args.build_id);
+        if (!build.is_production) {
+          return c2.error({
+            code: "PROMOTE_PENDING",
+            message: `Build ${build.id} was accepted but is still processing (status: ${build.status}). It will go live once approved \u2014 re-run \`whop apps promote ${build.id}\` to confirm.`,
+            retryable: true
+          });
+        }
+        const url = (await getApp(project.config.app_id)).hosted_url ?? void 0;
+        if (!c2.agent && !c2.formatExplicit) {
+          console.log(
+            [
+              "",
+              chalk.green.bold("\u2713 Promoted to production"),
+              `  ${chalk.dim(build.id)}`,
+              ...url ? [`  ${chalk.bold("Live")}  ${chalk.cyan.underline(url)}`] : [],
+              ""
+            ].join("\n")
+          );
+        }
+        return c2.ok({
+          id: build.id,
+          status: build.status,
+          is_production: build.is_production,
+          url
+        });
+      } catch (err) {
+        return c2.error({
+          code: "PROMOTE_FAILED",
+          message: err instanceof Error ? err.message : "Promote failed",
+          retryable: true
+        });
+      }
+    }
   });
-  registerItemCommands(checkout, {
-    path: "/checkout_configurations",
-    noun: "checkout configuration",
-    idLabel: "Checkout configuration ID",
-    schema: CheckoutConfigSchema
+  app.command("builds", {
+    description: "List builds for this app",
+    options: external_exports.object({
+      dir: external_exports.string().optional().describe("Project directory (defaults to the current directory)")
+    }),
+    output: external_exports.object({ builds: external_exports.array(BuildSchema) }),
+    outputPolicy: "agent-only",
+    run: async (c2) => {
+      const project = loadProject(c2.options.dir);
+      if (!project.ok) return c2.error(project.error);
+      try {
+        const builds = await listAppBuilds(project.config.app_id);
+        const rows = builds.map((build) => ({
+          id: build.id,
+          status: build.status,
+          is_production: build.is_production
+        }));
+        if (!c2.agent && !c2.formatExplicit) {
+          console.log("");
+          for (const row of rows) {
+            const marker = row.is_production ? chalk.green("\u25CF production") : chalk.dim(`\u25CB ${row.status}`);
+            console.log(`  ${row.id}  ${marker}`);
+          }
+          console.log("");
+        }
+        return c2.ok({ builds: rows });
+      } catch (err) {
+        return c2.error({
+          code: "LIST_FAILED",
+          message: err instanceof Error ? err.message : "Failed to list builds",
+          retryable: true
+        });
+      }
+    }
   });
-  return checkout;
+  return app;
 }
 
 // src/journey/quickstart.ts
 import chalk3 from "chalk";
-import { text as text2, select as select2, isCancel as isCancel3 } from "@clack/prompts";
+import { text as text2, select as select2, isCancel as isCancel2 } from "@clack/prompts";
+
+// src/journey/billing.ts
+var BILLING_PERIOD_DAYS = {
+  daily: 1,
+  weekly: 7,
+  monthly: 30,
+  quarterly: 90,
+  annually: 365,
+  every_two_years: 730
+};
 
 // src/lib/colors.ts
 import chalk2 from "chalk";
@@ -1225,7 +1903,7 @@ ${chalk3.bold("You don't have a business account yet \u2014 let's create one.")}
       message: "What's your business called?",
       placeholder: "My Business"
     });
-    if (isCancel3(name)) {
+    if (isCancel2(name)) {
       return c2.error({
         code: "CANCELLED",
         message: "Setup cancelled.",
@@ -1316,7 +1994,7 @@ async function resolveOrPrompt(c2, provided, missing, prompt) {
     });
   }
   const value = await prompt();
-  if (isCancel3(value))
+  if (isCancel2(value))
     throw new QuickstartError({
       code: "CANCELLED",
       message: "Setup cancelled.",
@@ -1340,7 +2018,7 @@ ${chalk3.bold("Let's get you set up to sell.")}
         { value: "new", label: "Create a new business account" }
       ]
     });
-    if (isCancel3(choice)) {
+    if (isCancel2(choice)) {
       throw new QuickstartError({
         code: "CANCELLED",
         message: "Setup cancelled.",
@@ -1352,7 +2030,7 @@ ${chalk3.bold("Let's get you set up to sell.")}
         message: "What's your new business called?",
         placeholder: "My Business"
       });
-      if (isCancel3(name)) {
+      if (isCancel2(name)) {
         throw new QuickstartError({
           code: "CANCELLED",
           message: "Setup cancelled.",
@@ -1392,7 +2070,7 @@ ${chalk3.bold("Let's get you set up to sell.")}
         placeholder: "9.99",
         validate: (v) => isNaN(Number(v)) ? "Enter a number" : void 0
       });
-      return isCancel3(p) ? p : Number(p);
+      return isCancel2(p) ? p : Number(p);
     }
   );
   const billingPeriod = await resolveOrPrompt(
@@ -1578,7 +2256,7 @@ async function resolveExistingProduct(c2, products) {
       hint: p.id
     }))
   });
-  if (isCancel3(chosen))
+  if (isCancel2(chosen))
     throw new QuickstartError({
       code: "CANCELLED",
       message: "Setup cancelled.",
@@ -1678,7 +2356,7 @@ ${c.success("\u2713 Your store is fully set up.")}`);
 // package.json
 var package_default = {
   name: "@whop/cli",
-  version: "0.2.0",
+  version: "0.3.0",
   description: "The Whop CLI \u2014 build and manage Whop apps from your terminal. Human and agent friendly.",
   keywords: [
     "agent",
@@ -1702,6 +2380,13 @@ var package_default = {
     "dist"
   ],
   type: "module",
+  exports: {
+    ".": "./dist/index.js",
+    "./vite": {
+      types: "./dist/vite.d.ts",
+      import: "./dist/vite.js"
+    }
+  },
   publishConfig: {
     access: "public"
   },
@@ -1728,10 +2413,12 @@ var package_default = {
   },
   devDependencies: {
     "@types/node": "25.3.5",
-    incur: "github:whopio/incur#5ca60d5",
+    fflate: "0.8.2",
+    incur: "github:whopio/incur#4b9ca91dc02472db944fb103984ffc4a13251b6f",
     tsup: "8.5.0",
     tsx: "4.19.4",
-    typescript: "5.9.3"
+    typescript: "5.9.3",
+    vite: "7.3.6"
   },
   engines: {
     node: ">=22"
@@ -2184,22 +2871,10 @@ var HANDWRITTEN_GROUPS = [
     })
   },
   {
-    name: "products",
-    description: "What you're selling",
-    section: "commerce",
-    register: (cli2) => cli2.command(buildProductsGroup())
-  },
-  {
-    name: "plans",
-    description: "Pricing for your products",
-    section: "commerce",
-    register: (cli2) => cli2.command(buildPlansGroup())
-  },
-  {
-    name: "checkout-configurations",
-    description: "Optional / advanced: customize the checkout page",
-    section: "commerce",
-    register: (cli2) => cli2.command(buildCheckoutGroup())
+    name: "apps",
+    description: "Build and deploy fully-hosted web apps (*.whop.app)",
+    section: "get-started",
+    register: (cli2) => cli2.command(buildAppGroup())
   },
   {
     name: "upgrade",
@@ -2473,9 +3148,9 @@ var tag_descriptions_default = {
   Deposits: "Add funds to your balance",
   Swaps: "Convert between currencies",
   Verifications: "Identity verification status",
-  Products: "Description of what you sell",
-  Plans: "Description of your pricing",
-  "Checkout Configurations": "What your checkout page looks like",
+  Products: "What you're selling",
+  Plans: "Pricing for your products",
+  "Checkout Configurations": "Optional / advanced: customize the checkout page",
   Referrals: "Referral programs",
   Ads: "Ad creatives",
   "Ad Campaigns": "Top-level campaign organization",
@@ -2489,7 +3164,6 @@ var descriptions = tag_descriptions_default;
 var toCliName = (tag) => tag.toLowerCase().replace(/\s+/g, "-");
 var SECTION_LABELS = {
   "get-started": "Get Started",
-  commerce: "Commerce",
   auth: "Auth"
 };
 var INTEGRATIONS = [
@@ -2532,16 +3206,16 @@ function buildGroupedHelp(version, description) {
       description: descriptions[tag] ?? ""
     }))
   })).filter((section) => section.commands.length > 0);
-  const extraCommerce = apiSections.filter((section) => section.label.toLowerCase() === "commerce").flatMap((section) => section.commands);
-  const commerceSection = handwrittenSection("commerce");
-  commerceSection.commands = [...commerceSection.commands, ...extraCommerce];
-  const filteredApiSections = apiSections.filter(
+  const commerceSections = apiSections.filter(
+    (section) => section.label.toLowerCase() === "commerce"
+  );
+  const otherApiSections = apiSections.filter(
     (section) => section.label.toLowerCase() !== "commerce"
   );
   const allSections = [
     handwrittenSection("get-started"),
-    commerceSection,
-    ...filteredApiSections,
+    ...commerceSections,
+    ...otherApiSections,
     handwrittenSection("auth")
   ].filter((section) => section.commands.length > 0);
   const maxCmdLen = Math.max(