@whop/cli 0.5.0 → 0.7.0

package/dist/index.js

@@ -21,6 +21,7 @@ import {
   getActiveProfile,
   getSecret,
   getValidAccessToken,
+  listOAuthAccounts,
   listProfiles,
   native_spec_default,
   performOAuthLogin,
@@ -29,107 +30,158 @@ import {
   removeAllProfiles,
   removeProfile,
   resolveActiveAccountId,
+  selectAccount,
   selectProfile,
   setActiveProfileAccount,
   startSpinner,
   switchProfile,
   upsertProfile,
   validateApiKey
-} from "./chunk-X34EUMEM.js";
+} from "./chunk-BSCOWFVU.js";
 import {
   external_exports
 } from "./chunk-KFCNNWPI.js";
 
 // src/api/groups.json
 var groups_default = [
-  [
-    "accounts",
-    "Accounts"
-  ],
-  [
-    "users",
-    "Users"
-  ],
-  [
-    "stats",
-    "Stats"
-  ],
-  [
-    "ledgers",
-    "Ledgers"
-  ],
-  [
-    "payouts",
-    "Payouts"
-  ],
-  [
-    "cards",
-    "Cards"
-  ],
-  [
-    "transfers",
-    "Transfers"
-  ],
-  [
-    "deposits",
-    "Deposits"
-  ],
-  [
-    "swaps",
-    "Swaps"
-  ],
-  [
-    "verifications",
-    "Verifications"
-  ],
-  [
-    "products",
-    "Products"
-  ],
-  [
-    "plans",
-    "Plans"
-  ],
-  [
-    "checkout-configurations",
-    "Checkout Configurations"
-  ],
-  [
-    "referrals",
-    "Referrals"
-  ],
-  [
-    "people",
-    "People"
-  ],
-  [
-    "events",
-    "Events"
-  ],
-  [
-    "ads",
-    "Ads"
-  ],
-  [
-    "ad-campaigns",
-    "Ad Campaigns"
-  ],
-  [
-    "ad-groups",
-    "Ad Groups"
-  ],
-  [
-    "audiences",
-    "Audiences"
-  ],
-  [
-    "media",
-    "Media"
-  ],
-  [
-    "social-accounts",
-    "Social Accounts"
-  ]
+  {
+    name: "accounts",
+    tag: "Accounts",
+    description: "A business on Whop: profile, wallet, capabilities, settings.",
+    group: "Core Resources"
+  },
+  {
+    name: "users",
+    tag: "Users",
+    description: "A person on Whop: profile and connected identities.",
+    group: "Core Resources"
+  },
+  {
+    name: "stats",
+    tag: "Stats",
+    description: "Aggregated financial time series for reporting.",
+    group: "Core Resources"
+  },
+  {
+    name: "ledgers",
+    tag: "Ledgers",
+    description: "The activity feed behind an account or user's balance.",
+    group: "Money"
+  },
+  {
+    name: "payouts",
+    tag: "Payouts",
+    description: "Send money from a balance to a bank or wallet.",
+    group: "Money"
+  },
+  {
+    name: "cards",
+    tag: "Cards",
+    description: "Issue cards that spend from a balance.",
+    group: "Money"
+  },
+  {
+    name: "transfers",
+    tag: "Transfers",
+    description: "Move funds between Whop accounts and users.",
+    group: "Money"
+  },
+  {
+    name: "deposits",
+    tag: "Deposits",
+    description: "Add funds to a balance.",
+    group: "Money"
+  },
+  {
+    name: "swaps",
+    tag: "Swaps",
+    description: "Convert a balance between currencies.",
+    group: "Money"
+  },
+  {
+    name: "verifications",
+    tag: "Verifications",
+    description: "Identity review required before payouts and card issuing.",
+    group: "Money"
+  },
+  {
+    name: "products",
+    tag: "Products",
+    description: "The things you sell. Each owns plans and a store page.",
+    group: "Commerce"
+  },
+  {
+    name: "plans",
+    tag: "Plans",
+    description: "Pricing for a product: one-time, recurring, trials, stock.",
+    group: "Commerce"
+  },
+  {
+    name: "checkout-configurations",
+    tag: "Checkout Configurations",
+    description: "Turn a plan into a shareable, prefilled checkout link.",
+    group: "Commerce"
+  },
+  {
+    name: "referrals",
+    tag: "Referrals",
+    description: "Track who referred a purchase and what they earn.",
+    group: "Commerce"
+  },
+  {
+    name: "people",
+    tag: "People",
+    description: "Visitors and customers of an account, aggregated from pixel events.",
+    group: "Tracking"
+  },
+  {
+    name: "events",
+    tag: "Events",
+    description: "Conversion and engagement events tracked for attribution.",
+    group: "Tracking"
+  },
+  {
+    name: "ads",
+    tag: "Ads",
+    description: "The creative: copy, assets, and destination URL.",
+    group: "Ads"
+  },
+  {
+    name: "ad-campaigns",
+    tag: "Ad Campaigns",
+    description: "Platform, objective, and budget for a set of ads.",
+    group: "Ads"
+  },
+  {
+    name: "ad-groups",
+    tag: "Ad Groups",
+    description: "Audience, placements, and schedule within a campaign.",
+    group: "Ads"
+  },
+  {
+    name: "audiences",
+    tag: "Audiences",
+    description: "Reusable targeting lists for ad groups.",
+    group: "Ads"
+  },
+  {
+    name: "media",
+    tag: "Media",
+    description: "AI-generated assets, billed from a balance, attachable wherever files are accepted.",
+    group: "Media"
+  },
+  {
+    name: "social-accounts",
+    tag: "Social Accounts",
+    description: "Connected Facebook and Instagram accounts that run ads.",
+    group: "Identity"
+  },
+  {
+    name: "apps",
+    tag: "Apps",
+    description: "Apps you build on Whop: metadata, hosted builds, runtime logs.",
+    group: "Developer"
+  }
 ];
 
 // src/auth/commands.ts
