@koda-sl/baker-cli 0.573.0 → 0.574.0

package/dist/chunk-U3LO5TDH.js

@@ -0,0 +1,296 @@
+import {
+  DIRECT_ROUTE,
+  captureProxyCredentials,
+  childEnvWith,
+  plannedRoutes,
+  shouldEscalate
+} from "./chunk-OMLZ35HJ.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-U3LO5TDH.js.map

package/dist/chunk-UDNN4POE.js

@@ -0,0 +1,111 @@
+import {
+  reportError,
+  splitList
+} from "./chunk-VRQ5HEVU.js";
+import {
+  apiGet
+} from "./chunk-JCFZ7ECN.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-NXNOXZGB.js";
+
+// src/commands/winning-ads/launches.ts
+import { defineCommand } from "citty";
+registerSchema({
+  command: "winning-ads.launches",
+  description: 'What the brands you follow (or the ones named) launched in the last N days and which of those ads still run, each with its stage (new, testing, killed_early\u2026), and the tests each brand decided in that window (the version kept, what differed). The "what did competitors launch last week" report. Compact by default; --full lists every launch.',
+  args: {
+    since: { type: "number", description: "Days to look back, 1-90 (default 7)", required: false, default: 7 },
+    advertiser: {
+      type: "string",
+      description: "Comma list of advertiser ids instead of every followed brand",
+      required: false
+    },
+    platform: { type: "string", description: "Only this platform: meta|linkedin|tiktok|google", required: false },
+    full: { type: "boolean", description: "List every launch", required: false, default: false }
+  }
+});
+var COMPACT_LAUNCHES = 10;
+function compactLaunches(report, full) {
+  return {
+    since_days: report.since_days,
+    advertisers: report.advertisers.map((b) => ({
+      advertiser_id: b.advertiser_id,
+      label: b.label,
+      launched: b.launched,
+      still_running: b.still_running,
+      launches: (full ? b.launches : b.launches.slice(0, COMPACT_LAUNCHES)).map((l) => ({
+        ad_id: l.ad_id,
+        platform: l.platform,
+        format: l.format,
+        headline: l.headline,
+        first_seen_at: l.first_seen_at,
+        stage: l.stage,
+        idea: l.idea ?? null,
+        ...full ? { media_url: l.media_url } : {}
+      })),
+      tests_decided: (b.tests_decided ?? []).map((t) => ({
+        concept: t.concept,
+        versions: t.versions,
+        kept_ad_id: t.winner_ad_id,
+        decided_at: t.decided_at ?? null,
+        what_differed: t.what_differed
+      }))
+    }))
+  };
+}
+var IDEA_HINT = "Idea: whether each launch was a `new` idea (the first day of its concept), another version of one the brand was still `testing`, or a version built on a `winner` it had already kept. Many launches and no new idea means the brand is iterating on what works, not testing new directions: say so.";
+function launchesHints(report, named) {
+  if (!named && report.following_count === 0) {
+    return ["You follow no brands yet: `baker winning-ads follow <domain>` adds one, or pass --advertiser <id>."];
+  }
+  if (report.advertisers.length === 0) {
+    return [`No launches in the last ${report.since_days} days. Widen the window with --since 30.`];
+  }
+  const withIdeas = report.advertisers.some((b) => b.launches.some((l) => l.idea));
+  return [
+    ...withIdeas ? [IDEA_HINT] : [],
+    "Stages: new \u22647 days, testing \u226421 days, proven \u226460 days, evergreen beyond, killed_early = stopped within 2 weeks (a lost test). tests_decided is what each brand learned in the window: the version it kept (kept_ad_id) and what differed. `baker winning-ads search --survived-test` finds the versions brands kept across the library."
+  ];
+}
+var launchesCommand = defineCommand({
+  meta: {
+    name: "launches",
+    description: "What competitors launched lately and what still runs. Start here: baker winning-ads launches --since 7 (every followed brand), or --advertiser adv_1,adv_2"
+  },
+  args: {
+    since: { type: "string", description: "Days to look back, 1-90 (default 7)", required: false },
+    advertiser: { type: "string", description: "Comma list of advertiser ids", required: false },
+    platform: { type: "string", description: "Only this platform: meta|linkedin|tiktok|google", required: false },
+    full: { type: "boolean", description: "List every launch", required: false, default: false }
+  },
+  run: async ({ args }) => {
+    try {
+      const named = splitList(args.advertiser);
+      const params = { since_days: String(args.since ?? 7) };
+      if (named.length > 0) {
+        params.advertiser = named.join(",");
+      }
+      if (args.platform) {
+        params.platform = String(args.platform);
+      }
+      const report = await apiGet("/api/ad-library/launches", params);
+      writeJson({
+        ok: true,
+        data: compactLaunches(report, Boolean(args.full)),
+        hints: launchesHints(report, named.length > 0)
+      });
+    } catch (err) {
+      reportError(err);
+    }
+  }
+});
+
+export {
+  compactLaunches,
+  IDEA_HINT,
+  launchesHints,
+  launchesCommand
+};
+//# sourceMappingURL=chunk-UDNN4POE.js.map

