@koda-sl/baker-cli 0.451.0-dev.b2a4eba2b → 0.451.0

package/dist/domain-B54ILSOO.js

@@ -0,0 +1,98 @@
+import {
+  failSite
+} from "./chunk-F4F3PLN3.js";
+import "./chunk-BAUSWB7O.js";
+import "./chunk-GXDLWBOY.js";
+import "./chunk-TEINLN64.js";
+import "./chunk-ZJWUBJYQ.js";
+import "./chunk-NE4F3FHN.js";
+import {
+  apiGet,
+  apiPost
+} from "./chunk-XBOK23HI.js";
+import "./chunk-IFWP3ZDO.js";
+import {
+  optionalChatId,
+  requireChatId
+} from "./chunk-NAWWC5I3.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-NU7JSWVA.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/site/domain.ts
+import { defineCommand } from "citty";
+registerSchema({
+  command: "site.domain.add",
+  description: "Stage connecting a custom domain (a subdomain such as shop.acme.com \u2014 not the bare acme.com) to the company's landings. Applies when the chat is published; then Baker starts verifying it. The client must add a CNAME record pointing the hostname at customers.withbaker.com \u2014 the response's hints give the exact record to ask for. Refused at once when another company already registered it or the company is at its domain limit.",
+  args: { hostname: { type: "string", description: "The subdomain to connect, e.g. shop.acme.com", required: true } }
+});
+registerSchema({
+  command: "site.domain.list",
+  description: "Every custom domain of the company and its status: pending_verification (waiting for the DNS record \u2014 `message` says what is missing), active (live), error, or staged (this chat adds it at publish). Read-only.",
+  args: {}
+});
+registerSchema({
+  command: "site.domain.verify",
+  description: "Re-check a domain that is waiting for verification now instead of waiting for the background check (every few minutes). Use after the client says they added the DNS record. Returns its state and, if it is not live yet, what is still missing. A staged domain cannot be checked until the chat is published.",
+  args: { hostname: { type: "string", description: "A domain from `baker site domain list`", required: true } }
+});
+var addCommand = defineCommand({
+  meta: {
+    name: "add",
+    description: "Stage connecting a custom domain; applies at publish. The client adds a CNAME to customers.withbaker.com.\n\nExample: baker site domain add shop.acme.com"
+  },
+  args: { hostname: { type: "positional", description: "Subdomain, e.g. shop.acme.com", required: true } },
+  run: async ({ args }) => {
+    try {
+      const body = {
+        chatId: requireChatId(),
+        inputs: [{ setting: "customDomain", hostname: String(args.hostname) }]
+      };
+      writeJson(await apiPost("/api/site/stage", body));
+    } catch (err) {
+      failSite(err);
+    }
+  }
+});
+var listCommand = defineCommand({
+  meta: {
+    name: "list",
+    description: "List the company's custom domains and what each is waiting for.\n\nExample: baker site domain list"
+  },
+  run: async () => {
+    try {
+      const chatId = optionalChatId();
+      writeJson(await apiGet("/api/site/domains", chatId ? { chatId } : void 0));
+    } catch (err) {
+      failSite(err);
+    }
+  }
+});
+var verifyCommand = defineCommand({
+  meta: {
+    name: "verify",
+    description: "Re-check a pending domain now, e.g. right after the client added the DNS record.\n\nExample: baker site domain verify shop.acme.com"
+  },
+  args: { hostname: { type: "positional", description: "A domain from `baker site domain list`", required: true } },
+  run: async ({ args }) => {
+    try {
+      const body = { hostname: String(args.hostname) };
+      writeJson(await apiPost("/api/site/domains/verify", body));
+    } catch (err) {
+      failSite(err);
+    }
+  }
+});
+var domainCommand = defineCommand({
+  meta: {
+    name: "domain",
+    description: "Custom domains for the company's landings. Subcommands: add (staged until publish), list, verify.\n\nExamples:\n  baker site domain add shop.acme.com\n  baker site domain list\n  baker site domain verify shop.acme.com"
+  },
+  subCommands: { add: addCommand, list: listCommand, verify: verifyCommand }
+});
+export {
+  domainCommand
+};
+//# sourceMappingURL=domain-B54ILSOO.js.map

package/dist/download-7T6HIJKD.js

@@ -0,0 +1,299 @@
+import {
+  atomicWrite,
+  isDirectory,
+  isRemoteUrl
+} from "./chunk-PBA3YCZA.js";
+import {
+  MAX_REMOTE_IMAGE_BYTES,
+  fetchExternalBytes
+} from "./chunk-YBMVHGY3.js";
+import {
+  ApiError,
+  apiGet,
+  validateConvexId
+} from "./chunk-XBOK23HI.js";
+import "./chunk-IFWP3ZDO.js";
+import "./chunk-NAWWC5I3.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-NU7JSWVA.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-7T6HIJKD.js.map

