@koda-sl/baker-cli 0.525.0 → 0.527.0

package/dist/download-SFWMT7DL.js

@@ -0,0 +1,299 @@
+import {
+  atomicWrite,
+  isDirectory,
+  isRemoteUrl
+} from "./chunk-2MXDSPUO.js";
+import {
+  MAX_REMOTE_IMAGE_BYTES,
+  fetchExternalBytes
+} from "./chunk-SWNCS2OD.js";
+import {
+  ApiError,
+  apiGet,
+  validateConvexId
+} from "./chunk-B4UVJCJ4.js";
+import "./chunk-AFQF6ISC.js";
+import "./chunk-52IYZCRS.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-FSGJSREN.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/images/download.ts
+import { defineCommand } from "citty";
+
+// src/commands/images/downloadPaths.ts
+import { basename, extname, join } from "path";
+var CONTENT_TYPE_EXTENSIONS = {
+  "image/webp": ".webp",
+  "image/png": ".png",
+  "image/jpeg": ".jpg",
+  "image/jpg": ".jpg",
+  "image/gif": ".gif",
+  "image/svg+xml": ".svg",
+  "image/avif": ".avif",
+  "image/bmp": ".bmp",
+  "image/tiff": ".tiff",
+  "image/x-icon": ".ico",
+  "image/vnd.microsoft.icon": ".ico"
+};
+var KNOWN_EXTENSIONS = /* @__PURE__ */ new Set([".webp", ".png", ".jpg", ".jpeg", ".gif", ".svg", ".avif", ".bmp", ".tiff", ".ico"]);
+function urlPath(sourceUrl) {
+  try {
+    return new URL(sourceUrl).pathname;
+  } catch {
+    return sourceUrl.split(/[?#]/)[0] ?? "";
+  }
+}
+function extensionFromUrl(sourceUrl) {
+  const ext = extname(urlPath(sourceUrl)).toLowerCase();
+  return KNOWN_EXTENSIONS.has(ext) ? ext : null;
+}
+function deriveExtension(contentType, sourceUrl) {
+  const normalized = (contentType ?? "").split(";")[0]?.trim().toLowerCase() ?? "";
+  const fromType = CONTENT_TYPE_EXTENSIONS[normalized];
+  if (fromType) {
+    return fromType;
+  }
+  return extensionFromUrl(sourceUrl) ?? ".bin";
+}
+function looksLikeCdnHash(stem) {
+  return stem.length >= 32 && !/[-_.]/.test(stem);
+}
+function hostLabel(sourceUrl) {
+  try {
+    const host = new URL(sourceUrl).hostname.replace(/^www\./, "");
+    const label = host.split(".").filter((part) => part !== "cdn" && part !== "images")[0];
+    return label && /^[a-z0-9-]+$/.test(label) ? label : null;
+  } catch {
+    return null;
+  }
+}
+function sanitizeBaseName(raw) {
+  const stem = raw.trim().toLowerCase().replace(/\.[a-z0-9]{1,5}$/i, "").replace(/[^a-z0-9._-]+/g, "-").replace(/^[-.]+|[-.]+$/g, "").slice(0, 80);
+  return stem.length > 0 ? stem : "image";
+}
+function baseNameFromUrl(sourceUrl) {
+  const stem = sanitizeBaseName(basename(urlPath(sourceUrl)));
+  if (looksLikeCdnHash(stem)) {
+    const label = hostLabel(sourceUrl);
+    if (label) return `${label}-${stem.slice(0, 8)}`;
+  }
+  return stem;
+}
+function resolveDownloadPath({ baseName, extension, out, outIsDirectory: outIsDirectory2 }) {
+  const filename = `${baseName}${extension}`;
+  if (!out) {
+    return filename;
+  }
+  if (outIsDirectory2) {
+    return join(out, filename);
+  }
+  return out;
+}
+function disambiguate(paths) {
+  const taken = /* @__PURE__ */ new Set();
+  return paths.map((path) => {
+    if (!taken.has(path)) {
+      taken.add(path);
+      return path;
+    }
+    const ext = extname(path);
+    const stem = path.slice(0, path.length - ext.length);
+    let n = 2;
+    while (taken.has(`${stem}-${n}${ext}`)) n += 1;
+    const unique = `${stem}-${n}${ext}`;
+    taken.add(unique);
+    return unique;
+  });
+}
+
+// src/commands/images/download.ts
+registerSchema({
+  command: "images.download",
+  description: "Download remote images or library images to local files, so the local transforms (normalize, crop, dimensions) can read them.",
+  args: {
+    targets: {
+      type: "string",
+      description: "One or more image URLs and/or library image ids, space- or comma-separated (e.g. 'https://\u2026/logo.webp j57abc123').",
+      required: true
+    },
+    out: {
+      type: "string",
+      description: "Output directory (must exist) or, with a single target, an exact file path. Default: the working directory.",
+      required: false
+    }
+  }
+});
+var ValidationError = class extends Error {
+};
+var UnusableTargetError = class extends Error {
+  constructor(target) {
+    super(`"${target}" is neither an image URL nor a library image id.`);
+    this.target = target;
+  }
+};
+function readTargets(args) {
+  const positionals = Array.isArray(args._) ? args._ : [];
+  const named = typeof args.targets === "string" ? [args.targets] : [];
+  const all = positionals.length > 0 ? positionals : named;
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const value of all) {
+    if (typeof value !== "string") continue;
+    for (const part of value.split(",").map((p) => p.trim())) {
+      if (part.length > 0 && !seen.has(part)) {
+        seen.add(part);
+        out.push(part);
+      }
+    }
+  }
+  return out;
+}
+function classify(raw) {
+  if (isRemoteUrl(raw)) {
+    return { raw, kind: "url" };
+  }
+  try {
+    validateConvexId(raw);
+  } catch {
+    throw new UnusableTargetError(raw);
+  }
+  return { raw, kind: "imageId" };
+}
+async function resolveTarget(target) {
+  if (target.kind === "url") {
+    return { input: target.raw, url: target.raw, baseName: baseNameFromUrl(target.raw) };
+  }
+  const doc = await apiGet("/api/images/get", { id: target.raw });
+  const stem = sanitizeBaseName(doc.name.length > 0 ? doc.name : target.raw);
+  return { input: target.raw, url: doc.imageUrl, baseName: stem };
+}
+async function fetchBytes(url) {
+  return await fetchExternalBytes(url, { maxBytes: MAX_REMOTE_IMAGE_BYTES });
+}
+var NEXT_STEP_HINT = "Downloaded files are local paths \u2014 the local transforms take them directly: `baker images normalize <file> --color '#FFFFFF' --height 40`, `baker images crop <file> --x \u2026 --y \u2026 --width \u2026 --height \u2026`, `baker images dimensions <file>`. For a landing, page-scoped images belong in `src/pages/{landing}/_images/`.";
+var PARTIAL_FAILURE_HINT = "Some targets did not download. Carry on with the ones that did \u2014 a missing asset never blocks the rest of the job. Retry a failed URL only if it was a transient 5xx; a 403 means the host will not serve these bytes to anyone but a browser, so re-source it (`baker images extract <page>`) instead.";
+var ALL_FAILED_FIX = {
+  action: "use_different_resource",
+  explanation: "None of the targets could be downloaded. A 403/404 means the host will not serve these bytes \u2014 re-source the asset (`baker images extract <page-url>`, `baker images stock <query>`) or, for a library image, check the row is `ready` with `baker images get <id>`. Do not retry the same URLs in a loop, and do not fall back to `curl` \u2014 continue the job with a placeholder if nothing can be fetched."
+};
+async function outIsDirectory(out) {
+  if (!out) return false;
+  return out.endsWith("/") || await isDirectory(out);
+}
+async function buildPlan(args) {
+  const raw = readTargets(args);
+  if (raw.length === 0) {
+    throw new ValidationError("At least one image URL or library image id is required.");
+  }
+  const targets = raw.map(classify);
+  const out = typeof args.out === "string" && args.out.length > 0 ? args.out : void 0;
+  const outIsDir = await outIsDirectory(out);
+  if (out && !outIsDir && targets.length > 1) {
+    throw new ValidationError(
+      `--out must be an existing directory when downloading more than one image (got "${out}").`
+    );
+  }
+  return { targets, out, outIsDir };
+}
+function failureMessage(err, fallback) {
+  return err instanceof Error ? err.message : fallback;
+}
+async function runDownloads(plan) {
+  const failed = [];
+  const fetched = [];
+  for (const target of plan.targets) {
+    try {
+      const resolved = await resolveTarget(target);
+      const { buffer, contentType } = await fetchBytes(resolved.url);
+      fetched.push({
+        input: resolved.input,
+        buffer,
+        contentType,
+        path: resolveDownloadPath({
+          baseName: resolved.baseName,
+          extension: deriveExtension(contentType, resolved.url),
+          out: plan.out,
+          outIsDirectory: plan.outIsDir
+        })
+      });
+    } catch (err) {
+      failed.push({ input: target.raw, error: failureMessage(err, "Download failed") });
+    }
+  }
+  const paths = disambiguate(fetched.map((item) => item.path));
+  const downloaded = [];
+  for (const [index, item] of fetched.entries()) {
+    const path = paths[index] ?? item.path;
+    try {
+      await atomicWrite(path, item.buffer);
+      downloaded.push({ input: item.input, output: path, bytes: item.buffer.length, contentType: item.contentType });
+    } catch (err) {
+      failed.push({ input: item.input, error: failureMessage(err, "Write failed") });
+    }
+  }
+  return { downloaded, failed };
+}
+function emitError(err) {
+  if (err instanceof UnusableTargetError) {
+    writeJson({
+      ok: false,
+      error: {
+        code: "VALIDATION_ERROR",
+        message: err.message,
+        fix: {
+          action: "retry_with_changes",
+          explanation: "`download` takes remote image URLs (https://\u2026) and library image ids. A path that is already on disk needs no download \u2014 pass it straight to `baker images normalize` / `crop` / `dimensions`. To get a library id, run `baker images library <query>` and read `_id`."
+        }
+      }
+    });
+    process.exit(1);
+  }
+  if (err instanceof ValidationError) {
+    writeJson({ ok: false, error: { code: "VALIDATION_ERROR", message: err.message } });
+    process.exit(1);
+  }
+  if (err instanceof ApiError) {
+    writeJson({ ok: false, error: { code: err.code, message: err.message } });
+    process.exit(1);
+  }
+  writeJson({ ok: false, error: { code: "INTERNAL_ERROR", message: "Unexpected error" } });
+  process.exit(1);
+}
+var downloadCommand = defineCommand({
+  meta: {
+    name: "download",
+    description: "Download image URLs and/or library images to local files \u2014 the missing first half of `source \u2192 download \u2192 normalize \u2192 place`. Never use `curl` for this.\n\nExamples:\n  baker images download https://media.withbaker.com/\u2026/logo.webp\n  baker images download j57abc123 j57def456 --out src/pages/pricing/_images/\n  baker images download https://\u2026/hero.png --out ./hero.png"
+  },
+  args: {
+    targets: { type: "positional", description: "Image URLs and/or library image ids", required: false },
+    out: { type: "string", description: "Output directory (must exist), or exact file path for a single target" }
+  },
+  run: async ({ args }) => {
+    try {
+      const plan = await buildPlan(args);
+      const { downloaded, failed } = await runDownloads(plan);
+      if (downloaded.length === 0) {
+        writeJson({
+          ok: false,
+          error: {
+            code: "DOWNLOAD_FAILED",
+            message: `None of the ${plan.targets.length} target(s) could be downloaded: ${failed.map((f) => `${f.input} (${f.error})`).join("; ")}`,
+            fix: ALL_FAILED_FIX
+          }
+        });
+        process.exit(1);
+      }
+      const hints = [NEXT_STEP_HINT, ...failed.length > 0 ? [PARTIAL_FAILURE_HINT] : []];
+      writeJson({ ok: true, data: { downloaded, failed }, hints });
+    } catch (err) {
+      emitError(err);
+    }
+  }
+});
+export {
+  downloadCommand
+};
+//# sourceMappingURL=download-SFWMT7DL.js.map

package/dist/draft-374Z4MGY.js

@@ -0,0 +1,103 @@
+import {
+  draftAction,
+  draftList,
+  loadJsonArg,
+  requireTarget
+} from "./chunk-TTKDFRON.js";
+import "./chunk-D5FY4FAK.js";
+import "./chunk-HPDGVK6R.js";
+import {
+  CHAT_READ_ARG
+} from "./chunk-PFBQERWX.js";
+import "./chunk-B4UVJCJ4.js";
+import "./chunk-AFQF6ISC.js";
+import "./chunk-52IYZCRS.js";
+import {
+  registerSchema
+} from "./chunk-FSGJSREN.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/tag-manager/draft.ts
+import { defineCommand } from "citty";
+registerSchema({
+  command: "tagManager.draft",
+  description: "Review and undo the Tag Manager changes staged on this chat. Use `list` to see everything staged, `show` to inspect one change in full before publish, `amend` to correct one in place, and `remove`/`clear` to drop them. `list` and `show` take --chat <id> to read an earlier chat's changes instead.",
+  args: {
+    json: { type: "boolean", description: "Print the raw JSON envelope instead of the readable list", required: false },
+    chat: { type: "string", description: CHAT_READ_ARG.description, required: false }
+  }
+});
+var draftCommand = defineCommand({
+  meta: {
+    name: "draft",
+    description: "List, show, amend, remove, or clear staged Tag Manager changes for this chat. `list` and `show` take --chat <id> to read an earlier chat's changes instead."
+  },
+  subCommands: {
+    list: defineCommand({
+      meta: {
+        name: "list",
+        description: "Review everything staged on this chat (--json for the raw envelope)"
+      },
+      args: {
+        json: { type: "boolean", description: "Print the raw JSON envelope", required: false },
+        chat: CHAT_READ_ARG
+      },
+      run: async ({ args }) => {
+        await draftList(args.json === true, args.chat);
+      }
+    }),
+    show: defineCommand({
+      meta: {
+        name: "show",
+        description: "Print the full staged payload for one change \u2014 the receipt to verify it looks right before publish (never truncated)."
+      },
+      args: {
+        ref: { type: "positional", description: "Staged ref (gtm_temp_*) or target", required: false },
+        chat: CHAT_READ_ARG
+      },
+      run: async ({ args }) => {
+        await draftAction(
+          "/api/tag-manager/draft/show",
+          { ref: requireTarget(args, "change") },
+          args.chat
+        );
+      }
+    }),
+    amend: defineCommand({
+      meta: {
+        name: "amend",
+        description: "Update a staged change in place \u2014 merges a JSON patch into its payload (objects deep-merge, null deletes a key, arrays/scalars replace) and re-validates. Use this instead of remove + re-create."
+      },
+      args: {
+        ref: { type: "positional", description: "Staged ref (gtm_temp_*) or target", required: false },
+        patch: { type: "string", description: "Inline JSON patch object", required: false },
+        file: { type: "string", description: "JSON file with the patch object", required: false }
+      },
+      run: async ({ args }) => {
+        await draftAction("/api/tag-manager/draft/amend", {
+          ref: requireTarget(args, "change"),
+          patch: loadJsonArg(args, "patch")
+        });
+      }
+    }),
+    remove: defineCommand({
+      meta: { name: "remove", description: "Remove one staged change (cascades to anything depending on it)" },
+      args: { ref: { type: "positional", description: "Staged ref (gtm_temp_*) or target", required: false } },
+      run: async ({ args }) => {
+        await draftAction("/api/tag-manager/draft/remove", {
+          ref: requireTarget(args, "change")
+        });
+      }
+    }),
+    clear: defineCommand({
+      meta: { name: "clear", description: "Discard all Tag Manager changes staged on this chat" },
+      run: async () => {
+        await draftAction("/api/tag-manager/draft/clear", {});
+      }
+    })
+  }
+});
+export {
+  draftCommand
+};
+//# sourceMappingURL=draft-374Z4MGY.js.map