@koda-sl/baker-cli 0.551.0 → 0.552.0

package/dist/add-QYLIXGQT.js

@@ -0,0 +1,305 @@
+import {
+  flowDataPath,
+  isUsableStepNameKey,
+  readFlowTree,
+  requestFlowInputCall,
+  stepNameKey,
+  walkNodes,
+  writeFlowTree
+} from "./chunk-DZLPWNR4.js";
+import {
+  flowCatalogEntry,
+  flowCatalogTypes,
+  flowNodeTriggers
+} from "./chunk-RCNAKWK7.js";
+import "./chunk-QV6AST5T.js";
+import "./chunk-WCU362Z6.js";
+import "./chunk-GIWHHCD6.js";
+import "./chunk-SOPVIIUW.js";
+import "./chunk-G4FG5EQO.js";
+import "./chunk-NSBNIPIW.js";
+import "./chunk-MSMTG6OC.js";
+import "./chunk-OQ7CLFEL.js";
+import "./chunk-S3TBE37M.js";
+import "./chunk-O4OPH3ZE.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-VYEFXIEM.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/flows/add.ts
+import { randomUUID } from "crypto";
+import { defineCommand } from "citty";
+function unknownType(kind, type) {
+  writeJson({
+    ok: false,
+    error: {
+      code: "VALIDATION_ERROR",
+      message: `No ${kind} type "${type}".`,
+      fix: `Known types: ${flowCatalogTypes(kind).join(", ")}. See: baker flows schema ${kind}`
+    }
+  });
+  process.exit(1);
+}
+function concrete(skeleton, replacements) {
+  return { ...structuredClone(skeleton), ...replacements };
+}
+function stepNameRefusal(nodes, name) {
+  const key = stepNameKey(name);
+  if (!isUsableStepNameKey(key)) {
+    return {
+      message: `"${name}" cannot be a step name: it becomes the constant \`${key || "(empty)"}\`, which is not a valid identifier.`,
+      fix: 'A step name becomes `export const <NAME> = \u2026` in the form\'s generated code, so it must start with a letter and hold only letters, digits, spaces and dashes. Try "Your Details" rather than "1. Your details".'
+    };
+  }
+  const clash = nodes.find((node) => typeof node.name === "string" && stepNameKey(node.name) === key);
+  if (!clash) return null;
+  return {
+    message: `This form already has a step named "${clash.name}", which collides with "${name}".`,
+    fix: `Both become the constant \`${key}\`, and the form's generated code cannot hold it twice. Pick a name that differs by more than case, spacing or punctuation.`
+  };
+}
+registerSchema({
+  command: "flows.add-node",
+  description: "Add a step to a form with a valid skeleton \u2014 fresh UUID, explicit condition, correct nodeData discriminator, and form.external:null for a widget. Author its copy and conditions afterwards by editing _data.json.",
+  args: {
+    slug: { type: "positional", description: "Form slug", required: true },
+    type: { type: "string", description: "Node type (see: baker flows schema node)", required: true },
+    name: { type: "string", description: "Step name \u2014 unique, Title Case", required: true },
+    parent: { type: "string", description: "Parent node id. Omit to append to the root's children.", required: false }
+  }
+});
+var addNodeCommand = defineCommand({
+  meta: {
+    name: "add-node",
+    description: 'Add a step to a form, with the skeleton its type requires. Example: baker flows add-node contact --type customForm --name "Contact Info"'
+  },
+  args: {
+    slug: { type: "positional", description: "Form slug", required: true },
+    type: { type: "string", description: "Node type", required: true },
+    name: { type: "string", description: "Step name \u2014 unique, Title Case", required: true },
+    parent: { type: "string", description: "Parent node id (default: the root)" }
+  },
+  run: ({ args }) => {
+    const slug = String(args.slug);
+    const type = String(args.type);
+    const name = String(args.name).trim();
+    const entry = flowCatalogEntry("node", type) ?? unknownType("node", type);
+    const tree = readFlowTree(slug);
+    const nodes = walkNodes(tree);
+    const refusal = stepNameRefusal(nodes, name);
+    if (refusal) {
+      writeJson({
+        ok: false,
+        error: {
+          code: "VALIDATION_ERROR",
+          message: refusal.message.replace("This form", `"${slug}"`),
+          fix: refusal.fix
+        }
+      });
+      process.exit(1);
+    }
+    const parent = args.parent ? nodes.find((node2) => node2.id === String(args.parent)) : tree;
+    if (!parent) {
+      writeJson({
+        ok: false,
+        error: {
+          code: "NOT_FOUND",
+          message: `No node with id "${args.parent}" in "${slug}".`,
+          fix: `Nodes in this form: ${nodes.map((node2) => `${node2.id} (${node2.name})`).join(", ")}`
+        }
+      });
+      process.exit(1);
+    }
+    const node = concrete(entry.skeleton, { id: randomUUID(), name });
+    if (!Array.isArray(parent.children)) parent.children = [];
+    parent.children.push(node);
+    writeFlowTree(slug, tree);
+    writeJson({
+      ok: true,
+      data: { slug, nodeId: node.id, type, parentId: parent.id ?? null, path: flowDataPath(slug) },
+      hints: [
+        `Now fill in this step's \`ai\` field and its copy by editing ${flowDataPath(slug)}.`,
+        // Said on every step added, because the moment a Form's shape changes
+        // is the moment its outcome can move — and a Form nobody named an
+        // outcome for reports zero conversions rather than an error.
+        `Say what this Form counts before you finish: \`baker analytics conversions --flow ${slug}\` lists every ending already spelled as an event key, including this step's. Nothing in _data.json decides it.`,
+        ...entry.owners?.["nodeData.form.external"] === "request_flow_input" ? [
+          `Pick this ${type} step's resource: ${requestFlowInputCall(slug, pendingItem("node", String(node.id), type))}.`
+        ] : [],
+        ...entry.gotcha ? [entry.gotcha] : []
+      ]
+    });
+  }
+});
+function resolveTrigger(node, requested) {
+  const triggers = flowNodeTriggers(node.nodeData);
+  const where = `Step "${String(node.name ?? node.id)}"${triggers.type ? ` (a ${triggers.type} step)` : ""}`;
+  const raises = triggers.available.length > 0 ? `It raises: ${triggers.available.join(", ")}.` : triggers.why ?? "";
+  const no = (message, fix) => ({ ok: false, message, fix });
+  if (!triggers.known) {
+    return requested ? { ok: true, triggerId: requested } : no(`${where} is not a node type this command knows, so --trigger is required.`, triggers.why ?? "");
+  }
+  if (requested) {
+    return triggers.available.includes(requested) ? { ok: true, triggerId: requested } : no(
+      `${where} never raises \`${requested}\`, so a side effect carrying it would be written, pass every check, and never run.`,
+      raises
+    );
+  }
+  return triggers.completion ? { ok: true, triggerId: triggers.completion } : no(`${where} has no trigger a side effect can answer.`, raises);
+}
+function freeSideEffectId(type, taken) {
+  for (let n = 1; ; n++) {
+    const candidate = `se-${type}-${n}`;
+    if (!taken.has(candidate)) return candidate;
+  }
+}
+function sameTrackingSideEffect(node, type, triggerId) {
+  if (flowCatalogEntry("side-effect", type)?.owners?.tagIds !== "tags") return null;
+  const effects = Array.isArray(node.sideEffects) ? node.sideEffects : [];
+  for (const raw of effects) {
+    const effect = raw;
+    if (effect?.type === type && effect.triggerId === triggerId) return effect;
+  }
+  return null;
+}
+function secondPixelHint(node, type, triggerId) {
+  const already = sameTrackingSideEffect(node, type, triggerId);
+  if (!already) return null;
+  const event = typeof already.eventName === "string" ? ` with event "${already.eventName}"` : "";
+  return `"${String(node.name ?? node.id)}" already reports \`${triggerId}\` to ${type} as "${String(already.id)}"${event}. Give this one a different event; to change that conversion, edit "${String(already.id)}" and delete this one \u2014 the same event to the same tag counts every conversion twice.`;
+}
+function pendingItem(target, nodeId, kind, sideEffectId) {
+  return {
+    target,
+    nodeId,
+    kind,
+    status: `${kind} \u2014 not configured`,
+    needsInput: true,
+    ...sideEffectId ? { sideEffectId } : {}
+  };
+}
+function configureHints(slug, nodeId, id, type, needsCard) {
+  if (!needsCard) return [];
+  return [
+    `Configure it: ${requestFlowInputCall(slug, pendingItem("sideEffect", nodeId, type, id))}. Read the destination off that call's result.`
+  ];
+}
+registerSchema({
+  command: "flows.add-side-effect",
+  description: "Add a side effect to a step with a valid skeleton \u2014 encryptedConfig:null for a CRM, a tagIds slot for a pixel, and no oauthProviderId key. Then set where it sends with `baker flows connect` (an email: --email/--subject, written by you); only a typed secret goes to request_flow_input.",
+  args: {
+    slug: { type: "positional", description: "Form slug", required: true },
+    node: { type: "string", description: "Id of the step that fires it", required: true },
+    type: { type: "string", description: "Side-effect type (see: baker flows schema side-effect)", required: true },
+    id: { type: "string", description: "Side-effect id. Defaults to se-{type}-{n}.", required: false },
+    trigger: {
+      type: "string",
+      description: "triggerId. Defaults to the moment the step named by --node completes, which is a different id per node type. Pass this only for a non-completion moment (a HubSpot form's onFormReady, a Calendly page view, one of several iframe events); an id the step never raises is refused.",
+      required: false
+    }
+  }
+});
+var addSideEffectCommand = defineCommand({
+  meta: {
+    name: "add-side-effect",
+    description: "Add a side effect to a step, with the skeleton its type requires. Example: baker flows add-side-effect contact --node <id> --type googleSpreadsheet"
+  },
+  args: {
+    slug: { type: "positional", description: "Form slug", required: true },
+    node: { type: "string", description: "Id of the step that fires it", required: true },
+    type: { type: "string", description: "Side-effect type", required: true },
+    id: { type: "string", description: "Side-effect id (default se-{type}-{n})" },
+    trigger: {
+      type: "string",
+      description: "triggerId, for a non-completion moment. Default: whatever the step named by --node raises"
+    }
+  },
+  run: ({ args }) => {
+    const slug = String(args.slug);
+    const type = String(args.type);
+    const entry = flowCatalogEntry("side-effect", type) ?? unknownType("side-effect", type);
+    const tree = readFlowTree(slug);
+    const nodes = walkNodes(tree);
+    const node = nodes.find((candidate) => candidate.id === String(args.node));
+    if (!node) {
+      writeJson({
+        ok: false,
+        error: {
+          code: "NOT_FOUND",
+          message: `No node with id "${args.node}" in "${slug}".`,
+          fix: `Nodes in this form: ${nodes.map((candidate) => `${candidate.id} (${candidate.name})`).join(", ")}`
+        }
+      });
+      process.exit(1);
+    }
+    if (!Array.isArray(node.sideEffects)) node.sideEffects = [];
+    const existing = node.sideEffects;
+    const takenIds = new Set(
+      nodes.flatMap((n) => (n.sideEffects ?? []).map((se) => String(se?.id ?? "")))
+    );
+    const id = args.id ? String(args.id) : freeSideEffectId(type, takenIds);
+    if (takenIds.has(id)) {
+      writeJson({
+        ok: false,
+        error: {
+          code: "VALIDATION_ERROR",
+          message: `"${slug}" already has a side effect with id "${id}".`,
+          fix: `Drop --id to be given a free one (${freeSideEffectId(type, takenIds)}), or pick another.`
+        }
+      });
+      process.exit(1);
+    }
+    const trigger = resolveTrigger(node, args.trigger ? String(args.trigger) : void 0);
+    if (!trigger.ok) {
+      writeJson({
+        ok: false,
+        error: { code: "VALIDATION_ERROR", message: trigger.message, ...trigger.fix ? { fix: trigger.fix } : {} }
+      });
+      process.exit(1);
+    }
+    const triggerId = trigger.triggerId;
+    const secondPixel = secondPixelHint(node, type, triggerId);
+    const sideEffect = concrete(entry.skeleton, { id, triggerId });
+    existing.push(sideEffect);
+    writeFlowTree(slug, tree);
+    const needsUser = Object.entries(entry.owners ?? {}).filter(([, owner]) => owner !== "agent");
+    writeJson({
+      ok: true,
+      data: { slug, nodeId: node.id, sideEffectId: id, type, triggerId, path: flowDataPath(slug) },
+      hints: [
+        `Fires on \`${triggerId}\` \u2014 the moment "${String(node.name ?? node.id)}" raises. A side effect only runs when its triggerId is the one its own step raises, so this is set from the step, never from the side-effect type.`,
+        // A pixel side effect is the thing most often mistaken for "setting the
+        // conversion". It tells the ad platform; it tells Baker nothing, and a
+        // Form can fire every pixel it has while every Baker report says it
+        // converted nobody.
+        ...needsUser.some(([, owner]) => owner === "tags") ? [
+          `This reports the conversion to ${type}. It does NOT make Baker count anything: what Baker counts is a named event, set with \`baker analytics conversions --flow ${slug}\`. Do both \u2014 they are two different systems asked the same question.`
+        ] : [],
+        ...secondPixel ? [secondPixel] : [],
+        ...configureHints(
+          slug,
+          String(node.id),
+          id,
+          type,
+          needsUser.some(([, owner]) => owner === "request_flow_input" || owner === "connect")
+        ),
+        ...needsUser.some(([, owner]) => owner === "tags") ? [
+          "Fill `tagIds` with a real ref from `baker tags list`, or stage the tag first with the `tags` skill. Never invent one."
+        ] : [],
+        ...entry.gotcha ? [entry.gotcha] : []
+      ]
+    });
+  }
+});
+export {
+  addNodeCommand,
+  addSideEffectCommand,
+  freeSideEffectId,
+  resolveTrigger,
+  sameTrackingSideEffect,
+  secondPixelHint,
+  stepNameRefusal
+};
+//# sourceMappingURL=add-QYLIXGQT.js.map

