@koda-sl/baker-cli 0.502.0 → 0.504.0

package/dist/chunk-CCEDZTP7.js

@@ -0,0 +1,391 @@
+import {
+  CUSTOMER_LIST_BATCH_ROWS,
+  CUSTOMER_LIST_KEYS,
+  IDENTIFYING_CUSTOMER_LIST_KEYS,
+  UNHASHED_CUSTOMER_LIST_KEYS,
+  customAudienceMembersSchema,
+  customerListBatchSchema
+} from "./chunk-VIPKDXGU.js";
+
+// src/commands/ads/meta/customer-list.ts
+import { createHash } from "crypto";
+import { parse } from "csv-parse/sync";
+import { isSupportedCountry, parsePhoneNumberFromString } from "libphonenumber-js";
+var DATE_ORDERS = ["DMY", "MDY"];
+function sha256(value) {
+  return createHash("sha256").update(value, "utf8").digest("hex");
+}
+function headerWords(cell) {
+  return cell.normalize("NFD").replace(new RegExp("\\p{Diacritic}", "gu"), "").toLowerCase().replace(/[^a-z0-9]+/g, " ").trim();
+}
+var HEADER_PATTERNS = [
+  [/^(e ?mail|email address|correo|correo electronico|mail)$/, "EMAIL"],
+  [/^(phone|phone number|mobile|mobile phone|telefono|movil|tel|celular|cell)$/, "PHONE"],
+  [/^(first name|firstname|fname|fn|given name|nombre)$/, "FN"],
+  [/^(last name|lastname|lname|ln|surname|family name|apellido|apellidos)$/, "LN"],
+  [/^(first initial|fi)$/, "FI"],
+  [/^(city|town|ct|ciudad|localidad)$/, "CT"],
+  [/^(state|province|region|st|provincia|estado)$/, "ST"],
+  [/^(zip|zip code|zipcode|postcode|post code|postal code|cp|codigo postal)$/, "ZIP"],
+  [/^(country|country code|pais)$/, "COUNTRY"],
+  [/^(dob|birthday|birth date|birthdate|date of birth|fecha de nacimiento|fecha nacimiento)$/, "DOB"],
+  [/^(doby|birth year|year of birth)$/, "DOBY"],
+  [/^(dobm|birth month)$/, "DOBM"],
+  [/^(dobd|birth day)$/, "DOBD"],
+  [/^(gen|gender|sex|genero|sexo)$/, "GEN"],
+  [/^(madid|idfa|aaid|gaid|advertising id|mobile advertiser id)$/, "MADID"],
+  [/^(extern id|external id|customer id|client id|crm id)$/, "EXTERN_ID"],
+  [/^(lookalike value|value)$/, "LOOKALIKE_VALUE"]
+];
+function headerKey(cell) {
+  const words = headerWords(cell);
+  const upper = cell.trim().toUpperCase();
+  if (CUSTOMER_LIST_KEYS.includes(upper)) {
+    return upper;
+  }
+  return HEADER_PATTERNS.find(([pattern]) => pattern.test(words))?.[1];
+}
+function lettersOnly(value) {
+  return value.normalize("NFC").toLowerCase().replace(/[^\p{L}]/gu, "");
+}
+function email(value) {
+  const normalized = value.trim().toLowerCase();
+  return /^[^@\s;,|]+@[^@\s;,|]+\.[^@\s;,|]+$/.test(normalized) ? normalized : void 0;
+}
+function country(value) {
+  const code = value.trim().toUpperCase();
+  return /^[A-Z]{2}$/.test(code) && isSupportedCountry(code) ? code : void 0;
+}
+function phone(value, rowCountry) {
+  const region = rowCountry ? rowCountry : void 0;
+  const parsed = parsePhoneNumberFromString(value.trim(), region);
+  return parsed?.isValid() ? parsed.number.replace(/^\+/, "") : void 0;
+}
+function zip(value, rowCountry) {
+  const compact = value.toLowerCase().replace(/\s+/g, "");
+  if (compact === "") return void 0;
+  const us = rowCountry === "US" || /^\d{5}-\d{4}$/.test(compact);
+  return us ? /^\d{5}/.exec(compact)?.[0] ?? void 0 : compact;
+}
+function gender(value) {
+  const first = value.trim().toLowerCase();
+  if (/^(m|male|man|hombre|masculino|h)$/.test(first)) return "m";
+  if (/^(f|female|woman|mujer|femenino)$/.test(first)) return "f";
+  return void 0;
+}
+var US_STATE_CODES = {
+  alabama: "al",
+  alaska: "ak",
+  arizona: "az",
+  arkansas: "ar",
+  california: "ca",
+  colorado: "co",
+  connecticut: "ct",
+  delaware: "de",
+  districtofcolumbia: "dc",
+  washingtondc: "dc",
+  florida: "fl",
+  georgia: "ga",
+  hawaii: "hi",
+  idaho: "id",
+  illinois: "il",
+  indiana: "in",
+  iowa: "ia",
+  kansas: "ks",
+  kentucky: "ky",
+  louisiana: "la",
+  maine: "me",
+  maryland: "md",
+  massachusetts: "ma",
+  michigan: "mi",
+  minnesota: "mn",
+  mississippi: "ms",
+  missouri: "mo",
+  montana: "mt",
+  nebraska: "ne",
+  nevada: "nv",
+  newhampshire: "nh",
+  newjersey: "nj",
+  newmexico: "nm",
+  newyork: "ny",
+  northcarolina: "nc",
+  northdakota: "nd",
+  ohio: "oh",
+  oklahoma: "ok",
+  oregon: "or",
+  pennsylvania: "pa",
+  rhodeisland: "ri",
+  southcarolina: "sc",
+  southdakota: "sd",
+  tennessee: "tn",
+  texas: "tx",
+  utah: "ut",
+  vermont: "vt",
+  virginia: "va",
+  washington: "wa",
+  westvirginia: "wv",
+  wisconsin: "wi",
+  wyoming: "wy",
+  puertorico: "pr",
+  guam: "gu",
+  americansamoa: "as",
+  virginislands: "vi",
+  usvirginislands: "vi",
+  northernmarianaislands: "mp"
+};
+var US_STATE_ABBREVIATIONS = new Set(Object.values(US_STATE_CODES));
+function state(value, rowCountry) {
+  const letters = lettersOnly(value);
+  if (letters === "") return void 0;
+  if (rowCountry === "US") {
+    return US_STATE_CODES[letters] ?? (US_STATE_ABBREVIATIONS.has(letters) ? letters : void 0);
+  }
+  return (rowCountry === void 0 ? US_STATE_CODES[letters] : void 0) ?? letters;
+}
+function datePart(value, length, max) {
+  const digits = value.trim();
+  if (!/^\d{1,4}$/.test(digits)) return void 0;
+  const n = Number(digits);
+  if (length === 4) return digits.length === 4 && n >= 1900 && n <= max ? digits : void 0;
+  return n >= 1 && n <= max ? String(n).padStart(2, "0") : void 0;
+}
+var SLASHED_DATE = /^(\d{1,2})[/.-](\d{1,2})[/.-](\d{4})$/;
+function dateOrderOf(values, explicit) {
+  if (explicit) return explicit;
+  let dayFirst = false;
+  let monthFirst = false;
+  let ambiguous = false;
+  for (const value of values) {
+    const match = SLASHED_DATE.exec(value.trim());
+    if (!match) continue;
+    const [first, second] = [Number(match[1]), Number(match[2])];
+    dayFirst ||= first > 12;
+    monthFirst ||= second > 12;
+    ambiguous ||= first <= 12 && second <= 12 && first !== second;
+  }
+  if (dayFirst && monthFirst) {
+    throw new Error(
+      "this file writes birthdays both day-first and month-first \u2014 make them one order, or pass --date-format DMY|MDY for the order most use"
+    );
+  }
+  if (dayFirst) return "DMY";
+  if (monthFirst) return "MDY";
+  if (ambiguous) {
+    throw new Error(
+      "this file's birthdays (like 03/07/1990) can be read day-first or month-first \u2014 pass --date-format DMY (day/month/year) or MDY (month/day/year)"
+    );
+  }
+  return void 0;
+}
+function dateOfBirth(value, order) {
+  const text = value.trim();
+  const iso = /^(\d{4})-(\d{1,2})-(\d{1,2})/.exec(text);
+  const slashed = SLASHED_DATE.exec(text);
+  const parts = iso ? [iso[1], iso[2], iso[3]] : slashed ? order === "MDY" ? [slashed[3], slashed[1], slashed[2]] : [slashed[3], slashed[2], slashed[1]] : void 0;
+  if (!parts) return void 0;
+  const year = datePart(parts[0] ?? "", 4, (/* @__PURE__ */ new Date()).getUTCFullYear());
+  const month = datePart(parts[1] ?? "", 2, 12);
+  const day = datePart(parts[2] ?? "", 2, 31);
+  return year && month && day ? [year, month, day] : void 0;
+}
+function decimalMarkShown(value) {
+  const cleaned = value.replace(/[^\d.,]/g, "");
+  const lastDot = cleaned.lastIndexOf(".");
+  const lastComma = cleaned.lastIndexOf(",");
+  if (lastDot >= 0 && lastComma >= 0) return lastDot > lastComma ? "." : ",";
+  const mark = lastDot >= 0 ? "." : lastComma >= 0 ? "," : void 0;
+  if (mark === void 0) return void 0;
+  if (cleaned.split(mark).length > 2) return mark === "." ? "," : ".";
+  return /^\d{3}$/.test(cleaned.slice(cleaned.indexOf(mark) + 1)) ? void 0 : mark;
+}
+function decimalMarkOf(values) {
+  for (const value of values) {
+    const mark = decimalMarkShown(value);
+    if (mark) return mark;
+  }
+  return void 0;
+}
+function numericValue(value, fileMark) {
+  const cleaned = value.replace(/[^\d.,-]/g, "");
+  const mark = decimalMarkShown(cleaned) ?? fileMark;
+  if (mark === void 0 && /[.,]/.test(cleaned)) return void 0;
+  const thousands = mark === "," ? "." : ",";
+  const plain = cleaned.split(thousands).join("").replace(",", ".");
+  const n = Number(plain);
+  return plain !== "" && Number.isFinite(n) && n >= 0 ? String(n) : void 0;
+}
+function normalizedCell(key, value, rowCountry, conventions) {
+  switch (key) {
+    case "EMAIL":
+      return email(value);
+    case "PHONE":
+      return phone(value, rowCountry);
+    case "FN":
+    case "LN":
+    case "CT":
+      return lettersOnly(value) || void 0;
+    case "FI":
+      return lettersOnly(value).slice(0, 1) || void 0;
+    case "ST":
+      return state(value, rowCountry);
+    case "ZIP":
+      return zip(value, rowCountry);
+    case "COUNTRY":
+      return country(value)?.toLowerCase();
+    case "DOBY":
+      return datePart(value, 4, (/* @__PURE__ */ new Date()).getUTCFullYear());
+    case "DOBM":
+      return datePart(value, 2, 12);
+    case "DOBD":
+      return datePart(value, 2, 31);
+    case "GEN":
+      return gender(value);
+    case "MADID":
+      return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/.test(value.trim().toLowerCase()) ? value.trim().toLowerCase() : void 0;
+    case "EXTERN_ID":
+      return value.trim() || void 0;
+    case "LOOKALIKE_VALUE":
+      return numericValue(value, conventions.decimalMark);
+    default:
+      return void 0;
+  }
+}
+function planColumns(firstRow, options) {
+  if (options.columns) {
+    const plan2 = options.columns.map((name, source) => {
+      const key = headerKey(name);
+      if (!key)
+        throw new Error(`--columns: "${name}" is not a column Meta matches on (${CUSTOMER_LIST_KEYS.join(", ")})`);
+      return { source, key };
+    });
+    return { plan: plan2, ignored: [], hasHeader: false };
+  }
+  const valueHeader = options.valueColumn ? headerWords(options.valueColumn) : void 0;
+  const plan = [];
+  const ignored = [];
+  firstRow.forEach((cell, source) => {
+    const named = valueHeader !== void 0 && headerWords(cell) === valueHeader;
+    const key = named ? "LOOKALIKE_VALUE" : headerKey(cell);
+    if (key && (key !== "LOOKALIKE_VALUE" || named) && !plan.some((entry) => entry.key === key)) {
+      plan.push({ source, key });
+    } else if (cell.trim() !== "") {
+      ignored.push(cell.trim());
+    }
+  });
+  if (valueHeader && !plan.some((entry) => entry.key === "LOOKALIKE_VALUE")) {
+    throw new Error(`--value-column "${options.valueColumn}" is not a column of this file`);
+  }
+  return { plan, ignored, hasHeader: true };
+}
+function schemaOf(plan) {
+  return plan.flatMap((entry) => entry.key === "DOB" ? ["DOBY", "DOBM", "DOBD"] : [entry.key]);
+}
+function hashed(key, normalized) {
+  return UNHASHED_CUSTOMER_LIST_KEYS.has(key) ? normalized : sha256(normalized);
+}
+function rowCountryOf(row, plan, defaultCountry) {
+  const column = plan.find((entry) => entry.key === "COUNTRY");
+  return (column ? country(row[column.source] ?? "") : void 0) ?? defaultCountry;
+}
+function countUnreadable(unreadable, key) {
+  unreadable[key] = (unreadable[key] ?? 0) + 1;
+}
+function columnCells(entry, raw, rowCountry, unreadable, conventions) {
+  const blank = raw.trim() === "";
+  if (entry.key === "DOB") {
+    const parts = blank ? void 0 : dateOfBirth(raw, conventions.dateOrder);
+    if (!blank && !parts) countUnreadable(unreadable, "DOBY");
+    return [
+      ["DOBY", parts?.[0] ?? ""],
+      ["DOBM", parts?.[1] ?? ""],
+      ["DOBD", parts?.[2] ?? ""]
+    ];
+  }
+  if (blank) return [[entry.key, ""]];
+  const normalized = normalizedCell(entry.key, raw, rowCountry, conventions);
+  if (normalized === void 0) countUnreadable(unreadable, entry.key);
+  return [[entry.key, normalized ?? ""]];
+}
+function delimiterOf(content) {
+  const firstLine = content.replace(/^\uFEFF/, "").split(/\r?\n/).find((line) => line.trim() !== "") ?? "";
+  const unquoted = firstLine.replace(/"[^"]*"/g, "");
+  const count = (mark) => unquoted.split(mark).length - 1;
+  const most = Math.max(count("	"), count(";"), count(","));
+  return most === 0 ? "," : ["	", ";", ","].find((mark) => count(mark) === most) ?? ",";
+}
+function customerListFromFile(content, options) {
+  const delimiter = delimiterOf(content);
+  const table = parse(content, {
+    bom: true,
+    skip_empty_lines: true,
+    relax_column_count: true,
+    trim: true,
+    delimiter
+  });
+  const { plan, ignored, hasHeader } = planColumns(table[0] ?? [], options);
+  const schema = schemaOf(plan);
+  if (!schema.some((key) => IDENTIFYING_CUSTOMER_LIST_KEYS.includes(key))) {
+    throw new Error(
+      "this file has no column Meta can match people on \u2014 it needs one of email, phone, mobile advertiser id or your own customer id (name the columns with --columns for a file without a header)"
+    );
+  }
+  const defaultCountry = options.defaultCountry ? country(options.defaultCountry) : void 0;
+  const body = table.slice(hasHeader ? 1 : 0);
+  const columnValues = (key) => {
+    const column = plan.find((entry) => entry.key === key);
+    return column ? body.map((row) => row[column.source] ?? "") : [];
+  };
+  const conventions = {
+    dateOrder: dateOrderOf(columnValues("DOB"), options.dateFormat),
+    decimalMark: decimalMarkOf(columnValues("LOOKALIKE_VALUE"))
+  };
+  const valueBased = schema.includes("LOOKALIKE_VALUE");
+  const unreadable = {};
+  const rows = [];
+  let skippedRows = 0;
+  for (const row of body) {
+    const rowCountry = rowCountryOf(row, plan, defaultCountry);
+    const cells = plan.flatMap(
+      (entry) => columnCells(entry, row[entry.source] ?? "", rowCountry, unreadable, conventions)
+    );
+    const identified = cells.some(([key, value]) => value !== "" && IDENTIFYING_CUSTOMER_LIST_KEYS.includes(key));
+    const valued = !valueBased || cells.some(([key, value]) => key === "LOOKALIKE_VALUE" && value !== "");
+    if (!identified || !valued) {
+      skippedRows++;
+      continue;
+    }
+    rows.push(cells.map(([key, value]) => value === "" ? "" : hashed(key, value)));
+  }
+  return { schema, rows, skippedRows, unreadable, ignoredColumns: ignored };
+}
+function customerListBatches(rows) {
+  const out = [];
+  for (let at = 0; at < rows.length; at += CUSTOMER_LIST_BATCH_ROWS)
+    out.push(rows.slice(at, at + CUSTOMER_LIST_BATCH_ROWS));
+  return out;
+}
+function customerListUploadRefusal(audienceId, action, list) {
+  const batches = customerListBatches(list.rows);
+  for (const rows of batches) {
+    const batch = customerListBatchSchema.safeParse({ schema: list.schema, rows });
+    if (!batch.success) return batch.error.issues[0]?.message;
+  }
+  const change = customAudienceMembersSchema.safeParse({
+    audience_id: audienceId,
+    action,
+    schema: list.schema,
+    batches: batches.map((rows, index) => ({ fileId: `local-${index}`, rows: rows.length }))
+  });
+  if (change.success) return void 0;
+  const issue = change.error.issues[0];
+  return issue?.path[0] === "audience_id" ? `${audienceId} is not a custom audience id or a meta_temp_* ref from this chat` : issue?.message;
+}
+
+export {
+  DATE_ORDERS,
+  decimalMarkShown,
+  customerListFromFile,
+  customerListBatches,
+  customerListUploadRefusal
+};
+//# sourceMappingURL=chunk-CCEDZTP7.js.map

