@koda-sl/baker-cli 0.385.0-dev.ec7b0e42b → 0.385.0-dev.f7ef4c7e1

package/dist/chunk-WN4KX7GE.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/commands/avatars/wait.ts"],"sourcesContent":["import type { AvatarStatus } from \"@baker/api\";\n\n/**\n * Waiting for an avatar's identity sheet, inside the command rather than in the agent.\n *\n * The sheet is a ~30s render, and the agent is told never to sleep on it — right, because\n * a turn spent standing still is a turn the user watches do nothing. But when the only\n * work left DEPENDS on that avatar, \"do the next piece of work\" names work that does not\n * exist, and the observed turn simply ended: the user had to come back and say \"ya está\n * lista\" for the clip to be made.\n *\n * A command that blocks internally is the sanctioned shape for this — it has its own\n * deadline and returns the moment the thing is ready, which a polling loop written by the\n * agent does neither of.\n */\n\n/** How long to keep asking before giving up. Twice the sheet's usual render. */\nexport const WAIT_TIMEOUT_MS = 90_000;\n/** Gap between reads. Short enough to return promptly, long enough not to hammer. */\nexport const WAIT_INTERVAL_MS = 3_000;\n\nexport type WaitDecision =\n  | { done: true; reason: \"ready\" | \"settled\" | \"needs-face\" }\n  | { done: false; reason: \"building\" | \"expired\" };\n\n/** Just enough of an avatar to know whether waiting on it can ever end. */\nexport interface WaitSubject {\n  status: AvatarStatus;\n  /**\n   * The build is parked on a face the user has not picked yet.\n   *\n   * `generating` normally means a render is running. This is the one case where it\n   * does not: the casting portraits are in front of the user and nothing starts until\n   * they answer.\n   */\n  needsFace?: boolean;\n}\n\n/**\n * Whether to stop waiting on this avatar, given how long we have waited.\n *\n * `error` and `archived` stop it too: both are settled states, and waiting out the\n * deadline for one of them would burn 90 seconds to learn what the first read said.\n *\n * So does an avatar waiting on its face. Nothing is rendering, so the only thing that\n * can happen here is the deadline expiring — and it is the user's own turn to act, not\n * the agent's. Observed: an agent blocked the full 90 seconds twice, concluded the\n * avatar was broken, and deleted the one the user was at that moment picking a face for.\n */\nexport function shouldKeepWaiting(avatar: WaitSubject, elapsedMs: number): WaitDecision {\n  if (avatar.status === \"ready\") return { done: true, reason: \"ready\" };\n  if (avatar.status === \"error\" || avatar.status === \"archived\") return { done: true, reason: \"settled\" };\n  if (avatar.needsFace) return { done: true, reason: \"needs-face\" };\n  if (elapsedMs >= WAIT_TIMEOUT_MS) return { done: false, reason: \"expired\" };\n  return { done: false, reason: \"building\" };\n}\n\n/**\n * Re-reads the avatar until its sheet settles, or the deadline passes.\n *\n * Returns whatever the last read said either way — an expired wait is not a failure, it\n * is a slow render, and the caller's own hints already say what a still-building avatar\n * can and cannot be used for.\n */\nexport async function waitForSheet<T extends WaitSubject>(\n  first: T,\n  read: () => Promise<T>,\n  sleep: (ms: number) => Promise<void> = (ms) => new Promise((resolve) => setTimeout(resolve, ms)),\n): Promise<T> {\n  const startedAt = Date.now();\n  let latest = first;\n  while (!shouldKeepWaiting(latest, Date.now() - startedAt).done) {\n    if (shouldKeepWaiting(latest, Date.now() - startedAt).reason === \"expired\") return latest;\n    await sleep(WAIT_INTERVAL_MS);\n    latest = await read();\n  }\n  return latest;\n}\n"],"mappings":";AAiBO,IAAM,kBAAkB;AAExB,IAAM,mBAAmB;AA8BzB,SAAS,kBAAkB,QAAqB,WAAiC;AACtF,MAAI,OAAO,WAAW,QAAS,QAAO,EAAE,MAAM,MAAM,QAAQ,QAAQ;AACpE,MAAI,OAAO,WAAW,WAAW,OAAO,WAAW,WAAY,QAAO,EAAE,MAAM,MAAM,QAAQ,UAAU;AACtG,MAAI,OAAO,UAAW,QAAO,EAAE,MAAM,MAAM,QAAQ,aAAa;AAChE,MAAI,aAAa,gBAAiB,QAAO,EAAE,MAAM,OAAO,QAAQ,UAAU;AAC1E,SAAO,EAAE,MAAM,OAAO,QAAQ,WAAW;AAC3C;AASA,eAAsB,aACpB,OACA,MACA,QAAuC,CAAC,OAAO,IAAI,QAAQ,CAAC,YAAY,WAAW,SAAS,EAAE,CAAC,GACnF;AACZ,QAAM,YAAY,KAAK,IAAI;AAC3B,MAAI,SAAS;AACb,SAAO,CAAC,kBAAkB,QAAQ,KAAK,IAAI,IAAI,SAAS,EAAE,MAAM;AAC9D,QAAI,kBAAkB,QAAQ,KAAK,IAAI,IAAI,SAAS,EAAE,WAAW,UAAW,QAAO;AACnF,UAAM,MAAM,gBAAgB;AAC5B,aAAS,MAAM,KAAK;AAAA,EACtB;AACA,SAAO;AACT;","names":[]}