package/dist/add-accounts-XCYWXGO3.js

@@ -0,0 +1,91 @@
+import {
+  PLATFORM_NAMES,
+  reportError,
+  splitList
+} from "./chunk-P4TA3B4C.js";
+import {
+  apiPost
+} from "./chunk-OQ7CLFEL.js";
+import "./chunk-S3TBE37M.js";
+import "./chunk-O4OPH3ZE.js";
+import {
+  BRAND_ACCOUNTS_MAX,
+  registerSchema,
+  writeJson
+} from "./chunk-VYEFXIEM.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/winning-ads/add-accounts.ts
+import { defineCommand } from "citty";
+var ADD_TIMEOUT_MS = 12e4;
+var named = (accounts) => accounts.map((a) => `${a.name} (${PLATFORM_NAMES[a.platform]})`).join(", ");
+function addAccountsHints(data) {
+  const hints = [];
+  if (data.added.length > 0) {
+    hints.push(
+      `Now tracking ${named(data.added)} \u2014 its ads arrive over the next minutes; check \`baker winning-ads following\`.`
+    );
+  }
+  if (data.already_tracked.length > 0) {
+    hints.push(`Already tracked under this brand: ${named(data.already_tracked)}.`);
+  }
+  for (const failure of data.failed) {
+    hints.push(`Not added: "${failure.input}" \u2014 ${failure.error}`);
+  }
+  return hints;
+}
+registerSchema({
+  command: "winning-ads.add-accounts",
+  description: "Track more accounts under a brand you already follow \u2014 another country's or language's Facebook page, a second LinkedIn company, another Google Ads entity. Pass the brand's advertiser id and one or more links (comma-separated): profile or ad-library links, Google advertiser ids (AR\u2026), or a website. `follow` returns ready-made calls for the look-alike accounts it found.",
+  args: {
+    advertiser: { type: "string", description: "Advertiser id of a followed brand (from `following`)", required: true },
+    inputs: {
+      type: "string",
+      description: `Comma-separated links, advertiser ids or websites \u2014 up to ${BRAND_ACCOUNTS_MAX}`,
+      required: true
+    }
+  }
+});
+var addAccountsCommand = defineCommand({
+  meta: {
+    name: "add-accounts",
+    description: `Add more of a followed brand's accounts (another market's Facebook page, a second LinkedIn company). Example: baker winning-ads add-accounts adv_123 "https://www.facebook.com/barkibu.it,AR01614014350098432001"`
+  },
+  args: {
+    advertiser: { type: "positional", description: "Advertiser id of a followed brand", required: true },
+    inputs: {
+      type: "positional",
+      description: "Comma-separated links, advertiser ids or websites",
+      required: true
+    }
+  },
+  run: async ({ args }) => {
+    try {
+      const inputs = [...new Set(splitList(String(args.inputs ?? "")))];
+      if (inputs.length === 0 || inputs.length > BRAND_ACCOUNTS_MAX) {
+        writeJson({
+          ok: false,
+          error: {
+            code: "VALIDATION_ERROR",
+            message: `Pass between 1 and ${BRAND_ACCOUNTS_MAX} comma-separated links.`
+          }
+        });
+        process.exit(1);
+      }
+      const data = await apiPost(
+        "/api/ad-library/accounts/add",
+        { advertiser_id: String(args.advertiser), inputs },
+        { timeoutMs: ADD_TIMEOUT_MS }
+      );
+      const hints = addAccountsHints(data);
+      writeJson({ ok: true, data, hints: hints.length > 0 ? hints : void 0 });
+    } catch (err) {
+      reportError(err);
+    }
+  }
+});
+export {
+  addAccountsCommand,
+  addAccountsHints
+};
+//# sourceMappingURL=add-accounts-XCYWXGO3.js.map

