@koda-sl/baker-cli 0.568.0 → 0.569.0-dev.1b455b3fe

package/dist/url-options-Y7I5EL55.js

@@ -0,0 +1,131 @@
+import {
+  mappingCommandFor,
+  proposeMappingFromTemplate
+} from "./chunk-PILLZPNC.js";
+import "./chunk-NKQWDEB7.js";
+import {
+  parseApiError
+} from "./chunk-HFZZKYUX.js";
+import {
+  urlOptionsHints
+} from "./chunk-WZXMZFVB.js";
+import {
+  getManagerIdForCustomer,
+  resolveCustomerId,
+  writeAdsJson,
+  writeJsonEnvelope
+} from "./chunk-MK4HCMEA.js";
+import "./chunk-G4FG5EQO.js";
+import "./chunk-IMS53EQU.js";
+import {
+  ApiError,
+  apiPost
+} from "./chunk-QEREDRZO.js";
+import "./chunk-JXTNP3B5.js";
+import "./chunk-45D6WRCJ.js";
+import {
+  registerSchema
+} from "./chunk-CCYZJMZ7.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/ads/google/url-options.ts
+import { defineCommand } from "citty";
+
+// src/commands/ads/google/mapping-hints.ts
+function observedTemplates(report) {
+  const values = [
+    report.account.final_url_suffix,
+    report.account.tracking_url_template,
+    ...[...report.campaigns.overrides, ...report.ad_groups.overrides, ...report.ads.overrides].flatMap((entity) => [
+      entity.final_url_suffix,
+      entity.tracking_url_template
+    ])
+  ];
+  return values.flatMap((value) => value.state === "set" ? [value.value] : []);
+}
+function mappingHints(report) {
+  const proposed = {};
+  const unexplained = /* @__PURE__ */ new Map();
+  for (const template of observedTemplates(report)) {
+    const proposal = proposeMappingFromTemplate(template, "google");
+    Object.assign(proposed, proposal.proposed);
+    for (const param of proposal.unexplained) unexplained.set(param.name, param.value);
+  }
+  const hints = [];
+  const command = mappingCommandFor("google", proposed);
+  if (command !== "") {
+    hints.push(
+      `These URLs carry campaign parameters Baker does not read yet: ${Object.keys(proposed).join(", ")}. Until it is told, their values are not stored at all \u2014 only that the name appeared \u2014 so every keyword and campaign breakdown for this account will come back empty rather than wrong. The placeholders say what each one is, so run: ${command}`
+    );
+  }
+  if (unexplained.size > 0) {
+    const named = [...unexplained].map(([name, value]) => `${name}=${value}`).join(", ");
+    hints.push(
+      `These carry something no placeholder explains: ${named}. Do not guess \u2014 if it is a dimension, map it by name with \`baker analytics map --platform google --set <name>=<role>\`; if it is a session token or a cache buster, \`=ignore\` stops it being listed as something to deal with.`
+    );
+  }
+  return hints;
+}
+
+// src/commands/ads/google/url-options.ts
+registerSchema({
+  command: "ads.google.url-options",
+  description: "Report the Google Ads URL/tracking options in force at every level: the account-level final URL suffix and tracking template, plus every campaign, ad group and ad that overrides them. Every value is tagged set | not_set | not_read, so an unread level is never mistaken for an unset one. Read this before answering any UTM / tracking-parameter question. Compact by default: only overriding campaigns are listed; --full lists every campaign read.",
+  args: {
+    "customer-id": {
+      type: "string",
+      description: "Google Ads customer ID (10 digits, no dashes). Falls back to BAKER_GOOGLE_ADS_CUSTOMER_ID env var.",
+      required: false
+    },
+    full: {
+      type: "boolean",
+      description: "List every campaign read, including those with no override of their own.",
+      required: false
+    },
+    "no-cache": { type: "boolean", description: "Skip the read cache", required: false }
+  }
+});
+var urlOptionsCommand = defineCommand({
+  meta: {
+    name: "url-options",
+    description: `Show the URL/tracking options in force \u2014 account-level final URL suffix and tracking template, plus the campaigns, ad groups and ads that override them (the most specific level wins).
+
+Start here for any "add utm_\u2026 / tracking parameter / agency tag" question: it tells you which level already carries one.
+Each value is tagged: set | not_set (Google carries no value there) | not_read (never observed \u2014 NOT a finding).
+Judgment on which level to use and what to put in it: /google-ads-playbook \u2192 18-naming-utm.md.
+
+Examples:
+  baker ads google url-options --customer-id 1234567890
+  baker ads google url-options --customer-id 1234567890 --full`
+  },
+  args: {
+    "customer-id": { type: "string", description: "Google Ads customer ID (10 digits)", required: false },
+    full: { type: "boolean", description: "List every campaign read, not only the overriding ones", required: false },
+    "no-cache": { type: "boolean", description: "Skip the read cache", required: false }
+  },
+  run: async ({ args }) => {
+    const customerId = await resolveCustomerId(args);
+    try {
+      const managerId = getManagerIdForCustomer(customerId);
+      const data = await apiPost("/api/ads/google/url-options", {
+        customerId,
+        ...managerId ? { managerId } : {},
+        ...args.full ? { full: true } : {},
+        ...args["no-cache"] ? { skipCache: true } : {}
+      });
+      const hints = [...urlOptionsHints(data), ...mappingHints(data)];
+      writeJsonEnvelope(hints.length > 0 ? { ok: true, data, hints } : { ok: true, data });
+    } catch (err) {
+      if (err instanceof ApiError) {
+        writeAdsJson(parseApiError(err.message, "", customerId, err.code));
+        process.exit(1);
+      }
+      writeAdsJson({ ok: false, error: { code: "NETWORK_ERROR", message: "Unexpected error" } });
+      process.exit(1);
+    }
+  }
+});
+export {
+  urlOptionsCommand
+};
+//# sourceMappingURL=url-options-Y7I5EL55.js.map

