@whop/cli 0.6.0 → 0.7.0

package/dist/index.js

@@ -21,6 +21,7 @@ import {
   getActiveProfile,
   getSecret,
   getValidAccessToken,
+  listOAuthAccounts,
   listProfiles,
   native_spec_default,
   performOAuthLogin,
@@ -29,13 +30,14 @@ import {
   removeAllProfiles,
   removeProfile,
   resolveActiveAccountId,
+  selectAccount,
   selectProfile,
   setActiveProfileAccount,
   startSpinner,
   switchProfile,
   upsertProfile,
   validateApiKey
-} from "./chunk-GKKJXDPK.js";
+} from "./chunk-BSCOWFVU.js";
 import {
   external_exports
 } from "./chunk-KFCNNWPI.js";
@@ -173,6 +175,12 @@ var groups_default = [
     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"
   }
 ];
 
@@ -225,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" },
   {
@@ -362,7 +393,7 @@ async function loginAdapter(c2) {
   const accountId = getActiveProfile()?.accountId ?? "";
   if (accountId) {
     try {
-      const { createWhopFetch: createWhopFetch2 } = await import("./api-P7EWPZKG.js");
+      const { createWhopFetch: createWhopFetch2 } = await import("./api-YDHSDKDV.js");
       const fetch3 = createWhopFetch2();
       const res = await fetch3(
         new Request(
@@ -568,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"],
@@ -695,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,
@@ -1421,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;
@@ -1430,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`"
@@ -1440,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 ?? {} });
     }
   });
@@ -1467,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 ?? {} });
@@ -1484,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 ?? {} });
@@ -1503,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.",
@@ -2384,7 +2688,7 @@ ${c.success("\u2713 Your store is fully set up.")}`);
 // package.json
 var package_default = {
   name: "@whop/cli",
-  version: "0.6.0",
+  version: "0.7.0",
   description: "The Whop CLI \u2014 build and manage Whop apps from your terminal. Human and agent friendly.",
   keywords: [
     "agent",
@@ -2443,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",
@@ -2981,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) {
@@ -3037,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;
 }
@@ -3111,6 +3642,10 @@ cli.use(async (c2, next) => {
 });
 await registerHandwrittenGroups(cli);
 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;