@koda-sl/baker-cli 0.510.0 → 0.512.0-dev.8a743a629

package/dist/campaigns-XZOQ2VTK.js

@@ -0,0 +1,130 @@
+import {
+  META_LIST_SHAPE_ARGS,
+  budgetUnitHints,
+  registerMetaListSchema,
+  shapeMetaListRows,
+  writeMetaListRows
+} from "./chunk-KUY26RCF.js";
+import {
+  NAME_CONTAINS_ARG,
+  csvOrJson,
+  handleMetaError,
+  resolveAccountIdArg,
+  resolveEffectiveStatus,
+  statusFilterHints
+} from "./chunk-B2POVFR2.js";
+import "./chunk-Y2JZX6JB.js";
+import "./chunk-ZRP7Y2DM.js";
+import {
+  NO_CACHE_ARG
+} from "./chunk-AGBBTTKA.js";
+import "./chunk-65Y3RCWP.js";
+import {
+  apiGet
+} from "./chunk-X7VQFLHI.js";
+import "./chunk-LU4HI4KI.js";
+import "./chunk-LGK7UWBN.js";
+import "./chunk-Q7US4OOA.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/ads/meta/campaigns.ts
+import { defineCommand } from "citty";
+function advantagePlusHints(rows) {
+  const named = rows.flatMap((row) => {
+    const info = row.advantage_state_info;
+    const state = info?.advantage_state;
+    return typeof state === "string" && state.startsWith("ADVANTAGE_PLUS_") ? [`${String(row.id)} (${state.slice("ADVANTAGE_PLUS_".length).toLowerCase()})`] : [];
+  });
+  return named.length > 0 ? [
+    `Advantage+ campaigns: ${named.join(", ")}. Per-lever states (budget, audience, placements): --fields id,name,advantage_state_info.`
+  ] : [];
+}
+var listArgs = {
+  "account-id": { type: "string", description: "Meta ad account ID" },
+  "effective-status": { type: "string", description: "Comma-separated effective_status filter (overrides default)" },
+  "all-statuses": { type: "boolean", description: "Drop the default ACTIVE filter and return everything" },
+  "name-contains": NAME_CONTAINS_ARG,
+  limit: { type: "string", description: "Max rows (default 1000)" },
+  "no-cache": NO_CACHE_ARG,
+  ...META_LIST_SHAPE_ARGS
+};
+registerMetaListSchema(
+  "campaigns",
+  "List campaigns in a Meta ad account, as a table by default: id, name, effective_status, daily_budget, lifetime_budget, created_date. ACTIVE only unless --all-statuses. Start here: baker ads meta campaigns --account-id act_123 --all-statuses. --fields takes dotted paths for anything else (e.g. id,name,objective,bid_strategy,special_ad_categories,advantage_state_info); --full returns every field Meta sent; --output json returns the rows in the envelope. A hint names the campaigns Meta counts as Advantage+.",
+  listArgs
+);
+var listCommand = defineCommand({
+  meta: {
+    name: "list",
+    description: "List campaigns for a Meta ad account. Runs by default when no subcommand is given. Example: baker ads meta campaigns --account-id act_123"
+  },
+  args: listArgs,
+  run: async ({ args }) => {
+    const accountId = resolveAccountIdArg(args);
+    const effectiveStatus = resolveEffectiveStatus(args);
+    try {
+      const params = { "account-id": accountId };
+      if (effectiveStatus) params["effective-status"] = effectiveStatus;
+      if (args["name-contains"]) params["name-contains"] = args["name-contains"];
+      if (args.limit) params.limit = args.limit;
+      if (args["no-cache"]) params["skip-cache"] = "true";
+      const data = await apiGet("/api/ads/meta/campaigns", params);
+      const shaped = shapeMetaListRows("campaigns", data, args);
+      writeMetaListRows("campaigns", shaped, csvOrJson(args), [
+        ...statusFilterHints(data, effectiveStatus, "campaigns"),
+        ...advantagePlusHints(data),
+        ...budgetUnitHints(data)
+      ]);
+    } catch (err) {
+      handleMetaError(err);
+    }
+  }
+});
+var campaignsCommand = defineCommand({
+  meta: {
+    name: "campaigns",
+    description: `List campaigns for a Meta ad account, or stage writes (create/update/pause/resume/archive/delete/duplicate/copy).
+Defaults to ACTIVE only \u2014 pass --all-statuses to widen. Write subcommands stage ops on this chat's draft and
+apply only when the chat is published.
+
+In Meta's API "campaign" is the top-of-tree object (what marketers usually call a campaign group).
+The dashboard shows effective_status: ACTIVE, PAUSED, DELETED, ARCHIVED, IN_PROCESS, WITH_ISSUES, etc.
+
+Listings print a table by default: id, name, effective_status, daily/lifetime budget, created_date.
+--fields takes dotted paths for anything else (objective, bid_strategy, special_ad_categories, created_time,
+advantage_state_info). A hint names the campaigns Meta counts as Advantage+ \u2014 a state Meta derives from a
+campaign budget, Advantage+ audience and automatic placements on every ad set, not a setting;
+--full returns every field; --output json returns the same rows in the { ok, data } envelope.
+
+Examples:
+  baker ads meta campaigns --account-id act_123                                   # ACTIVE only
+  baker ads meta campaigns --account-id act_123 --all-statuses                    # everything
+  baker ads meta campaigns --account-id act_123 --all-statuses --name-contains Q3               # find one by name
+  baker ads meta campaigns --account-id act_123 --fields id,name,objective,bid_strategy,special_ad_categories
+  baker ads meta campaigns --account-id act_123 --output json                     # rows as JSON
+  baker ads meta campaigns create --account-id act_123 --name "Q3" --objective OUTCOME_LEADS --daily-budget 50
+  baker ads meta campaigns pause 6123 --account-id act_123`
+  },
+  subCommands: {
+    list: listCommand,
+    create: () => import("./write-commands-K6M3RTVK.js").then((m) => m.campaignsCreateCommand),
+    update: () => import("./write-commands-K6M3RTVK.js").then((m) => m.campaignsUpdateCommand),
+    pause: () => import("./write-commands-K6M3RTVK.js").then((m) => m.campaignsPauseCommand),
+    resume: () => import("./write-commands-K6M3RTVK.js").then((m) => m.campaignsResumeCommand),
+    archive: () => import("./write-commands-K6M3RTVK.js").then((m) => m.campaignsArchiveCommand),
+    delete: () => import("./write-commands-K6M3RTVK.js").then((m) => m.campaignsDeleteCommand),
+    duplicate: () => import("./write-commands-K6M3RTVK.js").then((m) => m.campaignsDuplicateCommand),
+    copy: () => import("./copy-writes-P4WK6OPM.js").then((m) => m.campaignsCopyCommand)
+  },
+  // `args` stays even though the parent has no `run`: citty scans rawArgs for the
+  // subcommand name using THIS command's arg defs, so without them `--account-id act_1`
+  // would read `act_1` as a subcommand. `default` (not `run`) dispatches the bare
+  // invocation — citty falls through to `run` after a subcommand, double-executing it.
+  args: listArgs,
+  default: "list"
+});
+export {
+  advantagePlusHints,
+  campaignsCommand
+};
+//# sourceMappingURL=campaigns-XZOQ2VTK.js.map