package/dist/url-params-PE4XAQNH.js

@@ -0,0 +1,101 @@
+import {
+  handleLinkedinError,
+  resolveAccountIdArg
+} from "./chunk-34MZGC2Y.js";
+import {
+  writeAdsJson
+} from "./chunk-MK4HCMEA.js";
+import {
+  LINKEDIN_TRACKING_PARAMS_AD_SET_MAX
+} from "./chunk-YOHGEF2N.js";
+import "./chunk-QV6AST5T.js";
+import "./chunk-WCU362Z6.js";
+import "./chunk-GIWHHCD6.js";
+import "./chunk-SOPVIIUW.js";
+import "./chunk-G4FG5EQO.js";
+import "./chunk-R7XDGNZD.js";
+import "./chunk-IMS53EQU.js";
+import {
+  apiGet
+} from "./chunk-QEREDRZO.js";
+import "./chunk-JXTNP3B5.js";
+import "./chunk-45D6WRCJ.js";
+import "./chunk-CCYZJMZ7.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/ads/linkedin/url-params.ts
+import { defineCommand } from "citty";
+var urlParamsCommand = defineCommand({
+  meta: {
+    name: "url-params",
+    description: `Read the URL tracking parameters in effect \u2014 the ad account's, optionally every ad set's, and the keys set at BOTH (which LinkedIn appends twice).
+
+Start here before setting UTMs on an ad set: whatever the account already carries is appended on top of it.
+
+Examples:
+  baker ads linkedin url-params                                  \u2014 the ad account's parameters
+  baker ads linkedin url-params --ad-sets                        \u2014 plus every ad set's, and the collisions
+  baker ads linkedin url-params --campaign-ids 123456,789012     \u2014 plus just those ad sets'
+  baker ads linkedin url-params --ad-sets --collisions-only      \u2014 just what would land twice`
+  },
+  args: {
+    "account-id": { type: "string", description: "Numeric account ID or urn:li:sponsoredAccount:N" },
+    "account-urn": { type: "string", description: "Alias for --account-id" },
+    "ad-sets": {
+      type: "boolean",
+      description: `Also read every ad set's parameters (one call each, first ${LINKEDIN_TRACKING_PARAMS_AD_SET_MAX})`
+    },
+    "campaign-ids": { type: "string", description: "Comma-separated ad set ids to read instead of all of them" },
+    "collisions-only": { type: "boolean", description: "Report only the keys set at more than one level" }
+  },
+  run: async ({ args }) => {
+    const accountId = resolveAccountIdArg(args);
+    try {
+      const params = { "account-id": accountId };
+      if (args["campaign-ids"]) params["campaign-ids"] = String(args["campaign-ids"]);
+      if (args["ad-sets"]) params["all-ad-sets"] = "true";
+      const data = await apiGet("/api/ads/linkedin/url-params", params);
+      const examinedAdSets = Boolean(args["ad-sets"] || args["campaign-ids"]);
+      const notes = hints(data, examinedAdSets);
+      writeAdsJson({
+        ok: true,
+        data: args["collisions-only"] ? { collisions: data.collisions, adSetCoverage: data.adSetCoverage } : data,
+        ...notes.length > 0 ? { hints: notes } : {}
+      });
+    } catch (err) {
+      handleLinkedinError(err);
+    }
+  }
+});
+function hints(data, examinedAdSets) {
+  const out = [];
+  if (data.unreadable.length > 0) {
+    out.push(
+      `could NOT read ${data.unreadable.map((entry) => entry.level === "account" ? "the ad account" : `ad set ${entry.id}`).join(", ")} \u2014 treat that as unknown, not as empty. Do not stage url-params against it: either it does not exist, or it holds parameters this write would replace unseen. First reason: ${data.unreadable[0]?.reason ?? "unknown"}`
+    );
+  }
+  if (data.collisions.length > 0) {
+    out.push(
+      `${data.collisions.map((c) => c.key).join(", ")} set at BOTH the account and an ad set \u2014 LinkedIn appends both, so each lands twice in the served URL. Clear it at one level with \`account url-params\` or \`campaigns url-params --clear\`.`
+    );
+  }
+  if (data.adSetCoverage?.capped) {
+    out.push(
+      `only ${data.adSetCoverage.examined} of ${data.adSetCoverage.total} ad sets were read \u2014 the collisions above cover those, not the rest. Narrow with --campaign-ids to check the others.`
+    );
+  }
+  if (!examinedAdSets) {
+    out.push("only the ad account was read \u2014 pass --ad-sets to find keys an ad set sets on top of these");
+  }
+  const allAnswered = data.unreadable.length === 0;
+  const nothingSet = data.account.state === "not_set" && data.adSets.every((adSet) => adSet.state === "not_set");
+  if (allAnswered && nothingSet) {
+    out.push("nothing is tagged \u2014 set the constants once with `baker ads linkedin account url-params`");
+  }
+  return out;
+}
+export {
+  hints,
+  urlParamsCommand
+};
+//# sourceMappingURL=url-params-PE4XAQNH.js.map

