@koda-sl/baker-cli 0.386.0-dev.4e118c09a → 0.386.0-dev.d6e55699d

package/dist/chunk-EDNX3AOS.js

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

package/dist/chunk-EDNX3AOS.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/lib/image/io.ts"],"sourcesContent":["import { randomBytes } from \"node:crypto\";\nimport { glob as fsGlob, readFile, rename, stat, writeFile } from \"node:fs/promises\";\nimport { dirname, extname, join, resolve } from \"node:path\";\nimport { fetchExternalBytes, MAX_REMOTE_IMAGE_BYTES } from \"../externalFetch.ts\";\n\nconst REMOTE_RE = /^https?:\\/\\//i;\nconst GLOB_RE = /[*?[\\]{}]/;\n\nexport function isRemoteUrl(value: string): boolean {\n  return REMOTE_RE.test(value);\n}\n\nfunction looksLikeGlob(value: string): boolean {\n  return GLOB_RE.test(value);\n}\n\n/**\n * Expand a user-supplied input spec into a list of local file paths.\n * Accepts: single path, glob pattern, or comma-separated list. Inputs that look\n * like remote URLs are returned unchanged so callers can decide whether to\n * fetch them.\n */\nexport async function expandInputs(spec: string): Promise<string[]> {\n  const parts = spec\n    .split(\",\")\n    .map((p) => p.trim())\n    .filter(Boolean);\n  const out: string[] = [];\n  for (const part of parts) {\n    if (isRemoteUrl(part)) {\n      out.push(part);\n      continue;\n    }\n    if (looksLikeGlob(part)) {\n      for await (const match of fsGlob(part)) {\n        if (typeof match === \"string\") out.push(match);\n      }\n    } else {\n      out.push(part);\n    }\n  }\n  return out;\n}\n\nexport async function readImageBuffer(pathOrUrl: string): Promise<Buffer> {\n  if (isRemoteUrl(pathOrUrl)) {\n    // Everything reaching here is decoded by sharp — `crop`, `normalize`,\n    // `dimensions`. An image ceiling, not the canvas asset one.\n    const { buffer } = await fetchExternalBytes(pathOrUrl, { maxBytes: MAX_REMOTE_IMAGE_BYTES });\n    return buffer;\n  }\n  return readFile(pathOrUrl);\n}\n\nexport async function isDirectory(path: string): Promise<boolean> {\n  try {\n    const s = await stat(path);\n    return s.isDirectory();\n  } catch {\n    return false;\n  }\n}\n\n/**\n * Resolve the output path for a processed file.\n * - One input + --output=<file>  → that file path\n * - One input + --output=<dir>   → dir/basename\n * - One input, no --output       → input path (in-place)\n * - N inputs + --output=<dir>    → dir/basename\n * - N inputs, no --output        → each input path (in-place)\n * - N inputs + --output=<file>   → validation error before reaching here\n */\nexport async function resolveOutputPath(\n  inputPath: string,\n  outputArg: string | undefined,\n  options: { multipleInputs: boolean; newExtension?: string },\n): Promise<string> {\n  const base = options.newExtension ? inputPath.slice(0, -extname(inputPath).length) + options.newExtension : inputPath;\n\n  if (!outputArg) return base;\n\n  if (options.multipleInputs || (await isDirectory(outputArg))) {\n    const filename = base.split(\"/\").pop() ?? \"out.png\";\n    return join(outputArg, filename);\n  }\n  return outputArg;\n}\n\n/**\n * Write a file atomically: write to a tempfile in the same directory, then\n * rename. Prevents partial writes if the process is killed mid-write.\n */\nexport async function atomicWrite(targetPath: string, data: Buffer): Promise<void> {\n  const absolute = resolve(targetPath);\n  const dir = dirname(absolute);\n  const tmp = join(dir, `.baker-image-${randomBytes(8).toString(\"hex\")}.tmp`);\n  await writeFile(tmp, data);\n  await rename(tmp, absolute);\n}\n"],"mappings":";;;;;;AAAA,SAAS,mBAAmB;AAC5B,SAAS,QAAQ,QAAQ,UAAU,QAAQ,MAAM,iBAAiB;AAClE,SAAS,SAAS,SAAS,MAAM,eAAe;AAGhD,IAAM,YAAY;AAClB,IAAM,UAAU;AAET,SAAS,YAAY,OAAwB;AAClD,SAAO,UAAU,KAAK,KAAK;AAC7B;AAEA,SAAS,cAAc,OAAwB;AAC7C,SAAO,QAAQ,KAAK,KAAK;AAC3B;AAQA,eAAsB,aAAa,MAAiC;AAClE,QAAM,QAAQ,KACX,MAAM,GAAG,EACT,IAAI,CAAC,MAAM,EAAE,KAAK,CAAC,EACnB,OAAO,OAAO;AACjB,QAAM,MAAgB,CAAC;AACvB,aAAW,QAAQ,OAAO;AACxB,QAAI,YAAY,IAAI,GAAG;AACrB,UAAI,KAAK,IAAI;AACb;AAAA,IACF;AACA,QAAI,cAAc,IAAI,GAAG;AACvB,uBAAiB,SAAS,OAAO,IAAI,GAAG;AACtC,YAAI,OAAO,UAAU,SAAU,KAAI,KAAK,KAAK;AAAA,MAC/C;AAAA,IACF,OAAO;AACL,UAAI,KAAK,IAAI;AAAA,IACf;AAAA,EACF;AACA,SAAO;AACT;AAEA,eAAsB,gBAAgB,WAAoC;AACxE,MAAI,YAAY,SAAS,GAAG;AAG1B,UAAM,EAAE,OAAO,IAAI,MAAM,mBAAmB,WAAW,EAAE,UAAU,uBAAuB,CAAC;AAC3F,WAAO;AAAA,EACT;AACA,SAAO,SAAS,SAAS;AAC3B;AAEA,eAAsB,YAAY,MAAgC;AAChE,MAAI;AACF,UAAM,IAAI,MAAM,KAAK,IAAI;AACzB,WAAO,EAAE,YAAY;AAAA,EACvB,QAAQ;AACN,WAAO;AAAA,EACT;AACF;AAWA,eAAsB,kBACpB,WACA,WACA,SACiB;AACjB,QAAM,OAAO,QAAQ,eAAe,UAAU,MAAM,GAAG,CAAC,QAAQ,SAAS,EAAE,MAAM,IAAI,QAAQ,eAAe;AAE5G,MAAI,CAAC,UAAW,QAAO;AAEvB,MAAI,QAAQ,kBAAmB,MAAM,YAAY,SAAS,GAAI;AAC5D,UAAM,WAAW,KAAK,MAAM,GAAG,EAAE,IAAI,KAAK;AAC1C,WAAO,KAAK,WAAW,QAAQ;AAAA,EACjC;AACA,SAAO;AACT;AAMA,eAAsB,YAAY,YAAoB,MAA6B;AACjF,QAAM,WAAW,QAAQ,UAAU;AACnC,QAAM,MAAM,QAAQ,QAAQ;AAC5B,QAAM,MAAM,KAAK,KAAK,gBAAgB,YAAY,CAAC,EAAE,SAAS,KAAK,CAAC,MAAM;AAC1E,QAAM,UAAU,KAAK,IAAI;AACzB,QAAM,OAAO,KAAK,QAAQ;AAC5B;","names":[]}

