@koda-sl/baker-cli 0.510.0 → 0.512.0-dev.8a743a629

package/dist/chunk-4CBYHH33.js

@@ -0,0 +1,275 @@
+import {
+  FLOW_ACCOUNT_ONLY_KINDS,
+  FLOW_AGENT_DESTINATION_KINDS,
+  FLOW_DELIVERY_SIDE_EFFECT_TYPES,
+  FLOW_RESOURCE_NODE_TYPES,
+  FLOW_SECRET_FIELDS,
+  flowCatalogEntry,
+  isFlowOauthSideEffect
+} from "./chunk-7D7YRHN3.js";
+import {
+  apiPost
+} from "./chunk-X7VQFLHI.js";
+import {
+  writeJson
+} from "./chunk-Q7US4OOA.js";
+
+// src/commands/flows/shared.ts
+import { existsSync, readdirSync, readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+var FLOWS_DIR = "src/lib/flow-engine/flows";
+function flowsDir() {
+  let dir = process.cwd();
+  for (let i = 0; i < 6; i++) {
+    const candidate = join(dir, FLOWS_DIR);
+    if (existsSync(candidate)) {
+      return candidate;
+    }
+    const parent = join(dir, "..");
+    if (parent === dir) {
+      break;
+    }
+    dir = parent;
+  }
+  return join(process.cwd(), FLOWS_DIR);
+}
+function failLocal(message) {
+  writeJson({ ok: false, error: { code: "NOT_FOUND", message } });
+  process.exit(1);
+}
+function listFlowSlugs() {
+  const dir = flowsDir();
+  if (!existsSync(dir)) {
+    return [];
+  }
+  return readdirSync(dir, { withFileTypes: true }).filter((entry) => entry.isDirectory() && !entry.name.startsWith("_") && entry.name !== ".gitkeep").map((entry) => entry.name).sort();
+}
+function flowDataPath(slug) {
+  return join(flowsDir(), slug, "_data.json");
+}
+function writeFlowTree(slug, tree) {
+  writeFileSync(flowDataPath(slug), `${JSON.stringify(tree, null, 2)}
+`, "utf-8");
+}
+function walkNodes(node, acc = []) {
+  if (!node || typeof node !== "object") return acc;
+  acc.push(node);
+  if (Array.isArray(node.children)) {
+    for (const child of node.children) walkNodes(child, acc);
+  }
+  return acc;
+}
+function collectSideEffects(tree) {
+  return walkNodes(tree).flatMap(
+    (node) => Array.isArray(node.sideEffects) ? node.sideEffects.filter((sideEffect) => Boolean(sideEffect) && typeof sideEffect === "object").map((sideEffect) => ({ node, sideEffect })) : []
+  );
+}
+function sealedSideEffects(tree) {
+  return collectSideEffects(tree).flatMap(({ sideEffect }) => {
+    const { id, type, encryptedConfig } = sideEffect;
+    const sealed = typeof id === "string" && typeof type === "string" && FLOW_DELIVERY_SIDE_EFFECT_TYPES.includes(type) && typeof encryptedConfig === "string" && encryptedConfig.length > 0;
+    return sealed ? [{ sideEffectId: id, type, encryptedConfig }] : [];
+  });
+}
+function describeSettings(settings) {
+  if (typeof settings.email === "string") {
+    return `to ${settings.email}${typeof settings.subject === "string" ? ` \xB7 subject "${settings.subject}"` : ""}`;
+  }
+  return Object.entries(settings).filter(([, value]) => typeof value === "string" || typeof value === "number").map(([key, value]) => `${key}: ${String(value)}`).join(" \xB7 ");
+}
+function withSettings(rows, settingsById) {
+  return rows.map((row) => {
+    const settings = row.sideEffectId ? settingsById[row.sideEffectId] : void 0;
+    const described = settings ? describeSettings(settings) : "";
+    return described ? { ...row, status: `${row.status} \u2192 ${described}` } : row;
+  });
+}
+function flowExists(slug) {
+  return existsSync(join(flowsDir(), slug, "_data.json"));
+}
+function readFlowTree(slug) {
+  const path = join(flowsDir(), slug, "_data.json");
+  if (!existsSync(path)) {
+    failLocal(`No form "${slug}". Run "baker flows list" to see the forms in this workspace.`);
+  }
+  try {
+    return JSON.parse(readFileSync(path, "utf-8"));
+  } catch (error) {
+    failLocal(`Could not read form "${slug}": ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+function isConfigured(value) {
+  return typeof value === "string" && value.length > 0;
+}
+function nodeMeta(record) {
+  const nodeId = typeof record.id === "string" ? record.id : "";
+  const nodeName = typeof record.name === "string" ? record.name : void 0;
+  return { nodeId, ...nodeName ? { nodeName } : {} };
+}
+function widgetNodeStatus(record, meta) {
+  const nodeData = record.nodeData;
+  const nodeType = nodeData?.type;
+  if (typeof nodeType !== "string" || !FLOW_RESOURCE_NODE_TYPES.includes(nodeType)) {
+    return null;
+  }
+  const external = nodeData?.form?.external;
+  const selected = external != null && typeof external === "object";
+  const name = selected ? external.name : void 0;
+  return {
+    ...meta,
+    target: "node",
+    kind: nodeType,
+    status: selected ? `${nodeType} \u2014 selected${typeof name === "string" ? ` "${name}"` : ""}` : `${nodeType} \u2014 not selected`,
+    needsInput: !selected
+  };
+}
+function sideEffectNeedsInput(raw) {
+  const effect = raw;
+  const type = effect?.type;
+  if (typeof type !== "string" || !FLOW_DELIVERY_SIDE_EFFECT_TYPES.includes(type)) {
+    return false;
+  }
+  const configured = isConfigured(effect?.encryptedConfig);
+  if (!isFlowOauthSideEffect(type)) return !configured;
+  return !isConfigured(effect?.oauthProviderId) || !configured;
+}
+function trackingStatus(effect, type, meta) {
+  if (flowCatalogEntry("side-effect", type)?.owners?.tagIds !== "tags") return null;
+  const tags = Array.isArray(effect.tagIds) ? effect.tagIds.length : 0;
+  const event = typeof effect.eventName === "string" ? ` "${effect.eventName}"` : "";
+  return {
+    ...meta,
+    target: "sideEffect",
+    ...typeof effect.id === "string" ? { sideEffectId: effect.id } : {},
+    kind: type,
+    status: `${type}${event} \u2014 ${tags > 0 ? `[${tags} tag${tags === 1 ? "" : "s"}]` : "[no tag]"}`,
+    needsInput: false
+  };
+}
+function sideEffectStatus(raw, meta) {
+  const effect = raw;
+  const type = effect?.type;
+  if (typeof type !== "string") return null;
+  if (!FLOW_DELIVERY_SIDE_EFFECT_TYPES.includes(type)) {
+    return effect ? trackingStatus(effect, type, meta) : null;
+  }
+  const configured = isConfigured(effect?.encryptedConfig);
+  const oauth = isFlowOauthSideEffect(type);
+  const connected = isConfigured(effect?.oauthProviderId);
+  const needs = FLOW_SECRET_FIELDS[type];
+  const status = oauth ? `${type} \u2014 connection ${connected ? "[connected]" : "[needs connection]"}, config ${configured ? "[set]" : "[missing]"}` : configured ? `${type} \u2014 [configured]` : `${type} \u2014 [missing]${needs.length > 0 ? ` (needs: ${needs.join(", ")})` : ""}`;
+  return {
+    ...meta,
+    target: "sideEffect",
+    ...typeof effect?.id === "string" ? { sideEffectId: effect.id } : {},
+    kind: type,
+    status,
+    needsInput: sideEffectNeedsInput(effect)
+  };
+}
+function requestFlowInputCall(slug, status) {
+  const args = status.target === "node" ? `{ target: "node", flowSlug: "${slug}", nodeId: "${status.nodeId}", nodeType: "${status.kind}" }` : `{ target: "sideEffect", flowSlug: "${slug}", nodeId: "${status.nodeId}", sideEffectId: "${status.sideEffectId}", sideEffectType: "${status.kind}" }`;
+  const card = `request_flow_input with ${args}`;
+  const target = status.target === "node" ? `--node ${status.nodeId}` : `--side-effect ${status.sideEffectId}`;
+  const fallback = "only if nothing is connected or several could be meant";
+  if (status.kind === "email") {
+    return `baker flows connect ${slug} ${target} --email "<who receives each lead, comma-separated>" --subject "<New lead \u2014 the Form's name>"`;
+  }
+  if (status.kind === "httpWebhook") {
+    return `baker flows connect ${slug} ${target} --url <https address> \u2014 only a webhook that needs a token or password goes to the user: ${card}`;
+  }
+  if (status.kind === "hubspotForm") {
+    return `baker flows connect ${slug} ${target} --hubspot-form <formId from baker hubspot forms list> \u2014 ${fallback}: ${card}`;
+  }
+  if (status.kind === "hubspot" || status.kind === "hubspotMeeting") {
+    const list = status.kind === "hubspot" ? "forms view <id>" : "meetings view <slug>";
+    return `write \`baker hubspot ${list} --as-node\` into the step's form.external \u2014 ${fallback}: ${card}`;
+  }
+  if (FLOW_ACCOUNT_ONLY_KINDS.includes(status.kind)) {
+    return `baker flows connect ${slug} ${target} \u2014 ${fallback}: ${card}`;
+  }
+  if (FLOW_AGENT_DESTINATION_KINDS.includes(status.kind)) {
+    const sheet = status.kind === "googleSpreadsheet" ? ' (or --new-sheet "<title>" --columns "\u2026")' : "";
+    return `baker flows connect ${slug} ${target} --resource <id from baker flows options ${status.kind}>${sheet} \u2014 ${fallback}: ${card}`;
+  }
+  return card;
+}
+function collectConfigStatus(node, acc) {
+  if (!node || typeof node !== "object") {
+    return;
+  }
+  const record = node;
+  const meta = nodeMeta(record);
+  const widget = widgetNodeStatus(record, meta);
+  if (widget) {
+    acc.push(widget);
+  }
+  if (Array.isArray(record.sideEffects)) {
+    for (const raw of record.sideEffects) {
+      const status = sideEffectStatus(raw, meta);
+      if (status) {
+        acc.push(status);
+      }
+    }
+  }
+  if (Array.isArray(record.children)) {
+    for (const child of record.children) {
+      collectConfigStatus(child, acc);
+    }
+  }
+}
+function redactTree(node) {
+  if (Array.isArray(node)) {
+    return node.map(redactTree);
+  }
+  if (!node || typeof node !== "object") {
+    return node;
+  }
+  const out = {};
+  for (const [key, value] of Object.entries(node)) {
+    if (key === "encryptedConfig") {
+      out[key] = isConfigured(value) ? "[configured]" : value;
+    } else {
+      out[key] = redactTree(value);
+    }
+  }
+  return out;
+}
+function stepNameKey(name) {
+  return name.replace(/([a-z])([A-Z])/g, "$1_$2").replace(/[-\s]+/g, "_").toUpperCase();
+}
+function isUsableStepNameKey(key) {
+  return /^[\p{ID_Start}$_][\p{ID_Continue}$‌‍]*$/u.test(key);
+}
+async function readSettings(tree) {
+  const sealed = sealedSideEffects(tree);
+  if (sealed.length === 0) return {};
+  try {
+    const { data } = await apiPost("/api/flows/destinations/reveal", {
+      items: sealed.map(({ type, encryptedConfig }) => ({ type, encryptedConfig }))
+    });
+    return Object.fromEntries(sealed.map((item, index) => [item.sideEffectId, data.items[index] ?? null]));
+  } catch {
+    return null;
+  }
+}
+
+export {
+  flowsDir,
+  listFlowSlugs,
+  flowDataPath,
+  writeFlowTree,
+  walkNodes,
+  collectSideEffects,
+  withSettings,
+  flowExists,
+  readFlowTree,
+  sideEffectNeedsInput,
+  requestFlowInputCall,
+  collectConfigStatus,
+  redactTree,
+  stepNameKey,
+  isUsableStepNameKey,
+  readSettings
+};
+//# sourceMappingURL=chunk-4CBYHH33.js.map

package/dist/chunk-4IHWT7PH.js

@@ -0,0 +1,167 @@
+import {
+  parseRefExpr
+} from "./chunk-AULSX5ZA.js";
+import {
+  collectAssetRefLikes,
+  isPersistedAssetRef
+} from "./chunk-FOMFU2RX.js";
+
+// 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_NODE_FACTS_CHARS = 4096;
+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 withFacts(nodeOutputs) {
+  const facts = nodeOutputs.facts;
+  if (facts === void 0 || facts === null) return {};
+  const json = JSON.stringify(facts);
+  return json.length <= MAX_NODE_FACTS_CHARS ? { facts: json } : {};
+}
+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 } : {},
+      ...withFacts(result.outputs_by_node[run.node_id] ?? {})
+    };
+  });
+  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 {
+  creativeSlugFromCanvasPath,
+  finalOutputLabelsFromCanvas,
+  nodeOutputsToRecord,
+  finalFiles,
+  withFacts,
+  buildRunRecord,
+  buildInitialRunRecord,
+  buildFailedRunRecord
+};
+//# sourceMappingURL=chunk-4IHWT7PH.js.map

