@whop/cli 0.2.0 → 0.4.0

package/dist/index.js

@@ -5,10 +5,13 @@ import {
   Cli_exports,
   Identity,
   OAuthError,
+  Openapi_exports,
   Profile,
   PromptCancelledError,
   apiBaseUrl,
+  apps_spec_default,
   buildTarget,
+  buildVersion,
   chooseAuthMethod,
   configDir,
   createWhopFetch,
@@ -32,7 +35,7 @@ import {
   switchProfile,
   upsertProfile,
   validateApiKey
-} from "./chunk-2Y4EKBOD.js";
+} from "./chunk-2K4WBZA5.js";
 import {
   external_exports
 } from "./chunk-KFCNNWPI.js";
@@ -311,7 +314,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-7L74UEG4.js");
       const fetch3 = createWhopFetch2();
       const res = await fetch3(
         new Request(
@@ -590,10 +593,15 @@ function buildAuthGroup() {
   return auth;
 }
 
-// src/commerce/products.ts
-import { text, isCancel } from "@clack/prompts";
+// src/apps/commands.ts
+import { isCancel, select, spinner, 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, relative, 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 +616,1005 @@ 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 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({
-  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()
-});
-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")
-});
-function buildProductsGroup() {
-  const products = Cli_exports.create("products", {
-    description: "Products \u2014 what you're selling on Whop"
+// 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
   });
-  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,
-    outputPolicy: "agent-only",
-    examples: [
-      {
-        options: { title: "My Online Course" },
-        description: "Create a product"
-      },
-      {
-        options: { title: "My Course", visibility: "hidden" },
-        description: "Create a hidden product"
-      }
+  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";
+  }
+}
+var TANSTACK_CREATE_FLAGS = [
+  "--framework",
+  "React",
+  "--deployment",
+  "cloudflare",
+  "--no-git",
+  "--no-install",
+  "--no-intent",
+  "--no-toolchain",
+  "--no-examples",
+  "--non-interactive"
+];
+function tanstackCreateCommand(pm, projectName) {
+  return [
+    ...DLX_RUNNERS[pm],
+    "@tanstack/cli@latest",
+    "create",
+    projectName,
+    ...TANSTACK_CREATE_FLAGS
+  ].join(" ");
+}
+function outputTail(result) {
+  const combined = [result.stdout, result.stderr].filter(Boolean).join("\n").trim();
+  if (!combined) return "";
+  return `
+
+${combined.split("\n").slice(-15).join("\n")}`;
+}
+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,
+      ...TANSTACK_CREATE_FLAGS
     ],
