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

package/dist/chunk-DMEGESTD.js

@@ -0,0 +1,76 @@
+import {
+  MAX_REMOTE_IMAGE_BYTES,
+  fetchExternalBytes
+} from "./chunk-VVS5TLDG.js";
+
+// src/lib/image/io.ts
+import { randomBytes } from "crypto";
+import { glob as fsGlob, readFile, rename, stat, writeFile } from "fs/promises";
+import { dirname, extname, join, resolve } from "path";
+var REMOTE_RE = /^https?:\/\//i;
+var GLOB_RE = /[*?[\]{}]/;
+function isRemoteUrl(value) {
+  return REMOTE_RE.test(value);
+}
+function looksLikeGlob(value) {
+  return GLOB_RE.test(value);
+}
+async function expandInputs(spec) {
+  const parts = spec.split(",").map((p) => p.trim()).filter(Boolean);
+  const out = [];
+  for (const part of parts) {
+    if (isRemoteUrl(part)) {
+      out.push(part);
+      continue;
+    }
+    if (looksLikeGlob(part)) {
+      for await (const match of fsGlob(part)) {
+        if (typeof match === "string") out.push(match);
+      }
+    } else {
+      out.push(part);
+    }
+  }
+  return out;
+}
+async function readImageBuffer(pathOrUrl) {
+  if (isRemoteUrl(pathOrUrl)) {
+    const { buffer } = await fetchExternalBytes(pathOrUrl, { maxBytes: MAX_REMOTE_IMAGE_BYTES });
+    return buffer;
+  }
+  return readFile(pathOrUrl);
+}
+async function isDirectory(path) {
+  try {
+    const s = await stat(path);
+    return s.isDirectory();
+  } catch {
+    return false;
+  }
+}
+async function resolveOutputPath(inputPath, outputArg, options) {
+  const base = options.newExtension ? inputPath.slice(0, -extname(inputPath).length) + options.newExtension : inputPath;
+  if (!outputArg) return base;
+  if (options.multipleInputs || await isDirectory(outputArg)) {
+    const filename = base.split("/").pop() ?? "out.png";
+    return join(outputArg, filename);
+  }
+  return outputArg;
+}
+async function atomicWrite(targetPath, data) {
+  const absolute = resolve(targetPath);
+  const dir = dirname(absolute);
+  const tmp = join(dir, `.baker-image-${randomBytes(8).toString("hex")}.tmp`);
+  await writeFile(tmp, data);
+  await rename(tmp, absolute);
+}
+
+export {
+  isRemoteUrl,
+  expandInputs,
+  readImageBuffer,
+  isDirectory,
+  resolveOutputPath,
+  atomicWrite
+};
+//# sourceMappingURL=chunk-DMEGESTD.js.map

package/dist/chunk-E7XNUDS5.js

