@koda-sl/baker-cli 0.471.0 → 0.473.0

package/dist/add-TM7AYRYC.js

@@ -0,0 +1,302 @@
+import {
+  flowDataPath,
+  isUsableStepNameKey,
+  readFlowTree,
+  requestFlowInputCall,
+  stepNameKey,
+  walkNodes,
+  writeFlowTree
+} from "./chunk-ARFUXR65.js";
+import {
+  flowCatalogEntry,
+  flowCatalogTypes,
+  flowNodeTriggers
+} from "./chunk-XABVEMC3.js";
+import "./chunk-GXDLWBOY.js";
+import "./chunk-GIWHHCD6.js";
+import "./chunk-XQIOCIDO.js";
+import "./chunk-ML7DLFFY.js";
+import "./chunk-JLCK7K6Y.js";
+import "./chunk-F4H6VVPE.js";
+import "./chunk-G3UCXCC2.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-IWLWY2UD.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-TM7AYRYC.js.map

package/dist/add-XFCKOO6B.js

@@ -0,0 +1,104 @@
+import {
+  compactSource,
+  reportError,
+  reportInvalid
+} from "./chunk-6QNEVETC.js";
+import {
+  testimonialSourceRefreshIntervalSchema,
+  testimonialSourceTypeSchema,
+  testimonialSourcesAddRequestSchema
+} from "./chunk-XABVEMC3.js";
+import "./chunk-GXDLWBOY.js";
+import "./chunk-GIWHHCD6.js";
+import "./chunk-XQIOCIDO.js";
+import "./chunk-ML7DLFFY.js";
+import {
+  apiPost
+} from "./chunk-JLCK7K6Y.js";
+import "./chunk-F4H6VVPE.js";
+import "./chunk-G3UCXCC2.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-IWLWY2UD.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/testimonials/sources/add.ts
+import { defineCommand } from "citty";
+var SITES = testimonialSourceTypeSchema.options.join("|");
+registerSchema({
+  command: "testimonials.sources.add",
+  description: "Add a review page as a testimonial source \u2014 Google Maps, Trustpilot, Yelp, Tripadvisor, G2, Capterra, Amazon, App Store or Google Play. Pass the page's link (it names its own site), or a business name for Google Maps. Its reviews (up to 700) are imported, tagged and made searchable in the background over the next minutes. Each imported review costs a little, so add only the client's own listings the user asked for. Applies immediately and shows on the chat as an already-applied change. Adding a listing that is already a source is a no-op that starts a fresh import.",
+  args: {
+    input: {
+      type: "string",
+      description: "The review page's link, or a business name (Google Maps only)",
+      required: true
+    },
+    platform: {
+      type: "string",
+      description: `Only to force a site: ${SITES}. A bare domain with trustpilot is that company's Trustpilot page.`,
+      required: false
+    },
+    every: {
+      type: "string",
+      description: `Auto-sync cadence: ${testimonialSourceRefreshIntervalSchema.options.join("|")} (default never)`,
+      required: false
+    }
+  }
+});
+function addSourceHints(input, { created, source }) {
+  const hints = [
+    created ? `Added ${source.label} on ${source.platformLabel}. Its reviews are importing in the background \u2014 they become searchable with \`baker testimonials search\` as each one is analysed, usually within a few minutes. Don't wait on them in this turn; check with \`baker testimonials sources list\`.` : `${source.label} on ${source.platformLabel} was already a source; a fresh import was started if one wasn't running.`
+  ];
+  if (created && source.platform === "google" && !/^https?:\/\/|\.[a-z]{2,}\//i.test(input.trim())) {
+    hints.push(
+      `Matched the name to ${source.label} on Google Maps (${source.pageUrl ?? "no link"}). If that is not the client's business, run \`baker testimonials sources remove ${source.id}\` at once and add the listing's Google Maps link instead.`
+    );
+  }
+  if (source.refreshInterval === "never") {
+    hints.push(
+      `Auto-sync is off. If the user wants new reviews to keep arriving: \`baker testimonials sources schedule ${source.id} --every monthly\`.`
+    );
+  }
+  return hints;
+}
+var addCommand = defineCommand({
+  meta: {
+    name: "add",
+    description: `Add a review page as a testimonial source. Start here with the page's link; for Google Maps a business name also works.
+
+Examples:
+  baker testimonials sources add https://www.yelp.com/biz/acme-bakery-madrid
+  baker testimonials sources add https://www.g2.com/products/acme --every monthly
+  baker testimonials sources add "Acme Bakery Madrid"          # Google Maps, found by name
+  baker testimonials sources add acme.com --platform trustpilot`
+  },
+  args: {
+    input: { type: "positional", description: "Review page link, or a business name for Google Maps", required: true },
+    platform: { type: "string", description: `Force a site: ${SITES}`, required: false },
+    every: { type: "string", description: "Auto-sync: never|daily|weekly|monthly", required: false }
+  },
+  run: async ({ args }) => {
+    const parsed = testimonialSourcesAddRequestSchema.safeParse({
+      input: String(args.input ?? ""),
+      platform: args.platform ? String(args.platform).toLowerCase().replace(/[\s-]/g, "_") : void 0,
+      every: args.every ? String(args.every).toLowerCase() : void 0
+    });
+    if (!parsed.success) reportInvalid(parsed.error.issues[0]);
+    try {
+      const data = await apiPost("/api/testimonials/sources/add", parsed.data, {
+        timeoutMs: 12e4
+      });
+      const hints = addSourceHints(parsed.data.input, data);
+      writeJson({ ok: true, data: { created: data.created, source: compactSource(data.source) }, hints });
+    } catch (err) {
+      reportError(err);
+    }
+  }
+});
+export {
+  addCommand,
+  addSourceHints
+};
+//# sourceMappingURL=add-XFCKOO6B.js.map