-    run: async (c2) => {
-      let title = c2.options.title;
-      if (!title) {
-        if (c2.agent) {
-          return c2.error({
-            code: "TITLE_REQUIRED",
-            message: "Pass --title to set the product name.",
-            retryable: true
-          });
-        }
-        const t = await text({
-          message: "What are you selling?",
-          placeholder: "e.g. My Online Course, Trading Community, Fitness Program"
-        });
-        if (isCancel(t))
-          return c2.error({
-            code: "CANCELLED",
-            message: "Cancelled.",
-            exitCode: 130
-          });
-        title = t;
-      }
-      const body = { ...buildBody(c2.options), title };
-      let product;
-      try {
-        product = await makeWhopRequest(
-          "POST",
-          "/products",
-          body
-        );
-      } catch (err) {
-        return c2.error({
-          code: "API_ERROR",
-          message: err instanceof Error ? err.message : "Failed to create product",
-          retryable: true
-        });
+    {
+      stdio: ["ignore", "pipe", "pipe"],
+      encoding: "utf-8",
+      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.${outputTail(result)}`
+    );
+  }
+}
+var VITE_CONFIG_NAMES = [
+  "vite.config.ts",
+  "vite.config.mts",
+  "vite.config.js",
+  "vite.config.mjs"
+];
+function findViteConfig(dir) {
+  return VITE_CONFIG_NAMES.map((name) => join2(dir, name)).find(
+    (path3) => existsSync2(path3)
+  );
+}
+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 = findViteConfig(dir);
+  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;
       }
-      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"
-        }
-      });
-      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)"
-            }
-          ]
+      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;
     }
-  });
-  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;
+    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/commerce/plans.ts
-import { select, isCancel as isCancel2, spinner } from "@clack/prompts";
-
-// 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({
+// src/apps/commands.ts
+var BUILD_ARCHIVE = "dist/whop-build.zip";
+var BuildSchema = 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()
+  status: external_exports.string(),
+  is_production: external_exports.boolean().optional(),
+  url: external_exports.string().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;
+var DeployAbort = class extends Error {
+  constructor(options) {
+    super(options.message);
+    this.options = options;
   }
-  return body;
+};
+function detectProjectPackageManager(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";
+  if (existsSync3(join3(projectDir, "package-lock.json"))) return "npm";
+  return detectPackageManager() ?? "npm";
 }
-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;
+function hasScript(projectDir, script) {
   try {
-    const res = await makeWhopRequest("GET", `/products?${params}`);
-    data = res.data ?? [];
+    const pkg = JSON.parse(
+      readFileSync3(join3(projectDir, "package.json"), "utf-8")
+    );
+    return Boolean(pkg.scripts?.[script]);
   } catch {
-    return { ok: false, code: "API_ERROR", message: "Failed to fetch products" };
+    return false;
   }
-  if (data.length === 0) {
-    return {
-      ok: false,
-      code: "NO_PRODUCTS",
-      message: "No products found. Create one first."
-    };
+}
+var SPAWN_VIA_SHELL2 = process.platform === "win32";
+function runScript(projectDir, script, extraEnv = {}) {
+  const pm = detectProjectPackageManager(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 (data.length === 1) {
-    return { ok: true, productId: data[0].id, autoResolved: true };
+  if (result.status !== 0) {
+    throw new Error(
+      `\`${pm} run ${script}\` failed with exit code ${result.status ?? "unknown"}`
+    );
   }
-  if (isAgent) {
-    return { ok: false, code: "PRODUCT_REQUIRED", message: "Multiple products found. Pass --product_id.", candidates: data };
+}
+function runInstall(c2, projectDir) {
+  const pm = detectProjectPackageManager(projectDir);
+  const spin = c2.agent ? null : spinner();
+  spin?.start(`Installing dependencies with ${pm}`);
+  const result = spawnSync2(pm, ["install"], {
+    cwd: projectDir,
+    stdio: ["ignore", "pipe", "pipe"],
+    encoding: "utf-8",
+    shell: SPAWN_VIA_SHELL2
+  });
+  if (result.error || result.status !== 0) {
+    spin?.error(`${pm} install failed`);
+    throw new Error(
+      `\`${pm} install\` failed${result.status != null ? ` with exit code ${result.status}` : ""} \u2014 run it manually inside ${projectDir}, then re-run \`whop apps deploy\`.${outputTail(result)}`
+    );
   }
-  const chosen = await select({
-    message: "Which product is this plan for?",
-    options: data.map((p) => ({ value: p.id, label: p.title, hint: p.id }))
+  spin?.stop(`Installed dependencies with ${pm}`);
+}
+function log(c2, message) {
+  if (!c2.agent) console.log(message);
+}
+async function promptText(message, placeholder, initialValue) {
+  const value = await text({ message, placeholder, initialValue });
+  if (isCancel(value)) return null;
+  return String(value);
+}
+function cancelled() {
+  throw new DeployAbort({
+    code: "CANCELLED",
+    message: "Cancelled.",
+    exitCode: 130
   });
-  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"
+function formatManualSteps(steps) {
+  return steps.map((step, i) => `  ${i + 1}. ${step}`).join("\n");
+}
+function formatAppList(apps) {
+  const recent = [...apps].sort((a, b) => (b.created_at ?? 0) - (a.created_at ?? 0)).slice(0, 10);
+  return recent.map(
+    (a) => `  ${a.id}  ${a.name}${a.route ? `  (${a.route}.whop.app)` : ""}`
+  ).join("\n");
+}
+async function registerSpecCommands(group, tag) {
+  const spec2 = filterSpecByTag(apps_spec_default, tag);
+  const generated = await Openapi_exports.generateCommands(
+    spec2,
+    createWhopFetch()
+  );
+  for (const [name, entry] of generated) {
+    if ("run" in entry) group.command(name, entry);
+  }
+}
+function ensurePackageManager() {
+  const pm = detectPackageManager();
+  if (pm) return pm;
+  throw new DeployAbort({
+    code: "NO_PACKAGE_MANAGER",
+    message: `No package manager found (looked for bun, pnpm, npm). Install one and re-run \`whop apps deploy\`:
+
+  bun (recommended): ${pmInstallHint("bun")}
+  pnpm:              ${pmInstallHint("pnpm")}
+  npm:               ${pmInstallHint("npm")}`
   });
-  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: [
+}
+async function ensureViteApp(c2, pm, dirOption) {
+  const projectDir = dirOption ? resolve2(dirOption) : findProjectDir() ?? process.cwd();
+  const isViteApp = existsSync3(join3(projectDir, "package.json")) && findViteConfig(projectDir) !== void 0;
+  if (isViteApp) return { projectDir, freshlyScaffolded: false };
+  if (c2.agent) {
+    throw new DeployAbort({
+      code: "NOT_A_VITE_APP",
+      message: [
+        `${projectDir} doesn't look like a Vite app (missing package.json or vite config).`,
+        "",
+        "Ask the user whether to scaffold a new app here, or locate their existing Vite app.",
+        "",
+        "To scaffold a new app (TanStack Start), run:",
+        `  ${tanstackCreateCommand(pm, "<app-name>")}`,
+        `  cd <app-name> && ${pm} install`,
+        "",
+        "Then re-run `whop apps deploy` from inside the app directory.",
+        "Or, if a Vite app already exists somewhere else, re-run `whop apps deploy --dir <path-to-app>`."
+      ].join("\n"),
+      retryable: true,
+      cta: {
+        commands: [
+          {
+            command: "apps deploy",
+            description: "Re-run from inside a Vite app directory"
+          }
+        ]
+      }
+    });
+  }
+  const choice = await select({
+    message: `${projectDir} doesn't look like a Vite app. What do you want to do?`,
+    options: [
       {
-        options: { product_id: "prod_xxx", initial_price: 9.99, plan_type: "one_time" },
-        description: "One-time payment of $9.99"
+        value: "scaffold",
+        label: "Scaffold a new Whop app here (TanStack Start)"
       },
-      {
-        options: {
-          product_id: "prod_xxx",
-          initial_price: 19.99,
-          plan_type: "renewal",
-          billing_period: "monthly"
-        },
-        description: "Monthly subscription at $19.99"
+      { value: "cancel", label: "Cancel \u2014 I'll cd into my app directory" }
+    ]
+  });
+  if (isCancel(choice) || choice === "cancel") cancelled();
+  const scaffolded = await scaffoldNewApp(c2, pm);
+  return { projectDir: scaffolded, freshlyScaffolded: true };
+}
+async function scaffoldNewApp(c2, pm) {
+  const name = await promptText("What is your app called?", "My Site");
+  if (name === null) cancelled();
+  const slug = slugify(name);
+  const routeInput = await promptText(
+    "Which route should it live at? (your-route.whop.app)",
+    slug,
+    slug
+  );
+  if (routeInput === null) cancelled();
+  const route = slugify(routeInput);
+  if (!route) {
+    throw new DeployAbort({
+      code: "ROUTE_REQUIRED",
+      message: `Couldn't derive a route from "${routeInput}" \u2014 use letters and numbers (e.g. my-site).`,
+      retryable: true
+    });
+  }
+  const targetDir = resolve2(`./${route}`);
+  if (existsSync3(targetDir) && readdirSync(targetDir).length > 0) {
+    throw new DeployAbort({
+      code: "TARGET_NOT_EMPTY",
+      message: `Target directory is not empty: ${targetDir}. Pick a different route, or run \`whop apps deploy\` from an empty directory.`
+    });
+  }
+  let app;
+  try {
+    app = await createApp({ name, route });
+  } catch (err) {
+    throw new DeployAbort({
+      code: "CREATE_FAILED",
+      message: err instanceof Error ? err.message : "Failed to register the app",
+      retryable: true
+    });
+  }
+  const spin = c2.agent ? null : spinner();
+  spin?.start("Scaffolding the latest TanStack Start template");
+  try {
+    runTanstackCreate({ targetDir, projectName: route, pm });
+    spin?.stop(`Scaffolded ${route} from the latest TanStack Start template`);
+  } catch (err) {
+    spin?.error("Scaffold failed");
+    throw new DeployAbort({
+      code: "SCAFFOLD_FAILED",
+      message: `${err instanceof Error ? err.message : "Failed to scaffold the project"}
+
+The app ${app.id} is already registered \u2014 scaffold into a fresh directory and re-run \`whop apps deploy --app ${app.id}\` there.`
+    });
+  }
+  writeAppConfig(targetDir, { app_id: app.id, name, route });
+  return targetDir;
+}
+async function ensureAppLinked(c2, projectDir, appOption) {
+  if (appOption) {
+    let app;
+    try {
+      app = await getApp(appOption);
+    } catch (err) {
+      throw new DeployAbort({
+        code: "APP_NOT_FOUND",
+        message: `Could not load app ${appOption}: ${err instanceof Error ? err.message : "unknown error"}`,
+        retryable: true
+      });
+    }
+    const config2 = await withRoute(c2, app);
+    writeAppConfig(projectDir, config2);
+    log(
+      c2,
+      chalk.dim(
+        `Linked ${config2.name} (${config2.app_id}) \u2192 ${APP_CONFIG_FILENAME}`
+      )
+    );
+    return config2;
+  }
+  const existing = readAppConfig(projectDir);
+  if (existing) return existing;
+  const apps = await listApps();
+  if (c2.agent) {
+    const reuse = apps.length > 0 ? `This account has existing apps \u2014 ask the user whether to reuse one:
+${formatAppList(apps)}
+
+To reuse one:  whop apps deploy --app <app_id>
+
+` : "This account has no apps yet, so a new one must be created.\n\n";
+    throw new DeployAbort({
+      code: "NO_APP_LINKED",
+      message: [
+        `No ${APP_CONFIG_FILENAME} here \u2014 this project isn't linked to a Whop app yet.`,
+        "",
+        `${reuse}To create a new app, ask the user for a name and route (the route becomes <route>.whop.app), then run:`,
+        '  whop apps create --name "My Site" --route my-site',
+        "",
+        "Then deploy with the returned app id:",
+        "  whop apps deploy --app <app_id>"
+      ].join("\n"),
+      retryable: true,
+      cta: {
+        commands: [
+          {
+            command: "apps create",
+            description: "Create a new app (pass --name and --route)"
+          },
+          {
+            command: "apps deploy",
+            description: "Re-run with --app <app_id> to link and deploy"
+          }
+        ]
       }
-    ],
+    });
+  }
+  let selected = null;
+  if (apps.length > 0) {
+    const recent = [...apps].sort(
+      (a, b) => (b.created_at ?? 0) - (a.created_at ?? 0)
+    );
+    const choice = await select({
+      message: "Which app should this project deploy to?",
+      options: [
+        ...recent.map((a) => ({
+          value: a.id,
+          label: `${a.name} (${a.id}${a.route ? `, ${a.route}.whop.app` : ""})`
+        })),
+        { value: "__new__", label: "Create a new app" }
+      ]
+    });
+    if (isCancel(choice)) cancelled();
+    if (choice !== "__new__") {
+      selected = recent.find((a) => a.id === choice) ?? null;
+    }
+  }
+  if (!selected) {
+    const name = await promptText("What is your app called?", "My Site");
+    if (name === null) cancelled();
+    const slug = slugify(name);
+    const routeInput = await promptText(
+      "Which route should it live at? (your-route.whop.app)",
+      slug,
+      slug
+    );
+    if (routeInput === null) cancelled();
+    const route = slugify(routeInput);
+    if (!route) {
+      throw new DeployAbort({
+        code: "ROUTE_REQUIRED",
+        message: `Couldn't derive a route from "${routeInput}" \u2014 use letters and numbers (e.g. my-site).`,
+        retryable: true
+      });
+    }
+    try {
+      selected = await createApp({ name, route });
+    } catch (err) {
+      throw new DeployAbort({
+        code: "CREATE_FAILED",
+        message: err instanceof Error ? err.message : "Failed to register the app",
+        retryable: true
+      });
+    }
+  }
+  const config = await withRoute(c2, selected);
+  writeAppConfig(projectDir, config);
+  log(
+    c2,
+    chalk.dim(
+      `Linked ${config.name} (${config.app_id}) \u2192 ${APP_CONFIG_FILENAME}`
+    )
+  );
+  return config;
+}
+async function withRoute(c2, app) {
+  if (app.route) return { app_id: app.id, name: app.name, route: app.route };
+  if (c2.agent) {
+    throw new DeployAbort({
+      code: "ROUTE_REQUIRED",
+      message: `App ${app.id} (${app.name}) has no route \u2014 hosted apps are served from <route>.whop.app. Ask the user which route to claim, then run:
+  whop apps update ${app.id} --route <route>
+  whop apps deploy --app ${app.id}`,
+      retryable: true,
+      cta: {
+        commands: [
+          {
+            command: `apps update ${app.id}`,
+            description: "Set the route (pass --route)"
+          }
+        ]
+      }
+    });
+  }
+  const slug = slugify(app.name);
+  const routeInput = await promptText(
+    `${app.name} has no route yet. Which route should it live at? (your-route.whop.app)`,
+    slug,
+    slug
+  );
+  if (routeInput === null) cancelled();
+  const route = slugify(routeInput);
+  if (!route) {
+    throw new DeployAbort({
+      code: "ROUTE_REQUIRED",
+      message: `Couldn't derive a route from "${routeInput}" \u2014 use letters and numbers (e.g. my-site).`,
+      retryable: true
+    });
+  }
+  try {
+    const updated = await updateAppRoute(app.id, route);
+    return {
+      app_id: updated.id,
+      name: updated.name,
+      route: updated.route ?? route
+    };
+  } catch (err) {
+    throw new DeployAbort({
+      code: "UPDATE_FAILED",
+      message: err instanceof Error ? err.message : "Failed to set the route",
+      retryable: true
+    });
+  }
+}
+async function buildAppGroup() {
+  const app = Cli_exports.create("apps", {
+    description: "Build and deploy fully-hosted web apps on Whop (*.whop.app)"
+  });
+  await registerSpecCommands(app, "Apps");
+  const builds = Cli_exports.create("builds", {
+    description: "Manage app builds (list, inspect, promote)"
+  });
+  await registerSpecCommands(builds, "App builds");
+  app.command(builds);
+  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 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 projectDir = c2.options.dir ? resolve2(c2.options.dir) : findProjectDir();
+      const config = projectDir ? readAppConfig(projectDir) : null;
+      if (!projectDir || !config) {
         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: "NO_PROJECT",
+          message: `No ${APP_CONFIG_FILENAME} found in this directory or any parent. Run \`whop apps deploy\` to link this project to a Whop app.`,
+          cta: {
+            commands: [
+              {
+                command: "apps deploy",
+                description: "Link this project to a Whop app and ship it"
+              }
+            ]
+          }
         });
       }
-      if (resolved.autoResolved && !c2.agent) {
-        console.error(
-          `Note: using product ${resolved.productId} \u2014 pass --product_id to override`
+      const injected = {
+        WHOP_APP_ID: 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.`
+            )
+          );
+        }
       }
-      const body = normalizePlanBody({
-        ...buildBody(c2.options),
-        product_id: resolved.productId
-      });
-      let plan;
+      log(c2, chalk.dim(`Starting dev server for ${config.name}...`));
       try {
-        plan = await makeWhopRequest("POST", "/plans", body);
+        runScript(projectDir, "dev", injected);
       } catch (err) {
         return c2.error({
-          code: "API_ERROR",
-          message: err instanceof Error ? err.message : "Failed to create plan",
-          retryable: true
+          code: "DEV_FAILED",
+          message: err instanceof Error ? err.message : "Dev server exited with an error"
         });
       }
-      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"
-            }
-          ]
-        }
-      });
+      return c2.ok({ success: true });
     }
   });
-  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
-  });
-  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"
-  });
-  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: "The one-stop deploy: verifies the project is a Whop-ready Vite app (offering to scaffold or link one if not), builds, typechecks, uploads the build, and promotes it to production. Use --skip_promote to upload a preview-only build, then promote it later with `whop apps builds promote <build_id>`.",
+    options: external_exports.object({
+      dir: external_exports.string().optional().describe("Project directory (defaults to the current directory)"),
+      app: external_exports.string().optional().describe(
+        "Link this project to an app (app_xxx) before deploying \u2014 writes whop.app.json, replacing any existing link"
+      ),
+      skip_promote: external_exports.boolean().optional().describe(
+        "Upload the build without promoting it to production"
+      ),
+      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: { app: "app_xxxxxxxx" },
+        description: "Link this project to an existing app, then deploy"
       },
       {
-        options: { plan_id: "plan_xxx", redirect_url: "https://mysite.com/thank-you" },
-        description: "Redirect buyers to a custom thank-you page"
+        options: { skip_promote: true },
+        description: "Upload a preview build without promoting"
       }
     ],
     run: async (c2) => {
-      const body = buildBody(c2.options);
-      let config;
       try {
-        config = await makeWhopRequest(
-          "POST",
-          "/checkout_configurations",
-          body
+        const pm = ensurePackageManager();
+        const { projectDir, freshlyScaffolded } = await ensureViteApp(
+          c2,
+          pm,
+          c2.options.dir
+        );
+        const config = await ensureAppLinked(c2, projectDir, c2.options.app);
+        const { manualSteps } = whopifyProject({
+          targetDir: projectDir,
+          route: config.route
+        });
+        if (manualSteps.length > 0) {
+          return c2.error({
+            code: "WHOPIFY_INCOMPLETE",
+            message: `${config.name} is linked (${config.app_id}), but the project isn't fully wired for Whop hosting yet. Complete these steps:
+
+${formatManualSteps(manualSteps)}
+
+Then re-run \`whop apps deploy\` \u2014 it re-checks the wiring and applies anything it can.`
+          });
+        }
+        if (!c2.options.skip_build) {
+          if (freshlyScaffolded || !existsSync3(join3(projectDir, "node_modules", "@whop", "cli"))) {
+            runInstall(c2, projectDir);
+          }
+          log(c2, chalk.dim("[1/4] Building..."));
+          runScript(projectDir, "build", { WHOP_APP_ID: config.app_id });
+          if (!c2.options.skip_typecheck && hasScript(projectDir, "typecheck")) {
+            log(c2, chalk.dim("[2/4] 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.`
+          });
+        }
+        const zip = readFileSync3(archivePath);
+        const sizeMb = (zip.byteLength / 1024 / 1024).toFixed(1);
+        const checksum = createHash("sha256").update(zip).digest("hex");
+        const spin = c2.agent ? null : spinner();
+        spin?.start(`[3/4] Uploading build archive (${sizeMb} MB)`);
+        let build;
+        try {
+          const fileId = await uploadBuildArchive(
+            new Uint8Array(zip),
+            `${config.route}-build.zip`
+          );
+          spin?.message("[3/4] Processing archive");
+          await waitForFileReady(fileId);
+          spin?.message("[3/4] Creating build");
+          build = await createAppBuild({
+            app_id: config.app_id,
+            checksum,
+            file_id: fileId
+          });
+          spin?.stop(`[3/4] Build uploaded (${build.id})`);
+        } catch (err) {
+          spin?.error("[3/4] Upload failed");
+          throw err;
+        }
+        if (!c2.options.skip_promote) {
+          const promoteSpin = c2.agent ? null : spinner();
+          promoteSpin?.start("[4/4] Promoting to production");
+          try {
+            await promoteAppBuild(build.id);
+            build = await waitForBuildPromotion(build.id);
+            promoteSpin?.stop(
+              build.is_production ? "[4/4] Promoted to production" : `[4/4] Promotion pending (status: ${build.status})`
+            );
+          } catch (err) {
+            promoteSpin?.error("[4/4] Promote failed");
+            throw err;
+          }
+        } else {
+          log(c2, chalk.dim("[4/4] Skipping promotion (--skip_promote)"));
+        }
+        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) {
+          const cdTarget = relative(process.cwd(), projectDir) || ".";
+          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 builds promote ${build.id}`)}`
+              ],
+              ...freshlyScaffolded ? [
+                "",
+                chalk.bold("Next"),
+                ...cdTarget !== "." ? [`  cd ${cdTarget}`] : [],
+                `  ${chalk.cyan.bold("whop apps dev")}      ${chalk.dim("\u2192 local dev server")}`,
+                `  ${chalk.cyan.bold("whop apps deploy")}   ${chalk.dim("\u2192 ship your changes")}`
+              ] : [],
+              ""
+            ].join("\n")
+          );
+        }
+        return c2.ok(
+          {
+            id: build.id,
+            status: build.status,
+            is_production: promoted,
+            url: productionUrl
+          },
+          promoted ? void 0 : {
+            cta: {
+              commands: [
+                {
+                  command: `apps builds promote ${build.id}`,
+                  description: "Promote this build to production"
+                }
+              ]
+            }
+          }
         );
       } catch (err) {
+        if (err instanceof DeployAbort) return c2.error(err.options);
         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" }
-  });
-  registerItemCommands(checkout, {
-    path: "/checkout_configurations",
-    noun: "checkout configuration",
-    idLabel: "Checkout configuration ID",
-    schema: CheckoutConfigSchema
-  });
-  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 +1765,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 +1856,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 +1880,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 +1892,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 +1932,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 +2118,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 +2218,7 @@ ${c.success("\u2713 Your store is fully set up.")}`);
 // package.json
 var package_default = {
   name: "@whop/cli",
-  version: "0.2.0",
+  version: "0.4.0",
   description: "The Whop CLI \u2014 build and manage Whop apps from your terminal. Human and agent friendly.",
   keywords: [
     "agent",
@@ -1702,6 +2242,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 +2275,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"
@@ -1817,7 +2366,7 @@ var DEFAULT_MANIFEST_URL = "https://github.com/whopio/whop-public-cli/releases/l
 function manifestUrl(env = process.env) {
   return env.WHOP_CLI_MANIFEST_URL?.trim() || DEFAULT_MANIFEST_URL;
 }
-var CHECK_INTERVAL_MS = 24 * 60 * 60 * 1e3;
+var CHECK_INTERVAL_MS = 60 * 60 * 1e3;
 function cachePath(env) {
   return path.join(configDir(env), "update-check.json");
 }
@@ -2184,22 +2733,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: async (cli2) => cli2.command(await buildAppGroup())
   },
   {
     name: "upgrade",
@@ -2256,8 +2793,8 @@ var HANDWRITTEN_GROUP_NAMES = new Set(
 );
 var API_GROUPS = groups_default.map(([name, tag]) => ({ name, tag })).filter(({ name }) => !HANDWRITTEN_GROUP_NAMES.has(name));
 var COMMAND_GROUPS = [...API_GROUPS, ...HANDWRITTEN_GROUPS];
-function registerHandwrittenGroups(cli2) {
-  for (const group of HANDWRITTEN_GROUPS) group.register(cli2);
+async function registerHandwrittenGroups(cli2) {
+  for (const group of HANDWRITTEN_GROUPS) await group.register(cli2);
 }
 async function setupAgents(cli2) {
   for (const argv2 of [
@@ -2398,7 +2935,7 @@ cli.use(async (c2, next) => {
   }
   return next();
 });
-registerHandwrittenGroups(cli);
+await registerHandwrittenGroups(cli);
 for (const { name, tag } of API_GROUPS) {
   cli.command(name, { fetch: fetch2, openapi: spec(tag) });
 }
@@ -2473,9 +3010,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 +3026,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 +3068,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(