@koda-sl/baker-cli 0.462.0 → 0.463.0

package/dist/discover-T2YSRCGA.js

@@ -0,0 +1,172 @@
+import {
+  PLANNER_FIELD_DESCRIPTIONS,
+  PLANNER_SOURCE,
+  stampPlannerRows
+} from "./chunk-2Y5V23PU.js";
+import {
+  buildAdsQueryContext,
+  warnDefaults
+} from "./chunk-FEELV5IV.js";
+import "./chunk-7VHPAGPK.js";
+import {
+  buildQueryCacheKey,
+  cacheGet,
+  cacheSet,
+  getManagerIdForCustomer,
+  handleConnectionError,
+  isNotConnectedError,
+  resolveCustomerId,
+  writeAdsJson,
+  writeAdsOutput
+} from "./chunk-3ITK2SBF.js";
+import "./chunk-ML7DLFFY.js";
+import {
+  ApiError,
+  apiPost
+} from "./chunk-TU6CHBNF.js";
+import "./chunk-E6VWLJVK.js";
+import "./chunk-7HD4SFUW.js";
+import {
+  registerSchema
+} from "./chunk-V2PX6XX5.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/ads/google/keywords/discover.ts
+import { defineCommand } from "citty";
+registerSchema({
+  command: "ads.google.keywords.discover",
+  description: 'Discover keyword ideas from seed keywords or URLs. Returns { source: "keyword_planner_estimate", keywords, total_results, next_page_token? }. These are Keyword Planner estimates of total market search volume, not this account\'s data: every row carries a source column and every metric is prefixed planner_ (planner_avg_monthly_searches, planner_competition, ...). Never report a planner_ number as impressions, clicks or any account metric \u2014 read those with `baker ads google query` against the account. If --location and --language are omitted, they default to United States (2840) and English (1000); `query_context` shows which were used.',
+  args: {
+    "customer-id": {
+      type: "string",
+      description: "Google Ads customer ID (10 digits, no dashes). Falls back to BAKER_GOOGLE_ADS_CUSTOMER_ID env var.",
+      required: false
+    },
+    seeds: { type: "string", description: "Comma-separated seed keywords (max 10)", required: false },
+    url: { type: "string", description: "URL to extract keyword ideas from", required: false },
+    location: {
+      type: "string",
+      description: "Geo target ID. Defaults to 2840 (United States) if omitted \u2014 always set this for non-US markets",
+      required: false
+    },
+    language: {
+      type: "string",
+      description: "Language ID. Defaults to 1000 (English) if omitted \u2014 always set this for non-English markets",
+      required: false
+    },
+    limit: { type: "string", description: "Max keyword ideas (default: 20, max: 100)", required: false, default: 20 },
+    cursor: {
+      type: "string",
+      description: "Pagination cursor from previous response (next_page_token)",
+      required: false
+    },
+    output: { type: "string", description: "Format: json|csv|jsonl|md", required: false, default: "json" },
+    "no-cache": { type: "boolean", description: "Skip cache", required: false }
+  }
+});
+function stampDiscoverResponse(data) {
+  return { ...data, source: PLANNER_SOURCE, keywords: stampPlannerRows(data.keywords ?? []) };
+}
+function buildDiscoverBody(customerId, args) {
+  const body = {
+    customerId,
+    pageSize: args.limit ? Number(args.limit) : 20
+  };
+  const managerId = getManagerIdForCustomer(customerId);
+  if (managerId) body.managerId = managerId;
+  const seeds = args.seeds ? args.seeds.split(",").map((s) => s.trim()).filter(Boolean) : void 0;
+  if (seeds) body.seeds = seeds;
+  if (args.url) body.url = args.url;
+  if (args.location) body.locationIds = [args.location];
+  if (args.language) body.languageId = args.language;
+  if (args.cursor) body.pageToken = args.cursor;
+  return body;
+}
+function handleKeywordError(err) {
+  if (err instanceof ApiError) {
+    if (isNotConnectedError(err.code, err.message)) {
+      handleConnectionError("google_ads", err.message);
+    }
+    const envelope = {
+      ok: false,
+      error: {
+        code: err.code,
+        message: err.message,
+        fix: { action: "reject", explanation: err.message },
+        retryable: err.code === "RATE_LIMITED"
+      }
+    };
+    writeAdsJson(envelope);
+    process.exit(1);
+  }
+  writeAdsJson({ ok: false, error: { code: "NETWORK_ERROR", message: "Unexpected error" } });
+  process.exit(1);
+}
+var discoverCommand = defineCommand({
+  meta: {
+    name: "discover",
+    description: `Discover new keyword ideas from seed keywords or competitor URLs.
+
+Returns Keyword Planner ESTIMATES of market search volume, not this account's numbers. Every row carries source=keyword_planner_estimate and planner_-prefixed metrics; keep those names when you quote a figure, and never present one as an impression or click count.
+
+Examples:
+  baker ads google keywords discover --customer-id 1234567890 --seeds "running shoes,athletic footwear"
+  baker ads google keywords discover --customer-id 1234567890 --url "https://competitor.com"
+  baker ads google keywords discover --customer-id 1234567890 --seeds "seo tools" --location 2826 --limit 50`
+  },
+  args: {
+    "customer-id": { type: "string", description: "Google Ads customer ID", required: false },
+    seeds: { type: "string", description: "Comma-separated seed keywords", required: false },
+    url: { type: "string", description: "URL to extract ideas from", required: false },
+    location: { type: "string", description: "Geo target ID (default 2840)", required: false },
+    language: { type: "string", description: "Language ID (default 1000)", required: false },
+    limit: { type: "string", description: "Max results (default 20)", required: false },
+    cursor: { type: "string", description: "Pagination cursor from previous response", required: false },
+    "no-cache": { type: "boolean", description: "Skip cache", required: false },
+    output: { type: "string", description: "Format: json|csv|jsonl|md", required: false, default: "json" }
+  },
+  run: async ({ args }) => {
+    const customerId = await resolveCustomerId(args);
+    const queryContext = buildAdsQueryContext(args.location, args.language);
+    if (!args.seeds && !args.url) {
+      writeAdsJson({
+        ok: false,
+        error: { code: "VALIDATION_ERROR", message: "Provide --seeds or --url (at least one required)" }
+      });
+      process.exit(1);
+    }
+    const body = buildDiscoverBody(customerId, args);
+    const useCache = !args["no-cache"] && !args.cursor;
+    if (!useCache) body.skipCache = true;
+    const cacheKey = buildQueryCacheKey(customerId, JSON.stringify(body));
+    if (useCache) {
+      const cached = cacheGet("keywords", cacheKey);
+      if (cached) {
+        warnDefaults(queryContext);
+        writeAdsJson({ ok: true, data: stampDiscoverResponse(cached.data), cached: true, query_context: queryContext });
+        return;
+      }
+    }
+    try {
+      const data = await apiPost("/api/ads/google/keywords/discover", body);
+      if (useCache) {
+        cacheSet("keywords", cacheKey, data, 24 * 60 * 60 * 1e3);
+      }
+      warnDefaults(queryContext);
+      const stamped = stampDiscoverResponse(data);
+      const format = args.output || "json";
+      if (format !== "json") {
+        writeAdsOutput(stamped.keywords, format);
+        return;
+      }
+      writeAdsJson({ ok: true, data: stamped, fields: PLANNER_FIELD_DESCRIPTIONS, query_context: queryContext });
+    } catch (err) {
+      handleKeywordError(err);
+    }
+  }
+});
+export {
+  discoverCommand,
+  stampDiscoverResponse
+};
+//# sourceMappingURL=discover-T2YSRCGA.js.map

