@koda-sl/baker-cli 0.481.0-dev.2d33e194f → 0.498.0-dev.e2ca08ce6

package/dist/chunk-CKRSSMRT.js

@@ -0,0 +1,191 @@
+import {
+  hintLines,
+  splitHints
+} from "./chunk-D5FY4FAK.js";
+import {
+  isNotConnectedError,
+  writeJsonEnvelope
+} from "./chunk-OTNGMKI6.js";
+import {
+  ApiError,
+  apiPost
+} from "./chunk-OSWCEDFE.js";
+import {
+  requireChatId,
+  resolveChatId
+} from "./chunk-FZKUUI3F.js";
+
+// src/commands/ga4/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 as the positional argument`);
+  }
+  return target;
+}
+function readJsonSource(args, flag) {
+  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 {
+    return JSON.parse(raw);
+  } catch {
+    return failValidation(`--${flag} is not valid JSON`);
+  }
+}
+function asObject(value, flag, index) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    failValidation(
+      index === void 0 ? `--${flag} must be a JSON object` : `--${flag}[${index}] must be a JSON object`
+    );
+  }
+  return value;
+}
+function loadJsonArg(args, flag = "json") {
+  return asObject(readJsonSource(args, flag), flag);
+}
+function loadJsonPayloads(args) {
+  const parsed = readJsonSource(args, "json");
+  if (!Array.isArray(parsed)) {
+    return [asObject(parsed, "json")];
+  }
+  if (parsed.length === 0) {
+    failValidation("--json is an empty list \u2014 pass at least one definition");
+  }
+  return parsed.map((entry, index) => asObject(entry, "json", index));
+}
+var RETRYABLE_CODES = /* @__PURE__ */ new Set(["RATE_LIMITED", "UNAVAILABLE", "INTERNAL_ERROR", "NETWORK_ERROR", "TIMEOUT"]);
+function handleError(err) {
+  if (err instanceof ApiError) {
+    const readOnly = err.code === "FORBIDDEN" && /read the property but not change it/i.test(err.message);
+    writeJsonEnvelope({
+      ok: false,
+      error: {
+        code: err.code,
+        message: err.message,
+        ...readOnly ? {
+          fix: {
+            action: "reconnect",
+            explanation: "The Google Analytics connection is read-only. Ask the user to reconnect Google Analytics \u2014 in the dashboard, Brain \u2192 Integrations \u2192 Platforms \u2192 Google Analytics \u2014 which grants the permission to change the property. Reporting (`baker ga4 query`, `baker ga4 audit`) keeps working meanwhile, so carry on with the rest of the job and tell them what you will set up once they have reconnected. Don't claim anything was configured."
+          }
+        } : err.code === "UNAUTHORIZED" || err.code === "FORBIDDEN" && isNotConnectedError(err.code, err.message) ? {
+          fix: {
+            action: "request_connection",
+            explanation: 'Google Analytics is not connected for this company yet, or no property has been picked. Don\'t send the user to Settings \u2014 call the `request_connection` tool with { platform: "google-analytics", reason } and they connect and pick their property from inside the chat. If the `request_connection` call fails, say so plainly and give the exact route: dashboard \u2192 Brain \u2192 Integrations \u2192 Platforms \u2192 Google Analytics. 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 STAGE_HINTS = [
+  "Staged only \u2014 nothing has changed in Google Analytics yet. These apply when the chat completes, and an applied change takes effect on the property immediately: there is no version to publish afterwards and no undo. Say the changes are ready and take effect when the user completes the chat \u2014 not that they are done already."
+];
+var WARNING_HINT = "Read the warnings above before telling the user this is ready.";
+async function stageOp(op) {
+  const chatId = requireChatId();
+  try {
+    const { data, hints } = splitHints(await apiPost("/api/ga4/draft/stage", { chatId, op }));
+    writeJsonEnvelope({
+      ok: true,
+      data,
+      hints: [...hints, ...STAGE_HINTS, ...data.warnings.length > 0 ? [WARNING_HINT] : []]
+    });
+  } catch (err) {
+    handleError(err);
+  }
+}
+async function stageOps(ops) {
+  const [only] = ops;
+  if (ops.length === 1 && only) {
+    await stageOp(only);
+    return;
+  }
+  const chatId = requireChatId();
+  try {
+    const { data, hints } = splitHints(
+      await apiPost("/api/ga4/draft/stage-batch", { chatId, ops })
+    );
+    writeJsonEnvelope({
+      ok: true,
+      data,
+      hints: [...hints, ...STAGE_HINTS, ...data.ops.some((op) => op.warnings.length > 0) ? [WARNING_HINT] : []]
+    });
+  } catch (err) {
+    handleError(err);
+  }
+}
+async function draftAction(path, body, chat) {
+  const chatId = resolveChatId(chat);
+  try {
+    const { data, hints } = splitHints(await apiPost(path, { chatId, ...body }));
+    writeJsonEnvelope({ ok: true, data, ...hints.length > 0 ? { hints } : {} });
+    return data;
+  } catch (err) {
+    handleError(err);
+  }
+}
+function renderDraft(response) {
+  if (response.count === 0) {
+    return "No Google Analytics changes staged on this chat.";
+  }
+  const lines = [
+    `${response.count} staged Google Analytics change(s)`,
+    ...response.ops.map((op) => {
+      const status = op.result ? ` [${op.result.status}]` : "";
+      return `  ${op.ref}  ${op.summary}${status}`;
+    })
+  ];
+  if (response.status === "applied") {
+    const failed = response.ops.filter((op) => op.result?.status !== "applied");
+    lines.push(
+      "",
+      failed.length === 0 ? "All applied \u2014 these are in effect on the property now." : `${failed.length} of ${response.count} did not apply. The rest are in effect on the property.`
+    );
+  }
+  if (response.publishError) {
+    lines.push("", response.publishError);
+  }
+  return lines.join("\n");
+}
+async function draftList(json, chat) {
+  const chatId = resolveChatId(chat);
+  try {
+    const response = await apiPost("/api/ga4/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 {
+  failValidation,
+  requireTarget,
+  loadJsonArg,
+  loadJsonPayloads,
+  handleError,
+  stageOp,
+  stageOps,
+  draftAction,
+  draftList
+};
+//# sourceMappingURL=chunk-CKRSSMRT.js.map

package/dist/chunk-D53AAUG4.js

@@ -0,0 +1,215 @@
+import {
+  debugLogSetting
+} from "./chunk-FZKUUI3F.js";
+
+// src/debugLog.ts
+import { appendFileSync, mkdirSync, renameSync, statSync } from "fs";
+import { dirname, isAbsolute, resolve } from "path";
+var DEFAULT_FILE = "baker-cli-debug.jsonl";
+var BOOLEAN_ON = /* @__PURE__ */ new Set(["1", "true", "on", "yes"]);
+var BOOLEAN_OFF = /* @__PURE__ */ new Set(["0", "false", "off", "no"]);
+var MAX_BYTES = 64 * 1024 * 1024;
+var REDACTIONS = [
+  [/Bearer\s+[A-Za-z0-9._-]+/g, "Bearer [redacted]"],
+  // Authorization headers
+  // Every prefix, captured rather than listed thrice: `bkr_` and `bkv_` do not
+  // contain the literal `bk_`, so the company-key rule matched no part of the
+  // read-only credentials a Session review or a published report runs with.
+  [/\b(bk[rv]?)_[A-Za-z0-9]+/g, "$1_[redacted]"],
+  // Baker API keys
+  [/eyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+/g, "[redacted-jwt]"],
+  // JWTs / id tokens
+  [/ya29\.[A-Za-z0-9._-]+/g, "[redacted-google-token]"],
+  // Google OAuth access tokens
+  [/1\/\/[A-Za-z0-9._-]+/g, "[redacted-google-refresh]"],
+  // Google refresh tokens
+  [/EAA[A-Za-z0-9]{20,}/g, "[redacted-meta-token]"]
+  // Meta/Facebook access tokens
+];
+function redactSecrets(input) {
+  let out = input;
+  for (const [pattern, replacement] of REDACTIONS) {
+    out = out.replace(pattern, replacement);
+  }
+  return out;
+}
+var CREDENTIAL_VALUE = "[credential value]";
+var CREDENTIAL_PUT_PATH = "/api/credentials/put";
+function withoutCredentialValue(url, body) {
+  let path;
+  try {
+    path = new URL(url).pathname;
+  } catch {
+    path = url;
+  }
+  if (path !== CREDENTIAL_PUT_PATH || body === null || typeof body !== "object" || !("value" in body)) {
+    return body;
+  }
+  return { ...body, value: CREDENTIAL_VALUE };
+}
+var PUT_FLAGS_WITH_VALUES = /* @__PURE__ */ new Set(["--host", "--label"]);
+function argvWithoutCredentialValue(argv) {
+  if (argv[0] !== "credentials" || argv[1] !== "put") {
+    return argv;
+  }
+  let nameSeen = false;
+  let keepNext = false;
+  let redactNext = false;
+  return argv.map((arg, index) => {
+    if (index < 2) return arg;
+    if (keepNext || redactNext) {
+      const kept = keepNext ? arg : CREDENTIAL_VALUE;
+      keepNext = false;
+      redactNext = false;
+      return kept;
+    }
+    if (arg.startsWith("--value=")) return `--value=${CREDENTIAL_VALUE}`;
+    redactNext = arg === "--value";
+    keepNext = PUT_FLAGS_WITH_VALUES.has(arg);
+    if (arg.startsWith("-")) return arg;
+    const isName = !nameSeen;
+    nameSeen = true;
+    return isName ? arg : CREDENTIAL_VALUE;
+  });
+}
+function resolveTarget() {
+  const raw = debugLogSetting();
+  if (!raw) {
+    return void 0;
+  }
+  const lower = raw.toLowerCase();
+  if (BOOLEAN_OFF.has(lower)) {
+    return void 0;
+  }
+  const target = BOOLEAN_ON.has(lower) ? DEFAULT_FILE : raw;
+  return isAbsolute(target) ? target : resolve(process.cwd(), target);
+}
+function isDebugLogEnabled() {
+  return resolveTarget() !== void 0;
+}
+var sessionId;
+function getSessionId() {
+  if (!sessionId) {
+    sessionId = `${process.pid}-${Date.now()}`;
+  }
+  return sessionId;
+}
+var trackedPath;
+var bytesInFile = 0;
+function ensureReady(filePath) {
+  if (trackedPath !== filePath) {
+    trackedPath = filePath;
+    mkdirSync(dirname(filePath), { recursive: true });
+    try {
+      bytesInFile = statSync(filePath).size;
+    } catch {
+      bytesInFile = 0;
+    }
+  }
+}
+function append(entry) {
+  const filePath = resolveTarget();
+  if (!filePath) {
+    return;
+  }
+  try {
+    const payload = { ts: (/* @__PURE__ */ new Date()).toISOString(), session: getSessionId(), ...entry };
+    const line = `${redactSecrets(JSON.stringify(payload))}
+`;
+    ensureReady(filePath);
+    const size = Buffer.byteLength(line);
+    if (bytesInFile + size > MAX_BYTES) {
+      renameSync(filePath, `${filePath}.1`);
+      bytesInFile = 0;
+    }
+    appendFileSync(filePath, line);
+    bytesInFile += size;
+  } catch {
+  }
+}
+function errorToPlain(err) {
+  if (err instanceof Error) {
+    const code = err.code;
+    return { name: err.name, message: err.message, ...typeof code === "string" ? { code } : {} };
+  }
+  return { message: String(err) };
+}
+var invocationStartedAt;
+function logInvocation(argv) {
+  invocationStartedAt = Date.now();
+  append({ kind: "invocation", argv: argvWithoutCredentialValue(argv), cwd: process.cwd() });
+}
+function logExit(code) {
+  append({
+    kind: "exit",
+    code,
+    ...invocationStartedAt === void 0 ? {} : { durationMs: Date.now() - invocationStartedAt }
+  });
+}
+var exitHookInstalled = false;
+function installExitRecord() {
+  if (exitHookInstalled || !isDebugLogEnabled()) {
+    return;
+  }
+  exitHookInstalled = true;
+  process.on("exit", (code) => {
+    logExit(typeof code === "number" ? code : 0);
+  });
+}
+function debugLogHttp(entry) {
+  if (!isDebugLogEnabled()) {
+    return;
+  }
+  append({
+    kind: "http",
+    source: entry.source,
+    method: entry.method,
+    url: entry.url,
+    durationMs: entry.durationMs,
+    request: withoutCredentialValue(entry.url, entry.requestBody),
+    status: entry.status,
+    ok: entry.ok,
+    response: entry.responseBody,
+    error: entry.error === void 0 ? void 0 : errorToPlain(entry.error)
+  });
+}
+async function readBodyForLog(response) {
+  if (!isDebugLogEnabled()) {
+    return void 0;
+  }
+  try {
+    return await response.clone().text();
+  } catch {
+    return void 0;
+  }
+}
+function tapStream(name, stream) {
+  const original = stream.write.bind(stream);
+  const decoder = new TextDecoder("utf-8");
+  stream.write = ((chunk, ...rest) => {
+    try {
+      const text = typeof chunk === "string" ? chunk : chunk instanceof Uint8Array ? decoder.decode(chunk, { stream: true }) : String(chunk);
+      append({ kind: "output", stream: name, text });
+    } catch {
+    }
+    return original(chunk, ...rest);
+  });
+}
+var tapsInstalled = false;
+function installStreamTaps() {
+  if (tapsInstalled || !isDebugLogEnabled()) {
+    return;
+  }
+  tapsInstalled = true;
+  tapStream("stdout", process.stdout);
+  tapStream("stderr", process.stderr);
+}
+
+export {
+  logInvocation,
+  installExitRecord,
+  debugLogHttp,
+  readBodyForLog,
+  installStreamTaps
+};
+//# sourceMappingURL=chunk-D53AAUG4.js.map

package/dist/chunk-DGUYFROS.js

@@ -0,0 +1,76 @@
+import {
+  MAX_REMOTE_IMAGE_BYTES,
+  fetchExternalBytes
+} from "./chunk-3FFJYMKM.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-DGUYFROS.js.map

package/dist/chunk-DS2ZRTAL.js

@@ -0,0 +1,136 @@
+import {
+  coercePathUrlToUrl,
+  looksLikeHttpUrl
+} from "./chunk-EIJDXZW5.js";
+
+// src/commands/canvas/resolve-paths.ts
+import path from "path";
+function resolveRelativeCanvasPaths(canvas, baseDir) {
+  if (!canvas || typeof canvas !== "object") return canvas;
+  const c = canvas;
+  if (!Array.isArray(c.nodes)) return canvas;
+  return { ...canvas, nodes: c.nodes.map((n) => resolveNode(n, baseDir)) };
+}
+function localPathParam(node) {
+  if (node.type === "ingest") return node.params?.source === "path" ? "path" : null;
+  if (node.type === "hyperframe_render" || node.type === "hyperframe_snapshot") return "composition";
+  return null;
+}
+function resolveNode(node, baseDir) {
+  if (!node || typeof node !== "object") return node;
+  const n = node;
+  const params = n.params;
+  if (!params || typeof params !== "object") return node;
+  const key = localPathParam(n);
+  if (key && isResolvableRelative(params[key])) {
+    return { ...node, params: { ...params, [key]: path.resolve(baseDir, params[key]) } };
+  }
+  return node;
+}
+function isResolvableRelative(value) {
+  return typeof value === "string" && value.length > 0 && !value.includes("[TODO") && !looksLikeHttpUrl(value) && !path.isAbsolute(value);
+}
+
+// src/commands/canvas/normalize-paths.ts
+import { existsSync, realpathSync } from "fs";
+import { writeFile } from "fs/promises";
+import path2 from "path";
+function findWorkspaceRoot(startDir, exists = existsSync, maxDepth = 12) {
+  let dir = path2.resolve(startDir);
+  for (let i = 0; i < maxDepth; i++) {
+    if (exists(path2.join(dir, "package.json"))) return dir;
+    const parent = path2.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+function canvasOutputsRoot(canvasFile, cwd = process.cwd(), exists = existsSync) {
+  const root = findWorkspaceRoot(path2.dirname(path2.resolve(cwd, canvasFile)), exists) ?? cwd;
+  return path2.join(root, "canvas");
+}
+function canonicalize(target) {
+  const abs = path2.resolve(target);
+  let dir = abs;
+  for (; ; ) {
+    try {
+      const real = realpathSync(dir);
+      return dir === abs ? real : path2.join(real, path2.relative(dir, abs));
+    } catch {
+      const parent = path2.dirname(dir);
+      if (parent === dir) return abs;
+      dir = parent;
+    }
+  }
+}
+function isInside(root, target) {
+  const rel = path2.relative(root, target);
+  return rel !== "" && !rel.startsWith("..") && !path2.isAbsolute(rel);
+}
+function toCanvasRelative(canvasDir, target) {
+  return path2.relative(canvasDir, target).split(path2.sep).join("/");
+}
+var RUNTIME_WORKSPACE_ROOT = "/home/user/repo";
+function rewriteTarget(value, workspaceRoot) {
+  if (typeof value !== "string" || value.length === 0) return null;
+  if (value.includes("[TODO") || looksLikeHttpUrl(value) || !path2.isAbsolute(value)) return null;
+  const target = canonicalize(value);
+  if (isInside(workspaceRoot, target)) return target;
+  const fromRuntime = path2.relative(RUNTIME_WORKSPACE_ROOT, path2.normalize(value));
+  if (fromRuntime !== "" && !fromRuntime.startsWith("..") && !path2.isAbsolute(fromRuntime)) {
+    return path2.join(workspaceRoot, fromRuntime);
+  }
+  return null;
+}
+function normalizeCanvasPaths(canvas, canvasDir, workspaceRoot) {
+  if (!canvas || typeof canvas !== "object") return { canvas, rewrites: [] };
+  const c = canvas;
+  if (!Array.isArray(c.nodes)) return { canvas, rewrites: [] };
+  const root = canonicalize(workspaceRoot);
+  const dir = canonicalize(canvasDir);
+  const rewrites = [];
+  const nodes = c.nodes.map((node) => {
+    if (!node || typeof node !== "object") return node;
+    const n = node;
+    const params = n.params;
+    if (!params || typeof params !== "object") return node;
+    const nodeId = typeof n.id === "string" ? n.id : "?";
+    if (n.type === "ingest" && params.source === "path" && looksLikeHttpUrl(params.path)) {
+      rewrites.push({ nodeId, param: "source", from: "path", to: "url" });
+      return { ...node, params: coercePathUrlToUrl(params) };
+    }
+    const key = localPathParam(n);
+    if (!key) return node;
+    const target = rewriteTarget(params[key], root);
+    if (target === null) return node;
+    const to = toCanvasRelative(dir, target);
+    rewrites.push({ nodeId, param: key, from: params[key], to });
+    return { ...node, params: { ...params, [key]: to } };
+  });
+  return rewrites.length === 0 ? { canvas, rewrites } : { canvas: { ...canvas, nodes }, rewrites };
+}
+async function healCanvasPaths(filePath, canvas) {
+  const canvasDir = path2.dirname(filePath);
+  const workspaceRoot = findWorkspaceRoot(canvasDir);
+  if (!workspaceRoot) return { canvas, rewrites: [], text: null };
+  const normalized = normalizeCanvasPaths(canvas, canvasDir, workspaceRoot);
+  if (normalized.rewrites.length === 0) return { ...normalized, text: null };
+  const text = `${JSON.stringify(normalized.canvas, null, 2)}
+`;
+  await writeFile(filePath, text, "utf8");
+  return { ...normalized, text };
+}
+function describeRewrites(rewrites) {
+  return rewrites.map((r) => `  ${r.nodeId}.${r.param}: ${r.from} \u2192 ${r.to}`).join("\n");
+}
+
+export {
+  resolveRelativeCanvasPaths,
+  localPathParam,
+  findWorkspaceRoot,
+  canvasOutputsRoot,
+  normalizeCanvasPaths,
+  healCanvasPaths,
+  describeRewrites
+};
+//# sourceMappingURL=chunk-DS2ZRTAL.js.map