@koda-sl/baker-cli 0.461.0 → 0.462.0

package/dist/chunk-RO5ZC4J6.js

@@ -0,0 +1,296 @@
+import {
+  DIRECT_ROUTE,
+  captureProxyCredentials,
+  childEnvWith,
+  plannedRoutes,
+  shouldEscalate
+} from "./chunk-NBPJBJJD.js";
+
+// src/lib/vimeoCookie.ts
+import { writeFile } from "fs/promises";
+import path from "path";
+var COOKIE_NAME = "vimeo";
+async function writeVimeoCookieFile(cookie, workDir) {
+  const value = cookie?.trim();
+  if (!value) return void 0;
+  const expires = Math.floor(Date.now() / 1e3) + 365 * 24 * 60 * 60;
+  const jar = [
+    "# Netscape HTTP Cookie File",
+    [".vimeo.com", "TRUE", "/", "TRUE", String(expires), COOKIE_NAME, value].join("	"),
+    ""
+  ].join("\n");
+  const filePath = path.join(workDir, "vimeo-cookies.txt");
+  await writeFile(filePath, jar, { mode: 384 });
+  return filePath;
+}
+var VIMEO_AUTH_SIGNATURES = ["oauth token", "only works when logged-in", "unable to fetch new oauth tokens"];
+function isVimeoAuthFailure(detail) {
+  const haystack = detail.toLowerCase();
+  if (!haystack.includes("[vimeo]")) return false;
+  return VIMEO_AUTH_SIGNATURES.some((signature) => haystack.includes(signature));
+}
+
+// src/lib/ytDlpSignal.ts
+var HTTP_ERROR = /HTTP Error (\d{3})/i;
+var CHALLENGE_PHRASES = [
+  "sign in to confirm you're not a bot",
+  "sign in to confirm you\u2019re not a bot",
+  "confirm you are not a bot",
+  "unusual traffic",
+  "captcha"
+];
+var NOT_A_BLOCK_PHRASES = ["private video", "video unavailable", "members-only", "this video is available to"];
+var PROXY_TUNNEL_FAILURE = /tunnel connection failed: 407|proxy authentication required|http error 407/i;
+function ytDlpBlockSignal(stderr) {
+  const text = stderr.toLowerCase();
+  if (PROXY_TUNNEL_FAILURE.test(stderr)) return { status: 407 };
+  if (NOT_A_BLOCK_PHRASES.some((phrase) => text.includes(phrase))) return {};
+  const status = HTTP_ERROR.exec(stderr);
+  if (status) return { status: Number(status[1]) };
+  if (CHALLENGE_PHRASES.some((phrase) => text.includes(phrase))) return { challenge: true };
+  return {};
+}
+
+// src/lib/ytDlp.ts
+import { spawn } from "child_process";
+import { readdir, readFile } from "fs/promises";
+import path2 from "path";
+
+// src/lib/ytDlpFormat.ts
+function videoFormatArgs(maxResolution) {
+  const sort = maxResolution ? ["-S", `res:${maxResolution}`] : [];
+  return ["--format", "bv*+ba/b", ...sort, "--merge-output-format", "mp4"];
+}
+
+// src/lib/ytDlpPlayerClient.ts
+var YOUTUBE_FALLBACK_CLIENT_ARGS = ["--extractor-args", "youtube:player_client=android"];
+var MEDIA_FETCH_REFUSED = "unable to download video data";
+var YOUTUBE_HOSTS = ["youtube.com", "youtu.be"];
+function isYouTube(url) {
+  let host;
+  try {
+    host = new URL(url).hostname.toLowerCase();
+  } catch {
+    return false;
+  }
+  return YOUTUBE_HOSTS.some((known) => host === known || host.endsWith(`.${known}`));
+}
+function needsPlayerClientRetry(url, stderr) {
+  return isYouTube(url) && stderr.toLowerCase().includes(MEDIA_FETCH_REFUSED);
+}
+
+// src/lib/ytDlp.ts
+var YT_DLP_BIN = "yt-dlp";
+var YT_DLP_TIMEOUT_MS = 10 * 60 * 1e3;
+var YT_DLP_PROBE_TIMEOUT_MS = 60 * 1e3;
+var TRUST_SYSTEM_CERTS = ["--compat-options", "no-certifi"];
+var YtDlpError = class extends Error {
+  constructor(message, stderrTail) {
+    super(message);
+    this.stderrTail = stderrTail;
+    this.name = "YtDlpError";
+  }
+};
+function tail(text, maxLines) {
+  return text.split("\n").slice(-maxLines).join("\n");
+}
+async function runYtDlp(args) {
+  const outTemplate = path2.join(args.workDir, "out.%(ext)s");
+  const infoPath = path2.join(args.workDir, "out.info.json");
+  const argv = [
+    args.url,
+    "--no-playlist",
+    "--no-progress",
+    "--no-warnings",
+    "--quiet",
+    "--write-info-json",
+    ...TRUST_SYSTEM_CERTS,
+    "-o",
+    outTemplate
+  ];
+  if (args.audioOnly) {
+    argv.push("-x", "--audio-format", "m4a");
+  } else {
+    argv.push(...videoFormatArgs(args.maxHeight));
+  }
+  const cookieFile = await writeVimeoCookieFile(args.vimeoCookie, args.workDir);
+  if (cookieFile) argv.push("--cookies", cookieFile);
+  args.onLog?.(`yt-dlp: downloading ${args.audioOnly ? "audio" : "video"}`);
+  const timeoutMs = args.timeoutMs ?? YT_DLP_TIMEOUT_MS;
+  const { code, stderr, tier, reducedQuality } = await downloadWithClientFallback({
+    url: args.url,
+    argv,
+    onLog: args.onLog,
+    ladder: (attemptArgv) => runViaLadder({ url: args.url, argv: attemptArgv, timeoutMs, onLog: args.onLog, country: args.country }),
+    repeat: (attemptArgv, route) => spawnAndWait(YT_DLP_BIN, attemptArgv, timeoutMs, { extraEnv: proxyEnvFor(route) })
+  });
+  if (code !== 0) {
+    throw new YtDlpError(`yt-dlp exited ${code}`, tail(stderr, 40));
+  }
+  const files = await readdir(args.workDir);
+  const wanted = args.audioOnly ? ".m4a" : ".mp4";
+  const downloaded = files.find((f) => f.startsWith("out.") && f.endsWith(wanted));
+  if (!downloaded) {
+    throw new YtDlpError(`yt-dlp finished but produced no ${wanted} file (saw: ${files.join(", ")})`, "");
+  }
+  let info = {};
+  try {
+    info = JSON.parse(await readFile(infoPath, "utf-8"));
+  } catch {
+  }
+  return { filePath: path2.join(args.workDir, downloaded), info, tier, reducedQuality };
+}
+async function probeYtDlp(args) {
+  const argv = [
+    args.url,
+    "--no-playlist",
+    "--no-warnings",
+    "--dump-single-json",
+    "--skip-download",
+    // Without this the probe fails wherever the *download* would fail, which
+    // defeats the point of probing: yt-dlp still runs format selection for
+    // `--dump-single-json`, so a binary too old to read a site's format list
+    // exits "Requested format is not available" and we learn nothing — measured
+    // against a stale build, which returned full metadata the moment this flag
+    // was added. Duration and id come from the page, not from a format.
+    "--ignore-no-formats-error",
+    ...TRUST_SYSTEM_CERTS
+  ];
+  if (args.cookieDir) {
+    const cookieFile = await writeVimeoCookieFile(args.vimeoCookie, args.cookieDir);
+    if (cookieFile) argv.push("--cookies", cookieFile);
+  }
+  let stdout = "";
+  const { code, stderr, tier } = await walkYtDlpLadder({
+    url: args.url,
+    credentials: captureProxyCredentials(),
+    attempt: async (route) => {
+      const result = await spawnAndWait(YT_DLP_BIN, argv, args.timeoutMs ?? YT_DLP_PROBE_TIMEOUT_MS, {
+        extraEnv: proxyEnvFor(route),
+        captureStdout: true
+      });
+      stdout = result.stdout ?? "";
+      return result;
+    },
+    onLog: args.onLog,
+    country: args.country
+  });
+  if (code !== 0) {
+    throw new YtDlpError(`yt-dlp exited ${code}`, tail(stderr, 40));
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(stdout);
+  } catch {
+    throw new YtDlpError("yt-dlp returned metadata that could not be read", tail(stdout, 5));
+  }
+  if (parsed === null || typeof parsed !== "object") {
+    throw new YtDlpError("yt-dlp returned no metadata for that link", tail(stderr, 40));
+  }
+  return { info: parsed, tier };
+}
+function isAudioOnly(info) {
+  return info.vcodec === "none";
+}
+function durationSeconds(info) {
+  const raw = info.duration;
+  return typeof raw === "number" && Number.isFinite(raw) && raw > 0 ? raw : void 0;
+}
+function canonicalUrl(info) {
+  const raw = info.webpage_url;
+  return typeof raw === "string" && raw.length > 0 ? raw : void 0;
+}
+async function walkYtDlpLadder(args) {
+  const routes = plannedRoutes(args.url, args.credentials, args.country ? { country: args.country } : void 0);
+  let last = { code: -1, stderr: "", tier: "direct", route: DIRECT_ROUTE };
+  for (const route of routes) {
+    const tier = route.kind === "proxy" ? route.tier : "direct";
+    if (route.kind === "proxy") args.onLog?.(`yt-dlp: retrying via ${tier}`);
+    last = { ...await args.attempt(route), tier, route };
+    if (last.code === 0) return last;
+    if (!shouldEscalate(ytDlpBlockSignal(last.stderr))) return last;
+  }
+  return last;
+}
+async function downloadWithClientFallback(args) {
+  const first = await args.ladder(args.argv);
+  if (first.code === 0 || !needsPlayerClientRetry(args.url, first.stderr)) {
+    return { ...first, reducedQuality: false };
+  }
+  args.onLog?.("yt-dlp: retrying with the fallback player client");
+  const again = await args.repeat([...args.argv, ...YOUTUBE_FALLBACK_CLIENT_ARGS], first.route);
+  return { ...again, tier: first.tier, route: first.route, reducedQuality: again.code === 0 };
+}
+function runViaLadder(args) {
+  return walkYtDlpLadder({
+    url: args.url,
+    credentials: captureProxyCredentials(),
+    attempt: (route) => spawnAndWait(YT_DLP_BIN, args.argv, args.timeoutMs, { extraEnv: proxyEnvFor(route) }),
+    onLog: args.onLog,
+    country: args.country
+  });
+}
+function proxyEnvFor(route) {
+  if (route.kind !== "proxy") return void 0;
+  const uri = new URL(route.server);
+  uri.username = encodeURIComponent(route.username);
+  uri.password = encodeURIComponent(route.password);
+  return {
+    HTTP_PROXY: uri.toString(),
+    HTTPS_PROXY: uri.toString(),
+    http_proxy: uri.toString(),
+    https_proxy: uri.toString()
+  };
+}
+function spawnAndWait(bin, argv, timeoutMs, options = {}) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(bin, argv, {
+      stdio: ["ignore", "pipe", "pipe"],
+      // `childEnvWith` because `spawn`'s `env` REPLACES the environment rather
+      // than extending it — passing only the additions would strip PATH.
+      ...options.extraEnv ? { env: childEnvWith(options.extraEnv) } : {}
+    });
+    const stderrChunks = [];
+    const stdoutChunks = [];
+    let stderrLen = 0;
+    const MAX_STDERR = 256 * 1024;
+    child.stdout.on("data", (chunk) => {
+      if (options.captureStdout) stdoutChunks.push(chunk);
+    });
+    child.stderr.on("data", (chunk) => {
+      if (stderrLen < MAX_STDERR) {
+        stderrChunks.push(chunk);
+        stderrLen += chunk.length;
+      }
+    });
+    const timer = setTimeout(() => {
+      child.kill("SIGKILL");
+      reject(new Error(`${bin} timed out after ${timeoutMs}ms`));
+    }, timeoutMs);
+    child.on("error", (err) => {
+      clearTimeout(timer);
+      reject(new Error(`failed to spawn "${bin}" \u2014 ${err.message}`));
+    });
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      resolve({
+        code: code ?? -1,
+        stderr: Buffer.concat(stderrChunks).toString("utf-8"),
+        ...options.captureStdout ? { stdout: Buffer.concat(stdoutChunks).toString("utf-8") } : {}
+      });
+    });
+  });
+}
+
+export {
+  isVimeoAuthFailure,
+  ytDlpBlockSignal,
+  YT_DLP_BIN,
+  YtDlpError,
+  runYtDlp,
+  probeYtDlp,
+  isAudioOnly,
+  durationSeconds,
+  canonicalUrl
+};
+//# sourceMappingURL=chunk-RO5ZC4J6.js.map