package/dist/campaigns-ZBN2RDTI.js

@@ -0,0 +1,76 @@
+import {
+  CHATGPT_ADS_REFERENCE,
+  runChatgptListRead
+} from "./chunk-URBN6DXM.js";
+import "./chunk-ZRP7Y2DM.js";
+import "./chunk-X7VQFLHI.js";
+import "./chunk-LU4HI4KI.js";
+import "./chunk-LGK7UWBN.js";
+import {
+  registerSchema
+} from "./chunk-Q7US4OOA.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/ads/chatgpt/campaigns.ts
+import { defineCommand } from "citty";
+registerSchema({
+  command: "ads.chatgpt.campaigns",
+  description: "Every campaign in the connected ChatGPT Ads account: status, objective, daily or lifetime budget (currency units), schedule, locations, platforms, and the serving issues ChatGPT Ads reports for it.",
+  args: {
+    full: { type: "boolean", description: "Return ChatGPT Ads' own campaign objects", required: false }
+  }
+});
+var LIST_ARGS = {
+  full: { type: "boolean", description: "Return ChatGPT Ads' own campaign objects", required: false }
+};
+function campaignHints(campaigns) {
+  if (campaigns.length === 0) {
+    return ["This account has no campaigns yet."];
+  }
+  const blocked = campaigns.filter((campaign) => campaign.servingIssues.length > 0);
+  return blocked.length > 0 ? [
+    `${blocked.length} campaign(s) report serving issues. Read servingIssues before changing a bid or budget \u2014 a higher bid does not fix a paused parent, a spent budget or a rejected ad.`
+  ] : [];
+}
+var campaignsListCommand = defineCommand({
+  meta: { name: "list", description: "ChatGPT Ads campaigns, newest first. Example: baker ads chatgpt campaigns" },
+  args: LIST_ARGS,
+  run: async ({ args }) => {
+    await runChatgptListRead(
+      CHATGPT_ADS_REFERENCE.campaigns,
+      "/api/ads/chatgpt/campaigns",
+      args.full ? { full: "true" } : void 0,
+      (campaigns) => args.full ? [] : campaignHints(campaigns)
+    );
+  }
+});
+var campaignsCommand = defineCommand({
+  meta: {
+    name: "campaigns",
+    description: `ChatGPT Ads campaigns \u2014 read them with why each one is or is not serving, or stage a change that applies when the chat is published.
+
+Write subcommands stage changes on this chat's draft. They never call ChatGPT Ads directly.
+
+Examples:
+  baker ads chatgpt campaigns
+  baker ads chatgpt campaigns create --name "Spring push" --objective clicks --daily-budget 20 --countries ES
+  baker ads chatgpt campaigns update cmpn_123 --daily-budget 35
+  baker ads chatgpt campaigns pause cmpn_123,cmpn_456`
+  },
+  subCommands: {
+    list: campaignsListCommand,
+    create: () => import("./campaign-writes-2SPNUA2E.js").then((m) => m.campaignsCreateCommand),
+    update: () => import("./campaign-writes-2SPNUA2E.js").then((m) => m.campaignsUpdateCommand),
+    pause: () => import("./campaign-writes-2SPNUA2E.js").then((m) => m.campaignsPauseCommand),
+    resume: () => import("./campaign-writes-2SPNUA2E.js").then((m) => m.campaignsResumeCommand),
+    archive: () => import("./campaign-writes-2SPNUA2E.js").then((m) => m.campaignsArchiveCommand)
+  },
+  // A parent must never declare `run`: citty falls through to it after the
+  // matched subcommand, so every write would also trigger a live list.
+  args: LIST_ARGS,
+  default: "list"
+});
+export {
+  campaignsCommand
+};
+//# sourceMappingURL=campaigns-ZBN2RDTI.js.map