package/dist/validate-MMHBTNWU.js

@@ -0,0 +1,126 @@
+import {
+  outputRatioWarningsFor,
+  shownBaseline
+} from "./chunk-TAGJYHVI.js";
+import "./chunk-O7WRA3JU.js";
+import {
+  creativeSlugFromCanvasPath
+} from "./chunk-SOM4OTR5.js";
+import {
+  exitOnPrepareError,
+  prepareCanvas
+} from "./chunk-ROHICQPK.js";
+import "./chunk-CKHF7UXS.js";
+import "./chunk-HDMD6LXS.js";
+import "./chunk-CP6RFWLW.js";
+import "./chunk-EKX37C3T.js";
+import "./chunk-SZZ7BBED.js";
+import "./chunk-QMQSI4WA.js";
+import "./chunk-OFMFBRSL.js";
+import "./chunk-IKADYUXK.js";
+import "./chunk-46DHUWMV.js";
+import "./chunk-MWJ6BCZJ.js";
+import "./chunk-SYDPUGF5.js";
+import "./chunk-ESSA3AWR.js";
+import "./chunk-TQJLEVLA.js";
+import "./chunk-G6XKD7QE.js";
+import "./chunk-4H6XLX7E.js";
+import "./chunk-Y5PNLB24.js";
+import {
+  canvasOutputsRoot
+} from "./chunk-N3PASNUA.js";
+import {
+  defaultRegistry,
+  validateCanvasDeep
+} from "./chunk-IAYJKH4R.js";
+import "./chunk-7URHRPC7.js";
+import "./chunk-TW57RTKN.js";
+import "./chunk-AQNTVM6S.js";
+import "./chunk-DGCUPJZD.js";
+import "./chunk-Y2TOB4N5.js";
+import "./chunk-KJ3J2DYM.js";
+import "./chunk-MTFAG6E3.js";
+import "./chunk-F3CZFUXZ.js";
+import "./chunk-2WZI36D3.js";
+import "./chunk-65Y3RCWP.js";
+import "./chunk-E56V3RFO.js";
+import "./chunk-EL3TDR5S.js";
+import "./chunk-G6U45QD3.js";
+import "./chunk-X6U3B6YK.js";
+import "./chunk-YOHGEF2N.js";
+import "./chunk-QV6AST5T.js";
+import "./chunk-WCU362Z6.js";
+import "./chunk-GIWHHCD6.js";
+import "./chunk-SOPVIIUW.js";
+import "./chunk-G4FG5EQO.js";
+import "./chunk-R7XDGNZD.js";
+import "./chunk-IMS53EQU.js";
+import "./chunk-QEREDRZO.js";
+import "./chunk-JXTNP3B5.js";
+import {
+  optionalTurnId
+} from "./chunk-45D6WRCJ.js";
+import "./chunk-CCYZJMZ7.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/canvas/validate.ts
+import path from "path";
+import { defineCommand } from "citty";
+var validateCommand = defineCommand({
+  meta: {
+    name: "validate",
+    description: "Validate a canvas JSON file (no execution). Brings the canvas up to date with its prompt.json first (prompt.json and, for a video, scenes/*.json edits are written into the canvas, exactly as `run` does), then checks it: a per-node cost preview, each node's deep validators (composition meta checks for hyperframe_render/_snapshot), and each generator prompt measured with its {{slots}} filled against the model's character cap (PROMPT_OVER_MODEL_LIMIT)."
+  },
+  args: { file: { type: "positional", required: true, description: "Path to canvas JSON" } },
+  async run({ args }) {
+    const filePath = path.resolve(String(args.file));
+    const slug = creativeSlugFromCanvasPath(filePath) ?? void 0;
+    const baseline = slug ? (await shownBaseline({
+      canvasRoot: canvasOutputsRoot(filePath),
+      slug,
+      creativeDir: path.dirname(filePath),
+      turnId: optionalTurnId(),
+      record: false
+    })).baseline : void 0;
+    let prepared;
+    try {
+      prepared = await prepareCanvas(filePath, {
+        gate: true,
+        log: (line) => process.stderr.write(`${line}
+`),
+        ...baseline ? { baseline } : {}
+      });
+    } catch (e) {
+      exitOnPrepareError(e);
+    }
+    const result = await validateCanvasDeep(prepared.canvas, defaultRegistry());
+    if (!result.ok) {
+      process.stderr.write(`${JSON.stringify({ ok: false, error: { code: "validation", issues: result.issues } }, null, 2)}
+`);
+      process.exit(2);
+      return;
+    }
+    process.stdout.write(
+      `${JSON.stringify(
+        {
+          ok: true,
+          total_nodes: result.canvas.nodes.length,
+          estimated_credits: result.estimatedCredits,
+          cost_preview: result.perNodeCredits ?? [],
+          style_projection: prepared.projections.style,
+          scene_projection: prepared.projections.scenes,
+          canvas_updated: prepared.written,
+          normalized_paths: prepared.rewrites,
+          warnings: [...result.warnings ?? [], ...await outputRatioWarningsFor(prepared.canvas, filePath)]
+        },
+        null,
+        2
+      )}
+`
+    );
+  }
+});
+export {
+  validateCommand
+};
+//# sourceMappingURL=validate-MMHBTNWU.js.map

