@koda-sl/baker-cli 0.442.0 → 0.443.0-dev.043c1d4ac

package/dist/chunk-K3PN7TN5.js

@@ -0,0 +1,84 @@
+import {
+  findWorkspaceRoot
+} from "./chunk-HIPDMQZ6.js";
+
+// src/commands/canvas/unbilled-spend.ts
+import { randomUUID } from "crypto";
+import { mkdir, readdir, readFile, rename, unlink, writeFile } from "fs/promises";
+import path from "path";
+import { z } from "zod";
+var DIR = "unbilled-spend";
+var Held = z.array(
+  z.object({ model: z.string(), inputTokens: z.number(), outputTokens: z.number(), costUsd: z.number() })
+);
+async function holdUnbilledSpend(cacheDir, usage) {
+  if (usage.length === 0) return;
+  const dir = path.join(cacheDir, DIR);
+  await mkdir(dir, { recursive: true });
+  await writeFile(path.join(dir, `${Date.now()}-${randomUUID()}.json`), JSON.stringify(usage), "utf8");
+}
+async function holdWorkspaceSpend(usage) {
+  const root = findWorkspaceRoot(process.cwd()) ?? process.cwd();
+  await holdUnbilledSpend(path.join(root, "canvas", ".cache"), usage).catch(() => {
+  });
+}
+async function takeUnbilledSpend(cacheDir) {
+  const dir = path.join(cacheDir, DIR);
+  const files = await readdir(dir).catch(() => []);
+  const byModel = /* @__PURE__ */ new Map();
+  for (const file of files.filter((f) => f.endsWith(".json"))) {
+    const claimed = path.join(dir, `${file}.${randomUUID()}.taken`);
+    try {
+      await rename(path.join(dir, file), claimed);
+    } catch {
+      continue;
+    }
+    const parsed = Held.safeParse(await readFile(claimed, "utf8").then(JSON.parse, () => null).catch(() => null));
+    await unlink(claimed).catch(() => {
+    });
+    for (const call of parsed.success ? parsed.data : []) {
+      const sum = byModel.get(call.model);
+      byModel.set(
+        call.model,
+        sum ? {
+          model: call.model,
+          inputTokens: sum.inputTokens + call.inputTokens,
+          outputTokens: sum.outputTokens + call.outputTokens,
+          costUsd: sum.costUsd + call.costUsd
+        } : { ...call }
+      );
+    }
+  }
+  return [...byModel.values()];
+}
+async function sendBillingSpend(cacheDir, usage, send) {
+  try {
+    await send();
+    return null;
+  } catch (e) {
+    await holdUnbilledSpend(cacheDir, usage).catch(() => {
+    });
+    return e instanceof Error ? e.message : String(e);
+  }
+}
+function holdWhenSettled(cacheDir, spendOf) {
+  const pending = [];
+  return {
+    settled: (run, outputs) => {
+      pending.push(holdUnbilledSpend(cacheDir, spendOf(run, outputs)).catch(() => {
+      }));
+    },
+    drained: async () => {
+      await Promise.all(pending);
+    }
+  };
+}
+
+export {
+  holdUnbilledSpend,
+  holdWorkspaceSpend,
+  takeUnbilledSpend,
+  sendBillingSpend,
+  holdWhenSettled
+};
+//# sourceMappingURL=chunk-K3PN7TN5.js.map