package/dist/draft-5YAYCEYY.js

@@ -0,0 +1,107 @@
+import {
+  draftAction,
+  draftListAction,
+  loadPatchArg,
+  requireTarget
+} from "./chunk-LLOOWRBB.js";
+import "./chunk-ERSX3MKH.js";
+import "./chunk-T4DD5YMP.js";
+import "./chunk-4NZ47VXO.js";
+import "./chunk-D5FY4FAK.js";
+import "./chunk-F2S5BLPE.js";
+import "./chunk-XCM6XWOB.js";
+import "./chunk-VFIOJD5M.js";
+import "./chunk-WTOYCUKH.js";
+import "./chunk-DZSIUEGH.js";
+import "./chunk-VAJBWA2U.js";
+import "./chunk-HRYOZUSK.js";
+import "./chunk-VVZBBKRC.js";
+import "./chunk-YBMVHGY3.js";
+import {
+  CHAT_READ_ARG
+} from "./chunk-PFBQERWX.js";
+import "./chunk-ZJWUBJYQ.js";
+import "./chunk-NE4F3FHN.js";
+import "./chunk-XBOK23HI.js";
+import "./chunk-IFWP3ZDO.js";
+import "./chunk-NAWWC5I3.js";
+import "./chunk-NU7JSWVA.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/ads/google/draft.ts
+import { defineCommand } from "citty";
+var draftCommand = defineCommand({
+  meta: {
+    name: "draft",
+    description: "List, remove, clear, amend, or show staged Google Ads write ops 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 as a campaign \u25B8 ad group \u25B8 ad tree (--json for the raw envelope)"
+      },
+      args: {
+        json: { type: "boolean", description: "Print the raw JSON envelope instead of the readable tree" },
+        chat: CHAT_READ_ARG
+      },
+      run: async ({ args }) => {
+        await draftListAction(args.json === true, args.chat);
+      }
+    }),
+    remove: defineCommand({
+      meta: { name: "remove", description: "Remove one staged op (cascades to dependents)" },
+      args: { ref: { type: "positional", description: "Staged op ref (g_temp_* or target)", required: false } },
+      run: async ({ args }) => {
+        await draftAction("/api/ads/google/draft/remove", { ref: requireTarget(args, "op") });
+      }
+    }),
+    clear: defineCommand({
+      meta: { name: "clear", description: "Discard all staged ops on this chat" },
+      run: async () => {
+        await draftAction("/api/ads/google/draft/clear", {});
+      }
+    }),
+    amend: defineCommand({
+      meta: {
+        name: "amend",
+        description: "Update a staged op in place \u2014 merges a JSON patch into its payload (RFC-7386: 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 op ref (g_temp_*) or target id/resource name",
+          required: false
+        },
+        file: { type: "string", description: "JSON file with the patch object" },
+        patch: { type: "string", description: "Inline JSON patch object" }
+      },
+      run: async ({ args }) => {
+        const ref = requireTarget(args, "op");
+        const patch = loadPatchArg(args);
+        await draftAction("/api/ads/google/draft/amend", { ref, patch });
+      }
+    }),
+    show: defineCommand({
+      meta: {
+        name: "show",
+        description: "Print the full staged payload for one op \u2014 the receipt to verify a change looks right before publish (never truncated)."
+      },
+      args: {
+        ref: {
+          type: "positional",
+          description: "Staged op ref (g_temp_*) or target id/resource name",
+          required: false
+        },
+        chat: CHAT_READ_ARG
+      },
+      run: async ({ args }) => {
+        await draftAction("/api/ads/google/draft/show", { ref: requireTarget(args, "op") }, args.chat);
+      }
+    })
+  }
+});
+export {
+  draftCommand
+};
+//# sourceMappingURL=draft-5YAYCEYY.js.map

package/dist/draft-BGUJDHXR.js

@@ -0,0 +1,103 @@
+import {
+  draftAction,
+  draftList,
+  loadJsonArg,
+  requireTarget
+} from "./chunk-5ARG3CQG.js";
+import "./chunk-D5FY4FAK.js";
+import "./chunk-VFIOJD5M.js";
+import {
+  CHAT_READ_ARG
+} from "./chunk-PFBQERWX.js";
+import "./chunk-XBOK23HI.js";
+import "./chunk-IFWP3ZDO.js";
+import "./chunk-NAWWC5I3.js";
+import {
+  registerSchema
+} from "./chunk-NU7JSWVA.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-BGUJDHXR.js.map