@@ -0,0 +1,172 @@
+import {
+  writeAdsOutput
+} from "./chunk-XNMSJP2X.js";
+import {
+  asRecord,
+  shapeListRows
+} from "./chunk-KIGGMKAE.js";
+import {
+  registerSchema
+} from "./chunk-NU7JSWVA.js";
+
+// src/commands/ads/meta/list-rows.ts
+function pick(row, keys) {
+  const picked = {};
+  for (const key of keys) {
+    if (row[key] !== void 0) picked[key] = row[key];
+  }
+  return picked;
+}
+var CAMPAIGN_COLUMNS = ["id", "name", "effective_status", "daily_budget", "lifetime_budget", "created_date"];
+function compactCampaign(row) {
+  const created = row.created_time;
+  return {
+    ...pick(row, ["id", "name", "effective_status", "daily_budget", "lifetime_budget"]),
+    ...typeof created === "string" ? { created_date: created.slice(0, 10) } : {}
+  };
+}
+var ADSET_KEYS = [
+  "id",
+  "name",
+  "campaign_id",
+  "effective_status",
+  "optimization_goal",
+  "billing_event",
+  "bid_strategy",
+  "daily_budget",
+  "lifetime_budget",
+  "destination_type",
+  // A Dynamic Creative ad set refuses every new ad, which changes the plan before anything is staged.
+  "is_dynamic_creative"
+];
+var ADSET_COLUMNS = [...ADSET_KEYS, "learning_stage", "end_time", "created_time"];
+function compactAdSet(row) {
+  const learning = asRecord(row.learning_stage_info)?.status;
+  return {
+    ...pick(row, ADSET_KEYS),
+    ...typeof learning === "string" ? { learning_stage: learning } : {},
+    ...pick(row, ["end_time", "created_time"])
+  };
+}
+var AD_COLUMNS = [
+  "id",
+  "name",
+  "adset_id",
+  "campaign_id",
+  "effective_status",
+  "creative_id",
+  "issues",
+  "created_time"
+];
+function adIssues(value) {
+  if (!Array.isArray(value)) return [];
+  return value.flatMap((entry) => {
+    const issue = asRecord(entry);
+    const text = issue?.error_summary ?? issue?.error_message;
+    return typeof text === "string" && text ? [text] : [];
+  });
+}
+function compactAd(row) {
+  const creativeId = asRecord(row.creative)?.id;
+  const issues = adIssues(row.issues_info);
+  return {
+    ...pick(row, ["id", "name", "adset_id", "campaign_id", "effective_status"]),
+    ...creativeId !== void 0 ? { creative_id: creativeId } : {},
+    ...issues.length > 0 ? { issues } : {},
+    ...pick(row, ["created_time"])
+  };
+}
+var ACTIVITY_COLUMNS = [
+  "event_time",
+  "event_type",
+  "actor_name",
+  "object_type",
+  "object_name",
+  "object_id",
+  "change"
+];
+function isScalar(value) {
+  return value === null || typeof value === "string" || typeof value === "number";
+}
+function activityChange(extraData) {
+  if (typeof extraData !== "string") return void 0;
+  let parsed;
+  try {
+    parsed = JSON.parse(extraData);
+  } catch {
+    return void 0;
+  }
+  const data = asRecord(parsed);
+  if (!data || !("new_value" in data) || !("old_value" in data)) return void 0;
+  const { old_value: before, new_value: after } = data;
+  if (!isScalar(before) || !isScalar(after)) return void 0;
+  const show = (value) => value === null ? "(none)" : String(value);
+  return `${show(before)} \u2192 ${show(after)}`;
+}
+function compactActivity(row) {
+  const change = activityChange(row.extra_data);
+  return {
+    ...pick(row, ["event_time", "event_type", "actor_name", "object_type", "object_name", "object_id"]),
+    ...change !== void 0 ? { change } : {}
+  };
+}
+var PROJECTIONS = {
+  campaigns: { row: compactCampaign, columns: CAMPAIGN_COLUMNS },
+  adsets: { row: compactAdSet, columns: ADSET_COLUMNS },
+  ads: { row: compactAd, columns: AD_COLUMNS },
+  activities: { row: compactActivity, columns: ACTIVITY_COLUMNS }
+};
+function shapeMetaListRows(kind, rows, args) {
+  return shapeListRows(rows, args, PROJECTIONS[kind]);
+}
+var NOUNS = {
+  campaigns: "campaigns",
+  adsets: "ad sets",
+  ads: "ads",
+  activities: "activities"
+};
+function writeMetaListRows(kind, shaped, format, hints = []) {
+  if (format === "md" && shaped.rows.length === 0) {
+    process.stdout.write(`${hints.length > 0 ? hints.join("\n") : `No ${NOUNS[kind]} matched.`}
+`);
+    return;
+  }
+  writeAdsOutput(shaped.rows, format, shaped.fields, [...hints, ...shaped.hints ?? []]);
+}
+var META_LIST_SHAPE_ARGS = {
+  fields: {
+    type: "string",
+    description: "CSV of dotted paths to return instead of the compact row, e.g. id,name,targeting.geo_locations"
+  },
+  full: { type: "boolean", description: "Return every field Meta sent (targeting, tracking specs, raw extra_data)" },
+  output: {
+    type: "string",
+    description: "md|json|csv|jsonl \u2014 md (default) prints a table; json returns the rows in the { ok, data } envelope",
+    default: "md"
+  }
+};
+function registerMetaListSchema(kind, description, args) {
+  registerSchema({
+    command: `ads.meta.${kind}`,
+    description,
+    args: Object.fromEntries(
+      Object.entries(args).map(([name, def]) => [
+        name,
+        {
+          type: def.type,
+          description: def.description ?? "",
+          required: false,
+          ...def.default !== void 0 ? { default: def.default } : {}
+        }
+      ])
+    )
+  });
+}
+
+export {
+  shapeMetaListRows,
+  writeMetaListRows,
+  META_LIST_SHAPE_ARGS,
+  registerMetaListSchema
+};
+//# sourceMappingURL=chunk-E7XNUDS5.js.map