package/dist/chunk-S4P2LQ34.js

@@ -0,0 +1,166 @@
+import {
+  HEADLINE_SET_FLOOR,
+  SAME_CLAIM_HELD,
+  TELL_QUESTIONS,
+  copySentences,
+  sameClaimQuestion,
+  tellQuestionsFor
+} from "./chunk-4NZ47VXO.js";
+import {
+  rememberedJev
+} from "./chunk-KXRAAA6D.js";
+import {
+  holdUnbilledSpend
+} from "./chunk-PXDISZSC.js";
+import {
+  findWorkspaceRoot
+} from "./chunk-LOOPAOSC.js";
+import {
+  CAPABILITY_SURFACE_SPECS
+} from "./chunk-XQIOCIDO.js";
+
+// src/commands/capabilities/fix.ts
+function capabilityFix(surface) {
+  const spec = CAPABILITY_SURFACE_SPECS[surface];
+  return {
+    action: `baker capabilities ${surface}`,
+    explanation: `Do not guess another field name. \`baker capabilities ${surface}\` lists every ${spec.label} change with its required and optional fields and the exact values each field accepts, plus what cannot be changed here at all and why. Read it, then either re-stage correctly or tell the user this part is out of reach \u2014 and carry on with the rest of the job either way.`
+  };
+}
+
+// src/commands/ads/boolean-word-positional.ts
+var BOOLEAN_WORD = /^(true|false)$/i;
+function booleanWordPositionalError(args, entity) {
+  const positionals = Array.isArray(args._) ? args._ : [];
+  const word = positionals.find((value2) => typeof value2 === "string" && BOOLEAN_WORD.test(value2));
+  if (word === void 0) {
+    return void 0;
+  }
+  const value = word.toLowerCase();
+  const raised = Object.keys(args).filter((key) => key !== "_" && args[key] === true);
+  const named = raised.length > 0 ? raised.map((flag) => `--${flag}`).join(" or ") : "a boolean flag";
+  const fix = raised.length > 0 ? raised.map((flag) => `--${flag}=${value}`).join(" or ") : `--<flag>=${value}`;
+  const negated = raised.length === 1 && value === "false" ? ` (or --no-${raised[0]})` : "";
+  return `"${word}" was read as the ${entity} target, not as a value for ${named}. A boolean flag written with a space is set to TRUE and the word is dropped \u2014 attach it instead: ${fix}${negated}.`;
+}
+
+// src/commands/ads/copy-hints.ts
+import path from "path";
+
+// src/engine/copy-tells/judge.ts
+var SAMPLE_MAX = 60;
+var sample = (text) => text.length <= SAMPLE_MAX ? text : `${text.slice(0, SAMPLE_MAX)}\u2026`;
+async function judgedCopyTells(input, ask) {
+  const sentences = input.texts.flatMap((t) => copySentences(t));
+  const pairs = (input.headlineSets ?? []).map((set) => set.map((h) => h.trim()).filter(Boolean)).filter((set) => set.length >= HEADLINE_SET_FLOOR).flatMap((set, s) => set.flatMap((a, i) => set.slice(i + 1).map((b) => ({ set: s, a, b }))));
+  const questions = [...sentences.flatMap(tellQuestionsFor), ...pairs.map(({ a, b }) => sameClaimQuestion(a, b))];
+  if (questions.length === 0) return [];
+  const answers = await ask(questions);
+  if (answers === null) return null;
+  const tells = [];
+  TELL_QUESTIONS.forEach((tell, t) => {
+    const hits = sentences.filter((_, s) => (answers[s * TELL_QUESTIONS.length + t] ?? 0) >= tell.threshold);
+    if (hits.length > 0) tells.push({ id: tell.id, count: hits.length, sample: sample(hits[0]?.text ?? "") });
+  });
+  const offset = sentences.length * TELL_QUESTIONS.length;
+  const cycled = pairs.filter((_, p) => (answers[offset + p] ?? 0) >= SAME_CLAIM_HELD);
+  for (const set of new Set(cycled.map((p) => p.set))) {
+    const inSet = cycled.filter((p) => p.set === set);
+    const { a, b } = inSet[0] ?? { a: "", b: "" };
+    tells.push({ id: "synonym-cycling", count: inSet.length, sample: sample(`"${a}" / "${b}"`) });
+  }
+  return tells;
+}
+
+// src/commands/ads/copy-hints.ts
+var COPY_KEYS = /* @__PURE__ */ new Set([
+  "headline",
+  "headlines",
+  "longheadline",
+  "longheadlines",
+  "shortheadline",
+  "shortheadlines",
+  "description",
+  "descriptions",
+  "primarytext",
+  "primarytexts",
+  "message",
+  "messages",
+  "commentary",
+  "body",
+  "bodies",
+  "text",
+  "calltoaction",
+  "linkdescription",
+  "sitelinktext",
+  "callout",
+  "callouts",
+  "introtext"
+]);
+var HEADLINE_SET_KEYS = /* @__PURE__ */ new Set(["headlines", "longheadlines", "shortheadlines"]);
+var MAX_HINTS = 5;
+var SYNONYM_PAIR_FLOOR = 2;
+function asStrings(value) {
+  const one = (v) => {
+    const text = typeof v === "string" ? v : v !== null && typeof v === "object" ? v.text : "";
+    return typeof text === "string" && text.trim() ? text : void 0;
+  };
+  const values = Array.isArray(value) ? value : [value];
+  return values.map(one).filter((v) => v !== void 0);
+}
+function collectCopy(value, depth = 0) {
+  const texts = [];
+  const headlineSets = [];
+  if (depth > 4 || value === null || typeof value !== "object") return { texts, headlineSets };
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      const nested = collectCopy(item, depth + 1);
+      texts.push(...nested.texts);
+      headlineSets.push(...nested.headlineSets);
+    }
+    return { texts, headlineSets };
+  }
+  for (const [key, raw] of Object.entries(value)) {
+    const normalized = key.toLowerCase().replace(/[_-]/g, "");
+    const strings = COPY_KEYS.has(normalized) ? asStrings(raw) : [];
+    if (strings.length > 0) {
+      texts.push(...strings);
+      if (HEADLINE_SET_KEYS.has(normalized) && strings.length > 1) headlineSets.push(strings);
+      continue;
+    }
+    const nested = collectCopy(raw, depth + 1);
+    texts.push(...nested.texts);
+    headlineSets.push(...nested.headlineSets);
+  }
+  return { texts, headlineSets };
+}
+function hintFor(tell) {
+  if (tell.id === "synonym-cycling") {
+    return `AI COPY TELL \u2014 ${tell.count} headline pairs are the same claim reworded (${tell.sample}). A cycled set gives the auction nothing to choose between: make each headline a different claim, not a different verb.`;
+  }
+  return `AI COPY TELL (${tell.id}) \u2014 "${tell.sample}". This construction reads as machine-written; rewrite it as a plain, specific claim before publishing.`;
+}
+async function adCopyHints(payload, ask) {
+  const { texts, headlineSets } = collectCopy(payload);
+  if (texts.length === 0) return [];
+  const cacheDir = path.join(findWorkspaceRoot(process.cwd()) ?? process.cwd(), "canvas", ".cache");
+  const spent = [];
+  const judged = await judgedCopyTells(
+    { texts: texts.flatMap((t) => t.split("\n")), headlineSets },
+    ask ?? rememberedJev(path.join(cacheDir, "copy-tells.json"), (u) => spent.push(u))
+  ).catch(() => null);
+  await holdUnbilledSpend(cacheDir, spent).catch(() => void 0);
+  const cycled = (judged ?? []).filter((t) => t.id === "synonym-cycling" && t.count >= SYNONYM_PAIR_FLOOR).sort((a, b) => b.count - a.count).slice(0, 1);
+  const tells = [...cycled, ...(judged ?? []).filter((t) => t.id !== "synonym-cycling")];
+  tells.sort(
+    (a, b) => (b.id === "synonym-cycling" ? 1 : 0) - (a.id === "synonym-cycling" ? 1 : 0) || b.count - a.count
+  );
+  return tells.slice(0, MAX_HINTS).map(hintFor);
+}
+
+export {
+  capabilityFix,
+  booleanWordPositionalError,
+  adCopyHints
+};
+//# sourceMappingURL=chunk-S4P2LQ34.js.map

