@koda-sl/baker-cli 0.543.0 → 0.545.0-dev.2a6beac48

package/dist/audience-size-NN43B7FF.js

@@ -0,0 +1,76 @@
+import {
+  handleLinkedinError,
+  loadTargetingArg,
+  resolveAccountIdArg
+} from "./chunk-DD6IMD7G.js";
+import {
+  writeAdsJson
+} from "./chunk-MGWAZXY6.js";
+import {
+  NO_CACHE_ARG
+} from "./chunk-FPTEBOB5.js";
+import "./chunk-S47XHWFU.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-BNO3EFGR.js";
+import {
+  apiPost
+} from "./chunk-B2OHCWYB.js";
+import "./chunk-SVUFNCOE.js";
+import "./chunk-E54435XT.js";
+import "./chunk-WCIS4FZH.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/ads/linkedin/audience-size.ts
+import { defineCommand } from "citty";
+var audienceSizeCommand = defineCommand({
+  meta: {
+    name: "audience-size",
+    description: `Estimate audience size for a targeting payload \u2014 pre-launch sanity check.
+
+Returns total + active counts plus playbook \xA704 warnings:
+  size <20K      \u2192 too narrow (will not deliver)
+  size <50K      \u2192 outside the 50K\u2013500K sweet spot
+  size >500K     \u2192 outside the sweet spot
+  size >1M       \u2192 too broad, refine ICP
+
+The targeting payload must follow LinkedIn's 'targetingCriteria' shape \u2014 an
+include/exclude tree of and/or boolean operators with adTargetingFacet keys.
+The simplest form:
+  { "include": { "and": [{ "or": { "urn:li:adTargetingFacet:locations": ["urn:li:geo:103644278"] }}]}}
+
+Examples:
+  baker ads linkedin audience-size --account-id 503001492 --targeting-file targeting.json
+  baker ads linkedin audience-size --account-id 503001492 --targeting '{"include":{"and":[]}}'`
+  },
+  args: {
+    "account-id": { type: "string", description: "Numeric account ID or urn:li:sponsoredAccount:N" },
+    "account-urn": { type: "string", description: "Alias for --account-id" },
+    targeting: { type: "string", description: "Inline JSON targetingCriteria payload" },
+    "targeting-file": { type: "string", description: "Path to JSON file with targetingCriteria" },
+    "no-cache": NO_CACHE_ARG,
+    output: { type: "string", description: "json", default: "json" }
+  },
+  run: async ({ args }) => {
+    const accountId = resolveAccountIdArg(args);
+    const targetingCriteria = loadTargetingArg(args);
+    try {
+      const data = await apiPost("/api/ads/linkedin/audience-size", {
+        accountId,
+        targetingCriteria,
+        skipCache: Boolean(args["no-cache"])
+      });
+      writeAdsJson({ ok: true, data });
+    } catch (err) {
+      handleLinkedinError(err);
+    }
+  }
+});
+export {
+  audienceSizeCommand
+};
+//# sourceMappingURL=audience-size-NN43B7FF.js.map

package/dist/audience-writes-SHZKH2EI.js