package/dist/validate-MMHBTNWU.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/commands/canvas/validate.ts"],"sourcesContent":["import path from \"node:path\";\nimport { defineCommand } from \"citty\";\nimport { defaultRegistry, validateCanvasDeep } from \"../../engine/index.ts\";\nimport { optionalTurnId } from \"../../env.ts\";\nimport { outputRatioWarningsFor } from \"./output-ratio.ts\";\nimport { canvasOutputsRoot } from \"./normalize-paths.ts\";\nimport { creativeSlugFromCanvasPath } from \"./run-record.ts\";\nimport { shownBaseline } from \"./shown-anchor.ts\";\nimport { exitOnPrepareError, type PreparedCanvas, prepareCanvas } from \"./prepare-canvas.ts\";\n\nexport const validateCommand = defineCommand({\n  meta: {\n    name: \"validate\",\n    description:\n      \"Validate a canvas JSON file (no execution). Brings the canvas up to date with its prompt.json first (prompt.json and, for a video, scenes/*.json edits are written into the canvas, exactly as `run` does), then checks it: a per-node cost preview, each node's deep validators (composition meta checks for hyperframe_render/_snapshot), and each generator prompt measured with its {{slots}} filled against the model's character cap (PROMPT_OVER_MODEL_LIMIT).\",\n  },\n  args: { file: { type: \"positional\", required: true, description: \"Path to canvas JSON\" } },\n  async run({ args }) {\n    const filePath = path.resolve(String(args.file));\n    // The idea the person saw, as a run would hold it: validate is the free proof of that gate (it records nothing).\n    const slug = creativeSlugFromCanvasPath(filePath) ?? undefined;\n    const baseline = slug\n      ? (\n          await shownBaseline({\n            canvasRoot: canvasOutputsRoot(filePath),\n            slug,\n            creativeDir: path.dirname(filePath),\n            turnId: optionalTurnId(),\n            record: false,\n          })\n        ).baseline\n      : undefined;\n    let prepared: PreparedCanvas;\n    try {\n      prepared = await prepareCanvas(filePath, {\n        gate: true,\n        log: (line) => process.stderr.write(`${line}\\n`),\n        ...(baseline ? { baseline } : {}),\n      });\n    } catch (e) {\n      exitOnPrepareError(e);\n    }\n\n    const result = await validateCanvasDeep(prepared.canvas, defaultRegistry());\n    if (!result.ok) {\n      process.stderr.write(`${JSON.stringify({ ok: false, error: { code: \"validation\", issues: result.issues } }, null, 2)}\\n`);\n      process.exit(2);\n      return;\n    }\n\n    // Warnings are advisory: the canvas is valid and runnable, so exit 0. They flag\n    // likely-wrong-but-legal config (a missing element reference, a scene span past the\n    // assigned model's cap) the operator should review before billing.\n    process.stdout.write(\n      `${JSON.stringify(\n        {\n          ok: true,\n          total_nodes: result.canvas.nodes.length,\n          estimated_credits: result.estimatedCredits,\n          cost_preview: result.perNodeCredits ?? [],\n          style_projection: prepared.projections.style,\n          scene_projection: prepared.projections.scenes,\n          canvas_updated: prepared.written,\n          normalized_paths: prepared.rewrites,\n          warnings: [...(result.warnings ?? []), ...(await outputRatioWarningsFor(prepared.canvas, filePath))],\n        },\n        null,\n        2,\n      )}\\n`,\n    );\n  },\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,UAAU;AACjB,SAAS,qBAAqB;AASvB,IAAM,kBAAkB,cAAc;AAAA,EAC3C,MAAM;AAAA,IACJ,MAAM;AAAA,IACN,aACE;AAAA,EACJ;AAAA,EACA,MAAM,EAAE,MAAM,EAAE,MAAM,cAAc,UAAU,MAAM,aAAa,sBAAsB,EAAE;AAAA,EACzF,MAAM,IAAI,EAAE,KAAK,GAAG;AAClB,UAAM,WAAW,KAAK,QAAQ,OAAO,KAAK,IAAI,CAAC;AAE/C,UAAM,OAAO,2BAA2B,QAAQ,KAAK;AACrD,UAAM,WAAW,QAEX,MAAM,cAAc;AAAA,MAClB,YAAY,kBAAkB,QAAQ;AAAA,MACtC;AAAA,MACA,aAAa,KAAK,QAAQ,QAAQ;AAAA,MAClC,QAAQ,eAAe;AAAA,MACvB,QAAQ;AAAA,IACV,CAAC,GACD,WACF;AACJ,QAAI;AACJ,QAAI;AACF,iBAAW,MAAM,cAAc,UAAU;AAAA,QACvC,MAAM;AAAA,QACN,KAAK,CAAC,SAAS,QAAQ,OAAO,MAAM,GAAG,IAAI;AAAA,CAAI;AAAA,QAC/C,GAAI,WAAW,EAAE,SAAS,IAAI,CAAC;AAAA,MACjC,CAAC;AAAA,IACH,SAAS,GAAG;AACV,yBAAmB,CAAC;AAAA,IACtB;AAEA,UAAM,SAAS,MAAM,mBAAmB,SAAS,QAAQ,gBAAgB,CAAC;AAC1E,QAAI,CAAC,OAAO,IAAI;AACd,cAAQ,OAAO,MAAM,GAAG,KAAK,UAAU,EAAE,IAAI,OAAO,OAAO,EAAE,MAAM,cAAc,QAAQ,OAAO,OAAO,EAAE,GAAG,MAAM,CAAC,CAAC;AAAA,CAAI;AACxH,cAAQ,KAAK,CAAC;AACd;AAAA,IACF;AAKA,YAAQ,OAAO;AAAA,MACb,GAAG,KAAK;AAAA,QACN;AAAA,UACE,IAAI;AAAA,UACJ,aAAa,OAAO,OAAO,MAAM;AAAA,UACjC,mBAAmB,OAAO;AAAA,UAC1B,cAAc,OAAO,kBAAkB,CAAC;AAAA,UACxC,kBAAkB,SAAS,YAAY;AAAA,UACvC,kBAAkB,SAAS,YAAY;AAAA,UACvC,gBAAgB,SAAS;AAAA,UACzB,kBAAkB,SAAS;AAAA,UAC3B,UAAU,CAAC,GAAI,OAAO,YAAY,CAAC,GAAI,GAAI,MAAM,uBAAuB,SAAS,QAAQ,QAAQ,CAAE;AAAA,QACrG;AAAA,QACA;AAAA,QACA;AAAA,MACF,CAAC;AAAA;AAAA,IACH;AAAA,EACF;AACF,CAAC;","names":[]}