package/dist/chunk-K3PN7TN5.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/commands/canvas/unbilled-spend.ts"],"sourcesContent":["/**\n * Gateway spend the CLI made with no run record to carry it: the viewer check run on its\n * own (`baker canvas viewer-check`) or one that refused the render before any run existed.\n *\n * The run record's `reviewUsage` is how a call made in the Runtime reaches the credits\n * ledger (`POST /api/canvas/runs` bills it once, when the terminal record is accepted). So\n * the spend waits here, in the workspace's canvas cache, and the next run record of this\n * workspace takes it. One file per hold and a rename to claim it: two processes never take\n * the same call, and a hold never overwrites another.\n */\nimport { randomUUID } from \"node:crypto\";\nimport { mkdir, readdir, readFile, rename, unlink, writeFile } from \"node:fs/promises\";\nimport path from \"node:path\";\nimport { z } from \"zod\";\nimport type { NodeRunRecord } from \"../../engine/engine/executor.ts\";\nimport type { ReviewUsage } from \"../../engine/nodes/local/lib/render-review.ts\";\nimport { findWorkspaceRoot } from \"./normalize-paths.ts\";\n\nconst DIR = \"unbilled-spend\";\n\nconst Held = z.array(\n  z.object({ model: z.string(), inputTokens: z.number(), outputTokens: z.number(), costUsd: z.number() }),\n);\n\n/** Keep `usage` for the next run record of this workspace; nothing is written when it is empty. */\nexport async function holdUnbilledSpend(cacheDir: string, usage: readonly ReviewUsage[]): Promise<void> {\n  if (usage.length === 0) return;\n  const dir = path.join(cacheDir, DIR);\n  await mkdir(dir, { recursive: true });\n  await writeFile(path.join(dir, `${Date.now()}-${randomUUID()}.json`), JSON.stringify(usage), \"utf8\");\n}\n\n/**\n * One call made by a command with no canvas of its own (`baker actions create`, a feedback note,\n * a CRM file check), held in the workspace the command ran in. Never throws: a lost hold is a\n * call Baker absorbs, never a failed command.\n */\nexport async function holdWorkspaceSpend(usage: readonly ReviewUsage[]): Promise<void> {\n  const root = findWorkspaceRoot(process.cwd()) ?? process.cwd();\n  await holdUnbilledSpend(path.join(root, \"canvas\", \".cache\"), usage).catch(() => {});\n}\n\n/** Every held call, claimed and removed, summed per model (one record entry each). */\nexport async function takeUnbilledSpend(cacheDir: string): Promise<ReviewUsage[]> {\n  const dir = path.join(cacheDir, DIR);\n  const files = await readdir(dir).catch(() => [] as string[]);\n  const byModel = new Map<string, ReviewUsage>();\n  for (const file of files.filter((f) => f.endsWith(\".json\"))) {\n    const claimed = path.join(dir, `${file}.${randomUUID()}.taken`);\n    try {\n      await rename(path.join(dir, file), claimed);\n    } catch {\n      continue;\n    }\n    const parsed = Held.safeParse(await readFile(claimed, \"utf8\").then(JSON.parse, () => null).catch(() => null));\n    await unlink(claimed).catch(() => {});\n    for (const call of parsed.success ? parsed.data : []) {\n      const sum = byModel.get(call.model);\n      byModel.set(\n        call.model,\n        sum\n          ? {\n              model: call.model,\n              inputTokens: sum.inputTokens + call.inputTokens,\n              outputTokens: sum.outputTokens + call.outputTokens,\n              costUsd: sum.costUsd + call.costUsd,\n            }\n          : { ...call },\n      );\n    }\n  }\n  return [...byModel.values()];\n}\n\n/**\n * Send the record that carries `usage`: null when it landed, else why not. When it never does, the\n * spend is held again for the next one; the failure is reported, never thrown, because a\n * record that did not land must not turn a finished render into a failed one.\n */\nexport async function sendBillingSpend(\n  cacheDir: string,\n  usage: readonly ReviewUsage[],\n  send: () => Promise<void>,\n): Promise<string | null> {\n  try {\n    await send();\n    return null;\n  } catch (e) {\n    await holdUnbilledSpend(cacheDir, usage).catch(() => {});\n    return e instanceof Error ? e.message : String(e);\n  }\n}\n\n/**\n * Hold what a node's own gateway calls cost the moment it settles, so the spend survives the\n * run failing or being stopped after it: the resumed run takes that node from the cache and\n * bills nothing for it. `spendOf` returns [] for a cached node or one that calls nothing.\n */\nexport function holdWhenSettled(\n  cacheDir: string,\n  spendOf: (run: NodeRunRecord, outputs: Record<string, unknown>) => readonly ReviewUsage[],\n): { settled: (run: NodeRunRecord, outputs: Record<string, unknown>) => void; drained: () => Promise<void> } {\n  const pending: Promise<void>[] = [];\n  return {\n    settled: (run, outputs) => {\n      pending.push(holdUnbilledSpend(cacheDir, spendOf(run, outputs)).catch(() => {}));\n    },\n    drained: async () => {\n      await Promise.all(pending);\n    },\n  };\n}\n"],"mappings":";;;;;AAUA,SAAS,kBAAkB;AAC3B,SAAS,OAAO,SAAS,UAAU,QAAQ,QAAQ,iBAAiB;AACpE,OAAO,UAAU;AACjB,SAAS,SAAS;AAKlB,IAAM,MAAM;AAEZ,IAAM,OAAO,EAAE;AAAA,EACb,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,GAAG,aAAa,EAAE,OAAO,GAAG,cAAc,EAAE,OAAO,GAAG,SAAS,EAAE,OAAO,EAAE,CAAC;AACxG;AAGA,eAAsB,kBAAkB,UAAkB,OAA8C;AACtG,MAAI,MAAM,WAAW,EAAG;AACxB,QAAM,MAAM,KAAK,KAAK,UAAU,GAAG;AACnC,QAAM,MAAM,KAAK,EAAE,WAAW,KAAK,CAAC;AACpC,QAAM,UAAU,KAAK,KAAK,KAAK,GAAG,KAAK,IAAI,CAAC,IAAI,WAAW,CAAC,OAAO,GAAG,KAAK,UAAU,KAAK,GAAG,MAAM;AACrG;AAOA,eAAsB,mBAAmB,OAA8C;AACrF,QAAM,OAAO,kBAAkB,QAAQ,IAAI,CAAC,KAAK,QAAQ,IAAI;AAC7D,QAAM,kBAAkB,KAAK,KAAK,MAAM,UAAU,QAAQ,GAAG,KAAK,EAAE,MAAM,MAAM;AAAA,EAAC,CAAC;AACpF;AAGA,eAAsB,kBAAkB,UAA0C;AAChF,QAAM,MAAM,KAAK,KAAK,UAAU,GAAG;AACnC,QAAM,QAAQ,MAAM,QAAQ,GAAG,EAAE,MAAM,MAAM,CAAC,CAAa;AAC3D,QAAM,UAAU,oBAAI,IAAyB;AAC7C,aAAW,QAAQ,MAAM,OAAO,CAAC,MAAM,EAAE,SAAS,OAAO,CAAC,GAAG;AAC3D,UAAM,UAAU,KAAK,KAAK,KAAK,GAAG,IAAI,IAAI,WAAW,CAAC,QAAQ;AAC9D,QAAI;AACF,YAAM,OAAO,KAAK,KAAK,KAAK,IAAI,GAAG,OAAO;AAAA,IAC5C,QAAQ;AACN;AAAA,IACF;AACA,UAAM,SAAS,KAAK,UAAU,MAAM,SAAS,SAAS,MAAM,EAAE,KAAK,KAAK,OAAO,MAAM,IAAI,EAAE,MAAM,MAAM,IAAI,CAAC;AAC5G,UAAM,OAAO,OAAO,EAAE,MAAM,MAAM;AAAA,IAAC,CAAC;AACpC,eAAW,QAAQ,OAAO,UAAU,OAAO,OAAO,CAAC,GAAG;AACpD,YAAM,MAAM,QAAQ,IAAI,KAAK,KAAK;AAClC,cAAQ;AAAA,QACN,KAAK;AAAA,QACL,MACI;AAAA,UACE,OAAO,KAAK;AAAA,UACZ,aAAa,IAAI,cAAc,KAAK;AAAA,UACpC,cAAc,IAAI,eAAe,KAAK;AAAA,UACtC,SAAS,IAAI,UAAU,KAAK;AAAA,QAC9B,IACA,EAAE,GAAG,KAAK;AAAA,MAChB;AAAA,IACF;AAAA,EACF;AACA,SAAO,CAAC,GAAG,QAAQ,OAAO,CAAC;AAC7B;AAOA,eAAsB,iBACpB,UACA,OACA,MACwB;AACxB,MAAI;AACF,UAAM,KAAK;AACX,WAAO;AAAA,EACT,SAAS,GAAG;AACV,UAAM,kBAAkB,UAAU,KAAK,EAAE,MAAM,MAAM;AAAA,IAAC,CAAC;AACvD,WAAO,aAAa,QAAQ,EAAE,UAAU,OAAO,CAAC;AAAA,EAClD;AACF;AAOO,SAAS,gBACd,UACA,SAC2G;AAC3G,QAAM,UAA2B,CAAC;AAClC,SAAO;AAAA,IACL,SAAS,CAAC,KAAK,YAAY;AACzB,cAAQ,KAAK,kBAAkB,UAAU,QAAQ,KAAK,OAAO,CAAC,EAAE,MAAM,MAAM;AAAA,MAAC,CAAC,CAAC;AAAA,IACjF;AAAA,IACA,SAAS,YAAY;AACnB,YAAM,QAAQ,IAAI,OAAO;AAAA,IAC3B;AAAA,EACF;AACF;","names":[]}