@@ -181,6 +233,29 @@ var switchArgs = external_exports.object({
 var switchOutput = external_exports.object({
   active: external_exports.string().describe("The newly active profile")
 });
+var accountArgs = external_exports.object({
+  id: external_exports.string().optional().describe(
+    "Business account to make the default \u2014 id (biz_xxx) or route (interactive picker if omitted)"
+  )
+});
+var accountOptions = external_exports.object({
+  list: external_exports.boolean().optional().describe(
+    "List the business accounts you can manage without changing the default"
+  )
+});
+var accountListItem = external_exports.object({
+  id: external_exports.string(),
+  title: external_exports.string(),
+  route: external_exports.string(),
+  active: external_exports.boolean().describe("Whether this is the profile's default business account")
+});
+var accountOutput = external_exports.object({
+  profile: external_exports.string().describe("The active profile"),
+  account: Identity.nullable().describe(
+    "The default business account passed to scoped commands"
+  ),
+  accounts: external_exports.array(accountListItem).describe("Business accounts this user can manage")
+});
 var loginExamples = [
   { description: "Interactive login" },
   {
@@ -318,7 +393,7 @@ async function loginAdapter(c2) {
   const accountId = getActiveProfile()?.accountId ?? "";
   if (accountId) {
     try {
-      const { createWhopFetch: createWhopFetch2 } = await import("./api-E6Y2WAEG.js");
+      const { createWhopFetch: createWhopFetch2 } = await import("./api-YDHSDKDV.js");
       const fetch3 = createWhopFetch2();
       const res = await fetch3(
         new Request(
@@ -524,6 +599,196 @@ function buildAuthGroup() {
       );
     }
   });
+  auth.command("account", {
+    description: "List your business accounts or set the default one for the active profile",
+    aliases: ["accounts"],
+    args: accountArgs,
+    options: accountOptions,
+    output: accountOutput,
+    examples: [
+      { description: "Pick the default business account interactively" },
+      {
+        options: { list: true },
+        description: "List the business accounts you can manage"
+      },
+      {
+        args: { id: "biz_xxx" },
+        description: "Set the default business account"
+      }
+    ],
+    hint: "OAuth profiles only \u2014 API key profiles are tied to a single business account.",
+    run: async (c2) => {
+      const profile = getActiveProfile();
+      if (!profile) {
+        return c2.error({
+          code: "NO_ACTIVE_PROFILE",
+          message: "No active profile \u2014 log in first.",
+          retryable: true,
+          cta: {
+            description: "To authenticate:",
+            commands: [{ command: "auth login", description: "Log in to Whop" }]
+          }
+        });
+      }
+      if (profile.method !== "oauth") {
+        return c2.error({
+          code: "API_KEY_PROFILE",
+          message: "API key profiles are tied to a single business account. Log in with Whop (OAuth) to switch between the businesses you manage.",
+          retryable: false,
+          cta: {
+            description: "To use a different business account:",
+            commands: [
+              {
+                command: "auth login",
+                description: 'Choose "Log in with Whop"'
+              }
+            ]
+          }
+        });
+      }
+      let token;
+      try {
+        token = await getValidAccessToken(profile);
+      } catch {
+        token = null;
+      }
+      if (!token) {
+        return c2.error({
+          code: "SESSION_EXPIRED",
+          message: "Your session is no longer valid \u2014 log in again.",
+          retryable: false,
+          cta: {
+            description: "To authenticate:",
+            commands: [{ command: "auth login", description: "Log in to Whop" }]
+          }
+        });
+      }
+      const s = c2.agent ? null : startSpinner("Loading your business accounts\u2026");
+      let accounts;
+      try {
+        accounts = await listOAuthAccounts(token);
+        s?.stop(
+          `Found ${accounts.length} business account${accounts.length === 1 ? "" : "s"}.`
+        );
+      } catch {
+        s?.stop("Couldn't load your business accounts.");
+        return c2.error({
+          code: "ACCOUNT_LOOKUP_FAILED",
+          message: "Couldn't load your business accounts. Please try again.",
+          retryable: true
+        });
+      }
+      if (accounts.length === 0) {
+        return c2.error({
+          code: "NO_ACCOUNTS",
+          message: "You don't have a business account yet.",
+          retryable: false,
+          cta: {
+            description: "Create one and start selling in one command:",
+            commands: [
+              {
+                command: "quickstart",
+                description: "Create your business account, product, and checkout link"
+              }
+            ]
+          }
+        });
+      }
+      const currentAccount = profile.accountId || profile.accountTitle || profile.accountRoute ? {
+        id: profile.accountId,
+        title: profile.accountTitle,
+        route: profile.accountRoute
+      } : null;
+      if (c2.options.list) {
+        return c2.ok(
+          {
+            profile: profile.name,
+            account: currentAccount,
+            accounts: accounts.map((account) => ({
+              ...account,
+              active: account.id === profile.accountId
+            }))
+          },
+          {
+            cta: {
+              description: "Change the default business account:",
+              commands: [
+                {
+                  command: "auth account",
+                  args: { id: true },
+                  description: "Pass a business account id or route"
+                }
+              ]
+            }
+          }
+        );
+      }
+      let requested = c2.args.id;
+      if (!requested) {
+        if (c2.agent) {
+          return c2.error({
+            code: "ACCOUNT_REQUIRED",
+            message: `Specify a business account. Available: ${accounts.map((account) => `${account.id} (${account.title})`).join(", ")}.`,
+            retryable: true
+          });
+        }
+        try {
+          requested = (await selectAccount(accounts, profile.accountId)).id;
+        } catch (error) {
+          if (error instanceof PromptCancelledError) {
+            return c2.error({
+              code: "CANCELLED",
+              message: "Switch cancelled.",
+              exitCode: 130
+            });
+          }
+          throw error;
+        }
+      }
+      const match = accounts.find((account) => account.id === requested) ?? accounts.find((account) => account.route === requested);
+      if (!match) {
+        return c2.error({
+          code: "ACCOUNT_NOT_FOUND",
+          message: `No business account "${requested}" for this user. Available: ${accounts.map((account) => `${account.id} (${account.title})`).join(", ")}.`,
+          retryable: true
+        });
+      }
+      if (!setActiveProfileAccount(match, profile.name)) {
+        return c2.error({
+          code: "PROFILE_REMOVED",
+          message: `Profile "${profile.name}" was removed while switching \u2014 log in again.`,
+          retryable: false,
+          cta: {
+            description: "To authenticate:",
+            commands: [
+              { command: "auth login", description: "Log in to Whop" }
+            ]
+          }
+        });
+      }
+      return c2.ok(
+        {
+          profile: profile.name,
+          account: match,
+          accounts: accounts.map((account) => ({
+            ...account,
+            active: account.id === match.id
+          }))
+        },
+        {
+          cta: {
+            description: `Now acting on behalf of ${match.title}.`,
+            commands: [
+              {
+                command: "auth status",
+                description: "Show the active identity"
+              }
+            ]
+          }
+        }
+      );
+    }
+  });
   auth.command("status", {
     description: "Show the active identity (whoami)",
     aliases: ["whoami"],
@@ -651,6 +916,14 @@ async function updateAppRoute(appId, route) {
 async function updateAppSecrets(appId, secrets) {
   return makeWhopRequest("PATCH", `/apps/${appId}`, { secrets });
 }
+async function listAppLogs(appId, params) {
+  const query = new URLSearchParams();
+  for (const [key, value] of Object.entries(params)) {
+    if (value !== void 0 && value !== "") query.set(key, String(value));
+  }
+  const qs = query.size > 0 ? `?${query}` : "";
+  return makeWhopRequest("GET", `/apps/${appId}/logs${qs}`);
+}
 async function createAppBuild(input) {
   return makeWhopRequest("POST", "/app_builds", {
     app_id: input.app_id,
@@ -1377,7 +1650,7 @@ async function withRoute(c2, app) {
     });
   }
 }
-function resolveSecretsAppId(appOption) {
+function resolveLinkedAppId(appOption) {
   if (appOption) return appOption;
   const projectDir = findProjectDir();
   const config = projectDir ? readAppConfig(projectDir) : null;
@@ -1386,6 +1659,33 @@ function resolveSecretsAppId(appOption) {
     `No app specified. Pass --app app_xxx or run inside a project with ${APP_CONFIG_FILENAME}.`
   );
 }
+var DURATION_MS = {
+  s: 1e3,
+  m: 6e4,
+  h: 36e5,
+  d: 864e5
+};
+function parseTimeOption(value) {
+  if (!value) return void 0;
+  const match = /^(\d+)([smhd])$/.exec(value);
+  if (!match) return value;
+  return new Date(
+    Date.now() - Number(match[1]) * DURATION_MS[match[2]]
+  ).toISOString();
+}
+var LOG_LEVEL_COLORS = {
+  error: chalk.red,
+  warn: chalk.yellow
+};
+function printLogLine(row) {
+  const time = row.created_at.replace("T", " ").replace("Z", "");
+  const color = LOG_LEVEL_COLORS[row.level] ?? chalk.dim;
+  const request = row.request_method ? chalk.dim(` ${row.request_method} ${row.request_path ?? ""}`) : "";
+  console.log(
+    `${chalk.dim(time)} ${color(row.level.padEnd(5))}${request}  ${row.message}`
+  );
+  if (row.stack) console.log(chalk.dim(row.stack));
+}
 function buildSecretsGroup() {
   const secrets = Cli_exports.create("secrets", {
     description: "Manage app secrets \u2014 encrypted at rest, injected as env bindings into the hosted runtime and `whop apps dev`"
@@ -1396,7 +1696,7 @@ function buildSecretsGroup() {
       app: external_exports.string().optional().describe("App id (defaults to the project's linked app)")
     }),
     run: async (c2) => {
-      const remote = await getApp(resolveSecretsAppId(c2.options.app));
+      const remote = await getApp(resolveLinkedAppId(c2.options.app));
       return c2.ok({ app_id: remote.id, secrets: remote.secrets ?? {} });
     }
   });
@@ -1423,7 +1723,7 @@ function buildSecretsGroup() {
         updates[pair.slice(0, eq)] = pair.slice(eq + 1);
       }
       const remote = await updateAppSecrets(
-        resolveSecretsAppId(c2.options.app),
+        resolveLinkedAppId(c2.options.app),
         updates
       );
       return c2.ok({ app_id: remote.id, secrets: remote.secrets ?? {} });
@@ -1440,7 +1740,7 @@ function buildSecretsGroup() {
       const updates = {};
       for (const key of c2.options.key) updates[key] = null;
       const remote = await updateAppSecrets(
-        resolveSecretsAppId(c2.options.app),
+        resolveLinkedAppId(c2.options.app),
         updates
       );
       return c2.ok({ app_id: remote.id, secrets: remote.secrets ?? {} });
@@ -1459,6 +1759,54 @@ async function buildAppGroup() {
   await registerSpecCommands(builds, "App builds");
   app.command(builds);
   app.command(buildSecretsGroup());
+  app.command("logs", {
+    description: "Read the app's server runtime logs \u2014 console output, uncaught exceptions, failed requests (kept 7 days)",
+    hint: "Newest first in the structured output; the terminal view prints oldest to newest. Deploy, hit your app, then read its logs to debug server code.",
+    options: external_exports.object({
+      app: external_exports.string().optional().describe("App id (defaults to the project's linked app)"),
+      level: external_exports.enum(["log", "debug", "info", "warn", "error"]).optional().describe("Only console lines of this level"),
+      query: external_exports.string().optional().describe("Only logs whose message contains this text"),
+      build: external_exports.string().optional().describe("Only logs from this build (abld_xxx)"),
+      since: external_exports.string().optional().describe(
+        'Start of the window \u2014 a duration like "10m"/"2h"/"1d" or an ISO 8601 timestamp'
+      ),
+      until: external_exports.string().optional().describe("End of the window \u2014 a duration or ISO 8601 timestamp"),
+      first: external_exports.number().optional().describe("Number of log lines to return (max 500)"),
+      after: external_exports.string().optional().describe("Cursor from a previous page's page_info")
+    }),
+    examples: [
+      { description: "Recent logs for the linked app" },
+      {
+        options: { level: "error", since: "1h" },
+        description: "Errors from the last hour"
+      },
+      {
+        options: { query: "checkout", app: "app_xxxxxxxx" },
+        description: "Search another app's logs by message text"
+      }
+    ],
+    outputPolicy: "agent-only",
+    run: async (c2) => {
+      const appId = resolveLinkedAppId(c2.options.app);
+      const page = await listAppLogs(appId, {
+        level: c2.options.level,
+        query: c2.options.query,
+        app_build_id: c2.options.build,
+        created_after: parseTimeOption(c2.options.since),
+        created_before: parseTimeOption(c2.options.until),
+        first: c2.options.first,
+        after: c2.options.after
+      });
+      const logs = page.data ?? [];
+      if (!c2.agent && !c2.formatExplicit) {
+        if (logs.length === 0) {
+          console.log(chalk.dim("No logs in this window."));
+        }
+        for (const row of [...logs].reverse()) printLogLine(row);
+      }
+      return c2.ok({ app_id: appId, logs, page_info: page.page_info });
+    }
+  });
   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.",
@@ -2340,7 +2688,7 @@ ${c.success("\u2713 Your store is fully set up.")}`);
 // package.json
 var package_default = {
   name: "@whop/cli",
-  version: "0.5.0",
+  version: "0.7.0",
   description: "The Whop CLI \u2014 build and manage Whop apps from your terminal. Human and agent friendly.",
   keywords: [
     "agent",
@@ -2361,7 +2709,8 @@ var package_default = {
     "whop-cli": "dist/index.js"
   },
   files: [
-    "dist"
+    "dist",
+    "skills"
   ],
   type: "module",
   exports: {
@@ -2398,7 +2747,7 @@ var package_default = {
   devDependencies: {
     "@types/node": "25.3.5",
     fflate: "0.8.2",
-    incur: "github:whopio/incur#4b9ca91dc02472db944fb103984ffc4a13251b6f",
+    incur: "github:whopio/incur#fbe3f4dbf48f1bc780cb1bca476f7dade1fe12d3",
     tsup: "8.5.0",
     tsx: "4.19.4",
     typescript: "5.9.3",
@@ -2913,7 +3262,9 @@ var HANDWRITTEN_GROUPS = [
 var HANDWRITTEN_GROUP_NAMES = new Set(
   HANDWRITTEN_GROUPS.map(({ name }) => name)
 );
-var API_GROUPS = groups_default.map(([name, tag]) => ({ name, tag })).filter(({ name }) => !HANDWRITTEN_GROUP_NAMES.has(name));
+var API_GROUPS = groups_default.filter(
+  ({ name }) => !HANDWRITTEN_GROUP_NAMES.has(name)
+);
 var COMMAND_GROUPS = [...API_GROUPS, ...HANDWRITTEN_GROUPS];
 async function registerHandwrittenGroups(cli2) {
   for (const group of HANDWRITTEN_GROUPS) await group.register(cli2);
@@ -2934,6 +3285,155 @@ async function setupAgents(cli2) {
   }
 }
 
+// src/media/commands.ts
+import { spinner as spinner2 } from "@clack/prompts";
+var POLL_INTERVAL_MS = 3e3;
+var whopFetch2 = createWhopFetch();
+async function buildMediaGroup(description) {
+  const media = Cli_exports.create("media", { description });
+  const spec2 = filterSpecByTag(native_spec_default, "Media");
+  const generated = await Openapi_exports.generateCommands(
+    spec2,
+    whopFetch2
+  );
+  for (const [name, entry] of generated) {
+    if (!("run" in entry)) continue;
+    if (name === "generate") {
+      media.command(name, buildGenerateCommand(entry));
+      continue;
+    }
+    media.command(name, entry);
+  }
+  return media;
+}
+function buildGenerateCommand(entry) {
+  const options = (entry.options ?? external_exports.object({})).extend({
+    wait: external_exports.boolean().optional().describe(
+      "Block until generation finishes and return the terminal asset (with file.id when ready)"
+    ),
+    timeout: external_exports.coerce.number().default(600).describe("Max seconds to wait with --wait before giving up")
+  });
+  return {
+    description: entry.description,
+    options,
+    examples: [
+      {
+        options: {
+          type: "image",
+          prompt: "A running club jogging across a bridge at sunrise",
+          wait: true
+        },
+        description: "Generate an image and wait for the finished file"
+      },
+      {
+        options: {
+          type: "video",
+          prompt: "Sneaker product spin on a white background",
+          duration_seconds: 5,
+          wait: true
+        },
+        description: "Generate a 5s video and wait"
+      }
+    ],
+    run: async (c2) => {
+      const { wait, timeout, ...body } = c2.options;
+      const request = Object.fromEntries(
+        Object.entries(body).filter(([, value]) => value !== void 0)
+      );
+      const asset = await createGeneration(c2, request);
+      if (!wait) return asset;
+      return awaitGeneration(c2, asset, Number(timeout));
+    }
+  };
+}
+async function createGeneration(c2, body) {
+  const res = await whopFetch2(
+    new Request("https://api.whop.com/media/generate", {
+      method: "POST",
+      body: JSON.stringify(body)
+    })
+  );
+  const payload = await res.json().catch(() => null);
+  if (res.ok && payload) return payload;
+  if (res.status === 402) {
+    const depositUrl = payload?.error?.deposit_url;
+    return c2.error({
+      code: "INSUFFICIENT_BALANCE",
+      message: `${payload?.message ?? "Insufficient balance to fund this generation."}${depositUrl ? ` Deposit at ${depositUrl}` : ""}`,
+      retryable: true,
+      cta: {
+        description: "Fund your balance, then retry:",
+        commands: [
+          { command: "deposits create", description: "Add funds to your balance" }
+        ]
+      }
+    });
+  }
+  return c2.error({
+    code: "API_ERROR",
+    message: payload?.message ?? `Generation request failed (HTTP ${res.status})`,
+    retryable: true
+  });
+}
+async function awaitGeneration(c2, created, timeoutSeconds) {
+  const interactive = !c2.agent && process.stdout.isTTY;
+  const progress = interactive ? spinner2() : null;
+  progress?.start(`Generating ${created.media_type ?? "asset"}\u2026`);
+  const startedAt = Date.now();
+  let asset = created;
+  while (asset.status === "processing") {
+    if (Date.now() - startedAt > timeoutSeconds * 1e3) {
+      progress?.stop(`Still processing after ${timeoutSeconds}s.`);
+      return c2.error({
+        code: "WAIT_TIMEOUT",
+        message: `Generation ${asset.id} is still processing after ${timeoutSeconds}s. It keeps running server-side \u2014 check on it later.`,
+        retryable: true,
+        cta: {
+          description: "Check the asset:",
+          commands: [
+            { command: `media get ${asset.id}`, description: "Poll the asset status" }
+          ]
+        }
+      });
+    }
+    await sleep2(POLL_INTERVAL_MS);
+    progress?.message(
+      `Generating ${created.media_type ?? "asset"}\u2026 ${Math.round((Date.now() - startedAt) / 1e3)}s`
+    );
+    asset = await fetchAsset(c2, asset.id, progress);
+  }
+  if (asset.status === "failed") {
+    progress?.stop("Generation failed.");
+    return c2.error({
+      code: "GENERATION_FAILED",
+      message: `${asset.error_message ?? "Generation failed."} The charge was refunded \u2014 adjust the prompt and retry.`,
+      retryable: true
+    });
+  }
+  progress?.stop(
+    `Generated ${asset.file?.id ?? asset.id} in ${Math.round((Date.now() - startedAt) / 1e3)}s.`
+  );
+  return asset;
+}
+async function fetchAsset(c2, id, progress) {
+  const res = await whopFetch2(
+    new Request(`https://api.whop.com/media/${id}`, { method: "GET" })
+  );
+  const payload = await res.json().catch(() => null);
+  if (!res.ok || !payload) {
+    progress?.stop("Polling failed.");
+    return c2.error({
+      code: "API_ERROR",
+      message: payload?.message ?? `Couldn't poll media asset ${id} (HTTP ${res.status})`,
+      retryable: true
+    });
+  }
+  return payload;
+}
+function sleep2(ms) {
+  return new Promise((resolve3) => setTimeout(resolve3, ms));
+}
+
 // src/lib/renderer.ts
 var MAX_CELL_WIDTH = 40;
 function isPlainObject(value) {
@@ -2990,13 +3490,91 @@ function renderRows(rows) {
 ${c.muted(`& ${hiddenCount} more columns \u2014 use --format json to see all`)}` : "";
   return [header, separator, ...body].join("\n") + overflowHint;
 }
+function pruneEmpty(value) {
+  if (value == null) return { kept: void 0, hidden: 1 };
+  if (Array.isArray(value)) {
+    if (value.length === 0) return { kept: void 0, hidden: 1 };
+    if (!value.every(isPlainObject)) return { kept: value, hidden: 0 };
+    let hidden = 0;
+    const items = [];
+    for (const item of value) {
+      const pruned = pruneEmpty(item);
+      hidden += pruned.hidden;
+      if (pruned.kept !== void 0) items.push(pruned.kept);
+    }
+    if (items.length === 0) return { kept: void 0, hidden };
+    return { kept: items, hidden };
+  }
+  if (isPlainObject(value)) {
+    let hidden = 0;
+    const out = {};
+    for (const [key, entry] of Object.entries(value)) {
+      const pruned = pruneEmpty(entry);
+      hidden += pruned.hidden;
+      if (pruned.kept !== void 0) out[key] = pruned.kept;
+    }
+    if (Object.keys(out).length === 0) return { kept: void 0, hidden: Math.max(hidden, 1) };
+    return { kept: out, hidden };
+  }
+  return { kept: value, hidden: 0 };
+}
+function formatScalar(value) {
+  const text3 = String(value);
+  if (typeof value === "boolean") return value ? c.success(text3) : c.error(text3);
+  if (typeof value === "number") return c.number(text3);
+  if (typeof value === "string") {
+    if (WHOP_TAG.test(value)) return c.id(text3);
+    if (/^https?:\/\//.test(value)) return c.link(text3);
+  }
+  return text3;
+}
+function renderEntries(obj, depth) {
+  const pad = "  ".repeat(depth);
+  const lines = [];
+  for (const [key, value] of Object.entries(obj)) {
+    const label = c.muted(`${key}:`);
+    if (isPlainObject(value)) {
+      lines.push(`${pad}${label}`);
+      lines.push(...renderEntries(value, depth + 1));
+    } else if (isObjectArray(value)) {
+      lines.push(`${pad}${label}`);
+      for (const item of value) {
+        const itemLines = renderEntries(item, depth + 1);
+        itemLines[0] = `${pad}- ${itemLines[0].slice(pad.length + 2)}`;
+        lines.push(...itemLines);
+      }
+    } else if (Array.isArray(value)) {
+      lines.push(`${pad}${label} ${value.map(formatScalar).join(", ")}`);
+    } else {
+      lines.push(`${pad}${label} ${formatScalar(value)}`);
+    }
+  }
+  return lines;
+}
+function renderObject(data) {
+  const { kept, hidden } = pruneEmpty(data);
+  const lines = kept === void 0 ? [c.muted("(all fields empty)")] : renderEntries(kept, 0);
+  const hint = hidden > 0 ? `
+${c.muted(`${hidden} empty ${hidden === 1 ? "field" : "fields"} hidden \u2014 use --format json to see all`)}` : "";
+  return lines.join("\n") + hint;
+}
 function render(data) {
-  if (isObjectArray(data)) return renderRows(data);
+  if (Array.isArray(data)) {
+    if (data.length === 0) return c.muted("(no results)");
+    return isObjectArray(data) ? renderRows(data) : null;
+  }
   if (isPlainObject(data)) {
-    const arrayFields = Object.values(data).filter(isObjectArray);
-    if (arrayFields.length === 1) {
-      return renderRows(arrayFields[0]);
+    const values = Object.values(data);
+    const hasScalarField = values.some((v) => v !== null && typeof v !== "object");
+    if (!hasScalarField) {
+      const objectArrays = values.filter(isObjectArray);
+      if (objectArrays.length === 1) return renderRows(objectArrays[0]);
+      const arrays = values.filter(Array.isArray);
+      if (objectArrays.length === 0 && arrays.length === 1 && arrays[0].length === 0) {
+        return c.muted("(no results)");
+      }
     }
+    return renderObject(data);
   }
   return null;
 }
@@ -3007,6 +3585,11 @@ var cli = Cli_exports.create("whop", {
   description: "Build and manage Whop apps from your terminal.",
   renderer: render,
   sync: {
+    // Shipped skill files generated by scripts/sync-spec.ts from the
+    // spec's own tag copy (x-whop-summary + description, authored in
+    // backend/openapi/v1/tags.yml). A matching directory name overrides
+    // the auto-generated skill for that command group.
+    include: ["skills/*"],
     suggestions: [
       "start selling on Whop",
       "show my Whop business accounts",
@@ -3058,100 +3641,16 @@ cli.use(async (c2, next) => {
   return next();
 });
 await registerHandwrittenGroups(cli);
-for (const { name, tag } of API_GROUPS) {
-  cli.command(name, { fetch: fetch2, openapi: spec(tag) });
+for (const { name, tag, description } of API_GROUPS) {
+  if (name === "media") {
+    cli.command(await buildMediaGroup(description));
+    continue;
+  }
+  cli.command(name, { description, fetch: fetch2, openapi: spec(tag) });
 }
 var cli_default = cli;
 
-// src/api/api-structure.json
-var api_structure_default = [
-  {
-    group: "Core Resources",
-    tags: [
-      "Accounts",
-      "Users",
-      "Webhooks",
-      "Stats"
-    ]
-  },
-  {
-    group: "Money",
-    tags: [
-      "Ledgers",
-      "Payouts",
-      "Cards",
-      "Transfers",
-      "Deposits",
-      "Swaps",
-      "Payout Methods",
-      "Verifications"
-    ]
-  },
-  {
-    group: "Commerce",
-    tags: [
-      "Products",
-      "Plans",
-      "Checkout Configurations",
-      "Referrals"
-    ]
-  },
-  {
-    group: "Tracking",
-    tags: [
-      "People",
-      "Events"
-    ]
-  },
-  {
-    group: "Ads",
-    tags: [
-      "Ads",
-      "Ad Campaigns",
-      "Ad Groups",
-      "Audiences"
-    ]
-  },
-  {
-    group: "Media",
-    tags: [
-      "Media"
-    ]
-  },
-  {
-    group: "Identity",
-    tags: [
-      "Social Accounts"
-    ]
-  }
-];
-
-// src/api/tag-descriptions.json
-var tag_descriptions_default = {
-  Accounts: "Your Whop account",
-  Users: "Users on your platform",
-  Stats: "Platform-wide statistics",
-  Ledgers: "Transaction history",
-  Payouts: "Withdraw earnings",
-  Cards: "Issued virtual cards",
-  Transfers: "Move funds between accounts",
-  Deposits: "Add funds to your balance",
-  Swaps: "Convert between currencies",
-  Verifications: "Identity verification status",
-  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",
-  "Ad Groups": "Sets of related ads",
-  Audiences: "Who sees your ads",
-  "Social Accounts": "Linked social profiles"
-};
-
 // src/lib/grouped-help.ts
-var descriptions = tag_descriptions_default;
-var toCliName = (tag) => tag.toLowerCase().replace(/\s+/g, "-");
 var SECTION_LABELS = {
   "get-started": "Get Started",
   auth: "Auth"
@@ -3188,14 +3687,12 @@ var handwrittenSection = (section) => ({
 });
 function buildGroupedHelp(version, description) {
   const lines = [];
-  const presentCommands = new Set(API_GROUPS.map(({ name }) => name));
-  const apiSections = api_structure_default.map(({ group, tags }) => ({
-    label: group,
-    commands: tags.filter((tag) => presentCommands.has(toCliName(tag))).map((tag) => ({
-      name: toCliName(tag),
-      description: descriptions[tag] ?? ""
-    }))
-  })).filter((section) => section.commands.length > 0);
+  const apiSections = [];
+  for (const { name, description: description2, group } of API_GROUPS) {
+    let section = apiSections.find((s) => s.label === group);
+    if (!section) apiSections.push(section = { label: group, commands: [] });
+    section.commands.push({ name, description: description2 });
+  }
   const commerceSections = apiSections.filter(
     (section) => section.label.toLowerCase() === "commerce"
   );