package/dist/chunk-USFXKWTX.js

@@ -0,0 +1,79 @@
+import {
+  cacheGet,
+  cacheSet,
+  writeAdsJson
+} from "./chunk-VJUVTMHY.js";
+import {
+  getEnv,
+  setDefaultAccountEnv
+} from "./chunk-OMLZ35HJ.js";
+
+// src/commands/ads/sole-account.ts
+function accountDecision(accounts, requested, normalize) {
+  if (requested === void 0) {
+    const [only, ...rest] = accounts;
+    return only && rest.length === 0 ? { kind: "default", id: only.id } : { kind: "keep" };
+  }
+  const id = normalize(requested);
+  if (id === null || accounts.length === 0) return { kind: "keep" };
+  return accounts.some((account) => normalize(account.id) === id) ? { kind: "keep" } : { kind: "unknown", requested, accounts: [...accounts] };
+}
+function requestedAccount(rawArgs, flags) {
+  for (let index = 0; index < rawArgs.length; index++) {
+    const arg = rawArgs[index] ?? "";
+    for (const flag of flags) {
+      if (arg === flag) return rawArgs[index + 1];
+      if (arg.startsWith(`${flag}=`)) return arg.slice(flag.length + 1);
+    }
+  }
+  return void 0;
+}
+var ACCOUNTS_TTL_MS = 10 * 60 * 1e3;
+async function freshAccounts(spec) {
+  try {
+    const accounts = await spec.list();
+    cacheSet("accounts", `${spec.platform}-selected`, accounts, ACCOUNTS_TTL_MS);
+    return accounts;
+  } catch {
+    return null;
+  }
+}
+async function recheckedDecision(requested, remembered, readFresh, normalize) {
+  if (remembered !== null) {
+    const decision = accountDecision(remembered, requested, normalize);
+    if (decision.kind !== "unknown") return decision;
+  }
+  const fresh = await readFresh();
+  return fresh === null ? null : accountDecision(fresh, requested, normalize);
+}
+async function applyAccountRule(spec) {
+  const subcommand = spec.rawArgs[0];
+  if (subcommand === void 0 || spec.skip.has(subcommand) || spec.rawArgs.some((arg) => arg === "--help")) return;
+  const requested = requestedAccount(spec.rawArgs, spec.flags);
+  if (requested === void 0 && getEnv()[spec.envVar]) return;
+  const skipCache = spec.rawArgs.some((arg) => arg === "--no-cache" || arg === "--skip-cache");
+  const remembered = skipCache ? null : cacheGet("accounts", `${spec.platform}-selected`)?.data ?? null;
+  const decision = await recheckedDecision(requested, remembered, () => freshAccounts(spec), spec.normalize);
+  if (decision === null) return;
+  if (decision.kind === "default") setDefaultAccountEnv(spec.envVar, decision.id);
+  if (decision.kind !== "unknown") return;
+  const listed = decision.accounts.map((account) => `${account.id}${account.label ? ` (${account.label})` : ""}`);
+  writeAdsJson({
+    ok: false,
+    error: {
+      code: "UNKNOWN_ACCOUNT",
+      message: `${decision.requested} is not one of this company's selected ${spec.platform} ad accounts: ${listed.join("; ")}.`,
+      fix: {
+        action: "retry_with_flag",
+        explanation: decision.accounts.length === 1 ? "Drop the account flag \u2014 the only selected account is used \u2014 or pass the one listed." : `Pass one of the listed accounts with ${spec.flags[0]}.`
+      },
+      retryable: false
+    }
+  });
+  process.exit(1);
+}
+
+export {
+  applyAccountRule
+};
+//# sourceMappingURL=chunk-USFXKWTX.js.map