package/dist/chunk-KLNKEVIY.js

@@ -0,0 +1,136 @@
+import {
+  handleConnectionError,
+  needsConnectionFix,
+  writeAdsJson
+} from "./chunk-VFIOJD5M.js";
+import {
+  ApiError
+} from "./chunk-XBOK23HI.js";
+import {
+  getEnv
+} from "./chunk-NAWWC5I3.js";
+
+// src/commands/ads/meta/shared.ts
+var DAY_MS = 864e5;
+function metaForbiddenFix(message) {
+  if (message.includes("has not accepted Meta's Lead Generation Terms")) {
+    return {
+      action: "reject",
+      explanation: `${message}
+
+Meta confirmed the Page's terms status using its Page access. Give the Page owner the terms link in the error and ask them to accept it before trying the form or lead ad set again. Do not suggest reconnecting Meta for this refusal; continue with other work that does not require the form or ad set.`
+    };
+  }
+  return {
+    action: "reject",
+    explanation: [
+      message,
+      "This is a permission refusal, not a dead connection, and Meta returns the same code for two causes with opposite remedies. Tell them apart by how much else works before you answer.",
+      "If other reads on this account are ALSO refused (campaigns, ad sets, insights), the connection is short a permission it was never granted. Only the user can widen it, by reconnecting Meta from the dashboard.",
+      "If those reads work and only this object is refused, the asset (pixel/dataset, Page, or catalog) belongs to a Business the connected user holds no role in. Ad-account access does not carry asset access and reconnecting cannot grant it \u2014 the client assigns that asset to the connected user or partner in Meta Business settings, under the asset's own section (Data sources \u2192 Datasets for a pixel).",
+      "Either way do not retry the same call, and do not abort the wider job. Continue with what you can read, and state in your answer that this specific check could not run and why \u2014 never present the task as verified when this step was skipped."
+    ].join("\n\n")
+  };
+}
+function handleMetaError(err) {
+  if (err instanceof ApiError) {
+    if (needsConnectionFix(err.code, err.message)) {
+      handleConnectionError("meta_ads", err.message);
+    }
+    const envelope = {
+      ok: false,
+      error: {
+        code: err.code,
+        message: err.message,
+        fix: err.code === "FORBIDDEN" ? metaForbiddenFix(err.message) : { action: "reject", explanation: err.message },
+        retryable: err.code === "RATE_LIMITED" || err.code === "UNAVAILABLE" || err.code === "INTERNAL_ERROR"
+      }
+    };
+    writeAdsJson(envelope);
+    process.exit(1);
+  }
+  const message = err instanceof Error ? err.message : "Unexpected error";
+  writeAdsJson({ ok: false, error: { code: "NETWORK_ERROR", message } });
+  process.exit(1);
+}
+var ACCOUNT_ID_RE = /^(act_)?[0-9]+$/;
+function resolveAccountIdArg(args) {
+  const fromArgs = args["account-id"];
+  const id = fromArgs || getEnv().BAKER_META_AD_ACCOUNT_ID;
+  if (!id) {
+    writeAdsJson({
+      ok: false,
+      error: {
+        code: "MISSING_ACCOUNT_ID",
+        message: "Pass --account-id or set BAKER_META_AD_ACCOUNT_ID. Run `baker ads meta accounts` to find IDs."
+      }
+    });
+    process.exit(1);
+  }
+  if (!ACCOUNT_ID_RE.test(id)) {
+    writeAdsJson({
+      ok: false,
+      error: {
+        code: "INVALID_ACCOUNT_ID",
+        message: `Invalid account ID "${id}". Expected numeric ID, optionally prefixed with "act_".`
+      }
+    });
+    process.exit(1);
+  }
+  return id.startsWith("act_") ? id : `act_${id}`;
+}
+function getDateRange(args) {
+  const datePreset = args["date-preset"];
+  const since = args.since;
+  const until = args.until;
+  if (since && until) return { since, until };
+  return { datePreset: datePreset ?? "last_7d" };
+}
+function todayIso() {
+  return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+}
+function daysAgoIso(days) {
+  return new Date(Date.now() - days * DAY_MS).toISOString().slice(0, 10);
+}
+function csvOrJson(args) {
+  return args.output ?? "json";
+}
+var NAME_CONTAINS_ARG = {
+  type: "string",
+  description: "Only rows whose name contains this text, matched by Meta before anything is returned. Start here to find one entity by name: --name-contains octubre --all-statuses"
+};
+function resolveEffectiveStatus(args) {
+  if (args["all-statuses"]) {
+    return void 0;
+  }
+  const explicit = args["effective-status"];
+  if (explicit) {
+    return explicit;
+  }
+  return "ACTIVE";
+}
+function statusFilterHints(rows, effectiveStatus, noun) {
+  if (rows.length > 0 || effectiveStatus === void 0) return [];
+  if (effectiveStatus === "ACTIVE") {
+    return [
+      `No ACTIVE ${noun}. The ACTIVE filter hides paused, archived and in-review ones (under a paused campaign or ad set that is all of them), so this does NOT mean none exist. Re-run with --all-statuses before concluding there are none.`
+    ];
+  }
+  return [
+    `No ${noun} with effective_status ${effectiveStatus}. Re-run with --all-statuses to see every status before concluding there are none.`
+  ];
+}
+
+export {
+  metaForbiddenFix,
+  handleMetaError,
+  resolveAccountIdArg,
+  getDateRange,
+  todayIso,
+  daysAgoIso,
+  csvOrJson,
+  NAME_CONTAINS_ARG,
+  resolveEffectiveStatus,
+  statusFilterHints
+};
+//# sourceMappingURL=chunk-KLNKEVIY.js.map