package/dist/chunk-XIY7P54H.js

@@ -0,0 +1,84 @@
+import {
+  ApiError,
+  apiGet,
+  apiPost
+} from "./chunk-CUL3VB4L.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-XIY7P54H.js.map

package/dist/chunk-XIY7P54H.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/commands/videos/api.ts"],"sourcesContent":["import type { Buffer } from \"node:buffer\";\nimport { readFile } from \"node:fs/promises\";\nimport { basename, extname } from \"node:path\";\nimport type { VideosGetResponse, VideosUploadResponse } from \"@baker/api\";\nimport { ApiError, apiGet, apiPost } from \"../../client.ts\";\n\n/** Mux usually has a short render playable within a minute; this bounds the wait. */\nexport const videoProcessingTimeoutMs = 180_000;\nconst videoReadyPollIntervalMs = 3_000;\n\nconst mimeMap: Record<string, string> = {\n  \".mp4\": \"video/mp4\",\n  \".mov\": \"video/quicktime\",\n  \".webm\": \"video/webm\",\n  \".avi\": \"video/x-msvideo\",\n  \".mkv\": \"video/x-matroska\",\n};\n\nexport type VideoApiDeps = {\n  readFile: (path: string) => Promise<Buffer<ArrayBuffer>>;\n  post: typeof apiPost;\n  get: typeof apiGet;\n  sleep: (ms: number) => Promise<void>;\n  /** PUT the bytes to the Mux direct-upload URL. */\n  putFile: (url: string, contentType: string, body: Buffer<ArrayBuffer>) => Promise<void>;\n};\n\nexport const defaultVideoApiDeps: VideoApiDeps = {\n  readFile,\n  post: apiPost,\n  get: apiGet,\n  sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),\n  putFile: async (url, contentType, body) => {\n    const response = await fetch(url, { method: \"PUT\", headers: { \"Content-Type\": contentType }, body });\n    if (!response.ok) {\n      throw new ApiError(\"INTERNAL_ERROR\", `Mux upload failed: HTTP ${response.status} ${response.statusText}`);\n    }\n  },\n};\n\nexport function isVideoFile(filePath: string): boolean {\n  return mimeMap[extname(filePath).toLowerCase()] !== undefined;\n}\n\nexport function detectVideoContentType(\n  filePath: string,\n  opts: { allowedContentTypes?: readonly string[]; unsupportedMessage?: string } = {},\n): string {\n  const ext = extname(filePath).toLowerCase();\n  const contentType = mimeMap[ext];\n  if (!contentType || (opts.allowedContentTypes && !opts.allowedContentTypes.includes(contentType))) {\n    throw new ApiError(\n      \"VALIDATION_ERROR\",\n      opts.unsupportedMessage ?? `Cannot detect content type for extension \"${ext}\". Use --content-type.`,\n    );\n  }\n  return contentType;\n}\n\n/**\n * Add a local video file to the company's video library: a Mux direct-upload\n * URL from Baker, then the bytes straight to Mux. The filename travels along,\n * since the bytes never pass through Baker and it is often the only statement\n * of intent there is.\n */\nexport async function uploadLocalVideo(\n  args: { file: string; contentType: string; descriptionContext?: string },\n  deps: VideoApiDeps = defaultVideoApiDeps,\n): Promise<{ videoId: string }> {\n  const { uploadUrl, videoId } = await deps.post<VideosUploadResponse>(\"/api/videos/upload\", {\n    originalFilename: basename(args.file),\n    descriptionContext: args.descriptionContext,\n  });\n  await deps.putFile(uploadUrl, args.contentType, await deps.readFile(args.file));\n  return { videoId };\n}\n\nconst PLAYABLE_STATUSES: ReadonlySet<string> = new Set([\"uploaded\", \"processing\", \"ready\"]);\n\n/**\n * Wait until Baker can play the video: Mux has produced its playback id. Its\n * description (transcript, analysis) keeps running afterwards, and nothing\n * that saves or ships the video needs to wait for that.\n */\nexport async function waitForPlayableVideo(\n  deps: VideoApiDeps,\n  videoId: string,\n  opts: { timeoutMs?: number; pollIntervalMs?: number } = {},\n): Promise<VideosGetResponse> {\n  const timeoutMs = opts.timeoutMs ?? videoProcessingTimeoutMs;\n  const pollIntervalMs = opts.pollIntervalMs ?? videoReadyPollIntervalMs;\n  const deadline = Date.now() + timeoutMs;\n  let lastStatus = \"unknown\";\n  while (Date.now() <= deadline) {\n    const video = await deps.get<VideosGetResponse>(\"/api/videos/get\", { id: videoId });\n    lastStatus = video.status;\n    if (video.muxPlaybackId && PLAYABLE_STATUSES.has(video.status)) {\n      return video;\n    }\n    if (video.status === \"error\") {\n      throw new ApiError(\n        \"INTERNAL_ERROR\",\n        \"The video library could not process this file. Export it again as an MP4 (H.264) and retry.\",\n      );\n    }\n    await deps.sleep(pollIntervalMs);\n  }\n  throw new ApiError(\"TIMEOUT\", `Video was not playable before timeout; last status: ${lastStatus}`);\n}\n"],"mappings":";;;;;;;AACA,SAAS,gBAAgB;AACzB,SAAS,UAAU,eAAe;AAK3B,IAAM,2BAA2B;AACxC,IAAM,2BAA2B;AAEjC,IAAM,UAAkC;AAAA,EACtC,QAAQ;AAAA,EACR,QAAQ;AAAA,EACR,SAAS;AAAA,EACT,QAAQ;AAAA,EACR,QAAQ;AACV;AAWO,IAAM,sBAAoC;AAAA,EAC/C;AAAA,EACA,MAAM;AAAA,EACN,KAAK;AAAA,EACL,OAAO,CAAC,OAAO,IAAI,QAAQ,CAAC,YAAY,WAAW,SAAS,EAAE,CAAC;AAAA,EAC/D,SAAS,OAAO,KAAK,aAAa,SAAS;AACzC,UAAM,WAAW,MAAM,MAAM,KAAK,EAAE,QAAQ,OAAO,SAAS,EAAE,gBAAgB,YAAY,GAAG,KAAK,CAAC;AACnG,QAAI,CAAC,SAAS,IAAI;AAChB,YAAM,IAAI,SAAS,kBAAkB,2BAA2B,SAAS,MAAM,IAAI,SAAS,UAAU,EAAE;AAAA,IAC1G;AAAA,EACF;AACF;AAEO,SAAS,YAAY,UAA2B;AACrD,SAAO,QAAQ,QAAQ,QAAQ,EAAE,YAAY,CAAC,MAAM;AACtD;AAEO,SAAS,uBACd,UACA,OAAiF,CAAC,GAC1E;AACR,QAAM,MAAM,QAAQ,QAAQ,EAAE,YAAY;AAC1C,QAAM,cAAc,QAAQ,GAAG;AAC/B,MAAI,CAAC,eAAgB,KAAK,uBAAuB,CAAC,KAAK,oBAAoB,SAAS,WAAW,GAAI;AACjG,UAAM,IAAI;AAAA,MACR;AAAA,MACA,KAAK,sBAAsB,6CAA6C,GAAG;AAAA,IAC7E;AAAA,EACF;AACA,SAAO;AACT;AAQA,eAAsB,iBACpB,MACA,OAAqB,qBACS;AAC9B,QAAM,EAAE,WAAW,QAAQ,IAAI,MAAM,KAAK,KAA2B,sBAAsB;AAAA,IACzF,kBAAkB,SAAS,KAAK,IAAI;AAAA,IACpC,oBAAoB,KAAK;AAAA,EAC3B,CAAC;AACD,QAAM,KAAK,QAAQ,WAAW,KAAK,aAAa,MAAM,KAAK,SAAS,KAAK,IAAI,CAAC;AAC9E,SAAO,EAAE,QAAQ;AACnB;AAEA,IAAM,oBAAyC,oBAAI,IAAI,CAAC,YAAY,cAAc,OAAO,CAAC;AAO1F,eAAsB,qBACpB,MACA,SACA,OAAwD,CAAC,GAC7B;AAC5B,QAAM,YAAY,KAAK,aAAa;AACpC,QAAM,iBAAiB,KAAK,kBAAkB;AAC9C,QAAM,WAAW,KAAK,IAAI,IAAI;AAC9B,MAAI,aAAa;AACjB,SAAO,KAAK,IAAI,KAAK,UAAU;AAC7B,UAAM,QAAQ,MAAM,KAAK,IAAuB,mBAAmB,EAAE,IAAI,QAAQ,CAAC;AAClF,iBAAa,MAAM;AACnB,QAAI,MAAM,iBAAiB,kBAAkB,IAAI,MAAM,MAAM,GAAG;AAC9D,aAAO;AAAA,IACT;AACA,QAAI,MAAM,WAAW,SAAS;AAC5B,YAAM,IAAI;AAAA,QACR;AAAA,QACA;AAAA,MACF;AAAA,IACF;AACA,UAAM,KAAK,MAAM,cAAc;AAAA,EACjC;AACA,QAAM,IAAI,SAAS,WAAW,uDAAuD,UAAU,EAAE;AACnG;","names":[]}