package/dist/chunk-5FON5DHA.js

@@ -0,0 +1,103 @@
+import {
+  SITE_COLLECTION_MODES,
+  SITE_CONSENT_MODES,
+  SITE_HOME_MODES
+} from "./chunk-7D7YRHN3.js";
+import {
+  ApiError
+} from "./chunk-X7VQFLHI.js";
+import {
+  writeJson
+} from "./chunk-Q7US4OOA.js";
+
+// src/commands/site/setArgs.ts
+var SiteArgsError = class extends Error {
+};
+function oneOf(flag, value, allowed) {
+  if (!allowed.includes(value)) {
+    throw new SiteArgsError(`--${flag} must be one of: ${allowed.join(", ")}`);
+  }
+  return value;
+}
+function onOff(flag, value) {
+  if (value === "on" || value === "true") return true;
+  if (value === "off" || value === "false") return false;
+  throw new SiteArgsError(`--${flag} must be on or off`);
+}
+function parseProfile(raw, readFile) {
+  const text = raw.startsWith("@") ? readFile(raw.slice(1)) : raw;
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    throw new SiteArgsError("--export-profile must be JSON, or @path to a JSON file");
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    throw new SiteArgsError("--export-profile must be a JSON object");
+  }
+  return parsed;
+}
+function parseSetArgs(args, readFile) {
+  const inputs = [];
+  if (args.consent !== void 0) {
+    inputs.push({ setting: "consent", mode: oneOf("consent", args.consent, SITE_CONSENT_MODES) });
+  }
+  if (args.collection !== void 0) {
+    const mode = oneOf("collection", args.collection, SITE_COLLECTION_MODES);
+    inputs.push({
+      setting: "analyticsCollection",
+      mode,
+      ...args.payloads === void 0 ? {} : { payloads: onOff("payloads", args.payloads) }
+    });
+  } else if (args.payloads !== void 0) {
+    throw new SiteArgsError("--payloads goes with --collection, e.g. --collection full --payloads off");
+  }
+  if (args.indexing !== void 0) {
+    inputs.push({ setting: "indexing", enabled: onOff("indexing", args.indexing) });
+  }
+  if (args.home !== void 0) {
+    const slug = args.home.trim().replace(/^\/+|\/+$/g, "");
+    inputs.push(
+      slug === "none" || slug === "" ? { setting: "homePage", override: null } : {
+        setting: "homePage",
+        override: { mode: oneOf("home-mode", args["home-mode"] ?? "rewrite", SITE_HOME_MODES), slug }
+      }
+    );
+  } else if (args["home-mode"] !== void 0) {
+    throw new SiteArgsError("--home-mode goes with --home <landing slug>");
+  }
+  if (args.timezone !== void 0) {
+    inputs.push({ setting: "timezone", timezone: args.timezone });
+  }
+  if (args["export-profile"] !== void 0) {
+    inputs.push({ setting: "exportProfile", profile: parseProfile(args["export-profile"], readFile) });
+  }
+  if (inputs.length === 0) {
+    throw new SiteArgsError(
+      "Nothing to stage. Pass at least one of --consent, --collection, --indexing, --home, --timezone, --export-profile."
+    );
+  }
+  return inputs;
+}
+
+// src/commands/site/shared.ts
+function failSite(err) {
+  if (err instanceof SiteArgsError) {
+    writeJson({ ok: false, error: { code: "VALIDATION_ERROR", message: err.message } });
+  } else if (err instanceof ApiError) {
+    writeJson({ ok: false, error: { code: err.code, message: err.message } });
+  } else {
+    writeJson({
+      ok: false,
+      error: { code: "INTERNAL_ERROR", message: err instanceof Error ? err.message : "Unexpected error" }
+    });
+  }
+  process.exit(1);
+}
+
+export {
+  SiteArgsError,
+  parseSetArgs,
+  failSite
+};
+//# sourceMappingURL=chunk-5FON5DHA.js.map