package/dist/chunk-SG3Q24HG.js

@@ -0,0 +1,76 @@
+import {
+  handleConnectionError,
+  isNotConnectedError,
+  writeAdsJson
+} from "./chunk-V44SLD5J.js";
+import {
+  ApiError
+} from "./chunk-D4N5ZXEO.js";
+
+// src/commands/ads/google/service-read-errors.ts
+var KNOWN_REFUSALS = [
+  {
+    match: /BILLING_SETUP_NOT_ON_MONTHLY_INVOICING/,
+    code: "NOT_INVOICED",
+    message: "This account is not billed by monthly invoicing, so Google issues no invoices through the API.",
+    explanation: "Degrade, don't abort: the account pays automatically (card or bank), and its receipts are in Google Ads \u2192 Billing \u2192 Documents for the user to download. Spend itself is readable with `query --preset account-summary`. Carry on with the rest of the job."
+  },
+  {
+    match: /no approved billing setup/i,
+    code: "NO_BILLING_SETUP",
+    message: "This account has no approved billing setup, so it has no invoices.",
+    explanation: "Degrade, don't abort: nothing is billed to this account yet (or a manager account pays). Carry on with the rest of the job."
+  },
+  {
+    match: /BILLING_NOT_ON_MONTHLY_INVOICING|verification is only open to customers with billing setup for monthly invoicing/,
+    code: "VERIFICATION_NOT_READABLE",
+    message: "Google only reports advertiser verification through the API for accounts on monthly invoicing.",
+    explanation: "Degrade, don't abort: the status is in Google Ads \u2192 Billing \u2192 Advertiser verification, where the user can read it. Say that, and carry on with the rest of the job."
+  },
+  {
+    match: /UNSUPPORTED_AD_TYPE/,
+    code: "NO_PREVIEW_FOR_AD_TYPE",
+    message: "Google has no shareable preview for this ad type: --ads previews only video ads of Video campaigns, live on YouTube (search, display and Demand Gen ads answer unsupported).",
+    explanation: "Degrade, don't abort: preview a Performance Max campaign with --asset-groups, and describe any other ad from its copy (`ads list`, `query --preset ad-copy-performance`). Carry on with the rest of the job."
+  }
+];
+function serviceReadRefusal(message) {
+  const known = KNOWN_REFUSALS.find((refusal) => refusal.match.test(message));
+  if (!known) return null;
+  return {
+    ok: false,
+    error: {
+      code: known.code,
+      message: known.message,
+      fix: { action: "reject", explanation: known.explanation },
+      retryable: false
+    }
+  };
+}
+function exitWithServiceReadError(err) {
+  if (err instanceof ApiError) {
+    if (isNotConnectedError(err.code, err.message)) handleConnectionError("google_ads", err.message);
+    writeAdsJson(
+      serviceReadRefusal(err.message) ?? {
+        ok: false,
+        error: {
+          code: err.code,
+          message: err.message,
+          fix: { action: "reject", explanation: err.message },
+          retryable: err.code === "RATE_LIMITED" || err.code === "UNAVAILABLE"
+        }
+      }
+    );
+    process.exit(1);
+  }
+  writeAdsJson({
+    ok: false,
+    error: { code: "NETWORK_ERROR", message: err instanceof Error ? err.message : "Unexpected error" }
+  });
+  process.exit(1);
+}
+
+export {
+  exitWithServiceReadError
+};
+//# sourceMappingURL=chunk-SG3Q24HG.js.map