package/dist/chunk-XPLTWUMN.js

@@ -0,0 +1,103 @@
+import {
+  SITE_COLLECTION_MODES,
+  SITE_CONSENT_MODES,
+  SITE_HOME_MODES
+} from "./chunk-D46NOXRY.js";
+import {
+  ApiError
+} from "./chunk-CUL3VB4L.js";
+import {
+  writeJson
+} from "./chunk-MYTDK3AL.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-XPLTWUMN.js.map

package/dist/chunk-XPLTWUMN.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/commands/site/setArgs.ts","../src/commands/site/shared.ts"],"sourcesContent":["import { SITE_COLLECTION_MODES, SITE_CONSENT_MODES, SITE_HOME_MODES, type SiteStageInput } from \"@baker/api\";\n\n/** A flag the agent can fix by changing it — reported as a validation error, never as a failed call. */\nexport class SiteArgsError extends Error {}\n\nexport interface SiteSetArgs {\n  consent?: string;\n  collection?: string;\n  payloads?: string;\n  indexing?: string;\n  home?: string;\n  \"home-mode\"?: string;\n  timezone?: string;\n  \"export-profile\"?: string;\n}\n\nfunction oneOf<T extends string>(flag: string, value: string, allowed: readonly T[]): T {\n  if (!(allowed as readonly string[]).includes(value)) {\n    throw new SiteArgsError(`--${flag} must be one of: ${allowed.join(\", \")}`);\n  }\n  return value as T;\n}\n\nfunction onOff(flag: string, value: string): boolean {\n  if (value === \"on\" || value === \"true\") return true;\n  if (value === \"off\" || value === \"false\") return false;\n  throw new SiteArgsError(`--${flag} must be on or off`);\n}\n\nfunction parseProfile(raw: string, readFile: (path: string) => string): Record<string, unknown> {\n  const text = raw.startsWith(\"@\") ? readFile(raw.slice(1)) : raw;\n  let parsed: unknown;\n  try {\n    parsed = JSON.parse(text);\n  } catch {\n    throw new SiteArgsError(\"--export-profile must be JSON, or @path to a JSON file\");\n  }\n  if (typeof parsed !== \"object\" || parsed === null || Array.isArray(parsed)) {\n    throw new SiteArgsError(\"--export-profile must be a JSON object\");\n  }\n  return parsed as Record<string, unknown>;\n}\n\n/** Every setting one `baker site set` names, in the order the review lists them. */\nexport function parseSetArgs(args: SiteSetArgs, readFile: (path: string) => string): SiteStageInput[] {\n  const inputs: SiteStageInput[] = [];\n  if (args.consent !== undefined) {\n    inputs.push({ setting: \"consent\", mode: oneOf(\"consent\", args.consent, SITE_CONSENT_MODES) });\n  }\n  if (args.collection !== undefined) {\n    const mode = oneOf(\"collection\", args.collection, SITE_COLLECTION_MODES);\n    inputs.push({\n      setting: \"analyticsCollection\",\n      mode,\n      ...(args.payloads === undefined ? {} : { payloads: onOff(\"payloads\", args.payloads) }),\n    });\n  } else if (args.payloads !== undefined) {\n    throw new SiteArgsError(\"--payloads goes with --collection, e.g. --collection full --payloads off\");\n  }\n  if (args.indexing !== undefined) {\n    inputs.push({ setting: \"indexing\", enabled: onOff(\"indexing\", args.indexing) });\n  }\n  if (args.home !== undefined) {\n    const slug = args.home.trim().replace(/^\\/+|\\/+$/g, \"\");\n    inputs.push(\n      slug === \"none\" || slug === \"\"\n        ? { setting: \"homePage\", override: null }\n        : {\n            setting: \"homePage\",\n            override: { mode: oneOf(\"home-mode\", args[\"home-mode\"] ?? \"rewrite\", SITE_HOME_MODES), slug },\n          },\n    );\n  } else if (args[\"home-mode\"] !== undefined) {\n    throw new SiteArgsError(\"--home-mode goes with --home <landing slug>\");\n  }\n  if (args.timezone !== undefined) {\n    inputs.push({ setting: \"timezone\", timezone: args.timezone });\n  }\n  if (args[\"export-profile\"] !== undefined) {\n    inputs.push({ setting: \"exportProfile\", profile: parseProfile(args[\"export-profile\"], readFile) });\n  }\n  if (inputs.length === 0) {\n    throw new SiteArgsError(\n      \"Nothing to stage. Pass at least one of --consent, --collection, --indexing, --home, --timezone, --export-profile.\",\n    );\n  }\n  return inputs;\n}\n","import { ApiError } from \"../../client.ts\";\nimport { writeJson } from \"../../output.ts\";\nimport { SiteArgsError } from \"./setArgs.ts\";\n\n/** Emit the `{ ok: false, error }` envelope for any `baker site` failure and exit non-zero. */\nexport function failSite(err: unknown): never {\n  if (err instanceof SiteArgsError) {\n    writeJson({ ok: false, error: { code: \"VALIDATION_ERROR\", message: err.message } });\n  } else if (err instanceof ApiError) {\n    writeJson({ ok: false, error: { code: err.code, message: err.message } });\n  } else {\n    writeJson({\n      ok: false,\n      error: { code: \"INTERNAL_ERROR\", message: err instanceof Error ? err.message : \"Unexpected error\" },\n    });\n  }\n  process.exit(1);\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-Y6T5ZKBK.js