package/dist/chunk-EA5DXYCF.js

@@ -0,0 +1,304 @@
+import {
+  languageTag
+} from "./chunk-5HWY4R7Y.js";
+import {
+  parseRefExpr
+} from "./chunk-ERVDEVLC.js";
+import {
+  AWARENESS_VALUES
+} from "./chunk-5HYSKH77.js";
+import {
+  collectAssetRefLikes,
+  isPersistedAssetRef
+} from "./chunk-DIJBHIII.js";
+
+// src/commands/canvas/creative-definition.ts
+import { parseDocument } from "yaml";
+var PLATFORM_VALUES = ["meta", "google", "linkedin", "tiktok", "youtube", "x", "other"];
+var FORMAT_VALUES = ["1:1", "4:5", "9:16", "16:9", "1.91:1"];
+var EVIDENCE_VALUES = ["observed", "interpreted", "hypothesized", "generated"];
+function titleFromSlug(slug) {
+  const title = slug.split("-").filter(Boolean).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+  return title || slug;
+}
+function resolvePlatform(platform) {
+  const value = platform?.trim();
+  return value && PLATFORM_VALUES.includes(value) ? value : "meta";
+}
+function resolveFormats(aspect) {
+  const value = aspect?.trim();
+  return value && FORMAT_VALUES.includes(value) ? [value] : ["4:5"];
+}
+function resolveFormatList(formats) {
+  const valid = [...new Set(formats.map((f) => f.trim()))].filter(
+    (f) => FORMAT_VALUES.includes(f)
+  );
+  return valid.length > 0 ? valid : ["4:5"];
+}
+function describeBlueprintIntent(blueprint) {
+  const intent = blueprint?.ad_intent;
+  if (typeof intent === "string" && intent.trim()) return intent.trim();
+  if (intent && typeof intent === "object") {
+    const summary = intent.summary ?? intent.feeling;
+    if (typeof summary === "string" && summary.trim()) return summary.trim();
+  }
+  return void 0;
+}
+function yamlScalar(value) {
+  return JSON.stringify(value);
+}
+function buildCreativeDefinition(input) {
+  const lines = ["---", `title: ${yamlScalar(input.title)}`, `kind: ${input.kind}`, `platform: ${input.platform}`];
+  lines.push(`formats: [${input.formats.map(yamlScalar).join(", ")}]`);
+  lines.push(`status: ${input.status ?? "draft"}`);
+  if (input.sourceReferenceUrl) lines.push(`sourceReferenceUrl: ${yamlScalar(input.sourceReferenceUrl)}`);
+  if (input.sourceAdvertiser) lines.push(`sourceAdvertiser: ${yamlScalar(input.sourceAdvertiser)}`);
+  if (input.sourceAdvertiserId) lines.push(`sourceAdvertiserId: ${yamlScalar(input.sourceAdvertiserId)}`);
+  if (input.sourceAdId) lines.push(`sourceAdId: ${yamlScalar(input.sourceAdId)}`);
+  if (input.sourcePlatform) lines.push(`sourcePlatform: ${input.sourcePlatform}`);
+  if (input.sourceKind) lines.push(`sourceKind: ${input.sourceKind}`);
+  if (input.sourcePath) lines.push(`sourcePath: ${yamlScalar(input.sourcePath)}`);
+  if (input.targetAdSet) lines.push(`targetAdSet: ${yamlScalar(input.targetAdSet)}`);
+  if (input.viewer) lines.push(`viewer: ${JSON.stringify(input.viewer)}`);
+  lines.push("---", "");
+  lines.push(input.description?.trim() || `${input.title} \u2014 canvas-built ${input.kind} ad for ${input.platform}.`);
+  lines.push("");
+  return lines.join("\n");
+}
+var SOURCE_FIELD_KEYS = ["sourceAdId", "sourcePlatform", "sourceAdvertiserId"];
+function parseDefinitionSourceFields(raw) {
+  const match = raw.match(/^---\r?\n([\s\S]*?\r?\n)?---/);
+  if (!match) return {};
+  const doc = parseDocument(match[1] ?? "");
+  if (doc.errors.length > 0) return {};
+  const fields = {};
+  for (const key of SOURCE_FIELD_KEYS) {
+    const value = doc.get(key);
+    if (typeof value === "string" && value.trim()) fields[key] = value.trim();
+  }
+  return fields;
+}
+function oneOf(values, value) {
+  return values.find((allowed) => allowed === value);
+}
+function parseDefinitionStrategyFields(raw) {
+  const match = raw.match(/^---\r?\n([\s\S]*?\r?\n)?---/);
+  if (!match) return {};
+  const doc = parseDocument(match[1] ?? "");
+  if (doc.errors.length > 0) return {};
+  const text = (key) => {
+    const value = doc.get(key);
+    return typeof value === "string" && value.trim() ? value.trim() : void 0;
+  };
+  const ideaSlug = text("idea");
+  const message = text("message");
+  const evidence = oneOf(EVIDENCE_VALUES, text("evidence"));
+  const angle = text("angle");
+  const persona = text("persona");
+  const awareness = oneOf(AWARENESS_VALUES, text("awareness"));
+  const hypothesis = text("hypothesis");
+  const seriesLead = text("series");
+  const language = languageTag(text("language") ?? "");
+  return {
+    ...seriesLead ? { seriesLead } : {},
+    ...language ? { language } : {},
+    ...ideaSlug ? { ideaSlug } : {},
+    ...message ? { message } : {},
+    ...evidence ? { evidence } : {},
+    ...angle ? { angle } : {},
+    ...persona ? { persona } : {},
+    ...awareness ? { awareness } : {},
+    ...hypothesis ? { hypothesis } : {}
+  };
+}
+function parseDefinitionSeriesPlace(raw) {
+  const match = raw.match(/^---\r?\n([\s\S]*?\r?\n)?---/);
+  if (!match || parseDocument(match[1] ?? "").errors.length > 0) return null;
+  const { seriesLead, language } = parseDefinitionStrategyFields(raw);
+  return { seriesLead: seriesLead ?? null, language: language ?? null };
+}
+function parseDefinitionViewerFields(raw) {
+  const match = raw.match(/^---\r?\n([\s\S]*?\r?\n)?---/);
+  if (!match) return {};
+  const doc = parseDocument(match[1] ?? "");
+  if (doc.errors.length > 0) return {};
+  const data = doc.toJS();
+  const adSet = data?.targetAdSet;
+  const targetAdSet = typeof adSet === "string" || typeof adSet === "number" ? String(adSet).trim() : "";
+  return {
+    ...targetAdSet ? { targetAdSet } : {},
+    ...data?.viewer !== void 0 ? { viewer: data.viewer } : {}
+  };
+}
+function setDefinitionViewer(raw, fields) {
+  const match = raw.match(/^---\r?\n([\s\S]*?\r?\n)?---/);
+  if (!match) return raw;
+  const doc = parseDocument(match[1] ?? "");
+  if (doc.errors.length > 0) return raw;
+  if (fields.targetAdSet) doc.set("targetAdSet", fields.targetAdSet);
+  if (fields.viewer) doc.set("viewer", doc.createNode(fields.viewer, { flow: true }));
+  return `---
+${doc.toString()}---${raw.slice(match[0].length)}`;
+}
+
+// src/commands/canvas/run-record.ts
+import path from "path";
+var MAX_RUN_NODES = 200;
+var MAX_OUTPUTS_PER_NODE = 10;
+var MAX_FINAL_OUTPUTS = 10;
+var MAX_CREATIVE_SLUG_LENGTH = 100;
+function creativeSlugFromCanvasPath(filePath) {
+  const normalized = filePath.split(path.sep).join("/");
+  const match = normalized.match(/(?:^|\/)src\/creatives\/([a-z0-9](?:[a-z0-9-]*[a-z0-9])?)\//);
+  const slug = match?.[1] ?? null;
+  return slug && slug.length <= MAX_CREATIVE_SLUG_LENGTH ? slug : null;
+}
+function finalOutputLabelsFromCanvas(parsed) {
+  const canvas = parsed;
+  const outputNodeId = canvas?.output?.node;
+  if (typeof outputNodeId !== "string" || !Array.isArray(canvas?.nodes)) return null;
+  const node = canvas.nodes.find((n) => n?.id === outputNodeId);
+  if (node?.type !== "collect") return null;
+  const explicit = node.params?.labels;
+  if (Array.isArray(explicit) && explicit.every((l) => typeof l === "string")) {
+    return { nodeId: outputNodeId, labels: explicit };
+  }
+  const images = node.inputs?.images;
+  if (!Array.isArray(images)) return null;
+  const labels = images.map((entry) => {
+    if (typeof entry !== "string") return void 0;
+    return parseRefExpr(entry)?.nodeId;
+  });
+  return { nodeId: outputNodeId, labels };
+}
+var OUTPUT_KINDS = /* @__PURE__ */ new Set(["image", "video", "audio", "json", "text", "font"]);
+function toRecordOutput(slot, value, label) {
+  const refs = collectAssetRefLikes(value);
+  const ref = refs.length === 1 ? refs[0] : null;
+  if (!ref || !isPersistedAssetRef(ref)) return null;
+  const kind = typeof ref.kind === "string" && OUTPUT_KINDS.has(ref.kind) ? ref.kind : null;
+  if (!kind) return null;
+  return {
+    slot,
+    label,
+    kind,
+    sha256: ref.sha256,
+    url: ref.url,
+    mime: ref.mime,
+    width: typeof ref.width === "number" ? ref.width : void 0,
+    height: typeof ref.height === "number" ? ref.height : void 0,
+    durationMs: typeof ref.duration_ms === "number" ? ref.duration_ms : void 0
+  };
+}
+function nodeOutputsToRecord(nodeOutputs, labels) {
+  const out = [];
+  for (const [slot, value] of Object.entries(nodeOutputs)) {
+    if (Array.isArray(value)) {
+      value.forEach((item, i) => {
+        const rec = toRecordOutput(`${slot}#${i}`, item, labels?.[i]);
+        if (rec) out.push(rec);
+      });
+    } else {
+      const rec = toRecordOutput(slot, value);
+      if (rec) out.push(rec);
+    }
+  }
+  return out.slice(0, MAX_OUTPUTS_PER_NODE);
+}
+function finalOutputsToRecord(output, labels) {
+  if (Array.isArray(output)) {
+    return output.map((item, i) => toRecordOutput(`final#${i}`, item, labels?.[i])).filter((rec2) => rec2 !== null).slice(0, MAX_FINAL_OUTPUTS);
+  }
+  const rec = toRecordOutput("final", output);
+  return rec ? [rec] : [];
+}
+function finalFiles(output, labels) {
+  const items = Array.isArray(output) ? output : [output];
+  const files = {};
+  items.forEach((item, i) => {
+    const ref = collectAssetRefLikes(item)[0];
+    if (ref && typeof ref.path === "string") files[labels?.[i] ?? `final#${i}`] = ref.path;
+  });
+  return files;
+}
+function buildRunRecord(result, meta, plan, finalLabels) {
+  const nodes = result.node_runs.slice(0, MAX_RUN_NODES).map((run) => {
+    const planned = plan?.get(run.node_id);
+    return {
+      nodeId: run.node_id,
+      nodeType: run.node_type,
+      cached: run.cached,
+      credits: run.credits,
+      durationMs: run.duration_ms,
+      outputs: nodeOutputsToRecord(
+        result.outputs_by_node[run.node_id] ?? {},
+        run.node_id === finalLabels?.nodeId ? finalLabels.labels : void 0
+      ),
+      deps: planned?.deps,
+      status: plan ? "completed" : void 0,
+      paramsPreview: planned?.paramsPreview,
+      ...planned?.role !== void 0 ? { role: planned.role } : {}
+    };
+  });
+  const finalOutputs = finalOutputsToRecord(result.output, finalLabels?.labels);
+  return {
+    runId: result.run_id,
+    ...meta,
+    status: "completed",
+    stats: {
+      totalNodes: result.stats.total_nodes,
+      cachedNodes: result.stats.cached_nodes,
+      totalCredits: result.stats.total_credits,
+      durationMs: result.stats.duration_ms
+    },
+    nodes,
+    finalOutputs: finalOutputs.length > 0 ? finalOutputs : void 0,
+    // Sent whenever the review RAN, empty list included. Sending it only when there
+    // were findings makes a clean render and an unreviewed one look identical in the
+    // record — which is the exact ambiguity this field was added to remove: proving a
+    // review had happened once meant re-running a cached canvas and reading raw JSON.
+    // Only the fields the backend keeps: a static review's typed fields (`kind`) stay in the CLI.
+    ...meta.review ? { review: meta.review.slice(0, 40).map(({ severity, what, scene }) => ({ severity, what, ...scene ? { scene } : {} })) } : {}
+  };
+}
+function buildInitialRunRecord(runId, meta) {
+  return {
+    runId,
+    ...meta,
+    status: "running",
+    stats: { totalNodes: 0, cachedNodes: 0, totalCredits: 0, durationMs: 0 },
+    nodes: []
+  };
+}
+function buildFailedRunRecord(runId, errorMessage, meta) {
+  return {
+    runId,
+    ...meta,
+    status: "failed",
+    errorMessage: errorMessage.slice(0, 2e3),
+    stats: { totalNodes: 0, cachedNodes: 0, totalCredits: 0, durationMs: 0 },
+    nodes: []
+  };
+}
+
+export {
+  titleFromSlug,
+  resolvePlatform,
+  resolveFormats,
+  resolveFormatList,
+  describeBlueprintIntent,
+  buildCreativeDefinition,
+  parseDefinitionSourceFields,
+  parseDefinitionStrategyFields,
+  parseDefinitionSeriesPlace,
+  parseDefinitionViewerFields,
+  setDefinitionViewer,
+  creativeSlugFromCanvasPath,
+  finalOutputLabelsFromCanvas,
+  nodeOutputsToRecord,
+  finalFiles,
+  buildRunRecord,
+  buildInitialRunRecord,
+  buildFailedRunRecord
+};
+//# sourceMappingURL=chunk-EA5DXYCF.js.map