@koda-sl/baker-cli 0.534.0 → 0.535.0

package/dist/chunk-66O7GGOB.js

@@ -0,0 +1,131 @@
+import {
+  holdUnbilledSpend
+} from "./chunk-RJ675DP3.js";
+import {
+  askAboutText
+} from "./chunk-ZN22VDFS.js";
+
+// src/engine/brand/brand-doc.ts
+import { createHash } from "crypto";
+import { mkdir, readdir, readFile, writeFile } from "fs/promises";
+import path from "path";
+import { z } from "zod";
+var BRAND_DOC_MODEL = "google/gemini-3.5-flash-lite";
+var REQUEST = {
+  provider: { order: ["google-vertex"], allow_fallbacks: false },
+  seed: 0,
+  response_format: { type: "json_object" }
+};
+var PROMPT_VERSION = 3;
+var TIMEOUT_MS = 3e4;
+var BRAND_MD_CHARS = 32e3;
+var NOTE_CHARS = 600;
+var COMPANY_MD_CHARS = 4e3;
+var Font = z.object({
+  family: z.string().trim().min(1).max(60),
+  role: z.enum(["heading", "body", "any"]).catch("any"),
+  use: z.boolean()
+});
+var Color = z.object({
+  hex: z.string().trim().regex(/^#?[0-9a-fA-F]{6}$/).transform((h) => `#${h.replace(/^#/, "").toLowerCase()}`),
+  use: z.boolean()
+});
+var note = z.string().trim().min(1).max(NOTE_CHARS).nullable().optional().catch(null);
+var Reading = z.object({
+  name: z.string().trim().min(1).max(80).nullable().catch(null),
+  wordmark: z.array(z.string().trim().min(1).max(40)).catch([]),
+  logoNames: z.array(z.string().trim().min(1).max(40)).catch([]),
+  fonts: z.array(z.unknown()).catch([]),
+  colors: z.array(z.unknown()).catch([]),
+  voice: note,
+  imagery: note,
+  logoUsage: note
+});
+function brandDocPrompt(docs) {
+  return [
+    "You read a company's brand guidelines (BRAND.md), the start of its company profile (COMPANY.md) and the file names of its logos. They may be written in any language, or several. Extract only what they state; never invent a value.",
+    "",
+    "Return JSON only, in this shape:",
+    '{"name": string | null, "wordmark": string[], "logoNames": string[], "fonts": [{"family": string, "role": "heading" | "body" | "any", "use": boolean}], "colors": [{"hex": "#rrggbb", "use": boolean}], "voice": string | null, "imagery": string | null, "logoUsage": string | null}',
+    "",
+    `- name: the brand's name exactly as written ("# Zernio Brand Guidelines" names Zernio). null when neither document states one, as in an unfilled template ("# Brand Guidelines", "# Company", TODO).`,
+    `- wordmark: every word the documents say the logo prints, as they quote it ("Wordmark: \\"permut\\"" gives "permut"; 'symbol plus "Cubbo" wordmark' gives "Cubbo"), even when it is also the name. [] when they quote none.`,
+    '- logoNames: a product or brand name a logo file name carries ("logo-engage-blue.png" gives "Engage"). Colours, variants, sizes and formats (dark, white, icon, isotype, png) are not names. [] when none.',
+    `- fonts: every typeface the guidelines name, by its family name exactly, the banned ones included. role is heading, body, or any when they do not say. use is false when the guidelines ban it, forbid it or say to avoid it or never use it, in any wording or language; true when the brand uses it. Only a named typeface counts: a generic family (sans-serif, serif, monospace, system-ui) or the operating system's own fonts ("system stack", "system fonts") is not one, so leave it out.`,
+    "- colors: every hex colour the guidelines give. use is false when they ban it or say to avoid it, true when it is a brand colour.",
+    "- voice: how the brand speaks, as the guidelines put it, at most two sentences in their language. null when they do not say.",
+    "- imagery: what the brand's pictures look like and never look like (photography, illustration, people; a ```generation-style block says it too), at most two sentences in their language. null when they do not say.",
+    "- logoUsage: which logo file an ad uses and how it must appear (which file for which product, line or background, what never to do to it), at most two sentences in their language. null when they do not say.",
+    "",
+    "<brand_md>",
+    (docs.brandMd ?? "").slice(0, BRAND_MD_CHARS),
+    "</brand_md>",
+    "<company_md>",
+    (docs.companyMd ?? "").slice(0, COMPANY_MD_CHARS),
+    "</company_md>",
+    "<logo_files>",
+    (docs.logoFiles ?? []).join("\n"),
+    "</logo_files>"
+  ].join("\n");
+}
+function parseBrandDoc(answer) {
+  const parsed = Reading.safeParse(answer);
+  if (!parsed.success) return null;
+  const fonts = parsed.data.fonts.flatMap((f) => {
+    const font = Font.safeParse(f);
+    return font.success ? [font.data] : [];
+  });
+  const colors = parsed.data.colors.flatMap((c) => {
+    const color = Color.safeParse(c);
+    return color.success ? [color.data] : [];
+  });
+  const { voice, imagery, logoUsage } = parsed.data;
+  return {
+    ...parsed.data.name ? { name: parsed.data.name } : {},
+    wordmark: [.../* @__PURE__ */ new Set([...parsed.data.wordmark, ...parsed.data.logoNames])],
+    fonts,
+    colors,
+    ...voice ? { voice } : {},
+    ...imagery ? { imagery } : {},
+    ...logoUsage ? { logoUsage } : {}
+  };
+}
+function brandDocReader(cacheDir, onSpend) {
+  return async (docs) => {
+    const prompt = brandDocPrompt(docs);
+    const key = createHash("sha256").update(JSON.stringify([PROMPT_VERSION, BRAND_DOC_MODEL, prompt])).digest("hex");
+    const file = path.join(cacheDir, "brand-doc", `${key}.json`);
+    const cached = parseBrandDoc(await readFile(file, "utf8").then(JSON.parse, () => null));
+    if (cached) return cached;
+    const spent = [];
+    const answer = await askAboutText(BRAND_DOC_MODEL, prompt, (u) => onSpend ? onSpend(u) : spent.push(u), {
+      timeoutMs: TIMEOUT_MS,
+      request: REQUEST
+    }).catch(() => null);
+    await holdUnbilledSpend(cacheDir, spent).catch(() => void 0);
+    const reading = parseBrandDoc(answer);
+    if (reading) {
+      await mkdir(path.dirname(file), { recursive: true }).catch(() => void 0);
+      await writeFile(file, JSON.stringify(reading), "utf8").catch(() => void 0);
+    }
+    return reading;
+  };
+}
+var LOGO_FILE = /logo|lockup|wordmark|isotype|isologo/i;
+async function workspaceBrandDocs(root) {
+  const read = (rel) => readFile(path.join(root, rel), "utf8").catch(() => null);
+  const logoFiles = (await readdir(path.join(root, "src", "brand", "logos")).catch(() => [])).filter((f) => /\.(png|jpe?g|webp|svg)$/i.test(f) && LOGO_FILE.test(f)).sort();
+  return { brandMd: await read("src/brand/BRAND.md"), companyMd: await read("COMPANY.md"), logoFiles };
+}
+async function readWorkspaceBrandDoc(root, opts = {}) {
+  const docs = await workspaceBrandDocs(root);
+  if (!docs.brandMd?.trim() && !docs.companyMd?.trim()) return null;
+  const read = opts.read ?? brandDocReader(path.join(root, "canvas", ".cache"), opts.onSpend);
+  return await read(docs).catch(() => null);
+}
+
+export {
+  LOGO_FILE,
+  readWorkspaceBrandDoc
+};
+//# sourceMappingURL=chunk-66O7GGOB.js.map

package/dist/chunk-6LU64W5J.js

@@ -0,0 +1,333 @@
+import {
+  captureProxyCredentials,
+  isChallengeBody,
+  isPrivateAddress,
+  isProxyFailure,
+  nextPlannedRoute,
+  plannedRoutes,
+  refuseNonPublicUrl,
+  shouldEscalate
+} from "./chunk-6THXOWAP.js";
+
+// ../proxy/src/fetch.ts
+import { lookup as dnsLookup } from "dns";
+import { Agent, ProxyAgent, Response, fetch as undiciFetch } from "undici";
+
+// ../proxy/src/fetchDecision.ts
+function classifyFetchOutcome(signal) {
+  if (isProxyFailure(signal)) return "proxy_unavailable";
+  if (shouldEscalate(signal)) return "blocked";
+  if (signal.status != null && signal.status >= 200 && signal.status < 400 && !signal.challenge) return "ok";
+  return "failed";
+}
+function shouldTryNextRoute(outcome) {
+  return outcome === "blocked" || outcome === "proxy_unavailable";
+}
+var TIMEOUT_CODES = /* @__PURE__ */ new Set([
+  "UND_ERR_CONNECT_TIMEOUT",
+  "UND_ERR_HEADERS_TIMEOUT",
+  "UND_ERR_BODY_TIMEOUT",
+  "ETIMEDOUT"
+]);
+var RESET_CODES = /* @__PURE__ */ new Set(["ECONNRESET", "UND_ERR_SOCKET", "EPIPE"]);
+var PROXY_RESPONSE = /Proxy response \((\d+)\)/;
+function errorCode(error) {
+  if (typeof error !== "object" || error === null) return null;
+  const code = error.code;
+  if (typeof code === "string") return code;
+  const name = error.name;
+  return typeof name === "string" ? name : null;
+}
+function errorMessage(error) {
+  if (typeof error === "object" && error !== null) {
+    const message = error.message;
+    if (typeof message === "string") return message;
+  }
+  return String(error);
+}
+function errorBlockSignal(error, proxied) {
+  const proxyResponse = PROXY_RESPONSE.exec(errorMessage(error));
+  if (proxyResponse) {
+    const status = Number(proxyResponse[1]);
+    return status === 407 ? { status: 407 } : { netError: "ERR_TUNNEL_CONNECTION_FAILED" };
+  }
+  const code = errorCode(error);
+  if (code !== null && TIMEOUT_CODES.has(code)) return { timedOut: true };
+  if (code === "AbortError" || code === "TimeoutError") return { timedOut: true };
+  if (proxied) {
+    return { netError: "ERR_PROXY_CONNECTION_FAILED" };
+  }
+  if (code !== null && RESET_CODES.has(code)) return { netError: "ERR_CONNECTION_RESET" };
+  return { netError: code ?? "ERR_FAILED" };
+}
+function shouldSniffChallenge(contentType, contentLength, maxSniffBytes) {
+  if (contentLength !== null && contentLength > maxSniffBytes) return false;
+  if (contentType === null || contentType.trim() === "") return true;
+  const type = contentType.toLowerCase();
+  if (type.startsWith("image/") || type.startsWith("video/") || type.startsWith("audio/")) return false;
+  return type.includes("text/") || type.includes("html") || type.includes("json") || type.includes("xml");
+}
+
+// ../proxy/src/fetch.ts
+var DEFAULT_TIMEOUT_MS = 6e4;
+var MAX_SNIFF_BYTES = 64 * 1024;
+function tierOf(route) {
+  return route.kind === "proxy" ? route.tier : "direct";
+}
+function agentFor(route) {
+  if (route.kind !== "proxy") return directAgent();
+  const token = Buffer.from(`${route.username}:${route.password}`).toString("base64");
+  return new ProxyAgent({ uri: route.server, token: `Basic ${token}` });
+}
+function directAgent() {
+  return new Agent({
+    connect: {
+      lookup: (hostname, options, callback) => {
+        dnsLookup(hostname, options, (error, address, family) => {
+          if (error) {
+            callback(error, address, family);
+            return;
+          }
+          const found = Array.isArray(address) ? address.map((entry) => entry.address) : [address];
+          const blocked = found.find((entry) => isPrivateAddress(entry));
+          if (blocked !== void 0) {
+            callback(new Error(`${PRIVATE_ADDRESS_CODE}: ${hostname} resolves to ${blocked}`), "", 4);
+            return;
+          }
+          callback(null, address, family);
+        });
+      }
+    }
+  });
+}
+var PRIVATE_ADDRESS_CODE = "EPRIVATEADDR";
+var MAX_REDIRECTS = 20;
+var REDIRECT_STATUS = /* @__PURE__ */ new Set([301, 302, 303, 307, 308]);
+function originOf(url) {
+  try {
+    return new URL(url).origin;
+  } catch {
+    return null;
+  }
+}
+function refuseRedirect(entry, to) {
+  if (refuseNonPublicUrl(to) === null) return false;
+  const destination = originOf(to);
+  return destination === null || destination !== originOf(entry);
+}
+async function followRedirects(url, init) {
+  let current = url;
+  let request = { ...init, redirect: "manual" };
+  for (let hop = 0; hop <= MAX_REDIRECTS; hop++) {
+    const response = await undiciFetch(current, request);
+    const location = response.headers.get("location");
+    if (!REDIRECT_STATUS.has(response.status) || location === null) return response;
+    await response.body?.cancel();
+    const next = new URL(location, current).toString();
+    if (refuseRedirect(url, next)) {
+      throw new Error(`${PRIVATE_ADDRESS_CODE}: redirected to ${next}`);
+    }
+    const method = (request.method ?? "GET").toUpperCase();
+    const downgrade = response.status === 303 || (response.status === 301 || response.status === 302) && method === "POST";
+    request = downgrade ? { ...request, method: "GET", body: void 0 } : request;
+    current = next;
+  }
+  throw new Error(`too many redirects following ${url}`);
+}
+var NULL_BODY_STATUS = /* @__PURE__ */ new Set([101, 103, 204, 205, 304]);
+function rebuild(response, body) {
+  if (response.status < 200 || response.status > 599 || NULL_BODY_STATUS.has(response.status)) {
+    return new Response(null, { status: response.status, headers: response.headers });
+  }
+  return new Response(body, {
+    status: response.status,
+    statusText: response.statusText,
+    headers: response.headers
+  });
+}
+function declaredLength(response) {
+  const raw = response.headers.get("content-length");
+  if (raw === null) return null;
+  const value = Number(raw);
+  return Number.isFinite(value) ? value : null;
+}
+async function readOnce(response, sniff, maxBytes) {
+  const declared = declaredLength(response);
+  if (maxBytes !== void 0 && declared !== null && declared > maxBytes) {
+    await response.body?.cancel();
+    return { response: rebuild(response, new ArrayBuffer(0)), challenge: false };
+  }
+  const body = await response.arrayBuffer();
+  const wantsSniff = sniff && shouldSniffChallenge(response.headers.get("content-type"), body.byteLength, MAX_SNIFF_BYTES);
+  const challenge = wantsSniff ? isChallengeBody(new TextDecoder().decode(body)) : false;
+  return { response: rebuild(response, body), challenge };
+}
+async function attemptRoute(url, init, route, options) {
+  const tier = tierOf(route);
+  const agent = agentFor(route);
+  const startedAt = Date.now();
+  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const signal = init.signal ? AbortSignal.any([init.signal, AbortSignal.timeout(timeoutMs)]) : AbortSignal.timeout(timeoutMs);
+  try {
+    const raw = await followRedirects(url, { ...init, dispatcher: agent ?? void 0, signal });
+    const read = await readOnce(raw, options.sniffChallenge ?? true, options.maxBytes);
+    const outcome = classifyFetchOutcome({ status: raw.status, challenge: read.challenge });
+    return {
+      attempt: { tier, status: raw.status, ms: Date.now() - startedAt, outcome },
+      response: outcome === "proxy_unavailable" ? null : read.response
+    };
+  } catch (error) {
+    const blockSignal = errorBlockSignal(error, route.kind === "proxy");
+    return {
+      attempt: {
+        tier,
+        status: blockSignal.status ?? void 0,
+        ms: Date.now() - startedAt,
+        outcome: classifyFetchOutcome(blockSignal)
+      },
+      response: null,
+      error
+    };
+  } finally {
+    await agent?.close();
+  }
+}
+async function fetchWithEscalation(url, init, options) {
+  const attempts = [];
+  let originResponse = null;
+  let originTier = "direct";
+  let lastError;
+  const routes = plannedRoutes(url, options.credentials, options.routeOptions);
+  const tried = [];
+  for (let route = routes[0] ?? null; route !== null; route = nextPlannedRoute(routes, tried)) {
+    const rung = await attemptRoute(url, init, route, options);
+    attempts.push(rung.attempt);
+    tried.push({ tier: rung.attempt.tier, proxyFailure: rung.attempt.outcome === "proxy_unavailable" });
+    if (rung.response !== null) {
+      originResponse = rung.response;
+      originTier = rung.attempt.tier;
+    }
+    if (rung.error !== void 0) lastError = rung.error;
+    if (!shouldTryNextRoute(rung.attempt.outcome)) break;
+  }
+  return {
+    response: originResponse,
+    attempts,
+    finalTier: originResponse !== null ? originTier : lastAttempt(attempts)?.tier ?? "direct",
+    ...originResponse === null && lastError !== void 0 ? { error: lastError } : {}
+  };
+}
+function lastAttempt(attempts) {
+  return attempts[attempts.length - 1];
+}
+function describeLadder(result) {
+  const rungs = result.attempts.map((a) => `${a.tier}:${a.outcome}${a.status ? `(${a.status})` : ""}@${a.ms}ms`);
+  return `${rungs.join(" \u2192 ")} | final=${result.finalTier}`;
+}
+function rescued(result) {
+  return result.attempts.some((attempt) => attempt.outcome === "ok");
+}
+function endedBlocked(result) {
+  if (rescued(result)) return false;
+  return result.attempts.some((attempt) => attempt.outcome === "blocked");
+}
+function endedProxyUnavailable(result) {
+  if (rescued(result) || endedBlocked(result)) return false;
+  return result.attempts.some((attempt) => attempt.outcome === "proxy_unavailable");
+}
+function endedPrivateAddress(result) {
+  if (rescued(result)) return false;
+  for (let error = result.error, depth = 0; error instanceof Error && depth < 5; depth++) {
+    if (error.message.includes(PRIVATE_ADDRESS_CODE)) return true;
+    error = error.cause;
+  }
+  return false;
+}
+
+// src/lib/externalFetch.ts
+var BROWSER_HEADERS = {
+  "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36",
+  Accept: "image/avif,image/webp,image/apng,image/svg+xml,image/*,*/*;q=0.8",
+  "Accept-Language": "en-US,en;q=0.9"
+};
+var NOT_PUBLIC_MESSAGE = "That address is not reachable from the public web, so there is nothing to read.";
+var MAX_REMOTE_IMAGE_BYTES = 25e6;
+var ExternalFetchError = class extends Error {
+  /** True when the fault was ours — a route we could not open, not a dead host. */
+  ourFault;
+  constructor(message, ourFault) {
+    super(message);
+    this.name = "ExternalFetchError";
+    this.ourFault = ourFault;
+  }
+};
+async function fetchExternal(url, options = {}) {
+  if (refuseNonPublicUrl(url) !== null) {
+    throw new ExternalFetchError(NOT_PUBLIC_MESSAGE, false);
+  }
+  const result = await fetchWithEscalation(
+    url,
+    { headers: { ...BROWSER_HEADERS, ...options.headers } },
+    {
+      credentials: captureProxyCredentials(),
+      ...options.timeoutMs === void 0 ? {} : { timeoutMs: options.timeoutMs },
+      ...options.maxBytes === void 0 ? {} : { maxBytes: options.maxBytes },
+      ...options.sniffChallenge === void 0 ? {} : { sniffChallenge: options.sniffChallenge }
+    }
+  );
+  if (result.attempts.length > 1) {
+    process.stderr.write(`fetch ladder ${url} \u2014 ${describeLadder(result)}
+`);
+  }
+  if (result.response === null) {
+    if (endedPrivateAddress(result)) {
+      throw new ExternalFetchError(NOT_PUBLIC_MESSAGE, false);
+    }
+    const ourFault = endedProxyUnavailable(result);
+    throw new ExternalFetchError(
+      ourFault ? "Could not open a route to that address." : "That address did not answer.",
+      ourFault
+    );
+  }
+  return { response: result.response, blocked: endedBlocked(result) };
+}
+function refuseOversize(bytes, maxBytes) {
+  if (bytes === null || bytes <= maxBytes) return null;
+  return `That file is ${humanBytes(bytes)} \u2014 the limit is ${humanBytes(maxBytes)}.`;
+}
+function humanBytes(n) {
+  if (n >= 1024 ** 3) return `${(n / 1024 ** 3).toFixed(1)} GB`;
+  if (n >= 1024 ** 2) return `${(n / 1024 ** 2).toFixed(1)} MB`;
+  return `${Math.max(1, Math.round(n / 1024))} KB`;
+}
+function declaredBytes(response) {
+  const raw = response.headers.get("content-length");
+  if (raw === null) return null;
+  const value = Number(raw);
+  return Number.isFinite(value) ? value : null;
+}
+async function fetchExternalBytes(url, options) {
+  const { response, blocked } = await fetchExternal(url, options);
+  if (!response.ok) {
+    throw new ExternalFetchError(`${response.status} ${response.statusText}`, false);
+  }
+  if (blocked) {
+    throw new ExternalFetchError("That host served a security check instead of the file.", false);
+  }
+  const declared = refuseOversize(declaredBytes(response), options.maxBytes);
+  if (declared !== null) {
+    throw new ExternalFetchError(declared, false);
+  }
+  const buffer = Buffer.from(await response.arrayBuffer());
+  const actual = refuseOversize(buffer.byteLength, options.maxBytes);
+  if (actual !== null) {
+    throw new ExternalFetchError(actual, false);
+  }
+  return { buffer, contentType: response.headers.get("content-type") };
+}
+
+export {
+  MAX_REMOTE_IMAGE_BYTES,
+  fetchExternalBytes
+};
+//# sourceMappingURL=chunk-6LU64W5J.js.map