package/dist/chunk-USFXKWTX.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/commands/ads/sole-account.ts"],"sourcesContent":["/**\n * One account rule for an ad platform's commands: name an account with its\n * flag in any spelling the platform uses, or name none and the company's only\n * selected account is used. Several selected and none named is the command's\n * own refusal; an account the company did not select is refused here, with\n * the ones it did.\n *\n * Run from the platform command's `setup`, before any subcommand reads its\n * flags, so every subcommand gets the same rule without each resolving it.\n */\n\nimport { getEnv, setDefaultAccountEnv } from \"../../env.ts\";\nimport { cacheGet, cacheSet } from \"./cache.ts\";\nimport { writeAdsJson } from \"./output.ts\";\n\nexport interface AccountChoice {\n  id: string;\n  label?: string;\n}\n\nexport type AccountDecision =\n  | { kind: \"keep\" }\n  | { kind: \"default\"; id: string }\n  | { kind: \"unknown\"; requested: string; accounts: AccountChoice[] };\n\nexport function accountDecision(\n  accounts: readonly AccountChoice[],\n  requested: string | undefined,\n  normalize: (raw: string) => string | null,\n): AccountDecision {\n  if (requested === undefined) {\n    const [only, ...rest] = accounts;\n    return only && rest.length === 0 ? { kind: \"default\", id: only.id } : { kind: \"keep\" };\n  }\n  const id = normalize(requested);\n  if (id === null || accounts.length === 0) return { kind: \"keep\" };\n  return accounts.some((account) => normalize(account.id) === id)\n    ? { kind: \"keep\" }\n    : { kind: \"unknown\", requested, accounts: [...accounts] };\n}\n\n/** The value of the first of `flags` in `rawArgs` (`--flag v` or `--flag=v`). */\nexport function requestedAccount(rawArgs: readonly string[], flags: readonly string[]): string | undefined {\n  for (let index = 0; index < rawArgs.length; index++) {\n    const arg = rawArgs[index] ?? \"\";\n    for (const flag of flags) {\n      if (arg === flag) return rawArgs[index + 1];\n      if (arg.startsWith(`${flag}=`)) return arg.slice(flag.length + 1);\n    }\n  }\n  return undefined;\n}\n\n/** How long the selected accounts are trusted before they are read again. */\nconst ACCOUNTS_TTL_MS = 10 * 60 * 1000;\n\nexport interface AccountRuleSpec {\n  /** `linkedin`, `meta`: the platform command, as the agent types it. */\n  platform: string;\n  rawArgs: readonly string[];\n  flags: readonly string[];\n  envVar: \"BAKER_LINKEDIN_AD_ACCOUNT_ID\" | \"BAKER_META_AD_ACCOUNT_ID\";\n  /** Subcommands that name no account (listing accounts, resolving names). */\n  skip: ReadonlySet<string>;\n  list: () => Promise<AccountChoice[]>;\n  normalize: (raw: string) => string | null;\n}\n\n/** The selected accounts read now, and remembered for the next call; null when they cannot be read. */\nasync function freshAccounts(spec: AccountRuleSpec): Promise<AccountChoice[] | null> {\n  try {\n    const accounts = await spec.list();\n    cacheSet(\"accounts\", `${spec.platform}-selected`, accounts, ACCOUNTS_TTL_MS);\n    return accounts;\n  } catch {\n    // Not connected, or the read failed: the subcommand reports that itself.\n    return null;\n  }\n}\n\n/**\n * The decision on the remembered accounts, read again before refusing: an\n * account picked in Baker since they were remembered is not in them yet.\n */\nexport async function recheckedDecision(\n  requested: string | undefined,\n  remembered: readonly AccountChoice[] | null,\n  readFresh: () => Promise<AccountChoice[] | null>,\n  normalize: (raw: string) => string | null,\n): Promise<AccountDecision | null> {\n  if (remembered !== null) {\n    const decision = accountDecision(remembered, requested, normalize);\n    if (decision.kind !== \"unknown\") return decision;\n  }\n  const fresh = await readFresh();\n  return fresh === null ? null : accountDecision(fresh, requested, normalize);\n}\n\nexport async function applyAccountRule(spec: AccountRuleSpec): Promise<void> {\n  const subcommand = spec.rawArgs[0];\n  if (subcommand === undefined || spec.skip.has(subcommand) || spec.rawArgs.some((arg) => arg === \"--help\")) return;\n  const requested = requestedAccount(spec.rawArgs, spec.flags);\n  if (requested === undefined && getEnv()[spec.envVar]) return;\n  const skipCache = spec.rawArgs.some((arg) => arg === \"--no-cache\" || arg === \"--skip-cache\");\n  const remembered = skipCache\n    ? null\n    : (cacheGet<AccountChoice[]>(\"accounts\", `${spec.platform}-selected`)?.data ?? null);\n  const decision = await recheckedDecision(requested, remembered, () => freshAccounts(spec), spec.normalize);\n  if (decision === null) return;\n  if (decision.kind === \"default\") setDefaultAccountEnv(spec.envVar, decision.id);\n  if (decision.kind !== \"unknown\") return;\n  const listed = decision.accounts.map((account) => `${account.id}${account.label ? ` (${account.label})` : \"\"}`);\n  writeAdsJson({\n    ok: false,\n    error: {\n      code: \"UNKNOWN_ACCOUNT\",\n      message: `${decision.requested} is not one of this company's selected ${spec.platform} ad accounts: ${listed.join(\"; \")}.`,\n      fix: {\n        action: \"retry_with_flag\",\n        explanation:\n          decision.accounts.length === 1\n            ? \"Drop the account flag — the only selected account is used — or pass the one listed.\"\n            : `Pass one of the listed accounts with ${spec.flags[0]}.`,\n      },\n      retryable: false,\n    },\n  });\n  process.exit(1);\n}\n"],"mappings":"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","names":[]}