@@ -0,0 +1,327 @@
+import {
+  DATE_ORDERS,
+  customerListBatches,
+  customerListFromFile,
+  customerListUploadRefusal
+} from "./chunk-VBGRHAEX.js";
+import {
+  bareAccountId,
+  failWriteValidation,
+  repeatedListFlag,
+  requireTarget,
+  stageOp
+} from "./chunk-NIGDG522.js";
+import {
+  CUSTOMER_LIST_BATCH_ROWS,
+  CUSTOMER_LIST_MAX_BATCHES,
+  brandSafetyTargetingFields
+} from "./chunk-GC5P4KWY.js";
+import "./chunk-GDFJOCDO.js";
+import {
+  csvOrJson,
+  handleMetaError,
+  resolveAccountIdArg
+} from "./chunk-RW33IGR5.js";
+import "./chunk-ERSX3MKH.js";
+import "./chunk-3W4IORXH.js";
+import "./chunk-4NZ47VXO.js";
+import "./chunk-D5FY4FAK.js";
+import "./chunk-NGQ5J4FV.js";
+import "./chunk-QALAJNBG.js";
+import {
+  writeAdsOutput,
+  writeJsonEnvelope
+} from "./chunk-MGWAZXY6.js";
+import "./chunk-VWOKPC3T.js";
+import "./chunk-BGT5ZA4L.js";
+import "./chunk-JF2XP76K.js";
+import "./chunk-SYLPRIFM.js";
+import "./chunk-XBR7TSZN.js";
+import "./chunk-DGUN7FUH.js";
+import "./chunk-SOPVIIUW.js";
+import "./chunk-G4FG5EQO.js";
+import "./chunk-NSBNIPIW.js";
+import {
+  apiGet,
+  apiPost
+} from "./chunk-B2OHCWYB.js";
+import "./chunk-SVUFNCOE.js";
+import {
+  requireChatId
+} from "./chunk-E54435XT.js";
+import {
+  registerSchema
+} from "./chunk-WCIS4FZH.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/ads/meta/audience-writes.ts
+import { readFileSync } from "fs";
+import { defineCommand } from "citty";
+var STAGED_NOTE = "Staged until publish \u2014 review with `baker ads meta draft`.";
+var membersArgs = {
+  id: {
+    type: "positional",
+    description: "Customer-list audience id, or a meta_temp_* ref created in this chat",
+    required: true
+  },
+  "account-id": { type: "string", description: "Meta ad account ID (act_123)" },
+  file: {
+    type: "string",
+    description: "CSV (or ;/tab separated) in the workspace with a header row: email, phone, first name, last name, city, state, zip, country, birthday, gender, madid, external id"
+  },
+  country: {
+    type: "string",
+    description: "Two-letter country for phones written without their country code (when the row has no country column)"
+  },
+  "value-column": {
+    type: "string",
+    description: "Value-based list only: the column with each person's value (e.g. revenue)"
+  },
+  columns: {
+    type: "string",
+    description: "For a file without a header row: what each column is, in order (email,phone,country \u2014 comma-separated or repeated)"
+  },
+  "date-format": {
+    type: "string",
+    description: "How birthdays like 03/07/1990 are written: DMY (day first) or MDY (month first, US). Needed only when no date in the file shows it"
+  }
+};
+function schemaArgs(args) {
+  return Object.fromEntries(
+    Object.entries(args).map(([key, arg]) => [
+      key,
+      { type: arg.type, description: arg.description, required: arg.required === true }
+    ])
+  );
+}
+var ACTION_NOTES = {
+  add: "Adds the people in the file to the list; those already in it stay.",
+  remove: "Removes the people in the file from the list.",
+  replace: "Replaces the whole list with the file \u2014 everyone not in it leaves. Runs alone: not beside another change to the same list in this chat."
+};
+function dateFormatFlag(value) {
+  if (value === void 0) return void 0;
+  const upperValue = String(value).toUpperCase();
+  if (!DATE_ORDERS.includes(upperValue)) {
+    failWriteValidation(`--date-format takes ${DATE_ORDERS.join(" or ")}, not ${String(value)}`);
+  }
+  return upperValue;
+}
+function readList(args, rawArgs) {
+  const path = typeof args.file === "string" ? args.file : "";
+  if (!path) {
+    failWriteValidation("pass --file with the customer list (CSV in the workspace)");
+  }
+  let content;
+  try {
+    content = readFileSync(path, "utf8");
+  } catch (err) {
+    failWriteValidation(`could not read ${path}: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  try {
+    return customerListFromFile(content, {
+      defaultCountry: typeof args.country === "string" ? args.country : void 0,
+      valueColumn: typeof args["value-column"] === "string" ? args["value-column"] : void 0,
+      columns: repeatedListFlag(rawArgs, "columns", args.columns),
+      dateFormat: dateFormatFlag(args["date-format"])
+    });
+  } catch (err) {
+    failWriteValidation(err instanceof Error ? err.message : String(err));
+  }
+}
+function listHints(list) {
+  const hints = [`${list.rows.length.toLocaleString("en-US")} people read from the file, hashed before upload`];
+  const unreadable = Object.entries(list.unreadable).map(([key, count]) => `${count} ${key}`);
+  if (unreadable.length > 0) {
+    hints.push(`values that could not be read and were left out: ${unreadable.join(", ")}`);
+  }
+  if (list.skippedRows > 0) {
+    hints.push(
+      `${list.skippedRows} rows had nothing Meta can match on (no readable email, phone or id${list.schema.includes("LOOKALIKE_VALUE") ? ", or no readable value" : ""}) and were left out`
+    );
+  }
+  if (list.ignoredColumns.length > 0) {
+    hints.push(`columns not sent (Meta does not match on them): ${list.ignoredColumns.join(", ")}`);
+  }
+  if (list.rows.length < 100) {
+    hints.push("Meta needs about 100 matched people before a list can be used for ads or as a lookalike seed");
+  }
+  return hints;
+}
+async function stageMembers(action, args, rawArgs) {
+  const accountId = await bareAccountId(args);
+  const audienceId = requireTarget(args, "audience");
+  const list = readList(args, rawArgs);
+  if (list.rows.length === 0) {
+    failWriteValidation("no one in this file can be matched \u2014 check the columns (email, phone, \u2026) and their values");
+  }
+  const batches = customerListBatches(list);
+  if (batches.length > CUSTOMER_LIST_MAX_BATCHES) {
+    failWriteValidation(
+      `this file holds ${list.rows.length.toLocaleString("en-US")} people; one change carries at most ${(CUSTOMER_LIST_BATCH_ROWS * CUSTOMER_LIST_MAX_BATCHES).toLocaleString("en-US")} \u2014 split the file and stage one add per part`
+    );
+  }
+  const refusal = customerListUploadRefusal(audienceId, action, list);
+  if (refusal) {
+    failWriteValidation(refusal);
+  }
+  const stored = [];
+  try {
+    const chatId = requireChatId();
+    for (const batch of batches) {
+      const response = await apiPost(
+        "/api/ads/meta/draft/customer-list-batch",
+        { chatId, accountId, batch },
+        { timeoutMs: 12e4 }
+      );
+      stored.push(response.data);
+    }
+  } catch (err) {
+    handleMetaError(err);
+  }
+  await stageOp(
+    {
+      kind: "customAudience.members",
+      accountId,
+      payload: { audience_id: audienceId, action, schema: list.schema, batches: stored }
+    },
+    listHints(list)
+  );
+}
+function membersCommand(action) {
+  registerSchema({
+    command: `ads.meta.audiences.members.${action}`,
+    description: `Stage ${action === "add" ? "adding people to" : action === "remove" ? "removing people from" : "replacing everyone in"} a Meta customer list from a CSV in the workspace. ${ACTION_NOTES[action]} Every value is normalized and SHA-256 hashed on this machine before upload, as Meta asks, with a masked copy of each person (l***@empresa.com) for the review; only counts are printed. Applied at publish; Meta takes up to 24h to match.`,
+    args: schemaArgs(membersArgs)
+  });
+  return defineCommand({
+    meta: {
+      name: action,
+      description: `${ACTION_NOTES[action]} ${STAGED_NOTE}
+Example: baker ads meta audiences members ${action} 120249492603650208 --file customers.csv --country ES`
+    },
+    args: membersArgs,
+    run: async ({ args, rawArgs }) => {
+      await stageMembers(action, args, rawArgs);
+    }
+  });
+}
+var audiencesMembersCommand = defineCommand({
+  meta: {
+    name: "members",
+    description: `Change who is in a customer-list audience, from a CSV in the workspace. Hashed here before upload. ${STAGED_NOTE}
+  baker ads meta audiences members add <audienceId|meta_temp_\u2026> --file customers.csv [--country ES]
+  baker ads meta audiences members remove <audienceId> --file unsubscribed.csv
+  baker ads meta audiences members replace <audienceId> --file customers.csv
+  value-based list: add --value-column revenue`
+  },
+  subCommands: {
+    add: membersCommand("add"),
+    remove: membersCommand("remove"),
+    replace: membersCommand("replace")
+  }
+});
+registerSchema({
+  command: "ads.meta.audiences.delete",
+  description: "Stage deleting a Meta custom audience \u2014 permanent, applied at publish. Every ad that targets it stops and cannot be restarted; Meta refuses while a lookalike is built from it (delete the lookalike first).",
+  args: {
+    id: { type: "positional", description: "Audience id", required: true },
+    "account-id": { type: "string", description: "Meta ad account ID (act_123)", required: false }
+  }
+});
+var audiencesDeleteCommand = defineCommand({
+  meta: {
+    name: "delete",
+    description: `Stage deleting an audience \u2014 permanent: ads that target it stop for good. Only when the user asked to delete it. ${STAGED_NOTE}`
+  },
+  args: {
+    id: { type: "positional", description: "Audience id", required: true },
+    "account-id": { type: "string", description: "Meta ad account ID (act_123)" }
+  },
+  run: async ({ args }) => {
+    await stageOp({
+      kind: "customAudience.update",
+      accountId: await bareAccountId(args),
+      target: requireTarget(args, "audience"),
+      payload: { status: "DELETED" }
+    });
+  }
+});
+registerSchema({
+  command: "ads.meta.audiences.saved",
+  description: "List the ad account's saved audiences (targeting saved in Ads Manager), or one with --saved-audience-id. Read-only \u2014 Meta's API cannot create or change one. Use one on a new ad set with `adsets create --saved-audience <id>`.",
+  args: {
+    "account-id": { type: "string", description: "Meta ad account ID (act_123)", required: false },
+    "saved-audience-id": {
+      type: "string",
+      description: "One saved audience, with its full targeting",
+      required: false
+    },
+    full: { type: "boolean", description: "Include each audience's whole targeting spec", required: false },
+    output: { type: "string", description: "json|csv|jsonl|md", required: false, default: "json" }
+  }
+});
+var savedAudiencesCommand = defineCommand({
+  meta: {
+    name: "saved",
+    description: "Saved audiences on the account (read-only). Example: baker ads meta audiences saved --account-id act_123; use one with `adsets create --saved-audience <id>`"
+  },
+  args: {
+    "account-id": { type: "string", description: "Meta ad account ID (act_123)" },
+    "saved-audience-id": { type: "string", description: "One saved audience, with its full targeting" },
+    full: { type: "boolean", description: "Include each audience's whole targeting spec" },
+    output: { type: "string", description: "json|csv|jsonl|md", default: "json" }
+  },
+  run: async ({ args }) => {
+    const accountId = await resolveAccountIdArg(args);
+    try {
+      const params = { "account-id": accountId };
+      if (args["saved-audience-id"]) params["saved-audience-id"] = String(args["saved-audience-id"]);
+      const rows = await apiGet("/api/ads/meta/saved-audiences", params);
+      const shown = args.full || args["saved-audience-id"] ? rows : rows.map(({ targeting: _targeting, ...row }) => row);
+      const hints = rows.length === 0 ? [
+        "This account has no saved audiences \u2014 Meta's API cannot create one; build the targeting on the ad set instead."
+      ] : [
+        "Use one on a new ad set: `baker ads meta adsets create \u2026 --saved-audience <id>` (its targeting is copied)."
+      ];
+      const fmt = csvOrJson(args);
+      if (fmt !== "json") {
+        writeAdsOutput(shown, fmt, void 0, hints);
+        return;
+      }
+      writeJsonEnvelope({ ok: true, data: shown, hints });
+    } catch (err) {
+      handleMetaError(err);
+    }
+  }
+});
+function targetingFromSavedAudience(saved, flagged) {
+  if (flagged === void 0) return { targeting: saved };
+  if (!Object.keys(flagged).every((key) => key in brandSafetyTargetingFields)) {
+    return { refusal: "--saved-audience brings the targeting \u2014 pass it or --targeting-file, not both" };
+  }
+  return { targeting: { ...saved, ...flagged } };
+}
+async function savedAudienceTargeting(accountId, savedAudienceId) {
+  try {
+    const rows = await apiGet("/api/ads/meta/saved-audiences", {
+      "account-id": accountId,
+      "saved-audience-id": savedAudienceId
+    });
+    const targeting = rows[0]?.targeting;
+    if (!targeting) {
+      failWriteValidation(`saved audience ${savedAudienceId} has no targeting to copy`);
+    }
+    return targeting;
+  } catch (err) {
+    handleMetaError(err);
+  }
+}
+export {
+  audiencesDeleteCommand,
+  audiencesMembersCommand,
+  savedAudienceTargeting,
+  savedAudiencesCommand,
+  targetingFromSavedAudience
+};
+//# sourceMappingURL=audience-writes-SHZKH2EI.js.map

package/dist/audiences-3R574STZ.js

@@ -0,0 +1,280 @@
+import {
+  csvArg,
+  failWriteValidation,
+  requireTarget,
+  requireTargets,
+  schemaArgs,
+  stageChatgptOp,
+  stageChatgptOps
+} from "./chunk-64ALJ6TJ.js";
+import {
+  CHATGPT_ADS_REFERENCE,
+  CHATGPT_AUDIENCE_USES,
+  CHATGPT_MAX_STAGED_MEMBERS,
+  runChatgptListRead
+} from "./chunk-L7AJMZ6Z.js";
+import "./chunk-MGWAZXY6.js";
+import {
+  PEOPLE_PREVIEW_ROWS,
+  maskPersonValue
+} from "./chunk-SOPVIIUW.js";
+import "./chunk-G4FG5EQO.js";
+import "./chunk-B2OHCWYB.js";
+import "./chunk-SVUFNCOE.js";
+import "./chunk-E54435XT.js";
+import {
+  registerSchema
+} from "./chunk-WCIS4FZH.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/ads/chatgpt/audiences.ts
+import { readFileSync } from "fs";
+import { defineCommand } from "citty";
+
+// src/commands/ads/chatgpt/audience-members.ts
+import { createHash } from "crypto";
+import { parse } from "csv-parse/sync";
+import { isSupportedCountry, parsePhoneNumberFromString } from "libphonenumber-js";
+function sha256(value) {
+  return createHash("sha256").update(value, "utf8").digest("hex");
+}
+function normalizedEmail(value) {
+  const email = value.trim().toLowerCase();
+  return /^[^@\s;,|]+@[^@\s;,|]+\.[^@\s;,|]+$/.test(email) ? email : void 0;
+}
+function normalizedPhone(value, defaultCountry) {
+  const country = defaultCountry && isSupportedCountry(defaultCountry) ? defaultCountry : void 0;
+  const phone = parsePhoneNumberFromString(value.trim(), country);
+  return phone?.isValid() ? phone.number : void 0;
+}
+function hashedMembers(input) {
+  const rejected = [];
+  const emails = /* @__PURE__ */ new Map();
+  const phones = /* @__PURE__ */ new Map();
+  for (const value of input.emails) {
+    const email = normalizedEmail(value);
+    email ? emails.set(sha256(email), maskPersonValue("email", email)) : rejected.push(value.trim());
+  }
+  for (const value of input.phones) {
+    const phone = normalizedPhone(value, input.defaultCountry);
+    phone ? phones.set(sha256(phone), maskPersonValue("phone", phone)) : rejected.push(value.trim());
+  }
+  return {
+    emailHashes: [...emails.keys()],
+    phoneHashes: [...phones.keys()],
+    // The review shows the first of them; the rest are counted.
+    previews: [...emails.values(), ...phones.values()].slice(0, PEOPLE_PREVIEW_ROWS),
+    rejected
+  };
+}
+function headerWords(cell) {
+  return cell.normalize("NFD").replace(new RegExp("\\p{Diacritic}", "gu"), "").toLowerCase().replace(/[^a-z0-9]+/g, " ").trim();
+}
+var EMAIL_HEADER = /\b(e ?mail|correo|mail)\b/;
+var PHONE_HEADER = /\b(phone|telefono|movil|mobile|tel|celular)\b/;
+function membersFromFile(content) {
+  const rows = parse(content, {
+    bom: true,
+    skip_empty_lines: true,
+    relax_column_count: true,
+    trim: true,
+    delimiter: [",", ";", "	"]
+  });
+  const header = (rows[0] ?? []).map(headerWords);
+  const emailColumn = header.findIndex((cell) => EMAIL_HEADER.test(cell));
+  const phoneColumn = header.findIndex((cell) => !EMAIL_HEADER.test(cell) && PHONE_HEADER.test(cell));
+  if (emailColumn >= 0 || phoneColumn >= 0) {
+    const cells = (column) => column < 0 ? [] : rows.slice(1).flatMap((row) => row[column] ? [row[column]] : []);
+    return { emails: cells(emailColumn), phones: cells(phoneColumn) };
+  }
+  const values = rows.flatMap((row) => row[0] ? [row[0]] : []);
+  return values.some((value) => value.includes("@")) ? { emails: values, phones: [] } : { emails: [], phones: values };
+}
+
+// src/commands/ads/chatgpt/audiences.ts
+var REFERENCE = CHATGPT_ADS_REFERENCE.audiences;
+var MEMBER_ARGS = {
+  emails: { type: "string", description: "Emails, comma-separated" },
+  phones: { type: "string", description: "Phones, comma-separated \u2014 E.164 (+34\u2026), or local with --country" },
+  file: {
+    type: "string",
+    description: "A CSV with an email and/or phone column, or one email or phone per line \u2014 the company's own customers"
+  },
+  country: { type: "string", description: "Country of phones written without a +code, e.g. ES" }
+};
+function membersFromArgs(args, readFile = (path) => readFileSync(path, "utf8")) {
+  const fromFile = typeof args.file === "string" && args.file ? membersFromFile(readFile(args.file)) : { emails: [], phones: [] };
+  const given = [...csvArg(args.emails) ?? [], ...fromFile.emails];
+  const givenPhones = [...csvArg(args.phones) ?? [], ...fromFile.phones];
+  const members = hashedMembers({
+    emails: given,
+    phones: givenPhones,
+    defaultCountry: typeof args.country === "string" ? args.country.toUpperCase() : void 0
+  });
+  const count = members.emailHashes.length + members.phoneHashes.length;
+  const offered = given.length + givenPhones.length + (typeof args.file === "string" && args.file ? 1 : 0);
+  const refusal = count > CHATGPT_MAX_STAGED_MEMBERS ? `${count} members \u2014 at most ${CHATGPT_MAX_STAGED_MEMBERS} per change; split the file` : count === 0 && offered > 0 ? "none of the values was an email or a valid phone \u2014 name the columns email and phone, and give phones a +country code or --country" : void 0;
+  return {
+    payload: {
+      ...members.emailHashes.length > 0 ? { emailHashes: members.emailHashes } : {},
+      ...members.phoneHashes.length > 0 ? { phoneHashes: members.phoneHashes } : {},
+      ...members.previews.length > 0 ? { memberPreviews: members.previews } : {}
+    },
+    rejected: members.rejected.length,
+    ...refusal ? { refusal } : {}
+  };
+}
+function rejectedHint(rejected) {
+  return rejected > 0 ? [
+    `${rejected} value(s) were neither an email nor a valid phone and were left out \u2014 phones need a +country code, or --country.`
+  ] : [];
+}
+var LIST_ARGS = {
+  "eligible-for": {
+    type: "string",
+    description: `Only audiences ChatGPT Ads lets serve this use: ${CHATGPT_AUDIENCE_USES.join("|")}`
+  }
+};
+registerSchema({
+  command: "ads.chatgpt.audiences.list",
+  description: "The account's custom audiences: status, and matched people as a privacy range (under_25k\u2026). `ready` is not eligibility \u2014 pass --eligible-for to list only those a use accepts.",
+  args: schemaArgs(LIST_ARGS)
+});
+var audiencesListCommand = defineCommand({
+  meta: { name: "list", description: "List the account's custom audiences." },
+  args: LIST_ARGS,
+  run: async ({ args }) => {
+    const use = typeof args["eligible-for"] === "string" ? args["eligible-for"] : void 0;
+    await runChatgptListRead(
+      REFERENCE,
+      "/api/ads/chatgpt/audiences",
+      use ? { eligible_for: use } : void 0,
+      (rows) => rows.length === 0 ? ["No audience. Stage one with `baker ads chatgpt audiences create --name \u2026 --file customers.csv`."] : [
+        "Including an audience needs about 25,000 matched people; excluding works at any size. Custom audiences do not work in campaigns serving the EEA or Switzerland."
+      ]
+    );
+  }
+});
+var CREATE_ARGS = {
+  name: { type: "string", description: "Audience name (3+ characters)", required: true },
+  description: { type: "string", description: "What the list is" },
+  ...MEMBER_ARGS
+};
+registerSchema({
+  command: "ads.chatgpt.audiences.create",
+  description: "Stage a custom audience from the company's own customers (emails and/or phones, hashed on this machine), or an empty one. Created when the chat is published; only first-party data the company may use for ads.",
+  args: schemaArgs(CREATE_ARGS)
+});
+var audiencesCreateCommand = defineCommand({
+  meta: {
+    name: "create",
+    description: `Stage a custom audience (applies when the chat is published). Members are hashed here; nothing raw is sent.
+
+Examples:
+  baker ads chatgpt audiences create --name "Customers 2026" --file customers.csv --country ES
+  baker ads chatgpt audiences create --name "Recent buyers"   # empty, fill it later with add`
+  },
+  args: CREATE_ARGS,
+  run: async ({ args }) => {
+    const { payload, rejected, refusal } = membersFromArgs(args);
+    if (refusal) {
+      failWriteValidation(refusal);
+    }
+    await stageChatgptOp(
+      {
+        kind: "audience.create",
+        payload: { name: args.name, ...args.description ? { description: args.description } : {}, ...payload }
+      },
+      REFERENCE,
+      (staged) => [
+        ...rejectedHint(rejected),
+        `Use it on a campaign after the publish, once \`audiences\` shows it ready: campaigns update <cmpn_id> --excluded-audience-ids <caud_id>. (${staged.ref} is its ref in this chat.)`
+      ]
+    );
+  }
+});
+function membersCommand(verb) {
+  const args = {
+    id: { type: "positional", description: "Audience id (caud_\u2026)", required: true },
+    ...MEMBER_ARGS
+  };
+  registerSchema({
+    command: `ads.chatgpt.audiences.${verb}`,
+    description: `Stage ${verb === "add" ? "adding" : "removing"} members ${verb === "add" ? "to" : "from"} a live custom audience, hashed on this machine. Applies when the chat is published.`,
+    args: schemaArgs(args)
+  });
+  return defineCommand({
+    meta: {
+      name: verb,
+      description: `Stage ${verb === "add" ? "adding" : "removing"} members.
+
+Example:
+  baker ads chatgpt audiences ${verb} caud_123 --emails ana@example.com,luis@example.com`
+    },
+    args,
+    run: async ({ args: parsed }) => {
+      const { payload, rejected, refusal } = membersFromArgs(parsed);
+      if (refusal) {
+        failWriteValidation(refusal);
+      }
+      if (!payload.emailHashes && !payload.phoneHashes) {
+        failWriteValidation("name at least one email or phone with --emails, --phones or --file");
+      }
+      await stageChatgptOp(
+        { kind: `audience.${verb}`, target: requireTarget(parsed, "id"), payload },
+        REFERENCE,
+        () => rejectedHint(rejected)
+      );
+    }
+  });
+}
+var ARCHIVE_ARGS = {
+  ids: { type: "positional", description: "Audience ids, comma-separated", required: true }
+};
+registerSchema({
+  command: "ads.chatgpt.audiences.archive",
+  description: "Stage archiving custom audiences \u2014 for good: ChatGPT Ads cannot bring one back. Pass every id in one call.",
+  args: schemaArgs(ARCHIVE_ARGS)
+});
+var audiencesArchiveCommand = defineCommand({
+  meta: {
+    name: "archive",
+    description: `Stage archiving audiences, for good.
+
+Example:
+  baker ads chatgpt audiences archive caud_123`
+  },
+  args: ARCHIVE_ARGS,
+  run: async ({ args }) => {
+    await stageChatgptOps(
+      requireTargets(args, "ids").map((id) => ({ kind: "audience.archive", target: id, payload: {} })),
+      REFERENCE
+    );
+  }
+});
+var audiencesCommand = defineCommand({
+  meta: {
+    name: "audiences",
+    description: `Custom audiences \u2014 the company's own customer lists a campaign serves to or leaves out.
+
+Examples:
+  baker ads chatgpt audiences
+  baker ads chatgpt audiences create --name "Customers 2026" --file customers.csv --country ES
+  baker ads chatgpt audiences add caud_123 --emails ana@example.com`
+  },
+  subCommands: {
+    list: audiencesListCommand,
+    create: audiencesCreateCommand,
+    add: membersCommand("add"),
+    remove: membersCommand("remove"),
+    archive: audiencesArchiveCommand
+  },
+  // A parent must never declare `run`: citty falls through to it after the matched subcommand.
+  args: {},
+  default: "list"
+});
+export {
+  audiencesCommand,
+  membersFromArgs
+};
+//# sourceMappingURL=audiences-3R574STZ.js.map