package/dist/chunk-CLUJWAQE.js

@@ -0,0 +1,207 @@
+import {
+  handleConnectionError,
+  needsConnectionFix,
+  writeAdsJson
+} from "./chunk-ZRP7Y2DM.js";
+import {
+  LINKEDIN_SEARCH_STATUSES,
+  unsupportedLinkedinSearchStatuses
+} from "./chunk-EXELLNQS.js";
+import {
+  ApiError
+} from "./chunk-X7VQFLHI.js";
+import {
+  MissingChatIdError,
+  getEnv
+} from "./chunk-LGK7UWBN.js";
+
+// src/commands/ads/linkedin/shared.ts
+import { readFileSync } from "fs";
+var DAY_MS = 864e5;
+function handleLinkedinError(err) {
+  if (err instanceof ApiError) {
+    if (needsConnectionFix(err.code, err.message)) {
+      handleConnectionError("linkedin_ads", err.message);
+    }
+    if (isNoAccountsSelectedError(err.code, err.message)) {
+      handleConnectionError("linkedin_ads", err.message);
+    }
+    const explanation = explainLinkedinError(err);
+    const envelope = {
+      ok: false,
+      error: {
+        code: err.code,
+        message: err.message,
+        fix: {
+          action: explanation.action,
+          explanation: explanation.message,
+          correctedCommand: explanation.correctedCommand
+        },
+        retryable: err.code === "RATE_LIMITED" || err.code === "UNAVAILABLE" || err.code === "INTERNAL_ERROR"
+      }
+    };
+    writeAdsJson(envelope);
+    process.exit(1);
+  }
+  writeAdsJson(unexpectedErrorEnvelope(err));
+  process.exit(1);
+}
+function unexpectedErrorEnvelope(err) {
+  if (err instanceof MissingChatIdError) {
+    return {
+      ok: false,
+      error: {
+        code: err.code,
+        message: err.message,
+        fix: {
+          action: "reject",
+          explanation: "LinkedIn changes are staged in a chat and this run has none. Don't retry: carry on with the rest of the job and tell the user this change couldn't be staged from here."
+        },
+        retryable: false
+      }
+    };
+  }
+  const message = err instanceof Error ? err.message : "Unexpected error";
+  return { ok: false, error: { code: "NETWORK_ERROR", message } };
+}
+function isNoAccountsSelectedError(code, message) {
+  return code === "VALIDATION_ERROR" && /no linkedin ad accounts selected/i.test(message);
+}
+function explainLinkedinError(err) {
+  const lower = err.message.toLowerCase();
+  if (err.code === "VALIDATION_ERROR" && lower.includes("granularity") && lower.includes("daily")) {
+    return {
+      action: "retry_with_flag",
+      message: "LinkedIn rejects DAILY granularity when pivoting on demographic dims (job-title, company, etc.). Re-run with --granularity ALL or MONTHLY.",
+      correctedCommand: void 0
+    };
+  }
+  if (err.code === "RATE_LIMITED") {
+    return {
+      action: "wait_and_retry",
+      message: "LinkedIn asked Baker to wait. A short wait is already sat out for you, so this one is long \u2014 up to LinkedIn's daily limit, which resets at midnight UTC. Don't retry in a loop: carry on with the rest of the job without this LinkedIn data, and tell the user it can be read again later."
+    };
+  }
+  if (err.code === "INTERNAL_ERROR" && lower.includes("deprecat")) {
+    return {
+      action: "reject",
+      message: "LinkedIn-Version header is deprecated. The backend constant LINKEDIN_API_VERSION needs to be bumped \u2014 file an issue or update the constant."
+    };
+  }
+  return { action: "reject", message: err.message };
+}
+var LI_ACCOUNT_ID_RE = /^(urn:li:sponsoredAccount:)?\d+$/;
+function resolveAccountIdArg(args) {
+  const fromArgs = args["account-id"] ?? args["account-urn"];
+  const id = fromArgs || getEnv().BAKER_LINKEDIN_AD_ACCOUNT_ID;
+  if (!id) {
+    writeAdsJson({
+      ok: false,
+      error: {
+        code: "MISSING_ACCOUNT_ID",
+        message: "Pass --account-id (numeric) or --account-urn (urn:li:sponsoredAccount:N), or set BAKER_LINKEDIN_AD_ACCOUNT_ID. Run `baker ads linkedin accounts` to find IDs."
+      }
+    });
+    process.exit(1);
+  }
+  if (!LI_ACCOUNT_ID_RE.test(id)) {
+    writeAdsJson({
+      ok: false,
+      error: {
+        code: "INVALID_ACCOUNT_ID",
+        message: `Invalid LinkedIn account ID "${id}". Expected numeric or urn:li:sponsoredAccount:N.`
+      }
+    });
+    process.exit(1);
+  }
+  return id.startsWith("urn:") ? id.split(":").pop() ?? id : id;
+}
+function todayIso() {
+  return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+}
+function daysAgoIso(days) {
+  return new Date(Date.now() - days * DAY_MS).toISOString().slice(0, 10);
+}
+function csvOrJson(args) {
+  return args.output ?? "json";
+}
+function statusesArgDescription(level) {
+  return `CSV of statuses (${LINKEDIN_SEARCH_STATUSES[level].join(",")})`;
+}
+function statusFilterError(level, statuses) {
+  const unsupported = unsupportedLinkedinSearchStatuses(level, statuses);
+  if (unsupported.length === 0) {
+    return null;
+  }
+  const accepted = LINKEDIN_SEARCH_STATUSES[level].join(",");
+  return {
+    ok: false,
+    error: {
+      code: "INVALID_STATUS",
+      message: `LinkedIn does not accept status ${unsupported.join(", ")} for this listing.`,
+      fix: {
+        action: "retry_with_flag",
+        explanation: `Re-run with --statuses from ${accepted}, or --all-statuses to drop the filter.`
+      },
+      retryable: false
+    }
+  };
+}
+function resolveStatusFilter(args, level) {
+  if (args["all-statuses"]) {
+    return void 0;
+  }
+  const explicit = args.statuses;
+  if (!explicit) {
+    return ["ACTIVE"];
+  }
+  const statuses = explicit.split(",").map((s) => s.trim().toUpperCase()).filter(Boolean);
+  const error = statusFilterError(level, statuses);
+  if (error) {
+    writeAdsJson(error);
+    process.exit(1);
+  }
+  return statuses;
+}
+function loadTargetingArg(args) {
+  const inline = args.targeting;
+  if (inline) {
+    try {
+      return JSON.parse(inline);
+    } catch {
+      handleLinkedinError(new Error("--targeting must be valid JSON. See LinkedIn 'targetingCriteria' shape."));
+    }
+  }
+  const file = args["targeting-file"];
+  if (file) {
+    try {
+      return JSON.parse(readFileSync(file, "utf-8"));
+    } catch (e) {
+      handleLinkedinError(
+        new Error(`Failed to read --targeting-file: ${e instanceof Error ? e.message : "I/O error"}`)
+      );
+    }
+  }
+  handleLinkedinError(new Error("Pass --targeting-file <path> or --targeting '{...JSON...}'"));
+}
+function exitOnInvalidArgs(issues, flagByField) {
+  const messages = issues.map((issue) => {
+    const field = String(issue.path[0] ?? "");
+    return `${flagByField[field] ?? (field || "args")}: ${issue.message}`;
+  });
+  writeAdsJson({ ok: false, error: { code: "INVALID_ARGS", message: messages.join("; ") } });
+  process.exit(1);
+}
+
+export {
+  handleLinkedinError,
+  resolveAccountIdArg,
+  todayIso,
+  daysAgoIso,
+  csvOrJson,
+  statusesArgDescription,
+  resolveStatusFilter,
+  loadTargetingArg,
+  exitOnInvalidArgs
+};
+//# sourceMappingURL=chunk-CLUJWAQE.js.map