@koda-sl/baker-cli 0.452.0 → 0.453.0-dev.914a088e4

package/dist/chunk-O4HREVZO.js

@@ -0,0 +1,509 @@
+import {
+  finalOutputLabelsFromCanvas,
+  parseDefinitionStrategyFields
+} from "./chunk-EA5DXYCF.js";
+import {
+  readRenderState
+} from "./chunk-7ZZ7AHVM.js";
+import {
+  STATIC_AD_ROLE,
+  formatOfAdaptId,
+  isCustomersWords,
+  isSignatureLine,
+  sameTag,
+  seriesMemberAd
+} from "./chunk-5HWY4R7Y.js";
+import {
+  fetchRunRecord
+} from "./chunk-Q3RKWCVL.js";
+import {
+  localPathParam
+} from "./chunk-IFD5LJWU.js";
+import {
+  NodeDecl,
+  STATIC_ADAPT_FORMAT_ROLE,
+  STATIC_FIX_ROLE,
+  STATIC_MASTER_ROLE,
+  STATIC_PICK_ROLE,
+  STATIC_SAFE_FIT_ROLE,
+  STATIC_SIZE_ROLE,
+  STATIC_VARIANTS_ROLE,
+  nodesWithRole,
+  relaidPictureRole,
+  rolesById
+} from "./chunk-ERVDEVLC.js";
+import {
+  isAdSpec,
+  readAdSpec
+} from "./chunk-XR7TMGYY.js";
+import {
+  sha256Hex,
+  toModelSafeImage
+} from "./chunk-DIJBHIII.js";
+
+// src/commands/baker-child.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+var run = promisify(execFile);
+function lastJsonObject(stdout) {
+  for (let at = stdout.lastIndexOf("{"); at >= 0; at = stdout.lastIndexOf("{", at - 1)) {
+    if (at > 0 && stdout[at - 1] !== "\n") continue;
+    try {
+      const parsed = JSON.parse(stdout.slice(at));
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) return parsed;
+    } catch {
+    }
+    if (at === 0) break;
+  }
+  return null;
+}
+async function runBaker(args, signal) {
+  const entry = process.argv[1];
+  const [file, argv] = entry ? [process.execPath, [...process.execArgv, entry, ...args]] : ["baker", args];
+  try {
+    const { stdout } = await run(file, argv, { maxBuffer: 32 * 1024 * 1024, ...signal ? { signal } : {} });
+    return lastJsonObject(stdout) ?? { ok: false, error: { code: "INTERNAL_ERROR", message: "no answer" } };
+  } catch (err) {
+    const { stdout = "", stderr = "" } = err;
+    return lastJsonObject(stdout) ?? lastJsonObject(stderr) ?? {
+      ok: false,
+      error: { code: "INTERNAL_ERROR", message: err instanceof Error ? err.message.slice(0, 300) : String(err) }
+    };
+  }
+}
+
+// src/commands/canvas/static-ad-canvas.ts
+function isStaticAdCanvas(parsed) {
+  const nodes = parsed?.nodes;
+  if (!Array.isArray(nodes)) return false;
+  return nodes.some((n) => {
+    const role = n?.tags?.role;
+    if (role === STATIC_VARIANTS_ROLE) return true;
+    return n?.type === "ingest" && (role === STATIC_AD_ROLE || n?.id === "compose_spec");
+  });
+}
+
+// src/commands/canvas/static-fix.ts
+import { readFile } from "fs/promises";
+import path from "path";
+import { z } from "zod";
+async function previousAdImage(canvasRoot, runId, fetchRecord = fetchRunRecord, roles = {}) {
+  try {
+    const manifest = JSON.parse(await readFile(path.join(canvasRoot, runId, "manifest.json"), "utf8"));
+    const byNode = Object.fromEntries(
+      Object.entries(manifest.outputs_by_node ?? {}).map(([id, out]) => [id, { ...out, ...roles[id] ? { role: roles[id] } : {} }])
+    );
+    const local = chosenUrl(byNode);
+    if (local) return local;
+  } catch {
+  }
+  const record = await fetchRecord(runId).catch(() => null);
+  if (!record) return null;
+  return chosenUrl(
+    Object.fromEntries(
+      record.nodes.map((n) => {
+        const role = n.role ?? roles[n.nodeId];
+        return [n.nodeId, { images: n.outputs, ...role ? { role } : {} }];
+      })
+    )
+  );
+}
+async function previousDelivered(canvasRoot, runId, finalNode, labels, opts = {}) {
+  try {
+    const manifest = JSON.parse(await readFile(path.join(canvasRoot, runId, "manifest.json"), "utf8"));
+    const images = manifest.outputs_by_node?.[finalNode]?.images ?? [];
+    return images.flatMap((image, i) => {
+      const local = typeof image.path === "string" ? image.path : null;
+      const durable = typeof image.url === "string" ? image.url : null;
+      const source = opts.prefer === "url" ? durable ?? local : local ?? durable;
+      const format = labels[i];
+      return source && format ? [{ format, path: source }] : [];
+    });
+  } catch {
+    return [];
+  }
+}
+var CHOSEN = [
+  (_, out) => out.role === STATIC_MASTER_ROLE,
+  (_, out) => out.role === STATIC_PICK_ROLE,
+  (_, out) => out.role === STATIC_FIX_ROLE,
+  (id, out) => id === "pick" && out.role === void 0,
+  (id, out) => id === "ad" && out.role === void 0
+];
+function urlOf(out) {
+  const url = out.images?.find((o) => typeof o?.url === "string")?.url ?? out.image?.url ?? out.asset?.url;
+  return typeof url === "string" ? url : null;
+}
+function chosenUrl(byNode) {
+  const entries = Object.entries(byNode).filter(([, out]) => out.role !== STATIC_VARIANTS_ROLE);
+  for (const matches of CHOSEN) {
+    for (const [id, out] of entries) {
+      if (!matches(id, out)) continue;
+      const url = urlOf(out);
+      if (url) return url;
+    }
+  }
+  return null;
+}
+function correctedUrl(byNode) {
+  const editNumber = (id) => Number(id.match(/^edit_(\d+)$/)?.[1] ?? 0);
+  const entries = Object.entries(byNode).sort(([a], [b]) => editNumber(b) - editNumber(a));
+  for (const [id, out] of entries) {
+    if (id === "fix" || id === "chosen" || out.role === STATIC_FIX_ROLE) {
+      const url = urlOf(out);
+      if (url) return url;
+    }
+  }
+  return null;
+}
+async function fetchGraph(url) {
+  const res = await fetch(url);
+  return res.ok ? res.json() : null;
+}
+var HISTORY = { record: fetchRunRecord, graph: fetchGraph };
+var VersionGraph = z.object({ nodes: z.array(NodeDecl) });
+var VersionManifest = z.object({
+  canvas: VersionGraph,
+  outputs_by_node: z.record(z.string(), z.record(z.string(), z.unknown()))
+});
+async function versionRun(canvasRoot, runId, sources = HISTORY) {
+  try {
+    const manifest = VersionManifest.safeParse(JSON.parse(await readFile(path.join(canvasRoot, runId, "manifest.json"), "utf8")));
+    if (manifest.success) return { canvas: manifest.data.canvas, outputs: manifest.data.outputs_by_node };
+  } catch {
+  }
+  const record = await sources.record(runId).catch(() => null);
+  const graph = record?.graphUrl ? await sources.graph(record.graphUrl).catch(() => null) : null;
+  const canvas = VersionGraph.safeParse(graph);
+  return record && canvas.success ? { canvas: canvas.data, outputs: outputsByNode(record.nodes) } : null;
+}
+async function ingestedNow(files, canvasDir) {
+  const entries = await Promise.all(
+    files.map(async (file) => {
+      const bytes = await readFile(path.resolve(canvasDir, file.path)).catch(() => null);
+      if (!bytes) return [file.id, []];
+      const own = sha256Hex(bytes);
+      if (file.expect !== "image") return [file.id, [own]];
+      const raster = await toModelSafeImage(bytes).catch(() => null);
+      return [file.id, raster ? [.../* @__PURE__ */ new Set([own, sha256Hex(raster.bytes)])] : [own]];
+    })
+  );
+  return Object.fromEntries(entries);
+}
+function outputsByNode(nodes) {
+  const byNode = {};
+  for (const node of nodes) {
+    const outputs = {};
+    for (const out of node.outputs) {
+      const [slot = "", index] = String(out.slot ?? "").split("#");
+      const { slot: _slot, label: _label, durationMs, ...ref } = out;
+      const asset = { ...ref, ...typeof durationMs === "number" ? { duration_ms: durationMs } : {} };
+      if (index === void 0) outputs[slot] = asset;
+      else {
+        const list = Array.isArray(outputs[slot]) ? outputs[slot] : [];
+        list[Number(index)] = asset;
+        outputs[slot] = list;
+      }
+    }
+    if (Object.keys(outputs).length > 0) byNode[node.nodeId] = outputs;
+  }
+  return byNode;
+}
+async function correctedPicture(canvasRoot, runId, fetchRecord = fetchRunRecord) {
+  try {
+    const manifest = JSON.parse(await readFile(path.join(canvasRoot, runId, "manifest.json"), "utf8"));
+    if (manifest.outputs_by_node) return correctedUrl(manifest.outputs_by_node);
+  } catch {
+  }
+  const record = await fetchRecord(runId).catch(() => null);
+  if (!record) return null;
+  return correctedUrl(
+    Object.fromEntries(record.nodes.map((n) => [n.nodeId, { images: n.outputs, ...n.role ? { role: n.role } : {} }]))
+  );
+}
+function pictureRecord(runId, opts) {
+  const chosen = opts.chose === true || opts.keeps === true && keepsChosen(opts.of, opts.from);
+  return { runId, ...chosen ? { chosen: true } : {}, ...opts.redrawn ? { redrawn: true } : {} };
+}
+function keepsChosen(picture, from) {
+  return picture?.chosen === true && from !== void 0 && picture.runId === from;
+}
+function relaysSizesOnly(canvas, ids) {
+  const roles = rolesById(canvas);
+  const sizing = /* @__PURE__ */ new Set([STATIC_ADAPT_FORMAT_ROLE, STATIC_SIZE_ROLE, STATIC_SAFE_FIT_ROLE]);
+  return ids.length > 0 && ids.every((id) => sizing.has(roles[id] ?? ""));
+}
+var SHA_PREFIX = /^[0-9a-f]{8,64}$/;
+function matchVariant(outputs, sha) {
+  const hits = outputs.filter((o) => typeof o?.sha256 === "string" && o.sha256.startsWith(sha) && typeof o.url === "string");
+  const urls = [...new Set(hits.map((o) => o.url))];
+  return urls.length === 1 ? urls[0] : null;
+}
+async function variantImage(canvasRoot, runId, sha256, fetchRecord = fetchRunRecord, roles = {}) {
+  const sha = sha256.trim().toLowerCase();
+  if (!SHA_PREFIX.test(sha)) return null;
+  try {
+    const manifest = JSON.parse(await readFile(path.join(canvasRoot, runId, "manifest.json"), "utf8"));
+    for (const [id, out] of Object.entries(manifest.outputs_by_node ?? {})) {
+      if (roles[id] !== STATIC_VARIANTS_ROLE) continue;
+      const url = matchVariant(out.images ?? [], sha);
+      if (url) return url;
+    }
+  } catch {
+  }
+  const record = await fetchRecord(runId).catch(() => null);
+  const variants = record?.nodes.find((n) => n.role === STATIC_VARIANTS_ROLE);
+  return variants ? matchVariant(variants.outputs, sha) : null;
+}
+
+// src/commands/canvas/series-member.ts
+import { existsSync } from "fs";
+import { readdir, readFile as readFile2, writeFile } from "fs/promises";
+import path2 from "path";
+var creativeDir = (root, slug) => path2.join(root, "src", "creatives", slug);
+var canvasFile = (root, slug) => path2.join(creativeDir(root, slug), `${slug}.canvas.json`);
+async function seriesFieldsOf(root, slug) {
+  const raw = await readFile2(path2.join(creativeDir(root, slug), "_definition.md"), "utf8").catch(() => null);
+  return raw === null ? {} : parseDefinitionStrategyFields(raw);
+}
+async function seriesLeadOf(root, slug) {
+  return (await seriesFieldsOf(root, slug)).seriesLead ?? null;
+}
+async function translatedInto(root, slug, lead) {
+  const own = (await seriesFieldsOf(root, slug)).language;
+  const leads = (await seriesFieldsOf(root, lead)).language;
+  return own && !(leads && sameTag(own, leads)) ? own : void 0;
+}
+var SERIES_DEPTH = 3;
+async function seriesLeadsAbove(root, slug) {
+  const leads = [];
+  let at = await seriesLeadOf(root, slug);
+  while (at && at !== slug && !leads.includes(at) && leads.length < SERIES_DEPTH) {
+    leads.push(at);
+    at = await seriesLeadOf(root, at);
+  }
+  return leads;
+}
+async function seriesMembers(root, lead) {
+  const slugs = await readdir(path2.join(root, "src", "creatives")).catch(() => []);
+  const members = [];
+  for (const slug of slugs.sort()) {
+    if (slug !== lead && await seriesLeadOf(root, slug) === lead) members.push(slug);
+  }
+  return members;
+}
+function refusal(code, message, fix) {
+  return { refused: { code, message, fix } };
+}
+async function leadVersion(root, lead, fetchRecord = fetchRunRecord) {
+  const file = canvasFile(root, lead);
+  const canvas = existsSync(file) ? JSON.parse(await readFile2(file, "utf8")) : null;
+  if (!canvas || !isStaticAdCanvas(canvas)) {
+    return refusal(
+      "series_lead_not_found",
+      `The lead ad "${lead}" is not a static ad in this workspace.`,
+      "Name a static ad of this workspace as the lead: make it with `baker creatives make <idea>` and render it first."
+    );
+  }
+  const canvasRoot = path2.join(root, "canvas");
+  const state = await readRenderState(canvasRoot, lead);
+  const runId = state.rendered?.runId;
+  if (!runId) {
+    return refusal(
+      "series_lead_not_rendered",
+      `The lead ad "${lead}" has no finished version yet: every ad of its series is made from it.`,
+      `Render the lead first and get it ready: baker canvas run --slug ${lead}. Then make the series.`
+    );
+  }
+  if ((state.blocking ?? []).length > 0) {
+    return refusal(
+      "series_lead_not_ready",
+      `The lead ad "${lead}" still needs fixes (${(state.blocking ?? []).join(" | ")}): the series would copy them.`,
+      `Correct the lead until its verdict is ready (baker canvas run --slug ${lead}, or --fix "<what to change>"), then run the series again.`
+    );
+  }
+  const record = () => fetchRecord(runId).catch(() => null);
+  const picture = await previousAdImage(canvasRoot, runId, record, { ...rolesById(canvas), ...relaidPictureRole(canvas) });
+  const sizes = await deliveredSizes(canvasRoot, runId, canvas, record);
+  if (!picture) {
+    return refusal(
+      "series_lead_not_rendered",
+      `The finished picture of the lead's version (${runId}) is not available.`,
+      `Render the lead again (baker canvas run --slug ${lead}), then run the series.`
+    );
+  }
+  const drawn = state.prompt ?? JSON.parse(await readFile2(path2.join(creativeDir(root, lead), "prompt.json"), "utf8"));
+  const copy = readAdSpec(drawn).copy.map((l) => ({ text: l.text, ...l.role ? { role: l.role } : {} }));
+  return { lead: { slug: lead, runId, copy, picture, sizes }, canvas, spec: drawn };
+}
+async function deliveredSizes(canvasRoot, runId, canvas, record) {
+  const wanted = new Set(nodesWithRole(canvas, STATIC_ADAPT_FORMAT_ROLE).flatMap((n) => formatOfAdaptId(n.id) ?? []));
+  const labels = finalOutputLabelsFromCanvas(canvas);
+  const local = await previousDelivered(canvasRoot, runId, labels?.nodeId ?? "final", labels?.labels ?? [], {
+    prefer: "url"
+  });
+  const found = local.length > 0 ? local : ((await record())?.finalOutputs ?? []).flatMap(
+    (o) => o.label && o.url ? [{ format: o.label, path: o.url }] : []
+  );
+  return Object.fromEntries(found.filter((d) => wanted.has(d.format)).map((d) => [d.format, d.path]));
+}
+function rebaseLeadPaths(canvas, leadDir, memberDir) {
+  const out = structuredClone(canvas);
+  for (const node of out.nodes ?? []) {
+    const key = localPathParam(node);
+    const value = key ? node.params?.[key] : void 0;
+    if (!key || !node.params || typeof value !== "string" || node.id === "prompt" || path2.isAbsolute(value)) continue;
+    const rel = path2.relative(memberDir, path2.resolve(leadDir, value)).split(path2.sep).join("/");
+    node.params[key] = rel.startsWith(".") ? rel : `./${rel}`;
+  }
+  return out;
+}
+var DESIGN_FIELDS = [
+  "scene",
+  "brand",
+  "colors",
+  "references",
+  "logo",
+  "logo_position",
+  "third_party_brands",
+  "formats",
+  "direction"
+];
+function seriesDesignOf(spec) {
+  try {
+    const read = readAdSpec(spec);
+    return JSON.stringify(DESIGN_FIELDS.map((key) => read[key] ?? null));
+  } catch {
+    return null;
+  }
+}
+function withLeadDesign(memberSpec, leadSpec) {
+  const asSpec = (spec) => isAdSpec(spec) ? spec : readAdSpec(spec);
+  const lead = asSpec(leadSpec);
+  const out = { ...asSpec(memberSpec) };
+  for (const key of DESIGN_FIELDS) {
+    if (key in lead) out[key] = lead[key];
+    else delete out[key];
+  }
+  return out;
+}
+function unchangedCopyRefusal(lead, memberSpec) {
+  const words = (copy2) => copy2.map((l) => l.text.trim()).join("\n");
+  let copy;
+  try {
+    copy = readAdSpec(memberSpec).copy;
+  } catch {
+    return null;
+  }
+  if (words(copy) !== words(lead.copy)) return null;
+  return refusal(
+    "series_copy_unchanged",
+    `This ad's words are still the lead's ("${lead.copy[0]?.text ?? ""}"): it would render the lead again.`,
+    "Write this ad's own words in its prompt.json `copy`, one line for each of the lead's (same roles), saying this ad's message. Keep everything else: the design is the lead's."
+  );
+}
+function changedCustomerWordsRefusal(lead, memberSpec) {
+  let copy;
+  try {
+    copy = readAdSpec(memberSpec).copy;
+  } catch {
+    return null;
+  }
+  const said = new Set(copy.map((l) => l.text.trim()));
+  const changed = lead.copy.filter((line, i) => {
+    const below = lead.copy[i + 1];
+    const theirs = isCustomersWords(line) || below !== void 0 && isSignatureLine(below);
+    return theirs && !said.has(line.text.trim());
+  });
+  if (changed.length === 0) return null;
+  return refusal(
+    "series_customer_words_changed",
+    `This translation changed a customer's own words: ${changed.map((l) => `"${l.text}"`).join(", ")} is how they said it, and translated it would be words they never said under their name.`,
+    `Put ${changed.length === 1 ? "that line" : "those lines"} back in this ad's prompt.json exactly as the lead has ${changed.length === 1 ? "it" : "them"}: ${changed.map((l) => `"${l.text}"`).join(", ")}. Translate only the advertiser's own lines.`
+  );
+}
+function designChangedRefusal(lead, leads) {
+  const chain = leads.length > 0 ? leads : [lead];
+  const design = chain[chain.length - 1] ?? lead;
+  const runs = [...chain].reverse().map((l) => `baker canvas run --series ${l}`);
+  return refusal(
+    "series_design_changed",
+    `This ad's design (its scene, colours, pictures or logo in prompt.json) was changed on the ad itself, but every ad of the series has the design of "${design}".`,
+    `Make the change once, on ${design}: edit src/creatives/${design}/prompt.json (or baker canvas run --slug ${design} --fix "<the change>"), then ${runs.join(", then ")}: every ad takes the new design, its own words kept. Only this ad's copy belongs in its own prompt.json.`
+  );
+}
+async function writeSeriesMemberCanvas(root, slug, opts = {}) {
+  const lead = await seriesLeadOf(root, slug);
+  if (!lead) return null;
+  const version = await leadVersion(root, lead, opts.fetchRecord);
+  if ("refused" in version) return version;
+  const dir = creativeDir(root, slug);
+  const promptPath = path2.join(dir, "prompt.json");
+  let memberSpec = JSON.parse(await readFile2(promptPath, "utf8").catch(() => "null"));
+  const unchanged = opts.leadWords ? null : unchangedCopyRefusal(version.lead, memberSpec);
+  if (unchanged) return unchanged;
+  const language = await translatedInto(root, slug, lead);
+  const rewritten = language ? changedCustomerWordsRefusal(version.lead, memberSpec) : null;
+  if (rewritten) return rewritten;
+  const file = canvasFile(root, slug);
+  const before = await readFile2(file, "utf8").catch(() => null);
+  const leadDesign = seriesDesignOf(version.spec);
+  const ownDesign = seriesDesignOf(memberSpec);
+  const previous = before ? JSON.parse(before).metadata?.series : void 0;
+  const synced = previous?.design;
+  let designFromLead = false;
+  if (leadDesign !== null && ownDesign !== null && ownDesign !== leadDesign) {
+    if (!opts.takeLeadDesign && ownDesign !== synced) {
+      return designChangedRefusal(lead, await seriesLeadsAbove(root, slug));
+    }
+    memberSpec = withLeadDesign(memberSpec, version.spec);
+    await writeFile(promptPath, `${JSON.stringify(memberSpec, null, 2)}
+`, "utf8");
+    designFromLead = true;
+  }
+  const canvas = seriesMemberAd(
+    rebaseLeadPaths(version.canvas, creativeDir(root, lead), dir),
+    { ...version.lead, ...leadDesign !== null ? { design: leadDesign } : {} },
+    language ? { language } : {}
+  );
+  const text = `${JSON.stringify(canvas, null, 2)}
+`;
+  if (before !== text) await writeFile(file, text, "utf8");
+  const madeFrom = (await readRenderState(path2.join(root, "canvas"), slug)).seriesLeadRun;
+  const newLeadVersion = madeFrom !== void 0 && madeFrom !== version.lead.runId;
+  return { lead, leadRunId: version.lead.runId, canvasPath: file, written: before !== text, designFromLead, newLeadVersion };
+}
+function seriesRunHints(slug, series) {
+  const leads = series.leads?.length ? series.leads : series.lead ? [series.lead] : [];
+  const root = leads[leads.length - 1];
+  if (root) {
+    const runs = [...leads].reverse().map((lead) => `baker canvas run --series ${lead}`);
+    return [
+      `This ad is one of the series led by ${leads[0]}: its picture is ${root}'s with its own words. A change to what every ad shares (the picture, colours, layout, logo) is made once, on ${root} (src/creatives/${root}/prompt.json, or baker canvas run --slug ${root} --fix "<the change>"), then ${runs.join(", then ")}. Correct only this ad's own words or its own defect here.`
+    ];
+  }
+  if (series.members.length === 0) return [];
+  return [
+    `This ad leads a series of ${series.members.length + 1}: baker canvas run --series ${slug} makes ${series.members.join(", ")} again from this version, each with its own words. Until then they show the lead's earlier version; an ad of the series run by itself (baker canvas run --slug ${series.members[0]}) is made from this version too, its design included.`
+  ];
+}
+
+export {
+  runBaker,
+  isStaticAdCanvas,
+  previousAdImage,
+  previousDelivered,
+  versionRun,
+  ingestedNow,
+  correctedPicture,
+  pictureRecord,
+  keepsChosen,
+  relaysSizesOnly,
+  variantImage,
+  seriesLeadsAbove,
+  seriesMembers,
+  leadVersion,
+  writeSeriesMemberCanvas,
+  seriesRunHints
+};
+//# sourceMappingURL=chunk-O4HREVZO.js.map