package/dist/chunk-KNY76UGC.js

@@ -0,0 +1,84 @@
+import {
+  ApiError,
+  apiGet,
+  apiPost
+} from "./chunk-XBOK23HI.js";
+
+// src/commands/videos/api.ts
+import { readFile } from "fs/promises";
+import { basename, extname } from "path";
+var videoProcessingTimeoutMs = 18e4;
+var videoReadyPollIntervalMs = 3e3;
+var mimeMap = {
+  ".mp4": "video/mp4",
+  ".mov": "video/quicktime",
+  ".webm": "video/webm",
+  ".avi": "video/x-msvideo",
+  ".mkv": "video/x-matroska"
+};
+var defaultVideoApiDeps = {
+  readFile,
+  post: apiPost,
+  get: apiGet,
+  sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+  putFile: async (url, contentType, body) => {
+    const response = await fetch(url, { method: "PUT", headers: { "Content-Type": contentType }, body });
+    if (!response.ok) {
+      throw new ApiError("INTERNAL_ERROR", `Mux upload failed: HTTP ${response.status} ${response.statusText}`);
+    }
+  }
+};
+function isVideoFile(filePath) {
+  return mimeMap[extname(filePath).toLowerCase()] !== void 0;
+}
+function detectVideoContentType(filePath, opts = {}) {
+  const ext = extname(filePath).toLowerCase();
+  const contentType = mimeMap[ext];
+  if (!contentType || opts.allowedContentTypes && !opts.allowedContentTypes.includes(contentType)) {
+    throw new ApiError(
+      "VALIDATION_ERROR",
+      opts.unsupportedMessage ?? `Cannot detect content type for extension "${ext}". Use --content-type.`
+    );
+  }
+  return contentType;
+}
+async function uploadLocalVideo(args, deps = defaultVideoApiDeps) {
+  const { uploadUrl, videoId } = await deps.post("/api/videos/upload", {
+    originalFilename: basename(args.file),
+    descriptionContext: args.descriptionContext
+  });
+  await deps.putFile(uploadUrl, args.contentType, await deps.readFile(args.file));
+  return { videoId };
+}
+var PLAYABLE_STATUSES = /* @__PURE__ */ new Set(["uploaded", "processing", "ready"]);
+async function waitForPlayableVideo(deps, videoId, opts = {}) {
+  const timeoutMs = opts.timeoutMs ?? videoProcessingTimeoutMs;
+  const pollIntervalMs = opts.pollIntervalMs ?? videoReadyPollIntervalMs;
+  const deadline = Date.now() + timeoutMs;
+  let lastStatus = "unknown";
+  while (Date.now() <= deadline) {
+    const video = await deps.get("/api/videos/get", { id: videoId });
+    lastStatus = video.status;
+    if (video.muxPlaybackId && PLAYABLE_STATUSES.has(video.status)) {
+      return video;
+    }
+    if (video.status === "error") {
+      throw new ApiError(
+        "INTERNAL_ERROR",
+        "The video library could not process this file. Export it again as an MP4 (H.264) and retry."
+      );
+    }
+    await deps.sleep(pollIntervalMs);
+  }
+  throw new ApiError("TIMEOUT", `Video was not playable before timeout; last status: ${lastStatus}`);
+}
+
+export {
+  videoProcessingTimeoutMs,
+  defaultVideoApiDeps,
+  isVideoFile,
+  detectVideoContentType,
+  uploadLocalVideo,
+  waitForPlayableVideo
+};
+//# sourceMappingURL=chunk-KNY76UGC.js.map