package/dist/canvas-IYCM5PBE.js

@@ -0,0 +1,46 @@
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/canvas/index.ts
+import { defineCommand } from "citty";
+var canvasCommand = defineCommand({
+  meta: {
+    name: "canvas",
+    description: `Run Baker creative canvas JSON files locally. Local nodes execute in-process; remote nodes POST to the Convex backend gateway.
+
+Auth: BAKER_API_KEY (bk_, bkr_ or bkv_) + BAKER_API_URL (your Convex .convex.site URL).
+
+Subcommands:
+  baker canvas validate <file.json> : bring the canvas up to date with its blueprint, then schema/registry check + composition-meta deep check + cost preview
+  baker canvas critique <file.json> : pre-spend creative critic (advisory): video hook/legibility/retention or static text/grounding/type scores, never blocks
+  baker canvas viewer-check <slug> : would the viewer this static ad reaches understand it? (what is offered, to whom, what next; run makes the same check before it spends)
+  baker canvas run <file.json> : execute the canvas, write outputs to ./canvas/<run_id>/
+  baker canvas run --slug <slug> : run a creative by name; restores its files from run history when this workspace lacks them
+  baker canvas stale : creatives edited since their last render here (re-render each one listed)
+  baker canvas sync-definition <path> : push a creative's current node-graph + input thumbnails to the dashboard without rendering (runs automatically on canvas/prompt edits)
+  baker canvas catalog : one line per node; --node <id> for its full schema
+  baker canvas inspect <run_id> : one-page summary of a run (from run history when its folder is not here)
+  baker canvas scaffold-ad --spec <spec.json> : DEFAULT for a new ad: write beats (one spoken line + one shot each), get the whole runnable canvas
+  baker canvas scaffold-video <video> : reproduce a video the USER gave you (an ad you found is inspiration, not a copy target)
+  baker canvas scaffold-static-ad <image> : turn a source image into a runnable static-ad canvas (describe + element detection)
+Full guide: __tooling__/docs/tools/baker/canvas.md`
+  },
+  subCommands: {
+    run: () => import("./run-UZMOP22U.js").then((m) => m.runCommand),
+    rerun: () => import("./rerun-Q5CNS7LE.js").then((m) => m.rerunCommand),
+    validate: () => import("./validate-ELVTL2WL.js").then((m) => m.validateCommand),
+    critique: () => import("./critique-RATYHSIP.js").then((m) => m.critiqueCommand),
+    "viewer-check": () => import("./viewer-check-7MAJ3LGH.js").then((m) => m.viewerCheckCommand),
+    catalog: () => import("./catalog-ZY3MFT55.js").then((m) => m.catalogCommand),
+    inspect: () => import("./inspect-NJ6TYM3J.js").then((m) => m.inspectCommand),
+    "scaffold-ad": () => import("./scaffold-ad-T2VIQZ27.js").then((m) => m.scaffoldAdCommand),
+    "scaffold-video": () => import("./scaffold-video-74WN6WKE.js").then((m) => m.scaffoldVideoCommand),
+    "scaffold-static-ad": () => import("./scaffold-static-ad-BF2UV54V.js").then((m) => m.scaffoldStaticAdCommand),
+    "set-prompt": () => import("./set-prompt-B2C2XGOH.js").then((m) => m.setPromptCommand),
+    "sync-definition": () => import("./sync-definition-7ZGQAL7V.js").then((m) => m.syncDefinitionCommand),
+    stale: () => import("./stale-X2JN3PJB.js").then((m) => m.staleCommand)
+  }
+});
+export {
+  canvasCommand
+};
+//# sourceMappingURL=canvas-IYCM5PBE.js.map