package/dist/chunk-EF5DP6EB.js

@@ -0,0 +1,52 @@
+import {
+  commandFor,
+  declaredArg
+} from "./chunk-WOTDHRNF.js";
+
+// src/cache-flag.ts
+var NO_CACHE_ARG = {
+  type: "boolean",
+  description: "Skip cached results and read live from the platform (slower)",
+  required: false
+};
+var LEGACY = "--skip-cache";
+var CANONICAL = "--no-cache";
+var PARSEABLE = "--noCache";
+function respell(token, from, to) {
+  if (token === from) {
+    return [to];
+  }
+  if (!token.startsWith(`${from}=`)) {
+    return [token];
+  }
+  return token.slice(from.length + 1) === "false" ? [] : [to];
+}
+function normalizeCacheFlag(argv) {
+  return rewriteBeforeDoubleDash(argv, (token) => respell(token, LEGACY, CANONICAL));
+}
+function cacheFlagForCommand(root, argv) {
+  if (!argv.includes(CANONICAL)) {
+    return argv;
+  }
+  const command = commandFor(root, argv);
+  if (!command || declaredArg(command, "no-cache")) {
+    return argv;
+  }
+  return rewriteBeforeDoubleDash(argv, (token) => token === CANONICAL ? [] : [token]);
+}
+function cacheFlagForParser(argv) {
+  return rewriteBeforeDoubleDash(argv, (token) => respell(token, CANONICAL, PARSEABLE));
+}
+function rewriteBeforeDoubleDash(argv, rewrite) {
+  const end = argv.indexOf("--");
+  const limit = end === -1 ? argv.length : end;
+  return argv.flatMap((token, index) => index >= limit ? [token] : rewrite(token));
+}
+
+export {
+  NO_CACHE_ARG,
+  normalizeCacheFlag,
+  cacheFlagForCommand,
+  cacheFlagForParser
+};
+//# sourceMappingURL=chunk-EF5DP6EB.js.map