package/dist/ads-H6TOLQKA.js

@@ -0,0 +1,79 @@
+import {
+  CHATGPT_ADS_REFERENCE,
+  runChatgptListRead
+} from "./chunk-XLYLRUFX.js";
+import "./chunk-7KJ24KFI.js";
+import "./chunk-SOPVIIUW.js";
+import "./chunk-G4FG5EQO.js";
+import "./chunk-OQ7CLFEL.js";
+import "./chunk-S3TBE37M.js";
+import "./chunk-O4OPH3ZE.js";
+import {
+  registerSchema
+} from "./chunk-VYEFXIEM.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/ads/chatgpt/ads.ts
+import { defineCommand } from "citty";
+var args = {
+  "ad-group-id": { type: "string", description: "Only this ad group's ads (adgrp_\u2026)", required: false },
+  full: { type: "boolean", description: "Return ChatGPT Ads' own ad objects", required: false }
+};
+registerSchema({
+  command: "ads.chatgpt.ads",
+  description: "Ads in the connected ChatGPT Ads account, or in one ad group: the card's title, body, image and destination, its review outcome and reason, and serving issues.",
+  args
+});
+function adHints(ads) {
+  const rejected = ads.filter((ad) => ad.review === "rejected");
+  return rejected.length > 0 ? [
+    `${rejected.length} ad(s) were rejected in review; reviewReason says why. Editing the creative sends it back to review.`
+  ] : [];
+}
+var adsListCommand = defineCommand({
+  meta: { name: "list", description: "ChatGPT Ads chat cards. Example: baker ads chatgpt ads --ad-group-id adgrp_123" },
+  args,
+  run: async ({ args: input }) => {
+    const params = {};
+    if (input["ad-group-id"]) {
+      params["ad-group-id"] = input["ad-group-id"];
+    }
+    if (input.full) {
+      params.full = "true";
+    }
+    await runChatgptListRead(
+      CHATGPT_ADS_REFERENCE.ads,
+      "/api/ads/chatgpt/ads",
+      params,
+      (ads) => input.full ? [] : adHints(ads)
+    );
+  }
+});
+var adsCommand = defineCommand({
+  meta: {
+    name: "ads",
+    description: `ChatGPT Ads ads (chat cards): copy, image, destination and review status \u2014 or stage a change that applies when the chat is published.
+
+Examples:
+  baker ads chatgpt ads --ad-group-id adgrp_123
+  baker ads chatgpt ads create --ad-group-id adgrp_123 --name "Card A" --title "\u2026" --body "\u2026" --target-url https://\u2026 --image-url https://\u2026
+  baker ads chatgpt ads update ad_123 --title "Solar with no upfront cost"
+  baker ads chatgpt ads pause ad_123`
+  },
+  subCommands: {
+    list: adsListCommand,
+    create: () => import("./ad-writes-FF6PT3R5.js").then((m) => m.adsCreateCommand),
+    update: () => import("./ad-writes-FF6PT3R5.js").then((m) => m.adsUpdateCommand),
+    pause: () => import("./ad-writes-FF6PT3R5.js").then((m) => m.adsPauseCommand),
+    resume: () => import("./ad-writes-FF6PT3R5.js").then((m) => m.adsResumeCommand),
+    archive: () => import("./ad-writes-FF6PT3R5.js").then((m) => m.adsArchiveCommand),
+    "create-product": () => import("./ad-writes-FF6PT3R5.js").then((m) => m.adsCreateProductCommand)
+  },
+  // A parent must never declare `run`: citty falls through to it after the matched subcommand.
+  args,
+  default: "list"
+});
+export {
+  adsCommand
+};
+//# sourceMappingURL=ads-H6TOLQKA.js.map

