@koda-sl/baker-cli 0.560.0 → 0.561.0

package/dist/audience-size-PHFJ22TX.js

@@ -0,0 +1,76 @@
+import {
+  handleLinkedinError,
+  loadTargetingArg,
+  resolveAccountIdArg
+} from "./chunk-6QNXBEIN.js";
+import {
+  writeAdsJson
+} from "./chunk-RBCO3C3Q.js";
+import {
+  NO_CACHE_ARG
+} from "./chunk-GO6ISZUZ.js";
+import "./chunk-TK7VRZKM.js";
+import "./chunk-QV6AST5T.js";
+import "./chunk-WCU362Z6.js";
+import "./chunk-GIWHHCD6.js";
+import "./chunk-SOPVIIUW.js";
+import "./chunk-G4FG5EQO.js";
+import "./chunk-R7XDGNZD.js";
+import "./chunk-MSMTG6OC.js";
+import {
+  apiPost
+} from "./chunk-QEREDRZO.js";
+import "./chunk-JXTNP3B5.js";
+import "./chunk-45D6WRCJ.js";
+import "./chunk-CCYZJMZ7.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-PHFJ22TX.js.map

package/dist/audience-writes-RUGU6KEC.js

@@ -0,0 +1,327 @@
+import {
+  DATE_ORDERS,
+  customerListBatches,
+  customerListFromFile,
+  customerListUploadRefusal
+} from "./chunk-VBGRHAEX.js";
+import {
+  bareAccountId,
+  failWriteValidation,
+  repeatedListFlag,
+  requireTarget,
+  stageOp
+} from "./chunk-UYZ4FUC7.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-5H6N36LS.js";
+import "./chunk-ERSX3MKH.js";
+import "./chunk-CDTAKCJR.js";
+import "./chunk-4NZ47VXO.js";
+import "./chunk-D5FY4FAK.js";
+import "./chunk-4H6XLX7E.js";
+import "./chunk-QALAJNBG.js";
+import {
+  writeAdsOutput,
+  writeJsonEnvelope
+} from "./chunk-RBCO3C3Q.js";
+import "./chunk-Y5PNLB24.js";
+import "./chunk-N3PASNUA.js";
+import "./chunk-E56V3RFO.js";
+import "./chunk-EL3TDR5S.js";
+import "./chunk-G6U45QD3.js";
+import "./chunk-X6U3B6YK.js";
+import "./chunk-SOPVIIUW.js";
+import "./chunk-G4FG5EQO.js";
+import "./chunk-R7XDGNZD.js";
+import {
+  apiGet,
+  apiPost
+} from "./chunk-QEREDRZO.js";
+import "./chunk-JXTNP3B5.js";
+import {
+  requireChatId
+} from "./chunk-45D6WRCJ.js";
+import {
+  registerSchema
+} from "./chunk-CCYZJMZ7.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-RUGU6KEC.js.map

package/dist/audiences-6GVUZUCN.js

