@koda-sl/baker-cli 0.513.0 → 0.514.0-dev.555f7007e

package/dist/chunk-7BUIOP36.js

@@ -0,0 +1,287 @@
+import {
+  failWriteValidation,
+  parseDateFlag,
+  parseMoneyFlag
+} from "./chunk-QDQZ62FL.js";
+import {
+  repeatedValues
+} from "./chunk-ERSX3MKH.js";
+
+// src/commands/ads/meta/delivery-flags.ts
+function text(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function frequencyCapFlag(value) {
+  const raw = text(value);
+  if (raw === void 0) {
+    return void 0;
+  }
+  const match = /^(\d+)\s*\/\s*(\d+)\s*d?$/i.exec(raw.trim());
+  if (!match) {
+    failWriteValidation(
+      `--frequency-cap takes N/D \u2014 at most N impressions per person every D days, e.g. 2/7 (got "${raw}")`
+    );
+  }
+  return [{ event: "IMPRESSIONS", interval_days: Number(match[2]), max_frequency: Number(match[1]) }];
+}
+var DAY_INDEX = { sun: 0, mon: 1, tue: 2, wed: 3, thu: 4, fri: 5, sat: 6 };
+function dayIndex(name, flag) {
+  const index = DAY_INDEX[name.slice(0, 3).toLowerCase()];
+  if (index === void 0) {
+    failWriteValidation(`${flag}: "${name}" is not a day \u2014 use Mon, Tue, \u2026 Sun`);
+  }
+  return index;
+}
+function scheduleDays(spec) {
+  if (/^(daily|every ?day|all)$/i.test(spec)) {
+    return [0, 1, 2, 3, 4, 5, 6];
+  }
+  return spec.split(",").flatMap((part) => {
+    const [from, to] = part.split("-").map((day) => day.trim());
+    if (!from) {
+      return [];
+    }
+    const start = dayIndex(from, "--schedule");
+    if (!to) {
+      return [start];
+    }
+    const end = dayIndex(to, "--schedule");
+    const days = [];
+    for (let day = start; days.length < 7; day = (day + 1) % 7) {
+      days.push(day);
+      if (day === end) break;
+    }
+    return days;
+  });
+}
+function hourMinute(value) {
+  const [hours = "", minutes = "0"] = value.split(":");
+  return Number(hours) * 60 + Number(minutes);
+}
+function scheduleBlock(raw, timezone) {
+  const match = /^(.+?)\s+(\d{1,2}(?::\d{2})?)\s*-\s*(\d{1,2}(?::\d{2})?)$/.exec(raw.trim());
+  if (!match?.[1] || !match[2] || !match[3]) {
+    failWriteValidation(
+      `--schedule takes "<days> <from>-<to>", e.g. "Mon-Fri 09-18" or "sat,sun 10:00-14:00" (got "${raw}")`
+    );
+  }
+  return {
+    days: scheduleDays(match[1]),
+    start_minute: hourMinute(match[2]),
+    end_minute: hourMinute(match[3]),
+    timezone_type: timezone
+  };
+}
+function dayPartingFromFlags(args, rawArgs) {
+  const blocks = repeatedValues(rawArgs, "schedule", args.schedule).map((block) => {
+    const { timezone_type: _clock, ...rest } = scheduleBlock(block, "USER");
+    return rest;
+  });
+  return blocks.length > 0 ? blocks : void 0;
+}
+function scheduleTimezone(value) {
+  const raw = text(value)?.toLowerCase();
+  if (raw === void 0 || raw === "viewer" || raw === "user") {
+    return "USER";
+  }
+  if (raw === "account" || raw === "advertiser") {
+    return "ADVERTISER";
+  }
+  failWriteValidation(`--schedule-timezone takes viewer or account (got "${raw}")`);
+}
+var ATTRIBUTION_EVENTS = {
+  click: "CLICK_THROUGH",
+  view: "VIEW_THROUGH",
+  engaged_view: "ENGAGED_VIDEO_VIEW",
+  engaged_video_view: "ENGAGED_VIDEO_VIEW"
+};
+function attributionFlag(value) {
+  const raw = text(value);
+  if (raw === void 0) {
+    return void 0;
+  }
+  return raw.split(",").map((window) => {
+    const match = /^(\d+)d_([a-z_]+)$/i.exec(window.trim());
+    const event = match?.[2] ? ATTRIBUTION_EVENTS[match[2].toLowerCase()] : void 0;
+    if (!match || !event) {
+      failWriteValidation(`--attribution takes windows like 7d_click,1d_view,1d_engaged_view (got "${window}")`);
+    }
+    return { event_type: event, window_days: Number(match[1]) };
+  });
+}
+function numberArg(value, flag) {
+  const raw = text(value);
+  if (raw === void 0) {
+    return void 0;
+  }
+  const n = Number(raw);
+  if (!Number.isFinite(n)) {
+    failWriteValidation(`${flag} must be a number`);
+  }
+  return n;
+}
+function adSetDeliveryFromFlags(args, rawArgs) {
+  const timezone = scheduleTimezone(args["schedule-timezone"]);
+  const blocks = repeatedValues(rawArgs, "schedule", args.schedule).map((block) => scheduleBlock(block, timezone));
+  if (args["schedule-timezone"] !== void 0 && blocks.length === 0) {
+    failWriteValidation(
+      "--schedule-timezone says whose clock --schedule follows, so it goes with --schedule \u2014 pass the hours again with it"
+    );
+  }
+  const delivery = {
+    minRoas: numberArg(args["min-roas"], "--min-roas"),
+    frequency_control_specs: frequencyCapFlag(args["frequency-cap"]),
+    adset_schedule: blocks.length > 0 ? blocks : void 0,
+    pacing: text(args.pacing)?.toLowerCase(),
+    dailyMinSpendTarget: parseMoneyFlag(args["daily-min-spend"], args.currency, "--daily-min-spend"),
+    dailySpendCap: parseMoneyFlag(args["daily-spend-cap"], args.currency, "--daily-spend-cap"),
+    lifetimeMinSpendTarget: parseMoneyFlag(args["lifetime-min-spend"], args.currency, "--lifetime-min-spend"),
+    lifetimeSpendCap: parseMoneyFlag(args["lifetime-spend-cap"], args.currency, "--lifetime-spend-cap"),
+    is_dynamic_creative: args["dynamic-creative"] === void 0 ? void 0 : Boolean(args["dynamic-creative"]),
+    attribution_spec: attributionFlag(args.attribution)
+  };
+  return Object.fromEntries(Object.entries(delivery).filter(([, value]) => value !== void 0));
+}
+function budgetBoost(raw, currency) {
+  const match = /^(.+?)\.\.(.+?)=\+?(\d+(?:\.\d{1,3})?)(%?)$/.exec(raw.trim());
+  if (!match?.[1] || !match[2] || !match[3]) {
+    failWriteValidation(
+      `--budget-boost takes START..END=+AMOUNT or START..END=+PERCENT%, e.g. 2027-11-27T00:00Z..2027-11-28T00:00Z=+50% (got "${raw}")`
+    );
+  }
+  const period = {
+    time_start: parseDateFlag(match[1], "--budget-boost start"),
+    time_end: parseDateFlag(match[2], "--budget-boost end")
+  };
+  return match[4] === "%" ? { ...period, increasePercent: Number(match[3]) } : { ...period, increase: parseMoneyFlag(match[3], currency, "--budget-boost") };
+}
+function budgetBoostsFromFlags(args, rawArgs) {
+  const boosts = repeatedValues(rawArgs, "budget-boost", args["budget-boost"]);
+  return boosts.length > 0 ? boosts.map((boost) => budgetBoost(boost, args.currency)) : void 0;
+}
+function boostMove(raw) {
+  const match = /^(\d+)=(.+?)\.\.(.+)$/.exec(raw.trim());
+  if (!match?.[1] || !match[2] || !match[3]) {
+    failWriteValidation(
+      `--move-boost takes ID=START..END, e.g. 1633135568548763=2027-11-27T06:00Z..2027-11-27T12:00Z (got "${raw}")`
+    );
+  }
+  return {
+    id: match[1],
+    time_start: parseDateFlag(match[2], "--move-boost start"),
+    time_end: parseDateFlag(match[3], "--move-boost end")
+  };
+}
+function boostEditsFromFlags(args, rawArgs) {
+  const removed = repeatedValues(rawArgs, "remove-boost", args["remove-boost"]).flatMap((value) => value.split(",")).map((value) => value.trim()).filter(Boolean);
+  const moved = repeatedValues(rawArgs, "move-boost", args["move-boost"]);
+  return {
+    ...removed.length > 0 ? { removeBoosts: removed } : {},
+    ...moved.length > 0 ? { moveBoosts: moved.map(boostMove) } : {}
+  };
+}
+var boostEditArgs = {
+  "remove-boost": {
+    type: "string",
+    description: "Take one budget boost away, by its id from `baker ads meta high-demand-periods --campaign-id <id>` \u2014 repeatable or comma-separated. The others stay."
+  },
+  "move-boost": {
+    type: "string",
+    description: "Move one budget boost to another window, keeping its raise: ID=START..END, repeatable, at least 3 hours, on quarter hours. Meta has no boost update, so publish adds the same raise on the new window, then deletes the old boost. Example: --move-boost 1633135568548763=2027-11-27T06:00Z..2027-11-27T12:00Z"
+  }
+};
+var adSetDeliveryArgs = {
+  "min-roas": {
+    type: "string",
+    description: "Minimum ROAS for LOWEST_COST_WITH_MIN_ROAS bidding, as a multiple of spend: 2.5 = 250%. Needs --optimization-goal VALUE. Under a min-ROAS campaign budget every ad set needs its own. Example: --bid-strategy LOWEST_COST_WITH_MIN_ROAS --min-roas 2.5"
+  },
+  "frequency-cap": {
+    type: "string",
+    description: "At most N impressions per person every D days, as N/D \u2014 REACH and THRUPLAY goals only. Example: --frequency-cap 2/7"
+  },
+  schedule: {
+    type: "string",
+    description: 'Run ads only in these hours (dayparting), repeatable: "<days> <from>-<to>", whole hours. Needs --lifetime-budget and --end. Example: --schedule "Mon-Fri 09-18" --schedule "Sat 10-14"'
+  },
+  "schedule-timezone": {
+    type: "string",
+    description: "Whose clock --schedule follows: viewer (default) or account"
+  },
+  pacing: {
+    type: "string",
+    description: "standard (default) | no_pacing (accelerated \u2014 spends as fast as it can; LOWEST_COST_WITH_BID_CAP only) | day_parting (set by --schedule)"
+  },
+  "daily-min-spend": {
+    type: "string",
+    description: "Ad set spend limit under a DAILY campaign budget: spend at least this per day (best effort)"
+  },
+  "daily-spend-cap": {
+    type: "string",
+    description: "Ad set spend limit under a DAILY campaign budget: spend at most this per day. Example: --daily-spend-cap 15"
+  },
+  "lifetime-min-spend": {
+    type: "string",
+    description: "Ad set spend limit under a LIFETIME campaign budget: spend at least this in total"
+  },
+  "lifetime-spend-cap": {
+    type: "string",
+    description: "Ad set spend limit under a LIFETIME campaign budget: spend at most this in total"
+  },
+  attribution: {
+    type: "string",
+    description: "Attribution windows Meta optimizes on: 1d_click or 7d_click, plus 1d_view and/or 1d_engaged_view \u2014 conversion goals only; LINK_CLICKS, LANDING_PAGE_VIEWS and REACH take 1d_click alone. Fixed when the ad set is created: Meta refuses a change on a live ad set. Example: --attribution 7d_click,1d_view"
+  }
+};
+var budgetBoostArg = {
+  "budget-boost": {
+    type: "string",
+    description: "Raise the daily budget for a high-demand period, repeatable: START..END=+AMOUNT or START..END=+PERCENT% (max 800%), at least 3 hours, on quarter hours, all amounts or all percentages. Needs --daily-budget in the same command (the current one, on update). Example: --budget-boost 2027-11-27T00:00Z..2027-11-28T00:00Z=+50%"
+  }
+};
+var CLEAR_FLAGS = {
+  "daily-min-spend": "dailyMinSpendTarget",
+  "daily-spend-cap": "dailySpendCap",
+  "lifetime-min-spend": "lifetimeMinSpendTarget",
+  "lifetime-spend-cap": "lifetimeSpendCap",
+  schedule: "adset_schedule",
+  boosts: "budgetSchedules",
+  "budget-boost": "budgetSchedules"
+};
+var NOT_CLEARABLE = {
+  "min-roas": "a ROAS floor goes with ROAS goal bidding \u2014 switch --bid-strategy (e.g. LOWEST_COST_WITHOUT_CAP) and Baker drops the floor",
+  "frequency-cap": "Meta keeps a frequency cap on a reach ad set whatever is sent (an empty cap is accepted and ignored) \u2014 set another with --frequency-cap"
+};
+function clearFromFlags(rawArgs, entity) {
+  const names = repeatedValues(rawArgs, "clear", void 0).flatMap((value) => value.split(",")).map((value) => value.trim().toLowerCase()).filter(Boolean);
+  if (names.length === 0) return void 0;
+  const fields = names.map((name) => {
+    const why = NOT_CLEARABLE[name];
+    if (why) throw new Error(`--clear ${name}: ${why}`);
+    const field = CLEAR_FLAGS[name];
+    if (!field || entity === "campaign" && field !== "budgetSchedules") {
+      const takes = entity === "campaign" ? "boosts" : Object.keys(CLEAR_FLAGS).join(", ");
+      throw new Error(`--clear takes ${takes} \u2014 not "${name}"`);
+    }
+    return field;
+  });
+  return [...new Set(fields)];
+}
+var clearArg = {
+  clear: {
+    type: "string",
+    description: "Take a delivery control away (repeatable or comma-separated): daily-min-spend, daily-spend-cap, lifetime-min-spend, lifetime-spend-cap, schedule (back to standard pacing), boosts (every budget boost it has now). A ROAS floor goes by switching --bid-strategy; Meta keeps a reach ad set's frequency cap."
+  }
+};
+
+export {
+  dayPartingFromFlags,
+  adSetDeliveryFromFlags,
+  budgetBoostsFromFlags,
+  boostEditsFromFlags,
+  boostEditArgs,
+  adSetDeliveryArgs,
+  budgetBoostArg,
+  clearFromFlags,
+  clearArg
+};
+//# sourceMappingURL=chunk-7BUIOP36.js.map

package/dist/chunk-7I6ZVBLM.js

@@ -0,0 +1,358 @@
+import {
+  handleLinkedinError,
+  resolveAccountIdArg
+} from "./chunk-BJOK7QD4.js";
+import {
+  adCopyHints,
+  booleanWordPositionalError,
+  capabilityFix
+} from "./chunk-SCAGMX2I.js";
+import {
+  withHints
+} from "./chunk-D5FY4FAK.js";
+import {
+  writeJsonEnvelope
+} from "./chunk-ZRP7Y2DM.js";
+import {
+  LINKEDIN_DRAFT_BATCH_MAX,
+  linkedinDraftOpInputSchema,
+  listColumnField
+} from "./chunk-NZ34KM46.js";
+import {
+  maskPersonValue
+} from "./chunk-SOPVIIUW.js";
+import {
+  apiPost
+} from "./chunk-X7VQFLHI.js";
+import {
+  requireChatId
+} from "./chunk-LGK7UWBN.js";
+
+// src/commands/ads/linkedin/write-shared.ts
+import { createHash } from "crypto";
+import { readFileSync } from "fs";
+var TOTAL_BUDGET_HELP = "Lifetime budget \u2014 on something already running it must exceed spend to date, or LinkedIn rejects it";
+function bareAccountId(args) {
+  const raw = resolveAccountIdArg(args);
+  return raw.replace(/^urn:li:sponsoredAccount:/, "").replace(/^sponsoredAccount:/, "");
+}
+function failWriteValidation(message) {
+  writeJsonEnvelope({ ok: false, error: { code: "VALIDATION_ERROR", message } });
+  process.exit(1);
+}
+function loadJsonFileArg(path) {
+  if (typeof path !== "string" || path.length === 0) {
+    return {};
+  }
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf8"));
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+      failWriteValidation(`${path} must contain a JSON object`);
+    }
+    return parsed;
+  } catch (err) {
+    if (err instanceof SyntaxError) {
+      failWriteValidation(`${path} is not valid JSON: ${err.message}`);
+    }
+    throw err;
+  }
+}
+function mergePayload(file, flags) {
+  const merged = { ...file };
+  for (const [key, value] of Object.entries(flags)) {
+    if (value !== void 0) {
+      merged[key] = value;
+    }
+  }
+  return merged;
+}
+function loadPatchArg(args) {
+  const file = typeof args.file === "string" && args.file.length > 0 ? args.file : void 0;
+  const inline = typeof args.patch === "string" && args.patch.length > 0 ? args.patch : void 0;
+  if (Boolean(file) === Boolean(inline)) {
+    failWriteValidation("pass exactly one of --file <patch.json> or --patch '<json>'");
+  }
+  if (file) {
+    return loadJsonFileArg(file);
+  }
+  try {
+    const parsed = JSON.parse(inline);
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+      failWriteValidation("--patch must be a JSON object");
+    }
+    return parsed;
+  } catch (err) {
+    if (err instanceof SyntaxError) {
+      failWriteValidation(`--patch is not valid JSON: ${err.message}`);
+    }
+    throw err;
+  }
+}
+function parseMoneyFlag(amount, currency, flag) {
+  if (amount === void 0 || amount === null || amount === "") {
+    return void 0;
+  }
+  if (currency === void 0 || currency === null || currency === "") {
+    return { amount: String(amount) };
+  }
+  if (typeof currency !== "string" || currency.length !== 3) {
+    failWriteValidation(`${flag} got an invalid --currency (expected a 3-letter code like EUR)`);
+  }
+  return { amount: String(amount), currencyCode: currency.toUpperCase() };
+}
+function parseDateFlag(value, flag) {
+  if (value === void 0 || value === null || value === "") {
+    return void 0;
+  }
+  const raw = String(value);
+  if (/^\d{10,}$/.test(raw)) {
+    return Number(raw);
+  }
+  const parsed = Date.parse(raw);
+  if (Number.isNaN(parsed)) {
+    failWriteValidation(`${flag} must be an ISO date (2026-07-10) or epoch milliseconds`);
+  }
+  return parsed;
+}
+function parseOnOffFlag(value, flag) {
+  if (value === void 0 || value === null || value === "") {
+    return void 0;
+  }
+  const raw = String(value).toLowerCase();
+  if (raw === "on" || raw === "true") {
+    return true;
+  }
+  if (raw === "off" || raw === "false") {
+    return false;
+  }
+  failWriteValidation(`${flag} must be on|off`);
+}
+function parseLocaleFlag(value) {
+  if (value === void 0 || value === null || value === "") {
+    return void 0;
+  }
+  const match = /^([a-z]{2})[_-]([A-Za-z]{2})$/.exec(String(value));
+  if (!match) {
+    failWriteValidation("--locale must look like en_US (language_COUNTRY)");
+  }
+  return { language: match[1], country: match[2].toUpperCase() };
+}
+function loadTargetingFileArg(path) {
+  if (typeof path !== "string" || path.length === 0) {
+    return void 0;
+  }
+  const parsed = loadJsonFileArg(path);
+  const criteria = parsed.targetingCriteria ?? parsed;
+  if (!criteria.include) {
+    failWriteValidation(
+      `${path} must contain targeting criteria with an "include" block (see baker schema ads.linkedin.campaigns.create)`
+    );
+  }
+  return criteria;
+}
+var SHA256_HEX = /^[0-9a-f]{64}$/i;
+function sha256Lower(value) {
+  const email = value.trim().toLowerCase();
+  return SHA256_HEX.test(email) ? email : createHash("sha256").update(email).digest("hex");
+}
+function emailPreview(email) {
+  return email === "" || SHA256_HEX.test(email.trim()) ? "" : maskPersonValue("email", email);
+}
+function parseCsvLine(line) {
+  const cells = [];
+  let current = "";
+  let inQuotes = false;
+  for (let i = 0; i < line.length; i++) {
+    const char = line[i];
+    if (inQuotes) {
+      if (char === '"' && line[i + 1] === '"') {
+        current += '"';
+        i++;
+      } else if (char === '"') {
+        inQuotes = false;
+      } else {
+        current += char;
+      }
+    } else if (char === '"') {
+      inQuotes = true;
+    } else if (char === ",") {
+      cells.push(current);
+      current = "";
+    } else {
+      current += char;
+    }
+  }
+  cells.push(current);
+  return cells.map((cell) => cell.trim());
+}
+function parseListFileArg(path, maxRows) {
+  if (typeof path !== "string" || path.length === 0) {
+    return void 0;
+  }
+  const raw = readFileSync(path, "utf8");
+  const lines = raw.split(/\r?\n/).filter((line) => line.trim().length > 0);
+  if (lines.length < 2) {
+    failWriteValidation(`${path} needs a header row and at least one data row`);
+  }
+  const columns = parseCsvLine(lines[0]).map((column) => column.trim());
+  const rows = [];
+  const emailPreviews = [];
+  const emailColumn = columns.findIndex((column) => listColumnField(column) === "email");
+  for (const line of lines.slice(1)) {
+    const cells = parseCsvLine(line);
+    const row = {};
+    columns.forEach((column, index) => {
+      const value = cells[index] ?? "";
+      if (!value) {
+        return;
+      }
+      row[column] = listColumnField(column) === "email" ? sha256Lower(value) : value;
+    });
+    if (Object.keys(row).length > 0) {
+      rows.push(row);
+      emailPreviews.push(emailPreview(emailColumn >= 0 ? cells[emailColumn] ?? "" : ""));
+    }
+  }
+  if (rows.length > maxRows) {
+    failWriteValidation(`${path} has ${rows.length} rows \u2014 the inline limit is ${maxRows}. Split the list.`);
+  }
+  return { columns, rows, ...emailColumn >= 0 ? { emailPreviews } : {} };
+}
+function failPreflight(fields) {
+  writeJsonEnvelope({
+    ok: false,
+    error: {
+      code: "VALIDATION_ERROR",
+      message: fields.map((field) => field.path ? `${field.path}: ${field.message}` : field.message).join("; "),
+      fields,
+      fix: capabilityFix("linkedin-ads")
+    }
+  });
+  process.exit(1);
+}
+var BATCH_NUDGE = "This command takes several ids at once \u2014 pass them comma-separated or with --ids-file instead of one call per id.";
+function batchNudge(data) {
+  return data.sameKindStaged === void 0 ? [] : [BATCH_NUDGE];
+}
+async function stageOp(raw, hints) {
+  const preflight = linkedinDraftOpInputSchema.safeParse(raw);
+  if (!preflight.success) {
+    failPreflight(preflight.error.issues.map((issue) => ({ path: issue.path.join("."), message: issue.message })));
+  }
+  try {
+    const chatId = requireChatId();
+    const response = await apiPost("/api/ads/linkedin/draft/stage", {
+      chatId,
+      op: preflight.data
+    });
+    const allHints = [...batchNudge(response.data), ...hints ?? [], ...await adCopyHints(preflight.data)];
+    writeJsonEnvelope(withHints(response, allHints));
+  } catch (err) {
+    handleLinkedinError(err);
+  }
+}
+async function stageLinkedinOps(rawOps, hints) {
+  if (rawOps.length === 1 && rawOps[0]) {
+    await stageOp(rawOps[0], hints);
+    return;
+  }
+  const ops = [];
+  for (const [index, raw] of rawOps.entries()) {
+    const preflight = linkedinDraftOpInputSchema.safeParse(raw);
+    if (!preflight.success) {
+      failPreflight(
+        preflight.error.issues.map((issue) => ({
+          path: `ops[${index}]${issue.path.length > 0 ? `.${issue.path.join(".")}` : ""}`,
+          message: issue.message
+        }))
+      );
+    }
+    ops.push(preflight.data);
+  }
+  try {
+    const chatId = requireChatId();
+    const response = await apiPost("/api/ads/linkedin/draft/stage-batch", { chatId, ops });
+    const allHints = [...hints ?? [], ...await adCopyHints(ops)];
+    writeJsonEnvelope(withHints(response, allHints));
+  } catch (err) {
+    handleLinkedinError(err);
+  }
+}
+async function stageStatusChange(input) {
+  const payload = input.kind === "creative.update" ? { intendedStatus: input.status } : { status: input.status };
+  await stageLinkedinOps(
+    input.targets.map((target) => ({ kind: input.kind, accountId: input.accountId, target, payload }))
+  );
+}
+function requireTarget(args, entity) {
+  const inverted = booleanWordPositionalError(args, entity);
+  if (inverted !== void 0) {
+    failWriteValidation(inverted);
+  }
+  const positionals = readPositionals(args);
+  const target = args.id ?? args.target ?? args.ref ?? positionals[0];
+  if (typeof target !== "string" || target.length === 0) {
+    failWriteValidation(`pass the ${entity} id or URN as the positional argument`);
+  }
+  if (positionals.length > 1 || splitIdList(target).length > 1) {
+    failWriteValidation(
+      `this command takes one ${entity} id \u2014 run it once per id. Only pause/resume/archive/delete and 'creatives update' accept several ids in one call.`
+    );
+  }
+  return target;
+}
+function readPositionals(args) {
+  if (!Array.isArray(args._)) {
+    return [];
+  }
+  return args._.filter((value) => typeof value === "string" && value.length > 0);
+}
+function splitIdList(raw) {
+  return raw.split(",").map((id) => id.trim()).filter(Boolean);
+}
+function idsFileEntries(path) {
+  if (typeof path !== "string" || path.length === 0) {
+    return [];
+  }
+  return readFileSync(path, "utf8").split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#")).flatMap(splitIdList);
+}
+function requireTargets(args, entity) {
+  const positionals = readPositionals(args);
+  const named = [args.id, args.target, args.ref].filter(
+    (value) => typeof value === "string" && value.length > 0
+  );
+  const fromArgs = positionals.length > 0 ? positionals : named;
+  const targets = [.../* @__PURE__ */ new Set([...fromArgs.flatMap(splitIdList), ...idsFileEntries(args["ids-file"])])];
+  if (targets.length === 0) {
+    failWriteValidation(
+      `pass the ${entity} id or URN as the positional argument (comma-separated for several), or --ids-file <path>`
+    );
+  }
+  if (targets.length > LINKEDIN_DRAFT_BATCH_MAX) {
+    failWriteValidation(
+      `${targets.length} ids exceeds the batch limit of ${LINKEDIN_DRAFT_BATCH_MAX} \u2014 split the list`
+    );
+  }
+  return targets;
+}
+
+export {
+  TOTAL_BUDGET_HELP,
+  bareAccountId,
+  failWriteValidation,
+  loadJsonFileArg,
+  mergePayload,
+  loadPatchArg,
+  parseMoneyFlag,
+  parseDateFlag,
+  parseOnOffFlag,
+  parseLocaleFlag,
+  loadTargetingFileArg,
+  parseListFileArg,
+  stageOp,
+  stageLinkedinOps,
+  stageStatusChange,
+  requireTarget,
+  requireTargets
+};
+//# sourceMappingURL=chunk-7I6ZVBLM.js.map