@koda-sl/baker-cli 0.574.0-dev.19539e5a8 → 0.575.0-dev.85f21462e

package/dist/chunk-UQTINFCP.js

@@ -0,0 +1,455 @@
+import {
+  parseBrandTokens
+} from "./chunk-VSHXHSIW.js";
+
+// src/engine/brand/fonts.ts
+import { posix } from "path";
+var GOOGLE_CSS2 = "https://fonts.googleapis.com/css2";
+function parseGoogleFontFaces(css) {
+  const faces = [];
+  const re = /\/\*\s*([\w-]+)\s*\*\/\s*@font-face\s*\{([^}]*)\}/g;
+  for (const match of String(css).matchAll(re)) {
+    const subset = match[1] ?? "";
+    const body = match[2] ?? "";
+    const family = body.match(/font-family\s*:\s*['"]?([^'";]+)['"]?\s*;/i)?.[1]?.trim();
+    const url = body.match(/src\s*:\s*url\(\s*['"]?([^'")]+)['"]?\s*\)/i)?.[1]?.trim();
+    const weight = body.match(/font-weight\s*:\s*(\d{3})\s*;/i)?.[1];
+    if (!family || !url || !weight) continue;
+    faces.push({
+      subset,
+      family,
+      style: body.match(/font-style\s*:\s*([\w-]+)\s*;/i)?.[1]?.trim() ?? "normal",
+      weight: Number(weight),
+      url,
+      unicodeRange: body.match(/unicode-range\s*:\s*([^;]+);/i)?.[1]?.trim() ?? ""
+    });
+  }
+  return faces;
+}
+function fontFileName(face) {
+  const family = face.family.replace(/[^A-Za-z0-9]/g, "");
+  const style = face.style === "italic" ? "italic" : "";
+  return `${family}-${face.weight}${style}-${face.subset}.woff2`;
+}
+function fontFaceHref(face) {
+  return `../brand/fonts/${fontFileName(face)}`;
+}
+function renderFontFaceCss(faces) {
+  return faces.map(
+    (face) => [
+      "@font-face {",
+      `  font-family: '${face.family}';`,
+      `  font-style: ${face.style};`,
+      `  font-weight: ${face.weight};`,
+      "  font-display: swap;",
+      `  src: url('${fontFaceHref(face)}') format('woff2');`,
+      ...face.unicodeRange ? [`  unicode-range: ${face.unicodeRange};`] : [],
+      "}"
+    ].join("\n")
+  ).join("\n");
+}
+var FONT_PROVIDERS = ["google", "fontsource"];
+var FONTSOURCE_API = "https://api.fontsource.org/v1";
+var FONT_STYLES = ["normal", "italic"];
+var ITAL_AXIS = { normal: 0, italic: 1 };
+function fontsourceId(family) {
+  return family.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}
+function fontsourceFaces(meta, weights, subsets, styles = ["normal"]) {
+  const faces = [];
+  for (const subset of subsets.filter((s) => meta.subsets.includes(s))) {
+    for (const weight of weights.filter((w) => meta.weights.includes(w))) {
+      for (const style of styles.filter((style2) => meta.styles.includes(style2))) {
+        const url = meta.variants[String(weight)]?.[style]?.[subset]?.url?.woff2;
+        if (!url) continue;
+        faces.push({
+          subset,
+          family: meta.family,
+          style,
+          weight,
+          url,
+          unicodeRange: meta.unicodeRange?.[subset] ?? "",
+          provider: "fontsource"
+        });
+      }
+    }
+  }
+  return faces;
+}
+function undisambiguatedSubsets(faces) {
+  if (new Set(faces.map((face) => face.subset)).size < 2) return [];
+  return [...new Set(faces.filter((face) => !face.unicodeRange).map((face) => face.subset))];
+}
+function suggestFamilies(wanted, catalogue, limit = 5) {
+  const key = (s) => s.toLowerCase().replace(/[^a-z0-9]+/g, " ").trim();
+  const target = key(wanted);
+  if (!target) return [];
+  const words = target.split(" ");
+  const scored = catalogue.map((family) => {
+    const candidate = key(family);
+    if (candidate === target) return { family, score: 0 };
+    if (candidate.startsWith(target)) return { family, score: 1 };
+    if (candidate.includes(target)) return { family, score: 2 };
+    const shared = words.filter((w) => w.length > 2 && candidate.includes(w)).length;
+    return { family, score: shared > 0 ? 3 + (words.length - shared) : Number.POSITIVE_INFINITY };
+  }).filter((c) => Number.isFinite(c.score)).sort((a, b) => a.score - b.score || a.family.localeCompare(b.family));
+  return scored.slice(0, limit).map((c) => c.family);
+}
+function asFontsourceMeta(body) {
+  if (typeof body !== "object" || body === null) return null;
+  const meta = body;
+  const ok = typeof meta.family === "string" && Array.isArray(meta.weights) && Array.isArray(meta.styles) && Array.isArray(meta.subsets) && typeof meta.variants === "object" && meta.variants !== null;
+  return ok ? meta : null;
+}
+async function probeGoogleFaces(family, lookup) {
+  const got = await lookup(googleFontCssUrl(family, STANDARD_WEIGHTS, FONT_STYLES));
+  if (got.status === "unreachable") return null;
+  return got.status === "served" ? parseGoogleFontFaces(got.css) : [];
+}
+async function resolveFromGoogle(family, weights, subsets, styles, deps) {
+  const google = await deps.lookupGoogleCss(googleFontCssUrl(family, weights, FONT_STYLES));
+  if (google.status === "unreachable") return { ok: false, reason: "unreachable", provider: "google" };
+  if (google.status === "absent") {
+    const served2 = await probeGoogleFaces(family, deps.lookupGoogleCss);
+    if (served2 === null) return { ok: false, reason: "unreachable", provider: "google" };
+    const available = [...new Set(served2.map((face) => face.weight))].sort((a, b) => a - b);
+    return available.length > 0 ? { ok: false, reason: "weight", provider: "google", available } : null;
+  }
+  const served = parseGoogleFontFaces(google.css);
+  if (served.length === 0) return null;
+  const availableStyles = [...new Set(served.map((face) => face.style))].sort();
+  const inSubset = served.filter((face) => subsets.includes(face.subset));
+  const faces = inSubset.filter((face) => styles.includes(face.style)).map((face) => ({ ...face, provider: "google" }));
+  if (faces.length > 0) return { ok: true, provider: "google", faces, availableStyles };
+  return { ok: false, reason: "subset", provider: "google", available: [...new Set(served.map((f) => f.subset))] };
+}
+async function resolveBrandFaces(family, weights, subsets, deps, styles = ["normal"]) {
+  const google = await resolveFromGoogle(family, weights, subsets, styles, deps);
+  if (google) return google;
+  let body;
+  try {
+    body = await deps.fetchJson(`${FONTSOURCE_API}/fonts/${fontsourceId(family)}`);
+  } catch {
+    return { ok: false, reason: "unreachable", provider: "fontsource" };
+  }
+  const meta = asFontsourceMeta(body);
+  if (meta) {
+    const faces = fontsourceFaces(meta, weights, subsets, styles);
+    const ambiguous = undisambiguatedSubsets(faces);
+    if (ambiguous.length > 0) {
+      return { ok: false, reason: "ambiguous-subsets", provider: "fontsource", available: meta.subsets };
+    }
+    if (faces.length > 0) return { ok: true, provider: "fontsource", faces, availableStyles: [...meta.styles].sort() };
+    if (!subsets.some((subset) => meta.subsets.includes(subset))) {
+      return { ok: false, reason: "subset", provider: "fontsource", available: meta.subsets };
+    }
+    return { ok: false, reason: "weight", provider: "fontsource", available: meta.weights };
+  }
+  return { ok: false, reason: "unknown-family" };
+}
+function rebaseFontFaceSrc(block, fromDir, toDir = "src/styles") {
+  return block.replace(/url\(\s*(['"]?)([^'")]+)\1\s*\)/gi, (whole, _quote, href) => {
+    if (!isRepoFontHref(href)) return whole;
+    const target = posix.normalize(posix.join(fromDir, href));
+    return `url('${posix.relative(toDir, target)}')`;
+  });
+}
+function declaredFontFaces(source) {
+  const out = [];
+  for (const rule of stripCssComments(source).matchAll(/@font-face\s*\{[^}]*\}/gi)) {
+    const family = rule[0].match(/font-family\s*:\s*([^;]+)/i)?.[1];
+    if (!family || rule.index === void 0) continue;
+    out.push({ family: normalizeFamily(family), block: source.slice(rule.index, rule.index + rule[0].length) });
+  }
+  return out;
+}
+function isRepoFontHref(href) {
+  return !/^(?:data:|https?:|\/)/i.test(href);
+}
+function missingFontFiles(urls, available) {
+  return urls.filter(isRepoFontHref).map((url) => posix.basename(url.split("?")[0] ?? "")).filter((file) => !available.has(file));
+}
+function planFontAdoption(sources, families) {
+  const wanted = new Map(families.map((family) => [normalizeFamily(family), family]));
+  const byFamily = /* @__PURE__ */ new Map();
+  for (const { path, source } of sources) {
+    const dir = posix.dirname(path);
+    for (const face of declaredFontFaces(source)) {
+      if (!wanted.has(face.family)) continue;
+      const perFile = byFamily.get(face.family) ?? /* @__PURE__ */ new Map();
+      perFile.set(path, [...perFile.get(path) ?? [], rebaseFontFaceSrc(face.block, dir)]);
+      byFamily.set(face.family, perFile);
+    }
+  }
+  const plans = [];
+  const conflicts = [];
+  for (const [family, perFile] of byFamily) {
+    const display = wanted.get(family) ?? family;
+    const files = [...perFile.keys()];
+    const shapes = new Set([...perFile.values()].map((blocks2) => blocks2.join("\n")));
+    if (shapes.size > 1) {
+      conflicts.push({ family: display, files });
+      continue;
+    }
+    const blocks = perFile.get(files[0] ?? "") ?? [];
+    const urls = blocks.flatMap(
+      (block) => [...block.matchAll(/url\(\s*['"]?([^'")]+)['"]?\s*\)/gi)].map((m) => m[1] ?? "")
+    );
+    plans.push({ family: display, blocks, files, urls });
+  }
+  return { plans, conflicts };
+}
+async function fontsourceCatalogue(deps) {
+  const body = await deps.fetchJson(`${FONTSOURCE_API}/fonts`).catch(() => null);
+  if (!Array.isArray(body)) return [];
+  return body.map((entry) => typeof entry === "object" && entry !== null ? entry.family : null).filter((family) => typeof family === "string");
+}
+function parseWeightAxis(spec) {
+  const axis = spec.match(/wght@([^&]+)/i)?.[1] ?? "";
+  const weights = /* @__PURE__ */ new Set();
+  for (const tuple of axis.split(";")) {
+    const last = tuple.split(",").pop()?.trim() ?? "";
+    const range = last.match(/^(\d{3})\.\.(\d{3})$/);
+    if (range) {
+      for (let w = Number(range[1]); w <= Number(range[2]); w += 100) weights.add(w);
+    } else if (/^\d{3}$/.test(last)) {
+      weights.add(Number(last));
+    }
+  }
+  return [...weights].sort((a, b) => a - b);
+}
+function googleFontRequests(css) {
+  const out = [];
+  for (const link of String(css).matchAll(/fonts\.googleapis\.com\/[^\s"')]+/gi)) {
+    for (const param of link[0].matchAll(/[?&]family=([^&]+)/gi)) {
+      const [namePart, ...specParts] = (param[1] ?? "").split(":");
+      const family = decodeURIComponent((namePart ?? "").replaceAll("+", " ")).trim();
+      if (!family) continue;
+      out.push({ family, weights: parseWeightAxis(specParts.join(":")) });
+    }
+  }
+  return out;
+}
+function resolveFetchWeights(flag, declared) {
+  if (flag) {
+    return String(flag).split(",").map((w) => Number(w.trim())).filter((w) => Number.isInteger(w) && w >= 100 && w <= 900);
+  }
+  return declared?.length ? declared : [400];
+}
+var DEFAULT_SUBSETS = ["latin"];
+function resolveFetchSubsets(flag, selfHosted) {
+  const asked = String(flag ?? "").split(",").map((subset) => subset.trim()).filter(Boolean);
+  const named = flag ? [...new Set(asked)] : selfHosted;
+  return named.length > 0 ? named : [...DEFAULT_SUBSETS];
+}
+function resolveFetchStyles(italic, selfHosted) {
+  return italic || selfHosted.includes("italic") ? ["normal", "italic"] : ["normal"];
+}
+function googleFontCssUrl(family, weights, styles = ["normal"]) {
+  const name = family.trim().split(/\s+/).map(encodeURIComponent).join("+");
+  const sorted = [...new Set(weights)].sort((a, b) => a - b);
+  if (sorted.length === 0) return `${GOOGLE_CSS2}?family=${name}&display=swap`;
+  const wanted = FONT_STYLES.filter((style) => styles.includes(style));
+  const spec = wanted.length > 1 ? `${name}:ital,wght@${wanted.flatMap((style) => sorted.map((w) => `${ITAL_AXIS[style]},${w}`)).join(";")}` : `${name}:wght@${sorted.join(";")}`;
+  return `${GOOGLE_CSS2}?family=${spec}&display=swap`;
+}
+var STANDARD_WEIGHTS = [100, 200, 300, 400, 500, 600, 700, 800, 900];
+async function probeServedWeights(family, fetchCss) {
+  const css = await fetchCss(googleFontCssUrl(family, STANDARD_WEIGHTS));
+  if (css === null) return [];
+  return [...new Set(parseGoogleFontFaces(css).map((face) => face.weight))].sort((a, b) => a - b);
+}
+async function checkFontRequests(requests, fetchCss) {
+  const results = [];
+  for (const request of requests) {
+    const css = await fetchCss(googleFontCssUrl(request.family, request.weights));
+    if (css === null) {
+      const served2 = await probeServedWeights(request.family, fetchCss);
+      results.push({
+        family: request.family,
+        requested: request.weights,
+        served: served2,
+        missing: request.weights.filter((w) => !served2.includes(w)),
+        subsets: [],
+        cause: served2.length === 0 ? "unknown-family" : "unavailable-weight"
+      });
+      continue;
+    }
+    const faces = parseGoogleFontFaces(css);
+    const served = [...new Set(faces.map((f) => f.weight))].sort((a, b) => a - b);
+    results.push({
+      family: request.family,
+      requested: request.weights,
+      served,
+      missing: request.weights.filter((w) => !served.includes(w)),
+      subsets: [...new Set(faces.map((f) => f.subset))]
+    });
+  }
+  return results;
+}
+var GENERIC_FAMILIES = /* @__PURE__ */ new Set([
+  "sans-serif",
+  "serif",
+  "monospace",
+  "cursive",
+  "fantasy",
+  "system-ui",
+  "ui-sans-serif",
+  "ui-serif",
+  "ui-monospace",
+  "ui-rounded",
+  "arial",
+  "helvetica",
+  "georgia",
+  "times",
+  "courier",
+  "inherit",
+  "initial",
+  "unset"
+]);
+function stripCssComments(css) {
+  return css.replace(/\/\*[\s\S]*?\*\//g, (block) => block.replace(/[^\n]/g, " "));
+}
+function normalizeFamily(raw) {
+  return raw.trim().replace(/^['"]|['"]$/g, "").trim().toLowerCase();
+}
+function fontFaceFamilies(css) {
+  const out = /* @__PURE__ */ new Set();
+  for (const rule of stripCssComments(css).matchAll(/@font-face\s*\{([^}]*)\}/gi)) {
+    const family = (rule[1] ?? "").match(/font-family\s*:\s*([^;]+)/i)?.[1];
+    if (family) out.add(normalizeFamily(family));
+  }
+  return out;
+}
+function declaredWeights(body) {
+  const spec = (body.match(/font-weight\s*:\s*([^;}]+)/i)?.[1] ?? "").match(/\d{3}/g) ?? [];
+  if (spec.length !== 2) return spec.map(Number);
+  const range = [];
+  for (let w = Number(spec[0]); w <= Number(spec[1]); w += 100) range.push(w);
+  return range;
+}
+function selfHostedWeights(css, family) {
+  const target = normalizeFamily(family);
+  const weights = /* @__PURE__ */ new Set();
+  for (const rule of stripCssComments(css).matchAll(/@font-face\s*\{([^}]*)\}/gi)) {
+    const body = rule[1] ?? "";
+    const declared = body.match(/font-family\s*:\s*([^;]+)/i)?.[1];
+    if (!declared || normalizeFamily(declared) !== target) continue;
+    for (const weight of declaredWeights(body)) weights.add(weight);
+  }
+  return [...weights].sort((a, b) => a - b);
+}
+function fontFileSubset(href) {
+  const file = posix.basename((href.split("?")[0] ?? "").split("#")[0] ?? "");
+  return /^[A-Za-z0-9]+-[1-9]00(?:italic)?-([\w-]+)\.woff2$/.exec(file)?.[1] ?? null;
+}
+function selfHostedSubsets(css, family) {
+  const target = normalizeFamily(family);
+  const subsets = /* @__PURE__ */ new Set();
+  for (const rule of stripCssComments(css).matchAll(/@font-face\s*\{([^}]*)\}/gi)) {
+    const body = rule[1] ?? "";
+    const declared = body.match(/font-family\s*:\s*([^;]+)/i)?.[1];
+    if (!declared || normalizeFamily(declared) !== target) continue;
+    for (const url of body.matchAll(/url\(\s*['"]?([^'")]+)['"]?\s*\)/gi)) {
+      const subset = fontFileSubset(url[1] ?? "");
+      if (subset) subsets.add(subset);
+    }
+  }
+  return [...subsets].sort();
+}
+function selfHostedStyles(css, family) {
+  const target = normalizeFamily(family);
+  const styles = /* @__PURE__ */ new Set();
+  for (const rule of stripCssComments(css).matchAll(/@font-face\s*\{([^}]*)\}/gi)) {
+    const body = rule[1] ?? "";
+    const declared = body.match(/font-family\s*:\s*([^;]+)/i)?.[1];
+    if (declared && normalizeFamily(declared) === target) styles.add(faceStyle(body));
+  }
+  return [...styles].sort();
+}
+function fontsourceFamilies(css) {
+  const out = /* @__PURE__ */ new Set();
+  for (const imported of stripCssComments(css).matchAll(/@fontsource(-variable)?\/([\w-]+)/gi)) {
+    const slug = imported[2];
+    if (!slug) continue;
+    out.add(`${slug.replaceAll("-", " ")}${imported[1] ? " variable" : ""}`.toLowerCase());
+  }
+  return out;
+}
+function asAuthored(css, normalized) {
+  const escaped = normalized.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const text = stripCssComments(css);
+  return text.match(new RegExp(`["']${escaped}["']`, "i"))?.[0]?.slice(1, -1) ?? text.match(new RegExp(`(?<![\\w-])${escaped}(?![\\w-])`, "i"))?.[0] ?? normalized;
+}
+function unresolvedBrandFamilies(css) {
+  const declared = [...parseBrandTokens(css).fonts].filter((family) => !GENERIC_FAMILIES.has(family));
+  const loaded = fontFaceFamilies(css);
+  return declared.filter((family) => !loaded.has(family)).map((family) => asAuthored(css, family));
+}
+function stripFontFaceBlocks(source, family, styles) {
+  const target = normalizeFamily(family);
+  const ranges = [];
+  for (const rule of stripCssComments(source).matchAll(/@font-face\s*\{([^}]*)\}/gi)) {
+    const body = rule[1] ?? "";
+    const declared = body.match(/font-family\s*:\s*([^;]+)/i)?.[1];
+    if (!declared || normalizeFamily(declared) !== target || rule.index === void 0) continue;
+    if (styles && !styles.has(faceStyle(body))) continue;
+    ranges.push([rule.index, rule.index + rule[0].length]);
+  }
+  let out = source;
+  for (const [start, end] of ranges.reverse()) out = `${out.slice(0, start)}${out.slice(end)}`;
+  return out.replace(/\n{3,}/g, "\n\n");
+}
+function faceStyle(body) {
+  return body.match(/font-style\s*:\s*([\w-]+)/i)?.[1]?.trim().toLowerCase() ?? "normal";
+}
+function declaredStyles(block) {
+  const styles = /* @__PURE__ */ new Set();
+  for (const rule of stripCssComments(block).matchAll(/@font-face\s*\{([^}]*)\}/gi))
+    styles.add(faceStyle(rule[1] ?? ""));
+  return styles;
+}
+function upsertFontFaceCss(css, family, block) {
+  const styles = declaredStyles(block);
+  const out = stripFontFaceBlocks(css, family, styles.size > 0 ? styles : void 0);
+  const themeAt = stripCssComments(out).search(/@theme\b/);
+  if (themeAt < 0) return `${out.trimEnd()}
+
+${block}
+`;
+  const head = out.slice(0, themeAt).trimEnd();
+  const tail = out.slice(themeAt);
+  return head ? `${head}
+
+${block}
+
+${tail}` : `${block}
+
+${tail}`;
+}
+
+export {
+  fontFileName,
+  renderFontFaceCss,
+  FONT_PROVIDERS,
+  suggestFamilies,
+  resolveBrandFaces,
+  missingFontFiles,
+  planFontAdoption,
+  fontsourceCatalogue,
+  googleFontRequests,
+  resolveFetchWeights,
+  DEFAULT_SUBSETS,
+  resolveFetchSubsets,
+  resolveFetchStyles,
+  checkFontRequests,
+  GENERIC_FAMILIES,
+  selfHostedWeights,
+  selfHostedSubsets,
+  selfHostedStyles,
+  fontsourceFamilies,
+  unresolvedBrandFamilies,
+  stripFontFaceBlocks,
+  upsertFontFaceCss
+};
+//# sourceMappingURL=chunk-UQTINFCP.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":[]}