package/dist/capabilities-LRESBKYV.js

@@ -0,0 +1,145 @@
+import {
+  failApi
+} from "./chunk-GJ52W2U2.js";
+import "./chunk-7D7YRHN3.js";
+import "./chunk-CAZGM2NX.js";
+import "./chunk-NZS3KEQ2.js";
+import "./chunk-GIWHHCD6.js";
+import {
+  CAPABILITY_SURFACES
+} from "./chunk-NSBNIPIW.js";
+import "./chunk-HNNCAJNF.js";
+import {
+  apiPost
+} from "./chunk-X7VQFLHI.js";
+import "./chunk-LU4HI4KI.js";
+import {
+  getEnv
+} from "./chunk-LGK7UWBN.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-Q7US4OOA.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/capabilities/index.ts
+import { defineCommand } from "citty";
+registerSchema({
+  command: "capabilities",
+  description: "Start here, before promising the user anything on an ad platform, in Analytics, or in Tag Manager. Answers three questions in one call: what is connected and with what access, what a write on each surface actually does when it lands, and what CANNOT be done here and why. Run it with no arguments for every surface; name one surface to also get the exact fields every change on it accepts.",
+  args: {
+    surface: {
+      type: "positional",
+      description: `One of: ${CAPABILITY_SURFACES.join(" | ")}. Omit for all of them.`,
+      required: false
+    },
+    full: {
+      type: "boolean",
+      description: "Include the field-level contract of every change on every surface",
+      required: false,
+      default: false
+    }
+  }
+});
+function capabilityHints(surfaces, tools = []) {
+  const hints = [];
+  const immediate = surfaces.filter((surface) => surface.writeMode === "applies-at-publish");
+  if (immediate.length > 0) {
+    hints.push(
+      `REAL AND IMMEDIATE: ${immediate.map((s) => s.label).join(", ")}. Completing this chat changes the user's live setup, so agree the changes before you finish, not after.`
+    );
+  }
+  const blocked = surfaces.filter((surface) => surface.blockers.length > 0);
+  if (blocked.length > 0) {
+    hints.push(`BLOCKED: ${blocked.flatMap((surface) => surface.blockers).join(" ")}`);
+  }
+  const limitCount = surfaces.reduce((total, surface) => total + surface.limits.length, 0);
+  if (limitCount > 0) {
+    hints.push(
+      `${limitCount} thing(s) listed under \`limits\` cannot be done at all. Read them before you plan the work \u2014 each one says what to tell the user instead. Do not try them and report the failure as a surprise.`
+    );
+  }
+  if (surfaces.length > 1) {
+    hints.push(
+      "Naming one surface (`baker capabilities google-ads`) adds `ops` \u2014 the exact fields and accepted values of every change there. Read that instead of guessing a field name."
+    );
+  }
+  const usable = tools.filter((tool) => tool.ready);
+  if (usable.length > 0) {
+    hints.push(
+      `ALSO AVAILABLE, and not on any surface above: ${usable.map((tool) => tool.label).join(", ")}. These answer WHY a page behaves as it does, which no surface here can. See \`tools[].reach\` for how to call each one.`
+    );
+  }
+  const broken = tools.filter((tool) => !tool.ready);
+  if (broken.length > 0) {
+    hints.push(
+      `CONNECTED BUT UNUSABLE: ${broken.map((tool) => `${tool.label} \u2014 ${tool.note ?? "not reachable"}`).join(" ")} Tell the user rather than planning around it silently.`
+    );
+  }
+  return hints;
+}
+var runCapabilities = defineCommand({
+  meta: {
+    name: "capabilities",
+    description: `What Baker can and cannot do for this company, before any work starts.
+
+Reports, per surface: what is connected and with what access, what a write there does when it lands, the entities that can be changed, and \u2014 the part nothing else tells you \u2014 what cannot be changed and why.
+
+Also returns \`tools\`: everything else this company can reach that is not one of those surfaces \u2014 Microsoft Clarity and any other MCP toolkit, custom servers, HubSpot. This is the one call that answers "what do I actually have".
+
+Examples:
+  baker capabilities
+  baker capabilities google-ads
+  baker capabilities tag-manager
+  baker capabilities --full
+
+Full guide: __tooling__/docs/tools/baker/capabilities.md`
+  },
+  args: {
+    surface: {
+      type: "positional",
+      description: `Narrow to one surface: ${CAPABILITY_SURFACES.join(" | ")}`,
+      required: false
+    },
+    full: {
+      type: "boolean",
+      description: "Include the field-level contract of every change on every surface",
+      required: false,
+      default: false
+    }
+  },
+  run: async ({ args }) => {
+    try {
+      const body = {};
+      const surface = args.surface;
+      if (surface) {
+        if (!CAPABILITY_SURFACES.includes(surface)) {
+          throw new Error(`"${surface}" is not a surface. Use one of: ${CAPABILITY_SURFACES.join(", ")}`);
+        }
+        body.surface = surface;
+      }
+      if (args.full) {
+        body.full = true;
+      }
+      const actingUserId = getEnv().BAKER_ACTING_USER_ID;
+      if (actingUserId) {
+        body.actingUserId = actingUserId;
+      }
+      const response = await apiPost("/api/capabilities", body);
+      const hints = capabilityHints(response.data.surfaces, response.data.tools);
+      writeJson({
+        ...response,
+        meta: { count: response.data.surfaces.length },
+        ...hints.length > 0 ? { hints } : {}
+      });
+    } catch (err) {
+      failApi(err);
+    }
+  }
+});
+var capabilitiesCommand = runCapabilities;
+export {
+  capabilitiesCommand,
+  capabilityHints
+};
+//# sourceMappingURL=capabilities-LRESBKYV.js.map