@@ -0,0 +1,19 @@
+import {
+  latestVersion
+} from "./chunk-35NYNRRB.js";
+import {
+  canvasOutputsRoot
+} from "./chunk-TNOSX3PJ.js";
+
+// src/commands/creatives/version-of.ts
+import path from "path";
+async function versionOf(slug, run) {
+  if (typeof run === "string" && run.trim()) return run.trim();
+  const canvas = path.join("src", "creatives", slug, `${slug}.canvas.json`);
+  return await latestVersion(canvasOutputsRoot(canvas), slug) ?? void 0;
+}
+
+export {
+  versionOf
+};
+//# sourceMappingURL=chunk-Y6T5ZKBK.js.map

package/dist/chunk-Y6T5ZKBK.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/commands/creatives/version-of.ts"],"sourcesContent":["import path from \"node:path\";\nimport { canvasOutputsRoot } from \"../canvas/normalize-paths.ts\";\nimport { latestVersion } from \"../canvas/render-state.ts\";\n\n/** The version a command names: `--run` when given, else the one the creative shows now (`latestVersion`). */\nexport async function versionOf(slug: string, run: unknown): Promise<string | undefined> {\n  if (typeof run === \"string\" && run.trim()) return run.trim();\n  const canvas = path.join(\"src\", \"creatives\", slug, `${slug}.canvas.json`);\n  return (await latestVersion(canvasOutputsRoot(canvas), slug)) ?? undefined;\n}\n"],"mappings":";;;;;;;;AAAA,OAAO,UAAU;AAKjB,eAAsB,UAAU,MAAc,KAA2C;AACvF,MAAI,OAAO,QAAQ,YAAY,IAAI,KAAK,EAAG,QAAO,IAAI,KAAK;AAC3D,QAAM,SAAS,KAAK,KAAK,OAAO,aAAa,MAAM,GAAG,IAAI,cAAc;AACxE,SAAQ,MAAM,cAAc,kBAAkB,MAAM,GAAG,IAAI,KAAM;AACnE;","names":[]}

