@koda-sl/baker-cli 0.477.0-dev.55c09e3e8 → 0.495.0-dev.c2b64ccca

package/dist/download-ED52W77T.js

@@ -0,0 +1,299 @@
+import {
+  atomicWrite,
+  isDirectory,
+  isRemoteUrl
+} from "./chunk-DGUYFROS.js";
+import {
+  MAX_REMOTE_IMAGE_BYTES,
+  fetchExternalBytes
+} from "./chunk-3FFJYMKM.js";
+import {
+  ApiError,
+  apiGet,
+  validateConvexId
+} from "./chunk-OSWCEDFE.js";
+import "./chunk-D53AAUG4.js";
+import "./chunk-FZKUUI3F.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-4WYEGE4N.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-ED52W77T.js.map

package/dist/draft-3XYF2L4K.js

@@ -0,0 +1,306 @@
+import {
+  loadPatchArg,
+  requireTarget
+} from "./chunk-HLAAGGDS.js";
+import {
+  handleLinkedinError
+} from "./chunk-NG2DMLU6.js";
+import "./chunk-5ZIGEHQQ.js";
+import "./chunk-4NZ47VXO.js";
+import {
+  hintLines
+} from "./chunk-D5FY4FAK.js";
+import "./chunk-MMU6XHCH.js";
+import {
+  writeJsonEnvelope
+} from "./chunk-OTNGMKI6.js";
+import "./chunk-6FHP2HIK.js";
+import "./chunk-DS2ZRTAL.js";
+import "./chunk-4TBDEV7X.js";
+import "./chunk-EIJDXZW5.js";
+import "./chunk-2WRK44LZ.js";
+import "./chunk-3FFJYMKM.js";
+import {
+  CHAT_READ_ARG
+} from "./chunk-PFBQERWX.js";
+import "./chunk-MV2J73HP.js";
+import "./chunk-GXDLWBOY.js";
+import "./chunk-GIWHHCD6.js";
+import "./chunk-XQIOCIDO.js";
+import "./chunk-I2DNBEV6.js";
+import {
+  apiPost
+} from "./chunk-OSWCEDFE.js";
+import "./chunk-D53AAUG4.js";
+import {
+  requireChatId,
+  resolveChatId
+} from "./chunk-FZKUUI3F.js";
+import "./chunk-4WYEGE4N.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/ads/linkedin/draft.ts
+import { defineCommand } from "citty";
+
+// src/commands/ads/linkedin/draft-status.ts
+var OPERATION_LABELS = {
+  create: "Creating",
+  update: "Updating",
+  pause: "Pausing",
+  resume: "Resuming",
+  archive: "Archiving"
+};
+function badge(node) {
+  const label = node.operation ? OPERATION_LABELS[node.operation] : void 0;
+  if (label) {
+    return label;
+  }
+  return node.existing ? "on LinkedIn" : "staged";
+}
+function collectionLine(collection) {
+  const parts = [];
+  if (collection.added > 0) {
+    parts.push(`+${collection.added}`);
+  }
+  if (collection.existing > 0) {
+    parts.push(`${collection.existing} existing`);
+  }
+  if (collection.removed > 0) {
+    parts.push(`-${collection.removed}`);
+  }
+  return parts.length > 0 ? `${collection.label}: ${parts.join(", ")}` : void 0;
+}
+function accountsInTree(nodes) {
+  const accounts = /* @__PURE__ */ new Set();
+  const walk = (node) => {
+    accounts.add(node.accountId);
+    for (const child of node.children) {
+      walk(child);
+    }
+  };
+  for (const node of nodes) {
+    walk(node);
+  }
+  return accounts;
+}
+function renderNode(node, depth, lines, showAccount) {
+  const indent = "  ".repeat(depth);
+  const account = showAccount ? ` \xB7 account ${node.accountId}` : "";
+  lines.push(`${indent}\u2022 ${node.name} \xB7 ${badge(node)}${account}`);
+  for (const warning of node.warnings ?? []) {
+    lines.push(`${indent}    \u26A0 ${warning}`);
+  }
+  for (const collection of node.collections) {
+    const line = collectionLine(collection);
+    if (line) {
+      lines.push(`${indent}    ${line}`);
+    }
+  }
+  for (const child of node.children) {
+    renderNode(child, depth + 1, lines, showAccount);
+  }
+}
+function renderSection(title, nodes, lines, showAccount) {
+  if (nodes.length === 0) {
+    return;
+  }
+  lines.push("");
+  lines.push(title);
+  for (const node of nodes) {
+    renderNode(node, 1, lines, showAccount);
+  }
+}
+var CAMPAIGN_TREE_ENTITIES = /* @__PURE__ */ new Set(["campaignGroup", "campaign", "creative"]);
+function renderOutcome(data, lines) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const op of data.ops ?? []) {
+    const status = op.result?.status ?? "pending";
+    counts.set(status, (counts.get(status) ?? 0) + 1);
+  }
+  const summary = [...counts].map(([status, count]) => `${count} ${status}`).join(", ");
+  lines.push(`LinkedIn Ads \u2014 published \xB7 ${summary || `${data.count} op(s)`} \xB7 ${data.mode}`);
+  for (const op of data.ops ?? []) {
+    const status = op.result?.status;
+    if (status === "applied" && op.result?.error) {
+      lines.push(`  \u26A0 ${op.summary} \u2014 applied in part: ${op.result.error}`);
+      continue;
+    }
+    if (status !== "failed" && status !== "skipped") {
+      continue;
+    }
+    const reason = op.result?.error ?? op.result?.skippedBecause ?? "no reason recorded";
+    lines.push(`  \u2717 ${op.summary} \u2014 ${status}: ${reason}`);
+  }
+}
+function renderDraftStatus(data) {
+  if (data.status === "none" || data.count === 0) {
+    return "No staged LinkedIn changes on this chat.";
+  }
+  const modeNote = data.mode === "live" ? "Live \u2014 publishing writes directly to LinkedIn." : "Simulated \u2014 publishing completes the whole draft without calling LinkedIn.";
+  const lines = [];
+  if (data.status === "applied") {
+    renderOutcome(data, lines);
+  } else if (data.status === "publishing") {
+    lines.push(`LinkedIn Ads \u2014 publishing ${data.count} change${data.count === 1 ? "" : "s"} \xB7 ${data.mode}`);
+  } else {
+    lines.push(`LinkedIn Ads \u2014 ${data.count} staged change${data.count === 1 ? "" : "s"} \xB7 ${data.mode}`);
+  }
+  lines.push(modeNote);
+  const tree = data.tree ?? [];
+  const showAccount = accountsInTree(tree).size > 1;
+  renderSection(
+    "Campaigns",
+    tree.filter((node) => CAMPAIGN_TREE_ENTITIES.has(node.entity)),
+    lines,
+    showAccount
+  );
+  const rest = tree.filter((node) => !CAMPAIGN_TREE_ENTITIES.has(node.entity));
+  renderSection("Other", rest, lines, showAccount);
+  return lines.join("\n");
+}
+
+// src/commands/ads/linkedin/draft.ts
+async function listDraft(json, chat) {
+  try {
+    const chatId = resolveChatId(chat);
+    const response = await apiPost("/api/ads/linkedin/draft", {
+      chatId
+    });
+    if (json || !response.ok || !response.data) {
+      writeJsonEnvelope(response);
+      return;
+    }
+    process.stdout.write(`${renderDraftStatus(response.data)}${hintLines(response)}
+`);
+  } catch (err) {
+    handleLinkedinError(err);
+  }
+}
+var listCommand = defineCommand({
+  meta: {
+    name: "list",
+    description: "Review everything staged as a Campaign group \u25B8 Campaign \u25B8 Creative tree (--json for the raw envelope). Example: baker ads linkedin draft"
+  },
+  args: {
+    json: { type: "boolean", description: "Print the raw JSON envelope instead of the readable tree" },
+    chat: CHAT_READ_ARG
+  },
+  run: async ({ args }) => {
+    await listDraft(args.json === true, args.chat);
+  }
+});
+var removeCommand = defineCommand({
+  meta: {
+    name: "remove",
+    description: "Drop one staged LinkedIn op. Removing a create cascades to everything that depends on it \u2014 except a company exclusion, which only loses the removed audience and keeps its companies (listed under `updated`). Example: baker ads linkedin draft remove li_temp_abc123"
+  },
+  args: {
+    ref: {
+      type: "positional",
+      description: "Op ref (li_temp_* for creates, target id/URN for updates)",
+      required: true
+    }
+  },
+  run: async ({ args }) => {
+    try {
+      const chatId = requireChatId();
+      const response = await apiPost(
+        "/api/ads/linkedin/draft/remove",
+        { chatId, ref: args.ref }
+      );
+      writeJsonEnvelope(response);
+    } catch (err) {
+      handleLinkedinError(err);
+    }
+  }
+});
+var clearCommand = defineCommand({
+  meta: {
+    name: "clear",
+    description: "Discard ALL staged LinkedIn ops in this chat's draft \u2014 nothing will apply on publish. Example: baker ads linkedin draft clear"
+  },
+  run: async () => {
+    try {
+      const chatId = requireChatId();
+      const response = await apiPost("/api/ads/linkedin/draft/clear", {
+        chatId
+      });
+      writeJsonEnvelope(response);
+    } catch (err) {
+      handleLinkedinError(err);
+    }
+  }
+});
+var amendCommand = 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 (li_temp_*) or target id/URN", required: true },
+    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);
+    try {
+      const chatId = requireChatId();
+      const body = { chatId, ref, patch };
+      const response = await apiPost(
+        "/api/ads/linkedin/draft/amend",
+        body
+      );
+      writeJsonEnvelope(response);
+    } catch (err) {
+      handleLinkedinError(err);
+    }
+  }
+});
+var showCommand = 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 (li_temp_*) or target id/URN", required: true },
+    chat: CHAT_READ_ARG
+  },
+  run: async ({ args }) => {
+    const ref = requireTarget(args, "op");
+    try {
+      const chatId = resolveChatId(args.chat);
+      const body = { chatId, ref };
+      const response = await apiPost(
+        "/api/ads/linkedin/draft/show",
+        body
+      );
+      writeJsonEnvelope(response);
+    } catch (err) {
+      handleLinkedinError(err);
+    }
+  }
+});
+var linkedinDraftCommand = defineCommand({
+  meta: {
+    name: "draft",
+    description: "Review and edit the LinkedIn write ops staged in this chat BEFORE publish. Subcommands: list (default), remove, clear, amend, show. Ops never hit LinkedIn until the chat is published. `list` and `show` take --chat <id> to read an earlier chat's changes instead."
+  },
+  // Declared on the parent too: `default: "list"` dispatches the bare `draft --chat <id>` form, and
+  // citty prints help for a flag the parent does not know instead of forwarding it.
+  args: { chat: CHAT_READ_ARG },
+  subCommands: {
+    list: listCommand,
+    remove: removeCommand,
+    clear: clearCommand,
+    amend: amendCommand,
+    show: showCommand
+  },
+  // A parent must never declare `run`: citty falls through to it *after* running
+  // the matched subcommand, so `draft show <ref>` would also re-list the draft.
+  default: "list"
+});
+export {
+  linkedinDraftCommand
+};
+//# sourceMappingURL=draft-3XYF2L4K.js.map