package/dist/catalog-ZY3MFT55.js

@@ -0,0 +1,65 @@
+import {
+  catalogView,
+  defaultRegistry,
+  generateCatalog
+} from "./chunk-KPCHWDJM.js";
+import "./chunk-AULSX5ZA.js";
+import "./chunk-UMIX2BMM.js";
+import "./chunk-DGCUPJZD.js";
+import "./chunk-AVYUFJQQ.js";
+import "./chunk-QHZE62GP.js";
+import "./chunk-FJZYOVSW.js";
+import "./chunk-F3CZFUXZ.js";
+import "./chunk-2WZI36D3.js";
+import "./chunk-65Y3RCWP.js";
+import "./chunk-LNNTHEL7.js";
+import "./chunk-FOMFU2RX.js";
+import "./chunk-PSGIHSNC.js";
+import "./chunk-PONLPYD7.js";
+import "./chunk-LU4HI4KI.js";
+import "./chunk-LGK7UWBN.js";
+import {
+  registerSchema
+} from "./chunk-Q7US4OOA.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/canvas/catalog.ts
+import { defineCommand } from "citty";
+var DESCRIPTION = "The canvas node catalog. Start here: `baker canvas catalog` lists every node by category with one line each (a few KB). Then `--node video_generate` prints that node's full JSON Schema \u2014 params, inputs, outputs, models, when to use it. `--category image` narrows the list; add `--full` for that category's schemas. `--full` alone prints every schema (~160 KB) \u2014 prefer `--node`.";
+var ARGS = {
+  node: {
+    type: "string",
+    required: false,
+    description: "Node id(s) whose full schema to print, comma-separated. Example: --node video_generate,tts"
+  },
+  category: {
+    type: "string",
+    required: false,
+    description: "Only this category (audio, video, image, \u2026). Listed with one line per node unless --full."
+  },
+  full: {
+    type: "boolean",
+    required: false,
+    default: false,
+    description: "Print full JSON Schemas instead of the one-line index (every node, or the --category)."
+  }
+};
+registerSchema({ command: "canvas.catalog", description: DESCRIPTION, args: ARGS });
+var catalogCommand = defineCommand({
+  meta: { name: "catalog", description: DESCRIPTION },
+  args: ARGS,
+  async run({ args }) {
+    const view = catalogView(generateCatalog(defaultRegistry()), {
+      node: typeof args.node === "string" ? args.node : void 0,
+      category: typeof args.category === "string" ? args.category : void 0,
+      full: args.full === true
+    });
+    process.stdout.write(`${JSON.stringify(view, null, 2)}
+`);
+    if (!view.ok) process.exit(1);
+  }
+});
+export {
+  catalogCommand
+};
+//# sourceMappingURL=catalog-ZY3MFT55.js.map

