@koda-sl/baker-cli 0.501.0-dev.6e96f50b9 → 0.502.0

package/dist/draft-UHNTXGY7.js

@@ -0,0 +1,333 @@
+import {
+  failWriteValidation
+} from "./chunk-NT3NJVPZ.js";
+import {
+  parseXApiError
+} from "./chunk-FIN4ZXGJ.js";
+import "./chunk-7NF73SCB.js";
+import {
+  writeAdsJson,
+  writeJsonEnvelope
+} from "./chunk-ZRP7Y2DM.js";
+import {
+  CHAT_READ_ARG
+} from "./chunk-PFBQERWX.js";
+import "./chunk-5MSRVAUZ.js";
+import "./chunk-CAZGM2NX.js";
+import "./chunk-NZS3KEQ2.js";
+import "./chunk-GIWHHCD6.js";
+import "./chunk-UI6BKYQD.js";
+import "./chunk-ERSL4WZT.js";
+import {
+  ApiError,
+  apiPost
+} from "./chunk-X7VQFLHI.js";
+import "./chunk-LU4HI4KI.js";
+import {
+  requireChatId,
+  resolveChatId
+} from "./chunk-LGK7UWBN.js";
+import {
+  registerSchema
+} from "./chunk-Q7US4OOA.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/ads/x/draft.ts
+import { readFileSync } from "fs";
+import { defineCommand } from "citty";
+
+// src/commands/ads/x/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;
+  return label ?? (node.existing ? "on X" : "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}`);
+  }
+  return parts.length > 0 ? `${collection.label}: ${parts.join(", ")}` : void 0;
+}
+function accountsInTree(nodes) {
+  const accounts = /* @__PURE__ */ new Set();
+  const walk = (node) => {
+    accounts.add(node.accountId);
+    for (const child of node.children) {
+      walk(child);
+    }
+  };
+  for (const node of nodes) {
+    walk(node);
+  }
+  return accounts;
+}
+function renderNode(node, depth, showAccount, out) {
+  const indent = "  ".repeat(depth);
+  const account = showAccount ? ` [${node.accountId}]` : "";
+  out.push(`${indent}${node.entity}: ${node.name} \u2014 ${badge(node)}${account}`);
+  for (const collection of node.collections) {
+    const line = collectionLine(collection);
+    if (line) {
+      out.push(`${indent}  ${line}`);
+    }
+  }
+  for (const warning of node.warnings ?? []) {
+    out.push(`${indent}  ! ${warning}`);
+  }
+  for (const child of node.children) {
+    renderNode(child, depth + 1, showAccount, out);
+  }
+}
+var NO_CHANGES = "No X Ads changes staged";
+var STATUS_HEADINGS = {
+  active: "staged",
+  publishing: "publishing",
+  applied: "published",
+  discarded: "discarded"
+};
+function didNotApply(op) {
+  return op.result?.status === "failed" || op.result?.status === "skipped";
+}
+function didApply(op) {
+  return op.result?.status === "applied" || op.result?.status === "simulated";
+}
+function headingLine(draft) {
+  const heading = STATUS_HEADINGS[draft.status] ?? draft.status;
+  if (draft.status !== "applied" && draft.status !== "publishing") {
+    return `X Ads: ${draft.count} change${draft.count === 1 ? "" : "s"} ${heading}`;
+  }
+  const applied = draft.ops.filter(didApply).length;
+  const failed = draft.ops.filter(didNotApply).length;
+  return `X Ads: ${heading} \xB7 ${applied} applied${failed > 0 ? `, ${failed} failed` : ""}`;
+}
+function problemLines(draft) {
+  return draft.ops.filter(didNotApply).map((op) => {
+    const reason = op.result?.error ?? `skipped: waiting on ${op.result?.skippedBecause ?? "a change that did not apply"}`;
+    return `\u2717 ${op.summary} \u2014 failed: ${reason}`;
+  });
+}
+function renderDraftStatus(draft) {
+  if (draft.status === "none" || draft.count === 0) {
+    return NO_CHANGES;
+  }
+  const out = [headingLine(draft), ""];
+  const tree = draft.tree ?? [];
+  const showAccount = accountsInTree(tree).size > 1;
+  for (const node of tree) {
+    renderNode(node, 0, showAccount, out);
+  }
+  const problems = problemLines(draft);
+  if (problems.length > 0) {
+    out.push("", ...problems);
+  }
+  return out.join("\n");
+}
+
+// src/commands/ads/x/draft.ts
+function handleDraftError(err) {
+  if (err instanceof ApiError) {
+    writeAdsJson(parseXApiError(err.message, "\u2014"));
+    process.exit(1);
+  }
+  writeAdsJson({ ok: false, error: { code: "NETWORK_ERROR", message: "Unexpected error" } });
+  process.exit(1);
+}
+registerSchema({
+  command: "ads.x.draft",
+  description: "Review everything staged for X Ads on this chat as a Campaign \u25B8 Ad group \u25B8 Ad tree. After a publish this is the authoritative record: `published \xB7 N applied`, or a `\u2717 \u2026 failed:` line per op that did not land.",
+  args: {
+    json: { type: "boolean", description: "Raw JSON envelope instead of the readable tree", required: false },
+    chat: { type: "string", description: "Read another chat's draft instead of this one", required: false }
+  }
+});
+async function listDraft(json, chat) {
+  try {
+    const chatId = resolveChatId(chat);
+    const response = await apiPost("/api/ads/x/draft", { chatId });
+    if (json || !response.ok || !response.data) {
+      writeJsonEnvelope(response);
+      return;
+    }
+    process.stdout.write(`${renderDraftStatus(response.data)}
+`);
+  } catch (err) {
+    handleDraftError(err);
+  }
+}
+var listCommand = defineCommand({
+  meta: {
+    name: "list",
+    description: "Review everything staged as a Campaign \u25B8 Ad group \u25B8 Ad tree. Example: baker ads x draft"
+  },
+  args: {
+    json: { type: "boolean", description: "Print the raw JSON envelope instead of the readable tree" },
+    chat: CHAT_READ_ARG
+  },
+  run: async ({ args }) => {
+    await listDraft(args.json === true, args.chat);
+  }
+});
+registerSchema({
+  command: "ads.x.draft.show",
+  description: "The full staged payload, warnings and before-snapshot for one op \u2014 the receipt to check before publishing.",
+  args: {
+    ref: {
+      type: "positional",
+      description: "Op ref (x_temp_* for creates, the target id for updates)",
+      required: true
+    },
+    chat: { type: "string", description: "Read another chat's draft instead of this one", required: false }
+  }
+});
+var showCommand = defineCommand({
+  meta: {
+    name: "show",
+    description: "Show one staged op in full. Example: baker ads x draft show x_temp_abc123"
+  },
+  args: {
+    ref: { type: "positional", description: "Op ref, or the target id for a staged update", required: true },
+    chat: CHAT_READ_ARG
+  },
+  run: async ({ args }) => {
+    try {
+      const chatId = resolveChatId(args.chat);
+      const response = await apiPost("/api/ads/x/draft/show", {
+        chatId,
+        ref: String(args.ref)
+      });
+      writeJsonEnvelope(response);
+    } catch (err) {
+      handleDraftError(err);
+    }
+  }
+});
+registerSchema({
+  command: "ads.x.draft.amend",
+  description: "Change a staged op in place instead of removing and re-staging it. The patch merges into the payload (JSON merge-patch: `null` deletes a key) and the whole op re-validates.",
+  args: {
+    ref: { type: "positional", description: "Op ref or target id", required: true },
+    patch: { type: "positional", description: "JSON object, or @path to a file holding one", required: true }
+  }
+});
+var amendCommand = defineCommand({
+  meta: {
+    name: "amend",
+    description: `Change a staged op in place.
+
+Example:
+  baker ads x draft amend x_temp_abc '{"dailyBudgetAmountLocalMicro": 20000000}'`
+  },
+  args: {
+    ref: { type: "positional", description: "Op ref or target id", required: true },
+    patch: { type: "positional", description: "JSON object, or @path to a file", required: true }
+  },
+  run: async ({ args }) => {
+    const raw = String(args.patch);
+    let patch;
+    try {
+      patch = JSON.parse(raw.startsWith("@") ? readFileSync(raw.slice(1), "utf8") : raw);
+    } catch {
+      failWriteValidation("patch must be a JSON object, or @path to a file holding one");
+    }
+    if (patch === null || typeof patch !== "object" || Array.isArray(patch)) {
+      failWriteValidation("patch must be a JSON object");
+    }
+    try {
+      const chatId = requireChatId();
+      const response = await apiPost("/api/ads/x/draft/amend", {
+        chatId,
+        ref: String(args.ref),
+        patch
+      });
+      writeJsonEnvelope(response);
+    } catch (err) {
+      handleDraftError(err);
+    }
+  }
+});
+registerSchema({
+  command: "ads.x.draft.remove",
+  description: "Drop one staged X op. Removing a create cascades to everything staged that depends on it.",
+  args: { ref: { type: "positional", description: "Op ref or target id", required: true } }
+});
+var removeCommand = defineCommand({
+  meta: {
+    name: "remove",
+    description: "Drop one staged op (cascades to its dependents). Example: baker ads x draft remove x_temp_abc123"
+  },
+  args: { ref: { type: "positional", description: "Op ref or target id", required: true } },
+  run: async ({ args }) => {
+    try {
+      const chatId = requireChatId();
+      const response = await apiPost("/api/ads/x/draft/remove", {
+        chatId,
+        ref: String(args.ref)
+      });
+      writeJsonEnvelope(response);
+    } catch (err) {
+      handleDraftError(err);
+    }
+  }
+});
+registerSchema({
+  command: "ads.x.draft.clear",
+  description: "Drop every staged X op on this chat. Nothing reached X, so nothing needs reversing.",
+  args: {}
+});
+var clearCommand = defineCommand({
+  meta: { name: "clear", description: "Drop every staged X op on this chat. Example: baker ads x draft clear" },
+  args: {},
+  run: async () => {
+    try {
+      const chatId = requireChatId();
+      const response = await apiPost("/api/ads/x/draft/clear", { chatId });
+      writeJsonEnvelope(response);
+    } catch (err) {
+      handleDraftError(err);
+    }
+  }
+});
+var draftCommand = defineCommand({
+  meta: {
+    name: "draft",
+    description: `Review and edit the X Ads changes staged on this chat.
+
+Nothing staged has reached X. Everything applies when the chat is published,
+and discarding the chat reverses all of it.
+
+Examples:
+  baker ads x draft                       \u2014 the Campaign \u25B8 Ad group \u25B8 Ad tree
+  baker ads x draft show x_temp_abc123    \u2014 one op in full
+  baker ads x draft amend x_temp_abc '{"name":"New"}'
+  baker ads x draft remove x_temp_abc123
+  baker ads x draft clear`
+  },
+  subCommands: {
+    list: listCommand,
+    show: showCommand,
+    amend: amendCommand,
+    remove: removeCommand,
+    clear: clearCommand
+  },
+  // A parent must never declare `run`: citty falls through to it AFTER running
+  // the matched subcommand, so every edit would also trigger a full list.
+  args: { json: { type: "boolean", description: "Raw JSON envelope" }, chat: CHAT_READ_ARG },
+  default: "list"
+});
+export {
+  draftCommand
+};
+//# sourceMappingURL=draft-UHNTXGY7.js.map