package/dist/add-ZMZJSBQT.js

@@ -0,0 +1,105 @@
+import {
+  compactSource,
+  reportError
+} from "./chunk-IZNTYRKB.js";
+import {
+  mediaSourcePlatformSchema,
+  mediaSourceRefreshIntervalSchema,
+  mediaSourcesAddRequestSchema
+} from "./chunk-GXDLWBOY.js";
+import {
+  apiPost
+} from "./chunk-JLCK7K6Y.js";
+import "./chunk-F4H6VVPE.js";
+import "./chunk-G3UCXCC2.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-IWLWY2UD.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/media-sources/add.ts
+import { defineCommand } from "citty";
+registerSchema({
+  command: "media-sources.add",
+  description: "Connect a public social account as a source for the image and video libraries \u2014 Instagram, TikTok, YouTube (videos only), LinkedIn company pages, Facebook pages. Its recent posts (up to a year back) are imported. A Google Drive folder is not added here: ask for it with request_connection (platform google-drive, choose media-folder) and the user picks it in the chat. Everything is described and made searchable in the background. Applies immediately and shows on the chat as an already-applied change. Adding a source that is already connected is a no-op.",
+  args: {
+    input: {
+      type: "string",
+      description: "Profile URL (names its own platform), or @handle together with --platform",
+      required: true
+    },
+    platform: {
+      type: "string",
+      description: `Needed only for a bare handle: ${mediaSourcePlatformSchema.options.join("|")}`,
+      required: false
+    },
+    every: {
+      type: "string",
+      description: `Auto-sync cadence: ${mediaSourceRefreshIntervalSchema.options.join("|")} (default weekly for every source)`,
+      required: false
+    }
+  }
+});
+var addCommand = defineCommand({
+  meta: {
+    name: "add",
+    description: "Connect a social account (Instagram, TikTok, YouTube, LinkedIn page, Facebook page) as a media source. Start here with the profile URL. A Google Drive folder is never added by link: call request_connection with platform google-drive and choose media-folder, and the user picks the folder in the chat.\n\nExamples:\n  baker media-sources add https://www.tiktok.com/@acme\n  baker media-sources add @acme --platform instagram --every daily"
+  },
+  args: {
+    input: { type: "positional", description: "Profile URL or @handle", required: true },
+    platform: {
+      type: "string",
+      description: "instagram|tiktok|youtube|linkedin|facebook \u2014 only for a bare handle",
+      required: false
+    },
+    every: { type: "string", description: "Auto-sync: never|daily|weekly|monthly", required: false }
+  },
+  run: async ({ args }) => {
+    const parsed = mediaSourcesAddRequestSchema.safeParse({
+      input: String(args.input ?? ""),
+      platform: args.platform ? String(args.platform).toLowerCase() : void 0,
+      every: args.every ? String(args.every).toLowerCase() : void 0
+    });
+    if (!parsed.success) {
+      const issue = parsed.error.issues[0];
+      writeJson({
+        ok: false,
+        error: {
+          code: "VALIDATION_ERROR",
+          message: issue ? `${issue.path.join(".") || "input"}: ${issue.message}` : "Invalid request"
+        }
+      });
+      process.exit(1);
+    }
+    try {
+      const data = await apiPost("/api/media-sources/add", parsed.data, {
+        timeoutMs: 12e4
+      });
+      const hints = [
+        data.created ? `Connected ${data.source.label} on ${data.source.platformLabel}. Its posts are importing in the background \u2014 they become searchable with \`baker images search\` / \`baker videos search\` as each one is analysed. Check progress with \`baker media-sources list\`.` : `${data.source.label} on ${data.source.platformLabel} was already connected; a fresh import was started if one wasn't running.`
+      ];
+      if (data.source.platform === "youtube") {
+        hints.push(
+          "YouTube feeds the video library only, newest first, a batch per sync; videos over 20 minutes are skipped."
+        );
+      }
+      if (data.source.refreshInterval === "never") {
+        hints.push(
+          `Auto-sync is off. If the user wants new posts to keep arriving: \`baker media-sources schedule ${data.source.key} --every weekly\`.`
+        );
+      }
+      writeJson({
+        ok: true,
+        data: { created: data.created, source: compactSource(data.source), name: data.profile.displayName },
+        hints
+      });
+    } catch (err) {
+      reportError(err, parsed.data.input);
+    }
+  }
+});
+export {
+  addCommand
+};
+//# sourceMappingURL=add-ZMZJSBQT.js.map

