@koda-sl/baker-cli 0.539.0 → 0.540.0-dev.91934cfea

package/dist/chunk-MHRFRSQ6.js

@@ -0,0 +1,676 @@
+import {
+  repeatedValues
+} from "./chunk-ERSX3MKH.js";
+import {
+  adCopyHints,
+  booleanWordPositionalError,
+  capabilityFix
+} from "./chunk-MM6CCIL7.js";
+import {
+  hintLines,
+  withHints
+} from "./chunk-D5FY4FAK.js";
+import {
+  termsRefusalFix
+} from "./chunk-QALAJNBG.js";
+import {
+  cacheGet,
+  cacheSet,
+  handleConnectionError,
+  isNotConnectedError,
+  writeJsonEnvelope
+} from "./chunk-EAHBTBVR.js";
+import {
+  GOOGLE_DRAFT_BATCH_MAX,
+  OP_TOO_LARGE_FIX,
+  OP_TOO_LARGE_MESSAGE_START,
+  googleDraftOpInputSchema,
+  toMicros
+} from "./chunk-BNO3EFGR.js";
+import {
+  ApiError,
+  apiPost
+} from "./chunk-C35UMKYG.js";
+import {
+  requireChatId,
+  resolveChatId
+} from "./chunk-LBIF6FJY.js";
+
+// src/commands/ads/google/write-shared.ts
+import { readFileSync } from "fs";
+import { defineCommand } from "citty";
+
+// src/commands/ads/google/copy-list-usage.ts
+var AD_COPY_LIST_USAGE = `repeat the flag once per item, or pass one comma-separated list and wrap an item that contains a comma in double quotes: '"Fast, free quotes",Book today'. A flag given once is read as a list, so a lone item with a comma needs its double quotes too: '"Fast, free quotes"'`;
+var COPY_LIST_FLAG = {
+  headlines: "--headlines",
+  descriptions: "--descriptions",
+  longHeadlines: "--long-headlines"
+};
+function valueAt(root, path) {
+  let node = root;
+  for (const key of path) {
+    if (node === null || typeof node !== "object") return void 0;
+    node = node[key];
+  }
+  return node;
+}
+function countRefusal(op, issue) {
+  if (issue.code !== "too_big" && issue.code !== "too_small" || issue.origin !== "array") return void 0;
+  const flag = COPY_LIST_FLAG[String(issue.path.at(-1))];
+  if (!flag) return void 0;
+  const value = valueAt(op, issue.path);
+  const count = Array.isArray(value) ? value.length : void 0;
+  return issue.code === "too_big" ? { flag, count, bound: `at most ${issue.maximum}`, tooMany: true } : { flag, count, bound: `at least ${issue.minimum}`, tooMany: false };
+}
+function copyListCountFix(op, issues) {
+  const refusals = issues.map((issue) => countRefusal(op, issue));
+  if (refusals.length === 0 || refusals.some((refusal) => refusal === void 0)) return void 0;
+  const counted = refusals.filter((refusal) => refusal !== void 0);
+  const limits = counted.map(({ flag, count, bound }) => `${flag} has ${count ?? "the wrong number of"} items; this ad takes ${bound}.`).join(" ");
+  const commaCause = counted.some((refusal) => refusal.tooMany) ? ` If you meant fewer items, the copy was cut at its commas: a flag given once is read as a comma-separated list, so an item with a comma in it ("Fast, free quotes", a decimal like "4,5/5") becomes two. To keep a comma, ${AD_COPY_LIST_USAGE} \u2014 or put the content in --file as JSON.` : "";
+  return {
+    action: "fix_copy_list_count",
+    explanation: `${limits}${commaCause} ${commaCause ? "Otherwise add" : "Add"} or drop items to fit the limit, then stage again; the field names are right.`
+  };
+}
+
+// src/commands/ads/google/draft-status.ts
+var OPERATION_LABELS = {
+  create: "Creating",
+  update: "Updating",
+  pause: "Pausing",
+  resume: "Resuming",
+  remove: "Removing"
+};
+function badge(node) {
+  const label = node.operation ? OPERATION_LABELS[node.operation] : void 0;
+  if (label) {
+    return label;
+  }
+  return node.existing ? "on Google Ads" : "staged";
+}
+function collectionLine(collection) {
+  const parts = [];
+  if (collection.added > 0) {
+    parts.push(`+${collection.added}`);
+  }
+  if (collection.existing > 0) {
+    parts.push(`${collection.existing} existing`);
+  }
+  if (collection.removed > 0) {
+    parts.push(`-${collection.removed}`);
+  }
+  if ((collection.updated ?? 0) > 0) {
+    parts.push(`~${collection.updated}`);
+  }
+  return parts.length > 0 ? `${collection.label}: ${parts.join(", ")}` : void 0;
+}
+function accountsInTree(nodes) {
+  const accounts = /* @__PURE__ */ new Set();
+  const walk = (node) => {
+    accounts.add(node.customerId);
+    for (const child of node.children) {
+      walk(child);
+    }
+  };
+  for (const node of nodes) {
+    walk(node);
+  }
+  return accounts;
+}
+function renderNode(node, depth, lines, showAccount) {
+  const indent = "  ".repeat(depth);
+  const account = showAccount ? ` \xB7 account ${node.customerId}` : "";
+  lines.push(`${indent}\u2022 ${node.name} \xB7 ${badge(node)}${account}`);
+  for (const warning of node.warnings ?? []) {
+    lines.push(`${indent}    \u26A0 ${warning}`);
+  }
+  for (const collection of node.collections) {
+    const line = collectionLine(collection);
+    if (line) {
+      lines.push(`${indent}    ${line}`);
+    }
+  }
+  for (const child of node.children) {
+    renderNode(child, depth + 1, lines, showAccount);
+  }
+}
+var RESOURCE_ENTITIES = /* @__PURE__ */ new Set([
+  "sharedSet",
+  "biddingStrategy",
+  "audience",
+  "conversionAction",
+  "label",
+  "budget",
+  "asset"
+]);
+function renderSection(title, nodes, lines, showAccount) {
+  if (nodes.length === 0) {
+    return;
+  }
+  lines.push("");
+  lines.push(title);
+  for (const node of nodes) {
+    renderNode(node, 1, lines, showAccount);
+  }
+}
+function renderAdvisories(data, lines) {
+  const advisories = data.advisories ?? [];
+  if (advisories.length === 0 || data.status === "applied") {
+    return;
+  }
+  lines.push("");
+  lines.push("Advisories (non-blocking, checked across the whole draft \u2014 settle these before you publish)");
+  for (const advisory of advisories) {
+    lines.push(`  \u2022 ${advisory.message}`);
+  }
+}
+function renderOutcome(data, lines) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const op of data.ops) {
+    const status = op.result?.status ?? "pending";
+    counts.set(status, (counts.get(status) ?? 0) + 1);
+  }
+  const summary = [...counts].map(([status, count]) => `${count} ${status}`).join(", ");
+  lines.push(`Google Ads \u2014 published \xB7 ${summary || `${data.count} op(s)`} \xB7 ${data.mode}`);
+  for (const op of data.ops) {
+    const status = op.result?.status;
+    if (status !== "failed" && status !== "skipped") {
+      continue;
+    }
+    const reason = op.result?.error ?? op.result?.skippedBecause ?? "no reason recorded";
+    lines.push(`  \u2717 ${op.summary} \u2014 ${status}: ${reason}`);
+  }
+}
+function renderDraftStatus(data) {
+  if (data.status === "none" || data.count === 0) {
+    return "No staged Google Ads changes on this chat.";
+  }
+  const modeNote = data.mode === "live" ? "Live \u2014 publishing writes directly to Google Ads." : "Simulated \u2014 publishing completes the whole draft without calling Google Ads.";
+  const lines = [];
+  if (data.status === "applied") {
+    renderOutcome(data, lines);
+  } else if (data.status === "publishing") {
+    lines.push(`Google Ads \u2014 publishing ${data.count} change${data.count === 1 ? "" : "s"} \xB7 ${data.mode}`);
+  } else {
+    lines.push(`Google Ads \u2014 ${data.count} staged change${data.count === 1 ? "" : "s"} \xB7 ${data.mode}`);
+  }
+  lines.push(modeNote);
+  const tree = data.tree ?? [];
+  const showAccount = accountsInTree(tree).size > 1;
+  renderSection(
+    "Shared resources",
+    tree.filter((node) => RESOURCE_ENTITIES.has(node.entity)),
+    lines,
+    showAccount
+  );
+  renderSection(
+    "Campaigns",
+    tree.filter((node) => node.entity === "campaign"),
+    lines,
+    showAccount
+  );
+  const rest = tree.filter((node) => !RESOURCE_ENTITIES.has(node.entity) && node.entity !== "campaign");
+  renderSection("Other", rest, lines, showAccount);
+  renderAdvisories(data, lines);
+  return lines.join("\n");
+}
+
+// src/commands/ads/google/stage-streak.ts
+var STREAK_WINDOW_MS = 5 * 6e4;
+var STREAK_THRESHOLD = 5;
+function nextStageStreak(previous, kind, now) {
+  const continues = previous && previous.kind === kind && now - previous.lastAt <= STREAK_WINDOW_MS;
+  return { kind, count: continues ? previous.count + 1 : 1, lastAt: now };
+}
+var BATCH_FORMS = {
+  "google.keyword.add": "`keywords add --file keywords.txt` (one term[:MATCH_TYPE] per line)",
+  "google.keyword.update": "`keywords pause|resume <resource name> <resource name>\u2026` (or --file, one per line) for status",
+  "google.keyword.remove": "`draft stage --file` with one google.keyword.remove per target",
+  "google.negativeKeyword.add": "`negative-keywords add --file terms.txt`",
+  "google.sharedSetMember.add": "`keyword-lists add --file terms.txt`",
+  "google.sharedSetMember.remove": '`keyword-lists remove --list-ref <id> --text "a,b,c"`'
+};
+function stageStreakHints(streak) {
+  if (streak.count < STREAK_THRESHOLD) {
+    return [];
+  }
+  const form = BATCH_FORMS[streak.kind];
+  return [
+    `LOOP: that is ${streak.count} ${streak.kind} ops staged one command at a time. Stop looping \u2014 put every remaining change in one file and stage them in ONE call: \`baker ads google draft stage --file ops.json --customer-id <id>\` (a JSON array of {"kind","target"?,"payload"?}, up to 500, any mix of kinds)${form ? `, or ${form}` : ""}. Fix staged ops together with \`draft amend --file\`.`
+  ];
+}
+var STREAK_CACHE = "stage-streak";
+function recordSingleStage(chatId, kind) {
+  try {
+    const streak = nextStageStreak(cacheGet(STREAK_CACHE, chatId)?.data, kind, Date.now());
+    cacheSet(STREAK_CACHE, chatId, streak, STREAK_WINDOW_MS);
+    return stageStreakHints(streak);
+  } catch {
+    return [];
+  }
+}
+
+// src/commands/ads/google/write-shared.ts
+function failWriteValidation(message) {
+  writeJsonEnvelope({ ok: false, error: { code: "VALIDATION_ERROR", message } });
+  process.exit(1);
+}
+function requireCustomerId(args) {
+  const raw = args["customer-id"] ?? args.customerId;
+  if (!raw || !/^\d{10}$/.test(raw)) {
+    failWriteValidation("pass --customer-id as the 10-digit Google Ads customer id (no dashes)");
+  }
+  return raw;
+}
+function requireTarget(args, entity) {
+  const booleanWord = booleanWordPositionalError(args, entity);
+  if (booleanWord) {
+    failWriteValidation(booleanWord);
+  }
+  const positional = Array.isArray(args._) ? args._[0] : void 0;
+  const target = args.id ?? args.target ?? args.ref ?? positional;
+  if (typeof target !== "string" || target.length === 0) {
+    failWriteValidation(`pass the ${entity} resource name or id as the positional argument`);
+  }
+  return target;
+}
+function targetEntries(args, entity) {
+  const booleanWord = booleanWordPositionalError(args, entity);
+  if (booleanWord) {
+    failWriteValidation(booleanWord);
+  }
+  const positionals = Array.isArray(args._) ? args._.filter((v) => typeof v === "string") : [];
+  const raw = [...positionals.flatMap((v) => v.split(",")), ...rawFileEntries(args.file)].map((v) => v.trim()).filter(Boolean);
+  const targets = [...new Set(raw)];
+  if (targets.length === 0) {
+    failWriteValidation(`pass the ${entity} resource name(s) as positional arguments and/or --file (one per line)`);
+  }
+  if (targets.length > GOOGLE_DRAFT_BATCH_MAX) {
+    failWriteValidation(`${targets.length} targets exceeds the batch limit of ${GOOGLE_DRAFT_BATCH_MAX} \u2014 split them`);
+  }
+  return targets;
+}
+function requireStringFlag(value, flag) {
+  if (typeof value !== "string" || value.length === 0) {
+    failWriteValidation(`${flag} is required`);
+  }
+  return value;
+}
+function microsFlag(value, flag) {
+  if (value === void 0 || value === null || value === "") {
+    return void 0;
+  }
+  const num = Number(value);
+  if (Number.isNaN(num) || num <= 0) {
+    failWriteValidation(`${flag} must be a positive amount (major currency units, e.g. 50 or 50.00)`);
+  }
+  return toMicros(num);
+}
+function listFlag(value) {
+  if (typeof value !== "string" || value.length === 0) {
+    return void 0;
+  }
+  const items = value.split(",").map((v) => v.trim()).filter(Boolean);
+  return items.length > 0 ? items : void 0;
+}
+var MATCH_TYPES = /* @__PURE__ */ new Set(["EXACT", "PHRASE", "BROAD"]);
+function parseKeywordEntry(raw, defaultMatch) {
+  const colon = raw.lastIndexOf(":");
+  if (colon > 0) {
+    const suffix = raw.slice(colon + 1).trim().toUpperCase();
+    if (MATCH_TYPES.has(suffix)) {
+      return { text: raw.slice(0, colon).trim(), matchType: suffix };
+    }
+    failWriteValidation(`"${raw}": ":${raw.slice(colon + 1)}" is not a match type (EXACT | PHRASE | BROAD)`);
+  }
+  if (!defaultMatch) {
+    failWriteValidation(`"${raw}" has no match type \u2014 add a :EXACT/:PHRASE/:BROAD suffix or pass --match-type`);
+  }
+  return { text: raw, matchType: defaultMatch };
+}
+function rawTextEntries(value, rawArgs) {
+  return repeatedValues(rawArgs, "text", value).flatMap((v) => v.split(",")).map((v) => v.trim()).filter(Boolean);
+}
+function rawFileEntries(path) {
+  return typeof path === "string" && path.length > 0 ? fileLines(path) : [];
+}
+function fileLines(path) {
+  return readFileSync(path, "utf8").split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#"));
+}
+function keywordEntries(args, rawArgs) {
+  const defaultMatch = typeof args["match-type"] === "string" ? args["match-type"].toUpperCase() : void 0;
+  const raw = [...rawTextEntries(args.text, rawArgs), ...rawFileEntries(args.file)];
+  if (raw.length === 0) {
+    failWriteValidation("pass keywords via --text (comma-separated) and/or --file (one per line)");
+  }
+  if (raw.length > GOOGLE_DRAFT_BATCH_MAX) {
+    failWriteValidation(`${raw.length} keywords exceeds the batch limit of ${GOOGLE_DRAFT_BATCH_MAX}`);
+  }
+  const entries = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const item of raw) {
+    const entry = parseKeywordEntry(item, defaultMatch);
+    const key = JSON.stringify([entry.text, entry.matchType]);
+    if (!seen.has(key)) {
+      seen.add(key);
+      entries.push(entry);
+    }
+  }
+  return entries;
+}
+function loadJsonPayloads(path) {
+  if (typeof path !== "string" || path.length === 0) {
+    return [];
+  }
+  const inline = /^\s*[[{]/.test(path);
+  const source = inline ? "inline JSON" : path;
+  const text = inline ? path : readFileSync(path, "utf8");
+  return parsedPayloads(text, source).map((item, index, all) => {
+    if (item === null || typeof item !== "object" || Array.isArray(item)) {
+      failWriteValidation(
+        all.length === 1 ? `${source} must contain a JSON object` : `${source}: item ${index} must be a JSON object`
+      );
+    }
+    return item;
+  });
+}
+function parsedPayloads(text, source) {
+  try {
+    const parsed = JSON.parse(text);
+    return Array.isArray(parsed) ? parsed : [parsed];
+  } catch (err) {
+    if (!(err instanceof SyntaxError)) {
+      throw err;
+    }
+    const lines = text.split(/\r?\n/).filter((line) => line.trim().length > 0);
+    if (lines.length > 1) {
+      return lines.map((line, index) => parseJsonLine(line, index, source));
+    }
+    failWriteValidation(`${source} is not valid JSON: ${err.message}`);
+  }
+}
+function parseJsonLine(line, index, source) {
+  try {
+    return JSON.parse(line);
+  } catch (err) {
+    return failWriteValidation(
+      `${source} line ${index + 1} is not valid JSON: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+}
+function loadJsonFileArg(path) {
+  const payloads = loadJsonPayloads(path);
+  if (payloads.length > 1) {
+    failWriteValidation(
+      `this command changes one entity, and --file holds ${payloads.length} payloads \u2014 stage many changes from one file with \`baker ads google draft stage --file\` (one op per item: {"kind","customerId","target"?,"payload"?})`
+    );
+  }
+  return payloads[0] ?? {};
+}
+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 handleGoogleError(err) {
+  if (err instanceof ApiError) {
+    if (isNotConnectedError(err.code, err.message)) {
+      handleConnectionError("google_ads", err.message);
+    }
+    const terms = termsRefusalFix(err.code, err.message);
+    if (terms) {
+      writeJsonEnvelope({
+        ok: false,
+        error: { code: terms.code, message: err.message, retryable: false, fix: terms.fix }
+      });
+      process.exit(1);
+    }
+    if (err.message.includes(OP_TOO_LARGE_MESSAGE_START)) {
+      writeJsonEnvelope({
+        ok: false,
+        error: {
+          code: "OP_TOO_LARGE",
+          message: err.message,
+          retryable: false,
+          fix: { action: "split_the_change", explanation: OP_TOO_LARGE_FIX }
+        }
+      });
+      process.exit(1);
+    }
+    writeJsonEnvelope({ ok: false, error: { code: err.code ?? "API_ERROR", message: err.message } });
+    process.exit(1);
+  }
+  writeJsonEnvelope({
+    ok: false,
+    error: { code: "UNKNOWN", message: err instanceof Error ? err.message : String(err) }
+  });
+  process.exit(1);
+}
+function noopHints(data) {
+  return data.staged ? [] : [`NOT STAGED \u2014 ${data.reason}. Nothing to publish for this change; say so rather than reporting it as done.`];
+}
+function skippedHints(skipped, total) {
+  if (skipped.length === 0) {
+    return [];
+  }
+  const detail = skipped.map((s) => `${s.summary} \u2014 ${s.reason}`).join("; ");
+  return [
+    `${skipped.length} of ${total} op(s) NOT STAGED: ${detail}. Don't re-stage them; tell the user which changes couldn't be made and why, then carry on with the rest.`
+  ];
+}
+async function stageGoogleOp(raw, hints) {
+  const preflight = googleDraftOpInputSchema.safeParse(raw);
+  if (!preflight.success) {
+    const fields = preflight.error.issues.map((issue) => ({ path: issue.path.join("."), message: issue.message }));
+    writeJsonEnvelope({
+      ok: false,
+      error: {
+        code: "VALIDATION_ERROR",
+        message: fields.map((f) => f.path ? `${f.path}: ${f.message}` : f.message).join("; "),
+        fields,
+        fix: copyListCountFix(raw, preflight.error.issues) ?? capabilityFix("google-ads")
+      }
+    });
+    process.exit(1);
+  }
+  try {
+    const chatId = requireChatId();
+    const response = await apiPost("/api/ads/google/draft/stage", { chatId, op: preflight.data });
+    const allHints = [
+      ...noopHints(response.data),
+      ...recordSingleStage(chatId, preflight.data.kind),
+      ...hints ?? [],
+      ...await adCopyHints(preflight.data)
+    ];
+    writeJsonEnvelope(withHints(response, allHints));
+  } catch (err) {
+    handleGoogleError(err);
+  }
+}
+async function stageCreate(kind, customerId, payload, hints) {
+  await stageGoogleOp({ kind, customerId, payload }, hints);
+}
+var STAGE_BATCH_TIMEOUT_MS = 5 * 6e4;
+async function stageGoogleOps(rawOps, hints) {
+  if (rawOps.length === 1 && rawOps[0]) {
+    await stageGoogleOp(rawOps[0], hints);
+    return;
+  }
+  const ops = [];
+  for (const [index, raw] of rawOps.entries()) {
+    const preflight = googleDraftOpInputSchema.safeParse(raw);
+    if (!preflight.success) {
+      const fields = preflight.error.issues.map((issue) => ({
+        path: `ops[${index}].${issue.path.join(".")}`,
+        message: issue.message
+      }));
+      writeJsonEnvelope({
+        ok: false,
+        error: {
+          code: "VALIDATION_ERROR",
+          message: fields.map((f) => `${f.path}: ${f.message}`).join("; "),
+          fields,
+          fix: copyListCountFix(raw, preflight.error.issues) ?? capabilityFix("google-ads")
+        }
+      });
+      process.exit(1);
+    }
+    ops.push(preflight.data);
+  }
+  try {
+    const chatId = requireChatId();
+    const response = await apiPost(
+      "/api/ads/google/draft/stage-batch",
+      { chatId, ops },
+      { timeoutMs: STAGE_BATCH_TIMEOUT_MS }
+    );
+    const allHints = [
+      ...skippedHints(response.data.skipped ?? [], ops.length),
+      ...hints ?? [],
+      ...await adCopyHints(ops)
+    ];
+    writeJsonEnvelope(withHints(response, allHints));
+  } catch (err) {
+    handleGoogleError(err);
+  }
+}
+async function stageUpdate(kind, customerId, target, payload, hints) {
+  await stageGoogleOp({ kind, customerId, target, payload }, hints);
+}
+async function stageTarget(kind, customerId, target, hints) {
+  await stageGoogleOp({ kind, customerId, target }, hints);
+}
+async function draftAction(path, body, chat) {
+  try {
+    const chatId = resolveChatId(chat);
+    const response = await apiPost(path, { chatId, ...body });
+    writeJsonEnvelope(response);
+  } catch (err) {
+    handleGoogleError(err);
+  }
+}
+async function draftListAction(json, chat) {
+  try {
+    const chatId = resolveChatId(chat);
+    const response = await apiPost("/api/ads/google/draft", { chatId });
+    if (json || !response.ok || !response.data) {
+      writeJsonEnvelope(response);
+      return;
+    }
+    process.stdout.write(`${renderDraftStatus(response.data)}${hintLines(response)}
+`);
+  } catch (err) {
+    handleGoogleError(err);
+  }
+}
+var customerIdArg = {
+  "customer-id": { type: "string", description: "10-digit Google Ads customer id" }
+};
+var fileArg = {
+  file: {
+    type: "string",
+    description: "The op payload: a JSON file path, or the JSON object inline (flags override it)"
+  }
+};
+var fileBatchArg = {
+  file: {
+    type: "string",
+    description: "The op payload: a JSON file path or inline JSON \u2014 one object, or a JSON array / JSON Lines of objects to stage many in one call (up to 500)"
+  }
+};
+function fileCreateCommand(name, kind, description, hints) {
+  return defineCommand({
+    meta: { name, description },
+    args: { ...customerIdArg, ...fileBatchArg },
+    run: async ({ args }) => {
+      const customerId = requireCustomerId(args);
+      const payloads = loadJsonPayloads(args.file);
+      if (payloads.length === 0 || payloads.some((payload) => Object.keys(payload).length === 0)) {
+        failWriteValidation(`${kind} needs --file with the op payload (one object, or a JSON array to stage many)`);
+      }
+      if (payloads.length > GOOGLE_DRAFT_BATCH_MAX) {
+        failWriteValidation(
+          `${payloads.length} payloads exceeds the batch limit of ${GOOGLE_DRAFT_BATCH_MAX} \u2014 split the file`
+        );
+      }
+      const payloadHints = [
+        ...new Set(payloads.flatMap((payload) => typeof hints === "function" ? hints(payload) : hints ?? []))
+      ];
+      await stageGoogleOps(
+        payloads.map((payload) => ({ kind, customerId, payload })),
+        payloadHints
+      );
+    }
+  });
+}
+function bidModifierFlag(value) {
+  if (value === void 0 || value === null || value === "") {
+    failWriteValidation(
+      "--bid-modifier is required: 1 for no adjustment, 1.25 to bid 25% more, 0.9 to bid 10% less, 0 to stop serving on a device"
+    );
+  }
+  const num = Number(value);
+  if (Number.isNaN(num) || num < 0 || num > 10 || num > 0 && num < 0.1) {
+    failWriteValidation("--bid-modifier must be 0 (stop serving on it) or between 0.1 and 10.0");
+  }
+  return num;
+}
+
+export {
+  AD_COPY_LIST_USAGE,
+  failWriteValidation,
+  requireCustomerId,
+  requireTarget,
+  targetEntries,
+  requireStringFlag,
+  microsFlag,
+  listFlag,
+  fileLines,
+  keywordEntries,
+  loadJsonPayloads,
+  loadJsonFileArg,
+  mergePayload,
+  loadPatchArg,
+  handleGoogleError,
+  stageGoogleOp,
+  stageCreate,
+  stageGoogleOps,
+  stageUpdate,
+  stageTarget,
+  draftAction,
+  draftListAction,
+  customerIdArg,
+  fileArg,
+  fileBatchArg,
+  fileCreateCommand,
+  bidModifierFlag
+};
+//# sourceMappingURL=chunk-MHRFRSQ6.js.map