package/dist/videos-AHOLXU42.js

@@ -0,0 +1,146 @@
+import {
+  handleMetaError
+} from "./chunk-7TVVYP7K.js";
+import "./chunk-QALAJNBG.js";
+import {
+  writeJsonEnvelope
+} from "./chunk-MK4HCMEA.js";
+import {
+  apiGet
+} from "./chunk-QEREDRZO.js";
+import "./chunk-JXTNP3B5.js";
+import "./chunk-45D6WRCJ.js";
+import {
+  registerSchema
+} from "./chunk-CCYZJMZ7.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/ads/meta/videos.ts
+import { createWriteStream, mkdirSync } from "fs";
+import { join } from "path";
+import { Readable } from "stream";
+import { pipeline } from "stream/promises";
+
+// ../api/src/ads-meta/adVideos.ts
+import { z } from "zod";
+var metaAdVideoSchema = z.object({
+  videoId: z.string(),
+  /** Short-lived MP4 address; null when Meta does not hand the file to this connection. */
+  source: z.string().url().nullable(),
+  seconds: z.number().nullable(),
+  title: z.string().nullable(),
+  thumbnail: z.string().url().nullable()
+});
+var metaAdVideosResponseSchema = z.object({
+  adId: z.string().nullable(),
+  creativeId: z.string(),
+  videos: z.array(metaAdVideoSchema)
+});
+
+// src/commands/ads/meta/videos.ts
+import { defineCommand } from "citty";
+var DEFAULT_OUT_DIR = "/tmp/meta-ad-videos";
+function downloadHints(results) {
+  const all = results.flatMap((result) => result.videos);
+  const hints = [];
+  if (all.length === 0)
+    hints.push("No video in these ads: they are image or carousel ads (`creatives --creative-id` shows their assets).");
+  if (all.some((video) => video.file === null && video.url === void 0)) {
+    hints.push(
+      "A video with no file is a copy Meta does not hand to this connection (usually the Page's copy of the same upload); the other video of that ad is the same film."
+    );
+  }
+  if (all.some((video) => video.file !== null)) {
+    hints.push(
+      "Watch before judging: a frame strip (`ffmpeg -i <file> -vf fps=2,scale=240:-1,tile=8x2 strip.jpg`) and the 3-second hold rate from `insights --level ad --intent video`."
+    );
+  }
+  return hints;
+}
+async function download(url, file) {
+  const response = await fetch(url);
+  if (!response.ok || !response.body) throw new Error(`Meta's video address answered ${response.status}`);
+  await pipeline(Readable.fromWeb(response.body), createWriteStream(file));
+  return Number(response.headers.get("content-length") ?? 0);
+}
+async function fetchAndSave(params, outDir, save) {
+  const data = metaAdVideosResponseSchema.parse(await apiGet("/api/ads/meta/videos", params));
+  const owner = data.adId ?? data.creativeId;
+  const videos = [];
+  for (const video of data.videos) {
+    if (!video.source || !save) {
+      videos.push({
+        videoId: video.videoId,
+        file: null,
+        ...video.source ? { url: video.source } : {},
+        seconds: video.seconds,
+        megabytes: null
+      });
+      continue;
+    }
+    const file = join(outDir, `${owner}-${video.videoId}.mp4`);
+    const bytes = await download(video.source, file);
+    videos.push({
+      videoId: video.videoId,
+      file,
+      seconds: video.seconds,
+      megabytes: bytes ? Math.round(bytes / 1e5) / 10 : null
+    });
+  }
+  return { adId: data.adId, creativeId: data.creativeId, videos };
+}
+var splitIds = (value) => typeof value === "string" ? value.split(",").map((id) => id.trim()).filter(Boolean) : [];
+registerSchema({
+  command: "ads.meta.videos",
+  description: "Download the video files of running Meta ads (or creatives) to disk, to watch, cut or analyse them. One call for several ads.",
+  args: {
+    "ad-id": { type: "string", description: "Ad id, or several comma-separated", required: false },
+    "creative-id": { type: "string", description: "Creative id, or several comma-separated", required: false },
+    "out-dir": { type: "string", description: `Where the MP4s go (default ${DEFAULT_OUT_DIR})`, required: false },
+    "url-only": {
+      type: "boolean",
+      description: "Return Meta's short-lived addresses instead of files",
+      required: false
+    }
+  }
+});
+var videosCommand = defineCommand({
+  meta: {
+    name: "videos",
+    description: `Download the video files behind Meta ads, to watch, cut or analyse the company's own ads.
+  baker ads meta videos --ad-id 120211234567890,120211234567891     \u2014 MP4s in ${DEFAULT_OUT_DIR}
+  baker ads meta videos --creative-id 9988 --out-dir /tmp/ads        \u2014 by creative
+Start here when judging video ads: \`insights --level ad --intent video\` names the ads, this gets their files.`
+  },
+  args: {
+    "ad-id": { type: "string", description: "Ad id, or several comma-separated" },
+    "creative-id": { type: "string", description: "Creative id, or several comma-separated" },
+    "out-dir": { type: "string", description: `Where the MP4s go (default ${DEFAULT_OUT_DIR})` },
+    // Not `--no-download`: citty reads any `--no-x` as `x: false`, so that flag would never be set.
+    "url-only": { type: "boolean", description: "Return Meta's short-lived addresses instead of files" }
+  },
+  run: async ({ args }) => {
+    const adIds = splitIds(args["ad-id"]);
+    const creativeIds = splitIds(args["creative-id"]);
+    if (adIds.length + creativeIds.length === 0) {
+      writeJsonEnvelope({ ok: false, error: { code: "VALIDATION_ERROR", message: "Name --ad-id or --creative-id" } });
+      process.exit(1);
+    }
+    const outDir = typeof args["out-dir"] === "string" ? args["out-dir"] : DEFAULT_OUT_DIR;
+    const save = !args["url-only"];
+    if (save) mkdirSync(outDir, { recursive: true });
+    try {
+      const results = [];
+      for (const id of adIds) results.push(await fetchAndSave({ "ad-id": id }, outDir, save));
+      for (const id of creativeIds) results.push(await fetchAndSave({ "creative-id": id }, outDir, save));
+      writeJsonEnvelope({ ok: true, data: results, hints: downloadHints(results) });
+    } catch (err) {
+      handleMetaError(err);
+    }
+  }
+});
+export {
+  downloadHints,
+  videosCommand
+};
+//# sourceMappingURL=videos-AHOLXU42.js.map

