@koda-sl/baker-cli 0.458.0 → 0.459.0

package/dist/chunk-MD3B6MTI.js

@@ -0,0 +1,103 @@
+import {
+  SITE_COLLECTION_MODES,
+  SITE_CONSENT_MODES,
+  SITE_HOME_MODES
+} from "./chunk-ZJVHZHYP.js";
+import {
+  ApiError
+} from "./chunk-NUHMHZTZ.js";
+import {
+  writeJson
+} from "./chunk-USFTTDIO.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-MD3B6MTI.js.map

package/dist/chunk-ME76DRT3.js

@@ -0,0 +1,149 @@
+import {
+  hintLines,
+  splitHints
+} from "./chunk-D5FY4FAK.js";
+import {
+  isNotConnectedError,
+  writeJsonEnvelope
+} from "./chunk-OAYHDIW2.js";
+import {
+  ApiError,
+  apiPost
+} from "./chunk-NUHMHZTZ.js";
+import {
+  requireChatId,
+  resolveChatId
+} from "./chunk-3XA4JVMY.js";
+
+// src/commands/tag-manager/shared.ts
+import { readFileSync } from "fs";
+function failValidation(message) {
+  writeJsonEnvelope({ ok: false, error: { code: "VALIDATION_ERROR", message } });
+  process.exit(1);
+}
+function requireTarget(args, entity) {
+  const positional = Array.isArray(args._) ? args._[0] : void 0;
+  const target = args.id ?? args.target ?? positional;
+  if (typeof target !== "string" || target.length === 0) {
+    failValidation(`pass the ${entity} id or path as the positional argument`);
+  }
+  return target;
+}
+function loadJsonArg(args, flag = "json") {
+  const inline = args[flag];
+  const file = args.file;
+  const raw = typeof file === "string" && file.length > 0 ? readFileSync(file, "utf8") : typeof inline === "string" && inline.length > 0 ? inline : void 0;
+  if (raw === void 0) {
+    failValidation(`pass --${flag} with inline JSON or --file with a path to a JSON file`);
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      failValidation(`--${flag} must be a JSON object`);
+    }
+    return parsed;
+  } catch {
+    return failValidation(`--${flag} is not valid JSON`);
+  }
+}
+var RETRYABLE_CODES = /* @__PURE__ */ new Set(["RATE_LIMITED", "UNAVAILABLE", "INTERNAL_ERROR", "NETWORK_ERROR", "TIMEOUT"]);
+function handleError(err) {
+  if (err instanceof ApiError) {
+    writeJsonEnvelope({
+      ok: false,
+      error: {
+        code: err.code,
+        message: err.message,
+        ...err.code === "UNAUTHORIZED" || err.code === "FORBIDDEN" && isNotConnectedError(err.code, err.message) ? {
+          fix: {
+            action: "request_connection",
+            explanation: 'Tag Manager is not connected for this company yet, or no container has been picked. Don\'t send the user to Settings \u2014 call the `request_connection` tool with { platform: "google-tag-manager", reason } and they connect and pick their containers (they can pick more than one) from inside the chat. `request_tag_input` is not the route: that form manages the container snippet on the site, not what runs inside the container, and it cannot pick a container. If the `request_connection` call fails, say so plainly and give the exact route: dashboard \u2192 Brain \u2192 Integrations \u2192 Platforms \u2192 Google Tag Manager, where they also pick the container. Then carry on with the rest of the task.'
+          }
+        } : {},
+        retryable: RETRYABLE_CODES.has(err.code)
+      }
+    });
+    process.exit(1);
+  }
+  writeJsonEnvelope({ ok: false, error: { code: "NETWORK_ERROR", message: "Unexpected error", retryable: true } });
+  process.exit(1);
+}
+var TAG_MANAGER_TIMEOUT_MS = 18e4;
+var STAGE_HINTS = [
+  "Staged only \u2014 nothing has changed in Tag Manager yet. These apply when the chat completes, in dependency order, and close as a Tag Manager version that is then published, so they do go live on the user's site. Say the changes are ready and go live when they publish \u2014 not that they are live already."
+];
+async function stageOp(op) {
+  const chatId = requireChatId();
+  try {
+    const { data, hints } = splitHints(
+      await apiPost(
+        "/api/tag-manager/draft/stage",
+        { chatId, op },
+        { timeoutMs: TAG_MANAGER_TIMEOUT_MS }
+      )
+    );
+    writeJsonEnvelope({ ok: true, data, hints: [...hints, ...STAGE_HINTS] });
+  } catch (err) {
+    handleError(err);
+  }
+}
+async function draftAction(path, body, chat) {
+  const chatId = resolveChatId(chat);
+  try {
+    const { data, hints } = splitHints(
+      await apiPost(path, { chatId, ...body }, { timeoutMs: TAG_MANAGER_TIMEOUT_MS })
+    );
+    writeJsonEnvelope({ ok: true, data, ...hints.length > 0 ? { hints } : {} });
+    return data;
+  } catch (err) {
+    handleError(err);
+  }
+}
+function renderDraft(response) {
+  if (response.count === 0) {
+    return "No Tag Manager changes staged on this chat.";
+  }
+  const lines = [
+    `${response.count} staged Tag Manager change(s)`,
+    ...response.ops.flatMap((op) => {
+      const status = op.result ? ` [${op.result.status}]` : "";
+      return [`  ${op.ref}  ${op.summary}${status}`, ...(op.warnings ?? []).map((warning) => `    \u26A0 ${warning}`)];
+    })
+  ];
+  if (response.versionId) {
+    lines.push(
+      "",
+      response.published ? `Applied and published as Tag Manager version ${response.versionId}. These changes are live on the site.` : `Applied into Tag Manager version ${response.versionId}. It is NOT published \u2014 publish it in Tag Manager to go live.`
+    );
+  }
+  if (response.compilerError) {
+    lines.push("", `Tag Manager reported a problem building the version: ${response.compilerError}`);
+  }
+  return lines.join("\n");
+}
+async function draftList(json, chat) {
+  const chatId = resolveChatId(chat);
+  try {
+    const response = await apiPost("/api/tag-manager/draft", { chatId });
+    const { data, hints } = splitHints(response);
+    if (json) {
+      writeJsonEnvelope({ ok: true, data, ...hints.length > 0 ? { hints } : {} });
+      return;
+    }
+    process.stdout.write(`${renderDraft(data)}${hintLines(response)}
+`);
+  } catch (err) {
+    handleError(err);
+  }
+}
+
+export {
+  requireTarget,
+  loadJsonArg,
+  handleError,
+  TAG_MANAGER_TIMEOUT_MS,
+  stageOp,
+  draftAction,
+  draftList
+};
+//# sourceMappingURL=chunk-ME76DRT3.js.map