package/dist/chunk-YGGRQXDP.js

@@ -0,0 +1,382 @@
+import {
+  AUTO_PUBLISH_REFUSAL,
+  TRIGGER_KINDS,
+  TRIGGER_KIND_IDS,
+  TRIGGER_TARGETS,
+  TRIGGER_TARGET_FIELDS,
+  TRIGGER_TARGET_FIELD_IDS,
+  firstTimes,
+  isTriggerKind,
+  parseConditionsExpression
+} from "./chunk-D46NOXRY.js";
+import {
+  ApiError,
+  validateConvexId
+} from "./chunk-CUL3VB4L.js";
+import {
+  getEnv
+} from "./chunk-I4FTS5EE.js";
+import {
+  writeJson
+} from "./chunk-MYTDK3AL.js";
+
+// src/commands/scheduled-agents/shared.ts
+var TEMP_SCHEDULED_AGENT_PREFIX = "temp_agent_";
+var TEMP_ID_PREFIX = "temp_";
+function writeOk(data, hints) {
+  writeJson({ ok: true, data: data ?? null, ...hints && hints.length > 0 ? { hints } : {} });
+}
+function failValidation(message) {
+  writeJson({ ok: false, error: { code: "VALIDATION_ERROR", message } });
+  process.exit(1);
+}
+function failApi(err) {
+  if (err instanceof ApiError) {
+    writeJson({ ok: false, error: { code: err.code, message: err.message } });
+    process.exit(1);
+  }
+  if (err instanceof Error) {
+    writeJson({ ok: false, error: { code: "INTERNAL_ERROR", message: err.message } });
+    process.exit(1);
+  }
+  writeJson({ ok: false, error: { code: "INTERNAL_ERROR", message: "Unexpected error" } });
+  process.exit(1);
+}
+var AUTO_PUBLISH_ARG = {
+  "auto-publish": {
+    type: "string",
+    description: "Not available to the agent: publishing every run unreviewed is switched on by the user, on the item, after this chat is published. Passing it is refused and tells you what to ask them.",
+    required: false
+  }
+};
+function refuseAutoPublish(args) {
+  if (args["auto-publish"] === void 0) {
+    return;
+  }
+  writeJson({
+    ok: false,
+    error: {
+      code: "FORBIDDEN",
+      message: AUTO_PUBLISH_REFUSAL,
+      fix: {
+        action: "ask_user",
+        explanation: 'Run the command again without --auto-publish. After this chat is published, ask the user to open the item in Scheduled agents and switch on "Publish its work on its own" under "When a run finishes" \u2014 until then each run waits for their review.'
+      }
+    }
+  });
+  process.exit(1);
+}
+function isTempScheduledAgentId(id) {
+  return id.startsWith(TEMP_SCHEDULED_AGENT_PREFIX);
+}
+function isOtherTempId(id) {
+  return id.startsWith(TEMP_ID_PREFIX) && !isTempScheduledAgentId(id);
+}
+function validateScheduledAgentRef(ref) {
+  if (isOtherTempId(ref)) {
+    failValidation(`Scheduled agent temp IDs must start with ${TEMP_SCHEDULED_AGENT_PREFIX}.`);
+  }
+  if (!isTempScheduledAgentId(ref)) {
+    validateConvexId(ref);
+  }
+}
+var TRIGGER_ARG_DESCRIPTION = `What makes this run. ${TRIGGER_KIND_IDS.map(
+  (id) => `${id}: ${TRIGGER_KINDS[id].description}`
+).join(" ")} For the two time ones, pass --cron or --run-at instead and the kind is implied.`;
+var TRIGGER_KIND_LIST = [...TRIGGER_KIND_IDS];
+var NARROWING_DESCRIPTIONS = {
+  eventName: "With --trigger event.received: only this event name (a source's name, or one your site sends). Omit it to run on any event.",
+  toolkit: "With --trigger app.event (required): the connected tool, by its slug \u2014 gmail, slack, googlesheets.",
+  account: "With --trigger app.event (required): which connected account of that tool, by id (a tool can be connected more than once).",
+  appEvent: "With --trigger app.event (required): what happens in the tool, by the tool's own id \u2014 GMAIL_NEW_GMAIL_MESSAGE. `targets --field appEvent --app <tool>` lists them with the settings each needs.",
+  provider: "With --trigger connection.created, connection.removed or connection.needs_reconnect: only this tool (google-ads, hubspot, meta, or a connected tool's slug such as slack). Omit it for any tool.",
+  flowId: "With --trigger form.submitted or flow.step.submitted: which Form, by slug. Omit it on form.submitted for any Form.",
+  stepId: "With --trigger flow.step.submitted: which step of that Form, by id \u2014 `targets --field stepId --form <slug>` lists them by name.",
+  page: "With --trigger landing.created or landing.published: only this page, by slug. Omit it for any page.",
+  tag: "With --trigger task.created, task.claimed, task.completed, landing.created or landing.published: only ones carrying this tag. Omit it for any.",
+  experimentId: 'With --trigger experiment.decided, experiment.ended or experiment.concluded: only this test. Omit it for any test. Not for experiment.started \u2014 narrow that with --when "page = <page>".',
+  taskId: "With --trigger task.claimed or task.completed: only this Task, by id (a temp_ id of a Task staged in this chat works too). Omit it for any Task.",
+  agentId: "With --trigger session.published, session.publish_failed or session.publish_incomplete: only the runs of this scheduled agent, by id (a temp_agent_ id staged in this chat works too). Omit it for any agent's work.",
+  platform: "With --trigger session.publish_incomplete: only when this platform's changes did not all land \u2014 google-ads, meta-ads, linkedin-ads, x-ads, chatgpt-ads, tag-manager, ga4 or shopify. Omit it for any.",
+  collection: "With --trigger knowledge.updated: only this Knowledge collection. Omit it for any of them.",
+  sourceId: "With --trigger review.received: only reviews from this review source, by id. Omit it for any source.",
+  advertiserId: "With --trigger advertiser.new_ads: only this followed advertiser, by id. Omit it for any of them."
+};
+var NARROWING_ARGS = {
+  ...Object.fromEntries(
+    TRIGGER_TARGET_FIELD_IDS.map((field) => [
+      TRIGGER_TARGET_FIELDS[field].flag,
+      {
+        type: "string",
+        description: `${NARROWING_DESCRIPTIONS[field]} \`baker scheduled-agents targets --trigger <kind> --field ${field}\` lists the values.`,
+        required: false
+      }
+    ])
+  ),
+  config: {
+    type: "string",
+    description: `With --trigger app.event: the event's own settings as a JSON object \u2014 they filter inside the tool, before anything is sent. A Gmail search ('{"query":"from:ana@acme.com"}'), a label, a Slack channel, a GitHub repository ('{"owner":"acme","repo":"site"}'). \`targets --field appEvent --app <tool> --event <id>\` lists each setting with its examples.`,
+    required: false
+  }
+};
+function validateRunAt(runAt) {
+  if (!runAt.endsWith("Z")) {
+    failValidation("--run-at must be an ISO UTC timestamp ending in Z.");
+  }
+  const parsed = Date.parse(runAt);
+  if (!Number.isFinite(parsed)) {
+    failValidation("--run-at must be a valid ISO timestamp.");
+  }
+  if (parsed <= Date.now()) {
+    failValidation(
+      `--run-at ${runAt} has already passed. A one-off item only runs at a time still to come \u2014 pass a later ISO UTC timestamp, and check which timezone you converted from if you worked it out from a local time.`
+    );
+  }
+}
+function buildTriggerBody(args, options) {
+  const cron = args.cron;
+  const runAt = args["run-at"];
+  const timezone = args.timezone;
+  const kind = args.trigger;
+  const given = [cron, runAt, kind].filter(Boolean).length;
+  if (given > 1) {
+    failValidation("--cron, --run-at and --trigger are mutually exclusive.");
+  }
+  refuseNarrowingWithoutKind(args, kind, given);
+  if (runAt) {
+    validateRunAt(runAt);
+    return { runAt, ...timezone ? { timezone } : {} };
+  }
+  if (cron) {
+    return { cron, ...timezone ? { timezone } : {} };
+  }
+  if (kind) {
+    return { trigger: triggerFromFlags(kind, args), ...timezone ? { timezone } : {} };
+  }
+  if (timezone && !options.required) {
+    return { timezone };
+  }
+  if (options.required) {
+    failValidation(
+      `A trigger is required. Pass --cron or --run-at for a time-based one, or --trigger with one of: ${TRIGGER_KIND_IDS.join(", ")}.`
+    );
+  }
+  return void 0;
+}
+function flagText(args, key) {
+  const value = args[key];
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
+}
+function refuseMisusedKinds(kind, args) {
+  if (kind === "time.once") {
+    failValidation("Use --run-at for a one-off, rather than --trigger time.once.");
+  }
+  if (kind === "time.cron") {
+    failValidation("Use --cron for a repeating schedule, rather than --trigger time.cron.");
+  }
+  if (kind === "experiment.started" && flagText(args, "experiment")) {
+    failValidation(
+      'A test that exists has already started, so --experiment never fires on experiment.started. Leave it off and add --when "page = <page>" to watch one page.'
+    );
+  }
+}
+function refuseStrayFlags(kind, args) {
+  const allowed = new Set(TRIGGER_TARGETS[kind].map((target) => TRIGGER_TARGET_FIELDS[target.field].flag));
+  const stray = TRIGGER_TARGET_FIELD_IDS.map((field) => TRIGGER_TARGET_FIELDS[field].flag).filter(
+    (flag) => !allowed.has(flag) && flagText(args, flag) !== void 0 && !(kind === "experiment.started" && flag === "experiment")
+  );
+  if (stray.length === 0) {
+    return;
+  }
+  failValidation(
+    `${stray.map((flag) => `--${flag}`).join(", ")} does not narrow ${kind}. ${allowed.size > 0 ? `It can be pointed with ${[...allowed].map((flag) => `--${flag}`).join(", ")}.` : "It runs every time it happens \u2014 narrow it with --when rules over its payload instead."}`
+  );
+}
+var NARROWING_FLAGS = [...TRIGGER_TARGET_FIELD_IDS.map((field) => TRIGGER_TARGET_FIELDS[field].flag), "config"];
+function refuseNarrowingWithoutKind(args, kind, given) {
+  if (kind) {
+    return;
+  }
+  const stray = NARROWING_FLAGS.filter((flag) => flagText(args, flag) !== void 0);
+  if (stray.length === 0) {
+    return;
+  }
+  const flags = stray.map((flag) => `--${flag}`).join(", ");
+  failValidation(
+    given > 0 ? `${flags} does not narrow --cron or --run-at: a time trigger runs every time it comes round. Use --trigger <kind> with ${flags} instead, or leave ${flags} off.` : `${flags} narrows a trigger, and no trigger was given. Pass --trigger <kind> too \u2014 the item's whole trigger, with ${flags} \u2014 or leave ${flags} off.`
+  );
+}
+function configFromFlag(kind, args) {
+  const config = flagText(args, "config");
+  if (!config) {
+    return {};
+  }
+  if (kind !== "app.event") {
+    failValidation("--config is only for --trigger app.event: the settings of what happens in the tool.");
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(config);
+  } catch {
+    parsed = null;
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    failValidation(`--config must be a JSON object, e.g. '{"labelIds":"INBOX"}'.`);
+  }
+  return { configJson: config };
+}
+function triggerFromFlags(kind, args) {
+  if (!isTriggerKind(kind)) {
+    failValidation(`--trigger must be one of: ${TRIGGER_KIND_IDS.join(", ")}.`);
+  }
+  refuseMisusedKinds(kind, args);
+  refuseStrayFlags(kind, args);
+  const narrowings = {};
+  for (const { field, required } of TRIGGER_TARGETS[kind]) {
+    const value = flagText(args, TRIGGER_TARGET_FIELDS[field].flag);
+    if (value) {
+      narrowings[field] = value;
+    } else if (required) {
+      failValidation(
+        `--trigger ${kind} needs --${TRIGGER_TARGET_FIELDS[field].flag}. \`baker scheduled-agents targets --trigger ${kind} --field ${field}\` lists what it can be.`
+      );
+    }
+  }
+  return { kind, ...narrowings, ...configFromFlag(kind, args) };
+}
+function parseOccurrences(raw) {
+  if (raw === void 0) {
+    return void 0;
+  }
+  if (typeof raw !== "string") {
+    failValidation("--occurrences must be a comma-separated list of whole numbers, e.g. 1 or 1,3.");
+  }
+  const parts = raw.split(",").map((part) => part.trim()).filter((part) => part.length > 0);
+  const numbers = parts.map((part) => Number(part));
+  if (numbers.length === 0 || numbers.some((n) => !Number.isInteger(n) || n <= 0)) {
+    failValidation("--occurrences must be a comma-separated list of whole numbers above zero, e.g. 1 or 1,3.");
+  }
+  return numbers;
+}
+function parseBooleanFlag(raw, flagName) {
+  if (raw === void 0) {
+    return void 0;
+  }
+  if (raw === true || raw === "true") {
+    return true;
+  }
+  if (raw === false || raw === "false") {
+    return false;
+  }
+  failValidation(`${flagName} must be true or false.`);
+}
+var REACTION_ARGS = {
+  when: {
+    type: "string",
+    description: "Only run when what arrived passes these rules: `<field> <operator> <value>` joined by AND or by OR (either case). Fields are the trigger's payload fields (`baker scheduled-agents triggers --trigger <kind>` lists them; a webhook's are whatever was posted; an app.event's are what `targets --field appEvent --app <tool> --event <id>` says it sends). Operators: =, !=, contains, does not contain, starts with, ends with, >, <, >=, <=, in (comma list), exists, missing. Example: --when \"deal.stage = won AND amount > 10000\". A payload that fails is not counted and starts nothing. `none` clears the rules.",
+    required: false
+  },
+  times: {
+    type: "string",
+    description: "Only the first N times it fires (and its --when rules pass), then never again. `--times 1` is only the first time. Shorthand for --occurrences 1,2,\u2026,N.",
+    required: false
+  },
+  payload: {
+    type: "string",
+    description: "include (default) or omit. Whether the run's first message carries what arrived \u2014 the posted body, the event's properties, the Form's answers (emails and phones masked). Place single values in --prompt with {{payload.<field>}} instead; those are filled either way.",
+    required: false
+  },
+  cooldown: {
+    type: "string",
+    description: "At most one run per this many minutes, however often it fires. 0 removes it.",
+    required: false
+  }
+};
+var SLACK_ARG = {
+  slack: {
+    type: "string",
+    description: "Tell each run in Slack: `here` (the Slack conversation this chat came from), `me` (a direct message to the person in this chat), `#channel` (a channel linked to this company), or `off`. Each run opens its own thread there and Baker reports on it: what it found, what it needs, whether to publish.",
+    required: false
+  }
+};
+function slackBody(args) {
+  return typeof args.slack === "string" && args.slack.trim().length > 0 ? { slack: args.slack.trim() } : {};
+}
+function wholeNumber(raw, flag, { min }) {
+  if (raw === void 0) {
+    return void 0;
+  }
+  const value = Number(raw);
+  if (!Number.isInteger(value) || value < min) {
+    failValidation(`${flag} must be a whole number of at least ${min}.`);
+  }
+  return value;
+}
+function reactionBody(args) {
+  const occurrences = occurrencesFromFlags(args);
+  const when = whenFromFlag(args.when);
+  const includePayload = payloadFromFlag(args.payload);
+  const cooldownMinutes = wholeNumber(args.cooldown, "--cooldown", { min: 0 });
+  return {
+    ...occurrences !== void 0 ? { occurrences } : {},
+    ...when !== void 0 ? { when } : {},
+    ...includePayload !== void 0 ? { includePayload } : {},
+    ...cooldownMinutes !== void 0 ? { cooldownMinutes } : {}
+  };
+}
+function occurrencesFromFlags(args) {
+  const times = wholeNumber(args.times, "--times", { min: 1 });
+  const occurrences = parseOccurrences(args.occurrences);
+  if (times !== void 0 && occurrences !== void 0) {
+    failValidation("Pass --times or --occurrences, not both \u2014 --times 3 is --occurrences 1,2,3.");
+  }
+  return times !== void 0 ? firstTimes(times) : occurrences;
+}
+function whenFromFlag(raw) {
+  if (typeof raw !== "string") {
+    return void 0;
+  }
+  const text = raw.trim();
+  if (text.length === 0 || text.toLowerCase() === "none") {
+    return "none";
+  }
+  const parsed = parseConditionsExpression(text);
+  if (!parsed.ok) {
+    failValidation(parsed.error);
+  }
+  return text;
+}
+function payloadFromFlag(raw) {
+  if (raw === void 0) {
+    return void 0;
+  }
+  if (raw !== "include" && raw !== "omit") {
+    failValidation("--payload must be include or omit.");
+  }
+  return raw === "include";
+}
+function chatBody() {
+  const id = getEnv().BAKER_CHAT_ID;
+  return id ? { chatId: id } : {};
+}
+
+export {
+  writeOk,
+  failValidation,
+  failApi,
+  AUTO_PUBLISH_ARG,
+  refuseAutoPublish,
+  isTempScheduledAgentId,
+  validateScheduledAgentRef,
+  TRIGGER_ARG_DESCRIPTION,
+  TRIGGER_KIND_LIST,
+  NARROWING_ARGS,
+  buildTriggerBody,
+  parseBooleanFlag,
+  REACTION_ARGS,
+  SLACK_ARG,
+  slackBody,
+  reactionBody,
+  chatBody
+};
+//# sourceMappingURL=chunk-YGGRQXDP.js.map