package/dist/ads-JNXLC3PU.js

@@ -0,0 +1,120 @@
+import {
+  META_LIST_SHAPE_ARGS,
+  registerMetaListSchema,
+  shapeMetaListRows,
+  writeMetaListRows
+} from "./chunk-UOYVUUTX.js";
+import {
+  NAME_CONTAINS_ARG,
+  csvOrJson,
+  handleMetaError,
+  resolveAccountIdArg,
+  resolveEffectiveStatus,
+  statusFilterHints
+} from "./chunk-MGHPM72R.js";
+import "./chunk-QALAJNBG.js";
+import "./chunk-7KJ24KFI.js";
+import {
+  NO_CACHE_ARG
+} from "./chunk-T764KNWP.js";
+import "./chunk-65Y3RCWP.js";
+import {
+  apiGet
+} from "./chunk-OQ7CLFEL.js";
+import "./chunk-S3TBE37M.js";
+import "./chunk-O4OPH3ZE.js";
+import "./chunk-VYEFXIEM.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/ads/meta/ads.ts
+import { defineCommand } from "citty";
+var ACCOUNT_SELECTION = "Account: --account-id, else BAKER_META_AD_ACCOUNT_ID, else the company's only connected Meta ad account. With several connected it refuses with MISSING_ACCOUNT_ID listing each \u2014 re-run naming one.";
+var listArgs = {
+  "account-id": {
+    type: "string",
+    description: "Meta ad account ID (act_123). Optional when the company connected only one account (or BAKER_META_AD_ACCOUNT_ID is set); required when several are connected."
+  },
+  "adset-id": { type: "string", description: "Filter to one adset" },
+  "campaign-id": { type: "string", description: "Filter to one campaign" },
+  "effective-status": { type: "string", description: "Comma-separated effective_status filter (overrides default)" },
+  "all-statuses": { type: "boolean", description: "Drop the default ACTIVE filter" },
+  "name-contains": NAME_CONTAINS_ARG,
+  limit: { type: "string", description: "Max rows (default 1000)" },
+  "no-cache": NO_CACHE_ARG,
+  ...META_LIST_SHAPE_ARGS
+};
+registerMetaListSchema(
+  "ads",
+  `List ads in a Meta ad account, as a table by default: id, name, adset_id, campaign_id, effective_status, creative_id, issues (why an ad is WITH_ISSUES), created_time. Start here: baker ads meta ads --adset-id 6123. --fields takes dotted paths (e.g. id,tracking_specs); --full returns every field Meta sent; --output json returns the rows in the envelope. ${ACCOUNT_SELECTION}`,
+  listArgs
+);
+var listCommand = defineCommand({
+  meta: {
+    name: "list",
+    description: `List ads in a Meta ad account. Runs by default when no subcommand is given. ${ACCOUNT_SELECTION} Example: baker ads meta ads --account-id act_123`
+  },
+  args: listArgs,
+  run: async ({ args }) => {
+    const accountId = await resolveAccountIdArg(args);
+    const effectiveStatus = resolveEffectiveStatus(args);
+    try {
+      const params = { "account-id": accountId };
+      if (args["adset-id"]) params["adset-id"] = args["adset-id"];
+      if (args["campaign-id"]) params["campaign-id"] = args["campaign-id"];
+      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/ads", params);
+      const shaped = shapeMetaListRows("ads", data, args);
+      writeMetaListRows("ads", shaped, csvOrJson(args), statusFilterHints(data, effectiveStatus, "ads"));
+    } catch (err) {
+      handleMetaError(err);
+    }
+  }
+});
+var adsListCommand = defineCommand({
+  meta: {
+    name: "ads",
+    description: `List ads in a Meta ad account, or stage writes (create/update/pause/resume/archive/delete/duplicate/copy/retag).
+Defaults to ACTIVE only \u2014 pass --all-statuses to widen. Write subcommands stage ops on this chat's draft.
+${ACCOUNT_SELECTION}
+
+The dashboard shows effective_status (e.g. WITH_ISSUES, PENDING_REVIEW, DISAPPROVED, ADSET_PAUSED), not status.
+
+Listings print a table by default: id, name, adset_id, campaign_id, effective_status, creative_id, issues
+(why an ad is WITH_ISSUES), created_time. --fields takes dotted paths (e.g. tracking_specs,
+preview_shareable_link); --full returns every field; --output json returns the rows as JSON.
+
+Examples:
+  baker ads meta ads --account-id act_123
+  baker ads meta ads --adset-id 6123
+  baker ads meta ads --account-id act_123 --all-statuses --name-contains octubre --fields id,name,adset_id,creative_id   \u2014 find one ad by name
+  baker ads meta ads --adset-id 6123 --fields id,name,preview_shareable_link
+  baker ads meta ads create --name "Ad 1" --adset meta_temp_as01 --creative meta_temp_cr01
+  baker ads meta ads pause 6123 --account-id act_123
+  baker ads meta ads retag 6123 --set "utm_medium=paid-social"      \u2014 fix tracking on a LIVE ad, keeping everything else`
+  },
+  subCommands: {
+    list: listCommand,
+    create: () => import("./write-commands-EOIXXSVY.js").then((m) => m.adsCreateCommand),
+    update: () => import("./write-commands-EOIXXSVY.js").then((m) => m.adsUpdateCommand),
+    pause: () => import("./write-commands-EOIXXSVY.js").then((m) => m.adsPauseCommand),
+    resume: () => import("./write-commands-EOIXXSVY.js").then((m) => m.adsResumeCommand),
+    archive: () => import("./write-commands-EOIXXSVY.js").then((m) => m.adsArchiveCommand),
+    delete: () => import("./write-commands-EOIXXSVY.js").then((m) => m.adsDeleteCommand),
+    duplicate: () => import("./write-commands-EOIXXSVY.js").then((m) => m.adsDuplicateCommand),
+    copy: () => import("./copy-writes-OFXLTBQN.js").then((m) => m.adsCopyCommand),
+    retag: () => import("./write-commands-EOIXXSVY.js").then((m) => m.adsRetagCommand)
+  },
+  // `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 {
+  adsListCommand
+};
+//# sourceMappingURL=ads-JNXLC3PU.js.map

package/dist/ads-MXH4DNG2.js

@@ -0,0 +1,48 @@
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/ads/index.ts
+import { defineCommand } from "citty";
+var adsCommand = defineCommand({
+  meta: {
+    name: "ads",
+    description: `Ad platform commands. Each platform exposes its own native command surface \u2014 no forced parity.
+
+Platforms:
+  google    \u2014 Google Ads (GAQL queries, keywords, accounts, ad library)
+  meta      \u2014 Meta Ads (campaigns, adsets, ads, insights, previews)
+  linkedin  \u2014 LinkedIn Ads (firmographic analytics \u2014 job-title \xD7 company \xD7 industry \xD7 seniority pivots)
+  x         \u2014 X (Twitter) Ads (campaigns, line items, promoted tweets, analytics)
+  chatgpt   \u2014 ChatGPT Ads (account, campaigns, ad groups, ads, insights \u2014 read-only)
+  terms     \u2014 which platform terms an ad account has accepted (customer lists, lead forms, \u2026) and how to accept the rest
+
+Across platforms:
+  performance \u2014 Baker's stored copy of every connected platform's results, changes and alerts (no platform call). Start here for "how are the ads doing".
+
+Examples:
+  baker ads performance overview
+  baker ads google accounts
+  baker ads google query --preset campaign-performance --customer-id 1234567890
+  baker ads meta accounts
+  baker ads meta campaigns --account-id act_123 --effective-status ACTIVE
+  baker ads meta insights --object act_123 --level ad --date-preset last_7d --fields impressions,spend,ctr
+  baker ads linkedin accounts
+  baker ads x accounts
+  baker ads x stats sync --preset campaign-engagement-7d --entity-ids abc,def
+  baker ads chatgpt insights --days 30 --granularity daily
+  baker ads terms --platform google --account-id 1234567890
+Full guides: __tooling__/docs/tools/baker/ads-<platform>.md (google|meta|linkedin|x|chatgpt|performance|terms)`
+  },
+  subCommands: {
+    google: () => import("./google-V74DJSG6.js").then((m) => m.googleCommand),
+    meta: () => import("./meta-W2YTPZE7.js").then((m) => m.metaCommand),
+    linkedin: () => import("./linkedin-ICM5CNNS.js").then((m) => m.linkedinCommand),
+    x: () => import("./x-6VIOYUKX.js").then((m) => m.xCommand),
+    chatgpt: () => import("./chatgpt-D7MUGYE5.js").then((m) => m.chatgptCommand),
+    performance: () => import("./performance-QZGRGTTY.js").then((m) => m.performanceCommand),
+    terms: () => import("./terms-AY5LECWX.js").then((m) => m.termsCommand)
+  }
+});
+export {
+  adsCommand
+};
+//# sourceMappingURL=ads-MXH4DNG2.js.map