package/dist/videos-EVPJHY3B.js

@@ -0,0 +1,41 @@
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/videos/index.ts
+import { defineCommand } from "citty";
+var videosCommand = defineCommand({
+  meta: {
+    name: "videos",
+    description: `Find and manage videos in Baker. Subcommands: search, get, upload, ingest, fetch, download, describe, delete, retry, tags.
+
+Examples:
+  baker videos search "product demo" --limit 5
+  baker videos search "tutorial" --tags explainer
+  baker videos get <video-id>
+  baker videos upload ./demo.mp4
+  baker videos ingest https://www.youtube.com/watch?v=abc123
+  baker videos fetch https://www.youtube.com/watch?v=abc123 --out ./clips
+  baker videos download <video-id> --out /tmp/clips   # a library video as a local .mp4 to edit
+  baker videos describe <video-id> --description "Customer testimonial, 30s"
+  baker videos delete <video-id> --dry-run
+  baker videos retry <video-id>                    # process a failed video again
+  baker videos tags                                # list; tags create|update|delete for custom tags
+Full guide: __tooling__/docs/tools/baker/videos.md`
+  },
+  subCommands: {
+    get: () => import("./get-BQBLPGFE.js").then((m) => m.getCommand),
+    group: () => import("./group-THZPJALS.js").then((m) => m.groupCommand),
+    search: () => import("./search-QQDR74KQ.js").then((m) => m.searchCommand),
+    upload: () => import("./upload-UXYJDA2U.js").then((m) => m.uploadCommand),
+    ingest: () => import("./ingest-MSS52UO5.js").then((m) => m.ingestCommand),
+    fetch: () => import("./fetch-KB64NPDF.js").then((m) => m.fetchCommand),
+    download: () => import("./download-XERSDEN3.js").then((m) => m.downloadCommand),
+    describe: () => import("./describe-EAPKNUUU.js").then((m) => m.describeCommand),
+    delete: () => import("./delete-46B7DSQV.js").then((m) => m.deleteCommand),
+    retry: () => import("./retry-DVHDVHVP.js").then((m) => m.retryCommand),
+    tags: () => import("./tags-QF2V4B3M.js").then((m) => m.tagsCommand)
+  }
+});
+export {
+  videosCommand
+};
+//# sourceMappingURL=videos-EVPJHY3B.js.map