package/dist/engine/index.js

@@ -8,14 +8,14 @@ import {
   defaultRegistry,
   generateCatalog,
   validateCanvasDeep
-} from "../chunk-JYOVVJ2E.js";
-import "../chunk-B5JQM24Z.js";
-import "../chunk-S4L4H7JG.js";
+} from "../chunk-6KWEF6HF.js";
+import "../chunk-TX7CQTD4.js";
+import "../chunk-F4YQ5PVR.js";
 import "../chunk-DGCUPJZD.js";
-import "../chunk-6HS4YPW7.js";
-import "../chunk-N22J7UPW.js";
-import "../chunk-PSYAT3ZM.js";
-import "../chunk-3ZW3NYI6.js";
+import "../chunk-MVD7QIXI.js";
+import "../chunk-LRV6M2WB.js";
+import "../chunk-7HZSORAB.js";
+import "../chunk-MCJ5I5LR.js";
 import "../chunk-2WZI36D3.js";
 import "../chunk-65Y3RCWP.js";
 import "../chunk-LNNTHEL7.js";

package/dist/experiments-IGMLMSLX.js

@@ -0,0 +1,234 @@
+import {
+  bareAccountId,
+  failWriteValidation,
+  parseDateFlag,
+  requireTarget,
+  stageOp
+} from "./chunk-X64DJIZG.js";
+import {
+  handleLinkedinError
+} from "./chunk-I46D7YXI.js";
+import "./chunk-KJZPCLQE.js";
+import "./chunk-4NZ47VXO.js";
+import "./chunk-D5FY4FAK.js";
+import "./chunk-QPESDKZC.js";
+import {
+  writeJsonEnvelope
+} from "./chunk-ZRP7Y2DM.js";
+import "./chunk-E44NXCTL.js";
+import "./chunk-EJGAJHLB.js";
+import "./chunk-LNNTHEL7.js";
+import "./chunk-FOMFU2RX.js";
+import "./chunk-PSGIHSNC.js";
+import "./chunk-PONLPYD7.js";
+import "./chunk-5MSRVAUZ.js";
+import "./chunk-CAZGM2NX.js";
+import "./chunk-NZS3KEQ2.js";
+import "./chunk-GIWHHCD6.js";
+import "./chunk-UI6BKYQD.js";
+import "./chunk-ERSL4WZT.js";
+import {
+  apiGet
+} from "./chunk-X7VQFLHI.js";
+import "./chunk-LU4HI4KI.js";
+import "./chunk-LGK7UWBN.js";
+import "./chunk-Q7US4OOA.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/ads/linkedin/experiments.ts
+import { defineCommand } from "citty";
+var STAGED_NOTE = "Staged until publish \u2014 review with `baker ads linkedin draft`.";
+var accountArgs = {
+  "account-id": { type: "string", description: "Numeric account ID or urn:li:sponsoredAccount:N" },
+  "account-urn": { type: "string", description: "Alias for --account-id" }
+};
+var STOP_AT = {
+  "end-date": "AUTO_STOP_AT_END_DATE",
+  winner: "AUTO_STOP_AT_WINNER",
+  never: "AUTO_STOP_DISABLED"
+};
+function stopAtArg(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  const mapped = STOP_AT[String(value)];
+  if (!mapped) {
+    failWriteValidation(`--stop-at must be one of ${Object.keys(STOP_AT).join("|")}`);
+  }
+  return mapped;
+}
+function numberArg(value, flag) {
+  if (value === void 0) {
+    return void 0;
+  }
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed)) {
+    failWriteValidation(`${flag} must be a whole number`);
+  }
+  return parsed;
+}
+var experimentsListCommand = defineCommand({
+  meta: {
+    name: "list",
+    description: "List the ad account's A/B tests, newest first: name, state (what was asked), running (what LinkedIn is doing: PENDING|RUNNING|ON_HOLD|STOPPED|ENDED), metric, dates and the two versions (ad sets + traffic split). Runs by default."
+  },
+  args: { ...accountArgs },
+  run: async ({ args }) => {
+    try {
+      const data = await apiGet("/api/ads/linkedin/experiments", {
+        "account-id": bareAccountId(args)
+      });
+      writeJsonEnvelope({ ok: true, data });
+    } catch (err) {
+      handleLinkedinError(err);
+    }
+  }
+});
+var experimentsGetCommand = defineCommand({
+  meta: {
+    name: "get",
+    description: "One A/B test with LinkedIn's setup checks (an ERROR keeps it from running \u2014 e.g. NO_ACTIVE_CREATIVES; a WARNING may skew it) and its latest result: the winning version, p-value, and each version's confidence interval for the metric. `result: null` until LinkedIn computes the first one (daily)."
+  },
+  args: {
+    id: { type: "positional", description: "A/B test id from `experiments`", required: true },
+    ...accountArgs
+  },
+  run: async ({ args }) => {
+    try {
+      const data = await apiGet("/api/ads/linkedin/experiments", {
+        "account-id": bareAccountId(args),
+        id: requireTarget(args, "A/B test")
+      });
+      writeJsonEnvelope({ ok: true, data });
+    } catch (err) {
+      handleLinkedinError(err);
+    }
+  }
+});
+var experimentsCreateCommand = defineCommand({
+  meta: {
+    name: "create",
+    description: `Stage an A/B test between two ad sets of the SAME campaign: LinkedIn splits the audience so each member sees only one version, and calls a winner on the metric. ${STAGED_NOTE}
+Rules LinkedIn enforces: exactly 2 ad sets, same campaign, that campaign must NOT share its budget across ad sets, at most 90 days, confidence 51\u201399 (90+ recommended), each ad set needs an active ad. Best practice: two new ad sets identical but for the one thing tested, equal budgets, 3+ weeks.
+Examples:
+  baker ads linkedin experiments create --name "Image vs video" --version-a li_temp_x1 --version-b li_temp_x2 --metric CPC --start 2026-11-01 --end 2026-11-28
+  baker ads linkedin experiments create --name "Headline test" --version-a 896802423 --name-a "Pain" --version-b 896812053 --name-b "Gain" --metric CPM --start 2026-11-01 --end 2026-12-01 --stop-at winner --confidence 95`
+  },
+  args: {
+    ...accountArgs,
+    name: { type: "string", description: "Test name (\u2264100)", required: true },
+    description: { type: "string", description: "What is being tested" },
+    "version-a": { type: "string", description: "Ad set id/URN or li_temp_* ref for version A", required: true },
+    "version-b": { type: "string", description: "Ad set id/URN or li_temp_* ref for version B", required: true },
+    "name-a": { type: "string", description: "Version A label (default A)" },
+    "name-b": { type: "string", description: "Version B label (default B)" },
+    "weight-a": { type: "string", description: "Version A share of the audience, 1\u201399 (default 50; B gets the rest)" },
+    metric: { type: "string", description: "CPC|CPM|CPV (video ad sets)|CPMS (message ads)", required: true },
+    confidence: { type: "string", description: "51\u201399 (default 90)" },
+    start: { type: "string", description: "Start date (ISO or epoch ms)", required: true },
+    end: { type: "string", description: "End date (\u226490 days after start)", required: true },
+    "stop-at": {
+      type: "string",
+      description: "end-date (default, pauses both) | winner | never (ad sets keep running)"
+    },
+    draft: { type: "boolean", description: "Create it set up but not running" }
+  },
+  run: async ({ args }) => {
+    const weightA = numberArg(args["weight-a"], "--weight-a") ?? 50;
+    await stageOp({
+      kind: "experiment.create",
+      accountId: bareAccountId(args),
+      payload: {
+        name: args.name,
+        description: args.description,
+        keyMetric: args.metric ? String(args.metric).toUpperCase() : void 0,
+        confidence: numberArg(args.confidence, "--confidence"),
+        start: parseDateFlag(args.start, "--start"),
+        end: parseDateFlag(args.end, "--end"),
+        autoStop: stopAtArg(args["stop-at"]),
+        state: args.draft ? "DRAFT" : void 0,
+        cells: [
+          { name: args["name-a"] ?? "A", campaign: args["version-a"], trafficWeight: weightA },
+          { name: args["name-b"] ?? "B", campaign: args["version-b"], trafficWeight: 100 - weightA }
+        ]
+      }
+    });
+  }
+});
+var experimentsUpdateCommand = defineCommand({
+  meta: {
+    name: "update",
+    description: `Stage changes to an A/B test. Once it has started only the name, description, end date (still \u226490 days from start), confidence and when it stops can change \u2014 the versions are fixed. ${STAGED_NOTE}
+Example: baker ads linkedin experiments update 5633011 --end 2026-12-15 --stop-at winner`
+  },
+  args: {
+    id: { type: "positional", description: "A/B test id", required: true },
+    ...accountArgs,
+    name: { type: "string", description: "New name" },
+    description: { type: "string", description: "New description" },
+    end: { type: "string", description: "New end date" },
+    confidence: { type: "string", description: "51\u201399" },
+    "stop-at": { type: "string", description: "end-date|winner|never" }
+  },
+  run: async ({ args }) => {
+    await stageOp({
+      kind: "experiment.update",
+      accountId: bareAccountId(args),
+      target: requireTarget(args, "A/B test"),
+      payload: {
+        name: args.name,
+        description: args.description,
+        end: parseDateFlag(args.end, "--end"),
+        confidence: numberArg(args.confidence, "--confidence"),
+        autoStop: stopAtArg(args["stop-at"])
+      }
+    });
+  }
+});
+function experimentStateCommand(name, state, what) {
+  return defineCommand({
+    meta: {
+      name,
+      description: `Stage ${what}. ${STAGED_NOTE}
+Example: baker ads linkedin experiments ${name} 5633011`
+    },
+    args: {
+      id: { type: "positional", description: "A/B test id", required: true },
+      ...accountArgs
+    },
+    run: async ({ args }) => {
+      await stageOp({
+        kind: "experiment.update",
+        accountId: bareAccountId(args),
+        target: requireTarget(args, "A/B test"),
+        payload: { state }
+      });
+    }
+  });
+}
+var experimentsCommand = defineCommand({
+  meta: {
+    name: "experiments",
+    description: `LinkedIn A/B tests: two ad sets of one campaign shown to separate halves of the audience, with a winner called on CPC/CPM/CPV/CPMS.
+Examples:
+  baker ads linkedin experiments                       # list
+  baker ads linkedin experiments get 5633011           # setup checks + result
+  baker ads linkedin experiments create --name "Image vs video" --version-a <ad set> --version-b <ad set> --metric CPC --start 2026-11-01 --end 2026-11-28
+  baker ads linkedin experiments pause|start|end 5633011`
+  },
+  subCommands: {
+    list: experimentsListCommand,
+    get: experimentsGetCommand,
+    create: experimentsCreateCommand,
+    update: experimentsUpdateCommand,
+    start: experimentStateCommand("start", "ACTIVE", "starting (or resuming) an A/B test"),
+    pause: experimentStateCommand("pause", "PAUSED", "pausing an A/B test \u2014 both ad sets pause, the end date stays"),
+    end: experimentStateCommand("end", "CANCELED", "ending an A/B test for good")
+  },
+  args: { ...accountArgs },
+  default: "list"
+});
+export {
+  experimentsCommand
+};
+//# sourceMappingURL=experiments-IGMLMSLX.js.map