@@ -0,0 +1,106 @@
+import {
+  META_LIST_SHAPE_ARGS,
+  registerMetaListSchema,
+  shapeMetaListRows,
+  writeMetaListRows
+} from "./chunk-3E74OM2E.js";
+import {
+  csvOrJson,
+  handleMetaError,
+  resolveAccountIdArg
+} from "./chunk-5H6N36LS.js";
+import "./chunk-QALAJNBG.js";
+import "./chunk-RBCO3C3Q.js";
+import {
+  NO_CACHE_ARG
+} from "./chunk-GO6ISZUZ.js";
+import "./chunk-65Y3RCWP.js";
+import {
+  apiGet
+} from "./chunk-QEREDRZO.js";
+import "./chunk-JXTNP3B5.js";
+import "./chunk-45D6WRCJ.js";
+import "./chunk-CCYZJMZ7.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/ads/meta/audiences.ts
+import { defineCommand } from "citty";
+var listArgs = {
+  "account-id": { type: "string", description: "Meta ad account ID" },
+  "name-contains": {
+    type: "string",
+    description: "Only audiences whose name contains this text, matched by Meta before anything is returned: --name-contains Cerradas. A lookalike can be named anything, so find one audience's lookalikes with --seed <its id>"
+  },
+  seed: {
+    type: "string",
+    description: "Only the lookalikes built from this source audience id, whatever they are named: --seed 120240480760260208"
+  },
+  limit: { type: "string", description: "Max rows (default 500)" },
+  "no-cache": NO_CACHE_ARG,
+  ...META_LIST_SHAPE_ARGS
+};
+registerMetaListSchema(
+  "audiences",
+  "List custom and lookalike audiences, as a table by default: id, name, subtype, size_min, size_max, retention_days, updated_date \u2014 plus delivery (why Meta says it cannot be used) and seed_id (the audience a lookalike was built from) when a row has one. The rule, data source and pixel are one --fields away (--fields id,name,rule) or --full. Start here to find one audience: baker ads meta audiences --name-contains <text>; then its lookalikes, whatever they are named: --seed <its id>. --output json returns the rows in the envelope.",
+  listArgs
+);
+var listCommand = defineCommand({
+  meta: {
+    name: "list",
+    description: "List custom audiences. Runs by default when no subcommand is given. Example: baker ads meta audiences --name-contains buyers"
+  },
+  args: listArgs,
+  run: async ({ args }) => {
+    const accountId = await resolveAccountIdArg(args);
+    try {
+      const params = { "account-id": accountId };
+      if (args["name-contains"]) params["name-contains"] = args["name-contains"];
+      if (args.seed) params.seed = args.seed;
+      if (args.limit) params.limit = args.limit;
+      if (args["no-cache"]) params["skip-cache"] = "true";
+      const data = await apiGet("/api/ads/meta/audiences", params);
+      writeMetaListRows("audiences", shapeMetaListRows("audiences", data, args), csvOrJson(args));
+    } catch (err) {
+      handleMetaError(err);
+    }
+  }
+});
+var audiencesCommand = defineCommand({
+  meta: {
+    name: "audiences",
+    description: `List custom audiences, or stage writes (create/update/delete, members add|remove|replace). Write subcommands stage ops on this chat's draft.
+Includes lookalikes, website-pixel audiences, customer-file audiences. Meta hides exact size when count < 1000.
+
+Listings print a table by default: id, name, subtype, size_min, size_max, retention_days, updated_date, plus
+delivery and seed_id when a row has one. The rule and data source are --fields (dotted paths) or --full away.
+
+Examples:
+  baker ads meta audiences --account-id act_123
+  baker ads meta audiences --name-contains Cerradas            \u2014 find one audience by name
+  baker ads meta audiences --seed 120240480760260208           \u2014 the lookalikes built from that audience
+  baker ads meta audiences --name-contains Leads --fields id,name,rule,retention_days --output json
+  baker ads meta audiences create --name "Site 30d" --subtype WEBSITE --file rule.json
+  baker ads meta audiences create --name "Past buyers" --subtype CUSTOM --file buyers.json   # {"members":[{"email":"\u2026"}]}
+  baker ads meta audiences create --name "Customers" --subtype CUSTOM --customer-file-source USER_PROVIDED_ONLY
+  baker ads meta audiences members add meta_temp_ab12 --file customers.csv --country ES
+  baker ads meta audiences saved --account-id act_123            \u2014 saved audiences (read-only)`
+  },
+  subCommands: {
+    list: listCommand,
+    create: () => import("./write-commands-SIOVTRHH.js").then((m) => m.audiencesCreateCommand),
+    update: () => import("./write-commands-SIOVTRHH.js").then((m) => m.audiencesUpdateCommand),
+    delete: () => import("./audience-writes-RUGU6KEC.js").then((m) => m.audiencesDeleteCommand),
+    members: () => import("./audience-writes-RUGU6KEC.js").then((m) => m.audiencesMembersCommand),
+    saved: () => import("./audience-writes-RUGU6KEC.js").then((m) => m.savedAudiencesCommand)
+  },
+  // `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 {
+  audiencesCommand
+};
+//# sourceMappingURL=audiences-6GVUZUCN.js.map

package/dist/audiences-7OS2ZJYO.js

@@ -0,0 +1,85 @@
+import {
+  parseXApiError
+} from "./chunk-FIN4ZXGJ.js";
+import {
+  resolveXAccountId
+} from "./chunk-YD6OZSSY.js";
+import {
+  cacheGet,
+  cacheSet,
+  writeAdsJson,
+  writeAdsOutput
+} from "./chunk-RBCO3C3Q.js";
+import {
+  ApiError,
+  apiGet
+} from "./chunk-QEREDRZO.js";
+import "./chunk-JXTNP3B5.js";
+import "./chunk-45D6WRCJ.js";
+import {
+  registerSchema
+} from "./chunk-CCYZJMZ7.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/ads/x/audiences.ts
+import { defineCommand } from "citty";
+registerSchema({
+  command: "ads.x.audiences",
+  description: "List custom audiences for an X Ads account. Returns id, name, audience_size, audience_type, targetable status. Audiences need 100+ active users in the past 90 days to be targetable.",
+  args: {
+    "account-id": { type: "string", description: "X Ads account ID", required: false },
+    "no-cache": { type: "boolean", description: "Skip cache", required: false },
+    output: { type: "string", description: "Format: json|csv|md", required: false, default: "json" }
+  }
+});
+var audiencesCommand = defineCommand({
+  meta: {
+    name: "audiences",
+    description: `List X Ads custom audiences.
+
+Examples:
+  baker ads x audiences --account-id 18ce53xyz`
+  },
+  args: {
+    "account-id": { type: "string", description: "X Ads account ID", required: false },
+    "no-cache": { type: "boolean", description: "Skip cache", required: false },
+    output: { type: "string", description: "Format: json|csv|md", required: false, default: "json" }
+  },
+  run: async ({ args }) => {
+    const accountId = await resolveXAccountId(args);
+    const useCache = !args["no-cache"];
+    const cacheKey = `audiences:${accountId}`;
+    if (useCache) {
+      const cached = cacheGet("x-account-data", cacheKey);
+      if (cached) {
+        writeAdsJson({ ok: true, data: cached.data, cached: true });
+        return;
+      }
+    }
+    try {
+      const params = { "account-id": accountId };
+      if (!useCache) params["skip-cache"] = "true";
+      const data = await apiGet("/api/ads/x/custom-audiences", params);
+      if (useCache) {
+        cacheSet("x-account-data", cacheKey, data, 6 * 60 * 60 * 1e3);
+      }
+      const format = args.output || "json";
+      if (format !== "json") {
+        writeAdsOutput(data, format);
+        return;
+      }
+      writeAdsJson({ ok: true, data });
+    } catch (err) {
+      if (err instanceof ApiError) {
+        writeAdsJson(parseXApiError(err.message, accountId));
+        process.exit(1);
+      }
+      writeAdsJson({ ok: false, error: { code: "NETWORK_ERROR", message: "Unexpected error" } });
+      process.exit(1);
+    }
+  }
+});
+export {
+  audiencesCommand
+};
+//# sourceMappingURL=audiences-7OS2ZJYO.js.map