package/dist/viewer-check-NA4TMNY4.js

@@ -0,0 +1,83 @@
+import {
+  OFFER_READ,
+  VIEWER_CLARITY,
+  VIEWER_QUESTIONS,
+  VIEWER_REQUIRED_CLARITY,
+  ViewerAnswerSchema,
+  buildViewerPrompt,
+  checkViewer,
+  describeViewer,
+  gatewayViewerModel,
+  jevReadJudge,
+  judgeViewerAnswer,
+  liveViewerLookups,
+  misreadings,
+  personaSegments,
+  readCreativeForViewerCheck,
+  readPersonas,
+  resolveViewer,
+  sureEnough,
+  viewerCheckBeforeRender,
+  viewerCheckCacheKey,
+  viewerCheckCommand,
+  viewerCheckFailure,
+  viewerCheckSkip
+} from "./chunk-CKHF7UXS.js";
+import "./chunk-HDMD6LXS.js";
+import "./chunk-QMQSI4WA.js";
+import "./chunk-OFMFBRSL.js";
+import "./chunk-IKADYUXK.js";
+import "./chunk-46DHUWMV.js";
+import "./chunk-TQJLEVLA.js";
+import "./chunk-G6XKD7QE.js";
+import "./chunk-4H6XLX7E.js";
+import "./chunk-Y5PNLB24.js";
+import "./chunk-N3PASNUA.js";
+import "./chunk-KJ3J2DYM.js";
+import "./chunk-MTFAG6E3.js";
+import "./chunk-F3CZFUXZ.js";
+import "./chunk-2WZI36D3.js";
+import "./chunk-65Y3RCWP.js";
+import "./chunk-E56V3RFO.js";
+import "./chunk-EL3TDR5S.js";
+import "./chunk-G6U45QD3.js";
+import "./chunk-X6U3B6YK.js";
+import "./chunk-YOHGEF2N.js";
+import "./chunk-QV6AST5T.js";
+import "./chunk-WCU362Z6.js";
+import "./chunk-GIWHHCD6.js";
+import "./chunk-SOPVIIUW.js";
+import "./chunk-G4FG5EQO.js";
+import "./chunk-R7XDGNZD.js";
+import "./chunk-IMS53EQU.js";
+import "./chunk-QEREDRZO.js";
+import "./chunk-JXTNP3B5.js";
+import "./chunk-45D6WRCJ.js";
+import "./chunk-CCYZJMZ7.js";
+import "./chunk-YQSBHWOI.js";
+export {
+  OFFER_READ,
+  VIEWER_CLARITY,
+  VIEWER_QUESTIONS,
+  VIEWER_REQUIRED_CLARITY,
+  ViewerAnswerSchema,
+  buildViewerPrompt,
+  checkViewer,
+  describeViewer,
+  gatewayViewerModel,
+  jevReadJudge,
+  judgeViewerAnswer,
+  liveViewerLookups,
+  misreadings,
+  personaSegments,
+  readCreativeForViewerCheck,
+  readPersonas,
+  resolveViewer,
+  sureEnough,
+  viewerCheckBeforeRender,
+  viewerCheckCacheKey,
+  viewerCheckCommand,
+  viewerCheckFailure,
+  viewerCheckSkip
+};
+//# sourceMappingURL=viewer-check-NA4TMNY4.js.map