package/dist/chunk-EF5DP6EB.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/cache-flag.ts"],"sourcesContent":["/**\n * One way to ask for a fresh read.\n *\n * Cached reads used to be bypassed by two different flags: `--no-cache` on the\n * Google, GA4, GSC, research and X families, `--skip-cache` on LinkedIn and\n * Meta. They named the two cache layers — `--no-cache` the CLI's own disk cache,\n * `--skip-cache` the server's — which is a distinction no caller has ever wanted\n * to make: a caller asking for fresh data wants fresh data, and the layer that\n * would have answered instead is an implementation detail of ours.\n *\n * The split was not survivable once an unrecognised flag started failing the\n * call instead of being dropped. The reports runtime appends `--no-cache` for\n * `?fresh=true` and cannot know which family a report reads, so every report row\n * backed by `ads linkedin analytics` or `ads meta insights` failed on refresh —\n * silently, as an empty row. So `--no-cache` is the name, on every command that\n * caches anything, and it bypasses both layers.\n */\n\nimport { declaredArg } from \"./output-flag.ts\";\nimport { commandFor, type IntrospectableCommand } from \"./unknown-flags.ts\";\n\n/**\n * The declaration LinkedIn and Meta share, so `baker schema` reads the same on\n * every command in the families this rename covers. The older families still\n * carry their own wording for the same flag.\n */\nexport const NO_CACHE_ARG = {\n  type: \"boolean\",\n  description: \"Skip cached results and read live from the platform (slower)\",\n  required: false,\n} as const;\n\nconst LEGACY = \"--skip-cache\";\nconst CANONICAL = \"--no-cache\";\n/**\n * The spelling handed to the parser, and the reason this module exists twice\n * over. citty resolves a bare `--no-cache` to `cache: false` rather than filling\n * the `no-cache` arg the command declared, so every `args[\"no-cache\"]` read in\n * the CLI sees `undefined` and the flag does nothing at all — the same trap\n * `wantsAsync` in `ads/meta/insights.ts` records for `--no-async`. citty\n * registers `camelCase(name)` as an alias of every declared arg, and mri leaves\n * `--noCache` alone, so this spelling lands in `args[\"no-cache\"]` as intended.\n */\nconst PARSEABLE = \"--noCache\";\n\n/**\n * One token, respelled — and collapsed to the bare flag when it carried a value.\n *\n * `--no-cache=true` is not the same option with a value: mri's `--no-` branch\n * never splits on `=`, so the whole `cache=true` becomes the key and the flag is\n * dropped without a word. The bare flag says the same thing and survives, and\n * the one value mri read as off drops the flag rather than mis-stating it.\n */\nfunction respell(token: string, from: string, to: string): string[] {\n  if (token === from) {\n    return [to];\n  }\n  if (!token.startsWith(`${from}=`)) {\n    return [token];\n  }\n  return token.slice(from.length + 1) === \"false\" ? [] : [to];\n}\n\n/**\n * The legacy spelling, translated before anything parses it.\n *\n * Sandboxes already running carry the old tool docs until their next sync, and\n * an agent that reads `--skip-cache` there would now have its call refused —\n * turning a rename into exactly the failure the rename exists to fix. Kept for\n * one release; the guard in `cache-flag-coverage.test.ts` is what stops the\n * second spelling coming back into the commands themselves.\n */\nexport function normalizeCacheFlag(argv: string[]): string[] {\n  return rewriteBeforeDoubleDash(argv, (token) => respell(token, LEGACY, CANONICAL));\n}\n\n/**\n * `--no-cache` dropped where the command it addresses caches nothing.\n *\n * The reports runtime appends it to every read on `?fresh=true` and cannot know\n * which commands cache, so a report reading `winning-ads winners` failed on\n * every Refresh with \"not an option\" — and the same report answered fine\n * without it. A command with no cache already reads fresh, which is all the\n * flag asks for. Applied before `refuseUnknownFlags`, like `--output json`.\n */\nexport function cacheFlagForCommand(root: IntrospectableCommand, argv: string[]): string[] {\n  if (!argv.includes(CANONICAL)) {\n    return argv;\n  }\n  const command = commandFor(root, argv);\n  if (!command || declaredArg(command, \"no-cache\")) {\n    return argv;\n  }\n  return rewriteBeforeDoubleDash(argv, (token) => (token === CANONICAL ? [] : [token]));\n}\n\n/**\n * The canonical spelling in the form citty can actually parse.\n *\n * Deliberately applied after `refuseUnknownFlags`, not with the rewrite above:\n * that guard quotes the token back to the caller, and a command that does not\n * take this flag should be refused in the spelling the caller typed.\n */\nexport function cacheFlagForParser(argv: string[]): string[] {\n  return rewriteBeforeDoubleDash(argv, (token) => respell(token, CANONICAL, PARSEABLE));\n}\n\n/**\n * Everything after `--` is the caller's own payload, not ours to rewrite — the\n * same boundary `unknown-flags.ts` refuses to read past.\n */\nfunction rewriteBeforeDoubleDash(argv: string[], rewrite: (token: string) => string[]): string[] {\n  const end = argv.indexOf(\"--\");\n  const limit = end === -1 ? argv.length : end;\n  return argv.flatMap((token, index) => (index >= limit ? [token] : rewrite(token)));\n}\n"],"mappings":";;;;;;AA0BO,IAAM,eAAe;AAAA,EAC1B,MAAM;AAAA,EACN,aAAa;AAAA,EACb,UAAU;AACZ;AAEA,IAAM,SAAS;AACf,IAAM,YAAY;AAUlB,IAAM,YAAY;AAUlB,SAAS,QAAQ,OAAe,MAAc,IAAsB;AAClE,MAAI,UAAU,MAAM;AAClB,WAAO,CAAC,EAAE;AAAA,EACZ;AACA,MAAI,CAAC,MAAM,WAAW,GAAG,IAAI,GAAG,GAAG;AACjC,WAAO,CAAC,KAAK;AAAA,EACf;AACA,SAAO,MAAM,MAAM,KAAK,SAAS,CAAC,MAAM,UAAU,CAAC,IAAI,CAAC,EAAE;AAC5D;AAWO,SAAS,mBAAmB,MAA0B;AAC3D,SAAO,wBAAwB,MAAM,CAAC,UAAU,QAAQ,OAAO,QAAQ,SAAS,CAAC;AACnF;AAWO,SAAS,oBAAoB,MAA6B,MAA0B;AACzF,MAAI,CAAC,KAAK,SAAS,SAAS,GAAG;AAC7B,WAAO;AAAA,EACT;AACA,QAAM,UAAU,WAAW,MAAM,IAAI;AACrC,MAAI,CAAC,WAAW,YAAY,SAAS,UAAU,GAAG;AAChD,WAAO;AAAA,EACT;AACA,SAAO,wBAAwB,MAAM,CAAC,UAAW,UAAU,YAAY,CAAC,IAAI,CAAC,KAAK,CAAE;AACtF;AASO,SAAS,mBAAmB,MAA0B;AAC3D,SAAO,wBAAwB,MAAM,CAAC,UAAU,QAAQ,OAAO,WAAW,SAAS,CAAC;AACtF;AAMA,SAAS,wBAAwB,MAAgB,SAAgD;AAC/F,QAAM,MAAM,KAAK,QAAQ,IAAI;AAC7B,QAAM,QAAQ,QAAQ,KAAK,KAAK,SAAS;AACzC,SAAO,KAAK,QAAQ,CAAC,OAAO,UAAW,SAAS,QAAQ,CAAC,KAAK,IAAI,QAAQ,KAAK,CAAE;AACnF;","names":[]}