package/dist/add-accounts-A2YRT5NR.js

@@ -0,0 +1,91 @@
+import {
+  PLATFORM_NAMES,
+  reportError,
+  splitList
+} from "./chunk-G3AOJ5FE.js";
+import {
+  apiPost
+} from "./chunk-JLCK7K6Y.js";
+import "./chunk-F4H6VVPE.js";
+import "./chunk-G3UCXCC2.js";
+import {
+  BRAND_ACCOUNTS_MAX,
+  registerSchema,
+  writeJson
+} from "./chunk-IWLWY2UD.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-A2YRT5NR.js.map

package/dist/ads-HRCVRXPO.js

@@ -0,0 +1,77 @@
+import {
+  CHATGPT_ADS_REFERENCE,
+  runChatgptListRead
+} from "./chunk-MOMZOWYC.js";
+import "./chunk-CGOVXSSY.js";
+import "./chunk-JLCK7K6Y.js";
+import "./chunk-F4H6VVPE.js";
+import "./chunk-G3UCXCC2.js";
+import {
+  registerSchema
+} from "./chunk-IWLWY2UD.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-WTWRSFLW.js").then((m) => m.adsCreateCommand),
+    update: () => import("./ad-writes-WTWRSFLW.js").then((m) => m.adsUpdateCommand),
+    pause: () => import("./ad-writes-WTWRSFLW.js").then((m) => m.adsPauseCommand),
+    resume: () => import("./ad-writes-WTWRSFLW.js").then((m) => m.adsResumeCommand),
+    archive: () => import("./ad-writes-WTWRSFLW.js").then((m) => m.adsArchiveCommand),
+    "create-product": () => import("./ad-writes-WTWRSFLW.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-HRCVRXPO.js.map