package/dist/domain-H7VFZRFY.js

@@ -0,0 +1,97 @@
+import {
+  failSite
+} from "./chunk-GSTXGXAZ.js";
+import "./chunk-ZJVHZHYP.js";
+import "./chunk-GXDLWBOY.js";
+import "./chunk-XQIOCIDO.js";
+import "./chunk-ML7DLFFY.js";
+import {
+  apiGet,
+  apiPost
+} from "./chunk-TU6CHBNF.js";
+import "./chunk-E6VWLJVK.js";
+import {
+  optionalChatId,
+  requireChatId
+} from "./chunk-7HD4SFUW.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-V2PX6XX5.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-H7VFZRFY.js.map

package/dist/download-ZBYQ4GMD.js

@@ -0,0 +1,299 @@
+import {
+  atomicWrite,
+  isDirectory,
+  isRemoteUrl
+} from "./chunk-36TJTBOG.js";
+import {
+  MAX_REMOTE_IMAGE_BYTES,
+  fetchExternalBytes
+} from "./chunk-GOELHGIC.js";
+import {
+  ApiError,
+  apiGet,
+  validateConvexId
+} from "./chunk-TU6CHBNF.js";
+import "./chunk-E6VWLJVK.js";
+import "./chunk-7HD4SFUW.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-V2PX6XX5.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-ZBYQ4GMD.js.map