package/dist/catalogs-KZZN6W3M.js

@@ -0,0 +1,128 @@
+import {
+  failWriteValidation,
+  productFiltersArg,
+  schemaArgs
+} from "./chunk-HOHQXBFP.js";
+import {
+  CHATGPT_ADS_REFERENCE,
+  chatgptAdsProductQuerySchema,
+  runChatgptListRead,
+  runChatgptRead
+} from "./chunk-URBN6DXM.js";
+import "./chunk-ZRP7Y2DM.js";
+import {
+  apiGet,
+  apiPost
+} from "./chunk-X7VQFLHI.js";
+import "./chunk-LU4HI4KI.js";
+import "./chunk-LGK7UWBN.js";
+import {
+  registerSchema
+} from "./chunk-Q7US4OOA.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/ads/chatgpt/catalogs.ts
+import { defineCommand } from "citty";
+var REFERENCE = CHATGPT_ADS_REFERENCE.catalogs;
+registerSchema({
+  command: "ads.chatgpt.catalogs.list",
+  description: "The account's product catalogs: id (fd_\u2026), countries, and how many ad-eligible products each holds (0 while the first upload is processing).",
+  args: {}
+});
+var catalogsListCommand = defineCommand({
+  meta: { name: "list", description: "List the account's product catalogs." },
+  args: {},
+  run: async () => {
+    await runChatgptListRead(
+      REFERENCE,
+      "/api/ads/chatgpt/catalogs",
+      void 0,
+      (rows) => rows.length === 0 ? [
+        "No catalog. A catalog is created and filled in ChatGPT Ads Manager (or over its SFTP) from the company's product data \u2014 Baker does not upload products."
+      ] : ["A catalog campaign uses one: campaigns create --catalog-id fd_\u2026 --countries US \u2026"]
+    );
+  }
+});
+registerSchema({
+  command: "ads.chatgpt.catalogs.uploads",
+  description: "Each catalog's upload history: status (scanning, processing, completed, completed_with_errors, skipped, failed), rows accepted and rejected, and the problems ChatGPT Ads found.",
+  args: {}
+});
+var catalogsUploadsCommand = defineCommand({
+  meta: { name: "uploads", description: "How the catalogs' latest uploads went." },
+  args: {},
+  run: async () => {
+    await runChatgptRead(
+      REFERENCE,
+      () => apiGet("/api/ads/chatgpt/catalogs/uploads"),
+      (uploads) => uploads.some((upload) => upload.problems.length > 0 || upload.status === "failed") ? [
+        "Fix the rows named in problems in the source catalog and upload it again; Baker cannot edit catalog rows."
+      ] : []
+    );
+  }
+});
+var PRODUCTS_ARGS = {
+  "catalog-id": { type: "string", description: "The catalog (fd_\u2026)", required: true },
+  filters: {
+    type: "string",
+    description: "Conditions separated by ;, each field operator values \u2014 e.g. brand in Acme|Baker; price lte 5000. Operators: in, not_in, gt, gte, lt, lte, contains, not_contains, starts_with"
+  },
+  limit: { type: "string", description: "Products to show, 1-100 (default 20)" }
+};
+registerSchema({
+  command: "ads.chatgpt.catalogs.products",
+  description: "Preview the products a set of filters selects from a catalog \u2014 the same filters an ad group's --product-filters take. Check the match before staging them.",
+  args: schemaArgs(PRODUCTS_ARGS)
+});
+var catalogsProductsCommand = defineCommand({
+  meta: {
+    name: "products",
+    description: `Preview which products a set of filters selects.
+
+Examples:
+  baker ads chatgpt catalogs products --catalog-id fd_123
+  baker ads chatgpt catalogs products --catalog-id fd_123 --filters "brand in Acme; price lte 100"`
+  },
+  args: PRODUCTS_ARGS,
+  run: async ({ args }) => {
+    const parsed = chatgptAdsProductQuerySchema.safeParse({
+      catalogId: args["catalog-id"],
+      filters: productFiltersArg(args.filters) ?? [],
+      ...typeof args.limit === "string" && args.limit ? { limit: Number(args.limit) } : {}
+    });
+    if (!parsed.success) {
+      failWriteValidation(parsed.error.issues[0]?.message ?? "Invalid product query");
+    }
+    await runChatgptRead(
+      REFERENCE,
+      () => apiPost("/api/ads/chatgpt/catalogs/products", parsed.data),
+      (result) => [
+        ...result.matched === 0 ? [
+          "Nothing matches. Try without --filters: if that is empty too, the catalog's upload has not finished \u2014 see `catalogs uploads`."
+        ] : [],
+        ...result.products.some((product) => product.imageUrl === null) ? [
+          "Some products have no image yet (imageUrl null): ChatGPT Ads has not processed one, and a product ad shows the product's image \u2014 check the catalog's image links."
+        ] : []
+      ]
+    );
+  }
+});
+var catalogsCommand = defineCommand({
+  meta: {
+    name: "catalogs",
+    description: `Product catalogs for catalog campaigns \u2014 read them, check their uploads, preview products.
+
+Examples:
+  baker ads chatgpt catalogs
+  baker ads chatgpt catalogs uploads
+  baker ads chatgpt catalogs products --catalog-id fd_123 --filters "price lte 100"`
+  },
+  subCommands: { list: catalogsListCommand, uploads: catalogsUploadsCommand, products: catalogsProductsCommand },
+  // A parent must never declare `run`: citty falls through to it after the matched subcommand.
+  args: {},
+  default: "list"
+});
+export {
+  catalogsCommand
+};
+//# sourceMappingURL=catalogs-KZZN6W3M.js.map