package/dist/chunk-MQEA2YZZ.js

@@ -0,0 +1,96 @@
+import {
+  ApiError,
+  apiGet,
+  apiPost
+} from "./chunk-NUHMHZTZ.js";
+
+// src/commands/images/api.ts
+import { readFile } from "fs/promises";
+import { basename, extname } from "path";
+var imageProcessingTimeoutMs = 18e4;
+var imageReadyPollIntervalMs = 2e3;
+var mimeMap = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".svg": "image/svg+xml",
+  ".avif": "image/avif"
+};
+var defaultImageApiDeps = {
+  readFile,
+  post: apiPost,
+  get: apiGet,
+  sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms))
+};
+function detectImageContentType(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 uploadLocalImage(args, deps = defaultImageApiDeps) {
+  return uploadImageBytes(
+    {
+      bytes: await deps.readFile(args.file),
+      contentType: args.contentType,
+      // Only the bytes used to be sent, so "iso27001-badge.png" arrived as an
+      // anonymous blob. The describe pass treats this as a hint, not gospel.
+      originalFilename: basename(args.file),
+      source: args.source,
+      descriptionContext: args.descriptionContext
+    },
+    deps
+  );
+}
+function uploadImageBytes(args, deps = defaultImageApiDeps) {
+  const body = {
+    base64: args.bytes.toString("base64"),
+    contentType: args.contentType,
+    originalFilename: args.originalFilename
+  };
+  if (args.source) body.source = args.source;
+  if (args.descriptionContext) body.descriptionContext = args.descriptionContext;
+  return deps.post("/api/images/upload", body, { timeoutMs: imageProcessingTimeoutMs });
+}
+function getImage(deps, imageId) {
+  return deps.get("/api/images/get", { id: imageId });
+}
+function publishImageAsCreative(deps, args) {
+  return deps.post("/api/creatives/publish", args);
+}
+async function waitForReadyImage(deps, imageId, opts = {}) {
+  const timeoutMs = opts.timeoutMs ?? imageProcessingTimeoutMs;
+  const pollIntervalMs = opts.pollIntervalMs ?? imageReadyPollIntervalMs;
+  const deadline = Date.now() + timeoutMs;
+  let lastStatus = "unknown";
+  while (Date.now() <= deadline) {
+    const image = await getImage(deps, imageId);
+    lastStatus = image.status;
+    if (image.status === "ready") {
+      return image;
+    }
+    if (image.status === "error") {
+      throw new ApiError("IMAGE_PROCESSING_ERROR", "Image processing failed");
+    }
+    await deps.sleep(pollIntervalMs);
+  }
+  throw new ApiError("TIMEOUT", `Image was not ready before timeout; last status: ${lastStatus}`);
+}
+
+export {
+  imageProcessingTimeoutMs,
+  defaultImageApiDeps,
+  detectImageContentType,
+  uploadLocalImage,
+  uploadImageBytes,
+  publishImageAsCreative,
+  waitForReadyImage
+};
+//# sourceMappingURL=chunk-MQEA2YZZ.js.map