@koda-sl/baker-cli 0.563.0-dev.25ca3cbc8 → 0.564.0

package/dist/domain-GSQX4Z2V.js

@@ -0,0 +1,101 @@
+import {
+  failSite
+} from "./chunk-PNA7GXBR.js";
+import "./chunk-7BV5QN2P.js";
+import "./chunk-QV6AST5T.js";
+import "./chunk-WCU362Z6.js";
+import "./chunk-GIWHHCD6.js";
+import "./chunk-SOPVIIUW.js";
+import "./chunk-G4FG5EQO.js";
+import "./chunk-R7XDGNZD.js";
+import "./chunk-MSMTG6OC.js";
+import {
+  apiGet,
+  apiPost
+} from "./chunk-QEREDRZO.js";
+import "./chunk-JXTNP3B5.js";
+import {
+  optionalChatId,
+  requireChatId
+} from "./chunk-45D6WRCJ.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-CCYZJMZ7.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-GSQX4Z2V.js.map

package/dist/download-CP3Y2K54.js

@@ -0,0 +1,172 @@
+import {
+  videosDownloadResponseSchema
+} from "./chunk-7BV5QN2P.js";
+import "./chunk-QV6AST5T.js";
+import "./chunk-WCU362Z6.js";
+import "./chunk-GIWHHCD6.js";
+import "./chunk-SOPVIIUW.js";
+import "./chunk-G4FG5EQO.js";
+import "./chunk-R7XDGNZD.js";
+import "./chunk-MSMTG6OC.js";
+import {
+  ApiError,
+  apiPost,
+  validateConvexId
+} from "./chunk-QEREDRZO.js";
+import "./chunk-JXTNP3B5.js";
+import "./chunk-45D6WRCJ.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-CCYZJMZ7.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/videos/download.ts
+import { mkdir, open, rm, stat } from "fs/promises";
+import path from "path";
+import { Readable } from "stream";
+import { pipeline } from "stream/promises";
+import { defineCommand } from "citty";
+var DEFAULT_TIMEOUT_SECONDS = 20 * 60;
+var POLL_INTERVAL_MS = 1e4;
+registerSchema({
+  command: "videos.download",
+  description: "Save a library video (one from `videos search`, or one the user attached in chat) as a local .mp4 to edit with ffmpeg or a canvas ingest node. Waits while the file is prepared.",
+  args: {
+    id: { type: "string", description: "Library video ID", required: true },
+    out: { type: "string", description: "Directory to write the file into (created if missing)", required: true },
+    "timeout-seconds": {
+      type: "string",
+      description: `How long to wait for the file to be prepared (default ${DEFAULT_TIMEOUT_SECONDS})`,
+      required: false
+    }
+  }
+});
+async function awaitDownloadUrl(ask, options) {
+  const deadline = options.now() + options.timeoutMs;
+  for (; ; ) {
+    const answer = await ask();
+    if (answer.status === "ready") return { ready: true, url: answer.url, filename: answer.filename };
+    if (options.now() + options.intervalMs > deadline) return { ready: false, lastStatus: answer.status };
+    await options.sleep(options.intervalMs);
+  }
+}
+async function saveVideoFile(url, outDir, filename) {
+  await mkdir(outDir, { recursive: true });
+  const { name: stem, ext } = path.parse(path.basename(filename));
+  for (let n = 1; ; n++) {
+    const file = path.join(outDir, `${stem}${n === 1 ? "" : `-${n}`}${ext || ".mp4"}`);
+    let handle;
+    try {
+      handle = await open(file, "wx");
+    } catch (err) {
+      if (err instanceof Error && "code" in err && err.code === "EEXIST") continue;
+      throw err;
+    }
+    try {
+      const response = await fetch(url);
+      if (!response.ok || !response.body)
+        throw new Error(`The video file could not be fetched (HTTP ${response.status})`);
+      await pipeline(Readable.fromWeb(response.body), handle.createWriteStream());
+    } catch (err) {
+      await handle.close().catch(() => void 0);
+      await rm(file, { force: true });
+      throw err;
+    }
+    return { file, bytes: (await stat(file)).size };
+  }
+}
+async function downloadLibraryVideo(args, deps) {
+  let wait;
+  try {
+    wait = await awaitDownloadUrl(deps.ask, { timeoutMs: args.timeoutMs, intervalMs: args.intervalMs, ...deps });
+  } catch (err) {
+    if (!(err instanceof ApiError)) throw err;
+    const fix = err.fix ?? (err.code === "CONFLICT" ? {
+      action: "continue_without",
+      explanation: "Tell the user why this video cannot be used and carry on without it."
+    } : void 0);
+    return { ok: false, error: { code: err.code, message: err.message, ...fix ? { fix } : {} } };
+  }
+  if (!wait.ready) {
+    return {
+      ok: false,
+      error: {
+        code: "TIMEOUT",
+        message: wait.lastStatus === "processing" ? "The video is still being uploaded to the library." : "The library is still preparing a downloadable file of this video.",
+        fix: {
+          action: "wait_and_retry",
+          explanation: "Tell the user the video is still being prepared, carry on with the rest of the job, and run this command again in a few minutes. Do not abort the whole job."
+        }
+      }
+    };
+  }
+  try {
+    const saved = await saveVideoFile(wait.url, path.resolve(args.out), wait.filename);
+    return {
+      ok: true,
+      data: saved,
+      hints: [
+        `Edit ${saved.file} with ffprobe/ffmpeg, or feed it to a canvas ingest node as { source: "path", path, expect: "video" }. The library video is unchanged.`
+      ]
+    };
+  } catch (err) {
+    return {
+      ok: false,
+      error: { code: "DOWNLOAD_FAILED", message: err instanceof Error ? err.message : String(err) }
+    };
+  }
+}
+function positiveInt(value) {
+  const parsed = typeof value === "string" ? Number.parseInt(value, 10) : Number.NaN;
+  return Number.isInteger(parsed) && parsed > 0 ? parsed : void 0;
+}
+var downloadCommand = defineCommand({
+  meta: {
+    name: "download",
+    description: "Save a library video as a local .mp4 so you can edit it (ffmpeg, canvas ingest node). Use it for a video the user attached in chat, or one found with `videos search`. Waits up to 20 minutes while the file is prepared.\n\nExample: baker videos download j571abc123def --out /tmp/clips"
+  },
+  args: {
+    id: { type: "positional", description: "Library video ID", required: true },
+    out: { type: "string", description: "Directory to write the file into", required: true },
+    "timeout-seconds": {
+      type: "string",
+      description: `How long to wait for the file (default ${DEFAULT_TIMEOUT_SECONDS})`,
+      required: false
+    }
+  },
+  run: async ({ args }) => {
+    const id = String(args.id ?? "");
+    try {
+      validateConvexId(id);
+    } catch (err) {
+      writeJson({
+        ok: false,
+        error: { code: "VALIDATION_ERROR", message: err instanceof Error ? err.message : "Invalid video ID" }
+      });
+      process.exit(1);
+    }
+    const result = await downloadLibraryVideo(
+      {
+        id,
+        out: String(args.out ?? ""),
+        timeoutMs: (positiveInt(args["timeout-seconds"]) ?? DEFAULT_TIMEOUT_SECONDS) * 1e3,
+        intervalMs: POLL_INTERVAL_MS
+      },
+      {
+        ask: async () => videosDownloadResponseSchema.parse(await apiPost("/api/videos/download", { id })),
+        now: Date.now,
+        sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms))
+      }
+    );
+    writeJson(result);
+    if (!result.ok) process.exit(1);
+  }
+});
+export {
+  awaitDownloadUrl,
+  downloadCommand,
+  downloadLibraryVideo,
+  saveVideoFile
+};
+//# sourceMappingURL=download-CP3Y2K54.js.map

package/dist/draft-3HRGCNWA.js

@@ -0,0 +1,374 @@
+import {
+  failWriteValidation
+} from "./chunk-YXEUUGUJ.js";
+import {
+  parseXApiError
+} from "./chunk-FIN4ZXGJ.js";
+import "./chunk-YD6OZSSY.js";
+import {
+  amendDraftRefs,
+  draftRefs,
+  removeDraftRefs
+} from "./chunk-2DAWUWA4.js";
+import {
+  writeAdsJson,
+  writeJsonEnvelope
+} from "./chunk-RBCO3C3Q.js";
+import {
+  CHAT_READ_ARG,
+  DRAFT_FULL_ARG
+} from "./chunk-X32MFGWW.js";
+import "./chunk-7BV5QN2P.js";
+import "./chunk-QV6AST5T.js";
+import "./chunk-WCU362Z6.js";
+import "./chunk-GIWHHCD6.js";
+import "./chunk-SOPVIIUW.js";
+import "./chunk-G4FG5EQO.js";
+import "./chunk-R7XDGNZD.js";
+import "./chunk-MSMTG6OC.js";
+import {
+  ApiError,
+  apiPost
+} from "./chunk-QEREDRZO.js";
+import "./chunk-JXTNP3B5.js";
+import {
+  requireChatId,
+  resolveChatId
+} from "./chunk-45D6WRCJ.js";
+import {
+  registerSchema
+} from "./chunk-CCYZJMZ7.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/ads/x/draft.ts
+import { readFileSync } from "fs";
+import { defineCommand } from "citty";
+
+// src/commands/ads/x/draft-status.ts
+var OPERATION_LABELS = {
+  create: "Creating",
+  update: "Updating",
+  pause: "Pausing",
+  resume: "Resuming",
+  remove: "Removing"
+};
+function badge(node) {
+  const label = node.operation ? OPERATION_LABELS[node.operation] : void 0;
+  return label ?? (node.existing ? "on X" : "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, showAccount, out) {
+  const indent = "  ".repeat(depth);
+  const account = showAccount ? ` [${node.accountId}]` : "";
+  out.push(`${indent}${node.entity}: ${node.name} \u2014 ${badge(node)}${account}`);
+  for (const collection of node.collections) {
+    const line = collectionLine(collection);
+    if (line) {
+      out.push(`${indent}  ${line}`);
+    }
+  }
+  for (const warning of node.warnings ?? []) {
+    out.push(`${indent}  ! ${warning}`);
+  }
+  for (const child of node.children) {
+    renderNode(child, depth + 1, showAccount, out);
+  }
+}
+var NO_CHANGES = "No X Ads changes staged";
+var STATUS_HEADINGS = {
+  active: "staged",
+  publishing: "publishing",
+  applied: "published",
+  discarded: "discarded"
+};
+function didNotApply(op) {
+  return op.result?.status === "failed" || op.result?.status === "skipped";
+}
+function didApply(op) {
+  return op.result?.status === "applied" || op.result?.status === "simulated";
+}
+function headingLine(draft) {
+  const heading = STATUS_HEADINGS[draft.status] ?? draft.status;
+  if (draft.status !== "applied" && draft.status !== "publishing") {
+    return `X Ads: ${draft.count} change${draft.count === 1 ? "" : "s"} ${heading}`;
+  }
+  const applied = draft.ops.filter(didApply).length;
+  const failed = draft.ops.filter(didNotApply).length;
+  return `X Ads: ${heading} \xB7 ${applied} applied${failed > 0 ? `, ${failed} failed` : ""}`;
+}
+function problemLines(draft) {
+  return draft.ops.filter(didNotApply).map((op) => {
+    const reason = op.result?.error ?? `skipped: waiting on ${op.result?.skippedBecause ?? "a change that did not apply"}`;
+    return `\u2717 ${op.summary} \u2014 failed: ${reason}`;
+  });
+}
+function renderDraftStatus(draft) {
+  if (draft.status === "none" || draft.count === 0) {
+    return NO_CHANGES;
+  }
+  const out = [headingLine(draft), ""];
+  const tree = draft.tree ?? [];
+  const showAccount = accountsInTree(tree).size > 1;
+  for (const node of tree) {
+    renderNode(node, 0, showAccount, out);
+  }
+  const problems = problemLines(draft);
+  if (problems.length > 0) {
+    out.push("", ...problems);
+  }
+  return out.join("\n");
+}
+
+// src/commands/ads/x/draft.ts
+function handleDraftError(err) {
+  if (err instanceof ApiError) {
+    writeAdsJson(parseXApiError(err.message, "\u2014"));
+    process.exit(1);
+  }
+  writeAdsJson({ ok: false, error: { code: "NETWORK_ERROR", message: "Unexpected error" } });
+  process.exit(1);
+}
+registerSchema({
+  command: "ads.x.draft",
+  description: "Review everything staged for X Ads on this chat as a Campaign \u25B8 Ad group \u25B8 Ad tree. After a publish this is the authoritative record: `published \xB7 N applied`, or a `\u2717 \u2026 failed:` line per op that did not land.",
+  args: {
+    json: { type: "boolean", description: "Raw JSON envelope instead of the readable tree", required: false },
+    full: { type: "boolean", description: DRAFT_FULL_ARG.description, required: false },
+    chat: { type: "string", description: "Read another chat's draft instead of this one", required: false }
+  }
+});
+async function listDraft(json, chat, full = false) {
+  try {
+    const chatId = resolveChatId(chat);
+    const response = await apiPost("/api/ads/x/draft", {
+      chatId,
+      ...full ? { full: true } : {}
+    });
+    if (json || full || !response.ok || !response.data) {
+      writeJsonEnvelope(response);
+      return;
+    }
+    process.stdout.write(`${renderDraftStatus(response.data)}
+`);
+  } catch (err) {
+    handleDraftError(err);
+  }
+}
+var listCommand = defineCommand({
+  meta: {
+    name: "list",
+    description: "Review everything staged as a Campaign \u25B8 Ad group \u25B8 Ad tree. Example: baker ads x draft"
+  },
+  args: {
+    json: { type: "boolean", description: "Print the raw JSON envelope instead of the readable tree" },
+    full: DRAFT_FULL_ARG,
+    chat: CHAT_READ_ARG
+  },
+  run: async ({ args }) => {
+    await listDraft(args.json === true, args.chat, args.full === true);
+  }
+});
+registerSchema({
+  command: "ads.x.draft.show",
+  description: "The full staged payload, warnings and before-snapshot for one op \u2014 the receipt to check before publishing.",
+  args: {
+    ref: {
+      type: "positional",
+      description: "Op ref (x_temp_* for creates, the target id for updates)",
+      required: true
+    },
+    chat: { type: "string", description: "Read another chat's draft instead of this one", required: false }
+  }
+});
+var showCommand = defineCommand({
+  meta: {
+    name: "show",
+    description: "Show one staged op in full. Example: baker ads x draft show x_temp_abc123"
+  },
+  args: {
+    ref: { type: "positional", description: "Op ref, or the target id for a staged update", required: true },
+    chat: CHAT_READ_ARG
+  },
+  run: async ({ args }) => {
+    try {
+      const chatId = resolveChatId(args.chat);
+      const response = await apiPost("/api/ads/x/draft/show", {
+        chatId,
+        ref: String(args.ref)
+      });
+      writeJsonEnvelope(response);
+    } catch (err) {
+      handleDraftError(err);
+    }
+  }
+});
+registerSchema({
+  command: "ads.x.draft.amend",
+  description: "Change staged ops in place instead of removing and re-staging them \u2014 one, or many with the same patch in one call. The patch merges into the payload (JSON merge-patch: `null` deletes a key) and the whole op re-validates.",
+  args: {
+    ref: {
+      type: "positional",
+      description: "Op ref(s) or target id(s) \u2014 several, space- or comma-separated, before the patch",
+      required: true
+    },
+    patch: { type: "positional", description: "JSON object, or @path to a file holding one", required: true }
+  }
+});
+var amendCommand = defineCommand({
+  meta: {
+    name: "amend",
+    description: `Change a staged op in place.
+
+Examples:
+  baker ads x draft amend x_temp_abc '{"dailyBudgetAmountLocalMicro": 20000000}'
+  baker ads x draft amend x_temp_abc x_temp_def '{"entityStatus":"ACTIVE"}'   # many refs, one patch`
+  },
+  args: {
+    ref: {
+      type: "positional",
+      description: "Op ref(s) or target id(s) \u2014 several, space- or comma-separated, before the patch",
+      required: true
+    },
+    patch: { type: "positional", description: "JSON object, or @path to a file", required: true }
+  },
+  run: async ({ args }) => {
+    const positionals = Array.isArray(args._) ? args._ : [];
+    const refs = draftRefs(positionals.slice(0, -1));
+    const raw = String(positionals.at(-1) ?? args.patch);
+    let patch;
+    try {
+      patch = JSON.parse(raw.startsWith("@") ? readFileSync(raw.slice(1), "utf8") : raw);
+    } catch {
+      failWriteValidation("patch must be a JSON object, or @path to a file holding one");
+    }
+    if (patch === null || typeof patch !== "object" || Array.isArray(patch)) {
+      failWriteValidation("patch must be a JSON object");
+    }
+    if (refs.length > 1) {
+      await amendDraftRefs("/api/ads/x/draft/amend", refs, patch);
+      return;
+    }
+    try {
+      const chatId = requireChatId();
+      const response = await apiPost("/api/ads/x/draft/amend", {
+        chatId,
+        ref: String(args.ref),
+        patch
+      });
+      writeJsonEnvelope(response);
+    } catch (err) {
+      handleDraftError(err);
+    }
+  }
+});
+var REMOVE_REF_ARG = {
+  ref: {
+    type: "positional",
+    description: "Op ref(s) or target id(s) \u2014 several, space- or comma-separated",
+    required: true
+  }
+};
+registerSchema({
+  command: "ads.x.draft.remove",
+  description: "Drop staged X ops \u2014 one, or many in one call. Removing a create cascades to everything staged that depends on it.",
+  args: REMOVE_REF_ARG
+});
+var removeCommand = defineCommand({
+  meta: {
+    name: "remove",
+    description: "Drop staged ops \u2014 one, or many in one call (cascades to their dependents). Example: baker ads x draft remove x_temp_abc123 x_temp_def456"
+  },
+  args: REMOVE_REF_ARG,
+  run: async ({ args }) => {
+    const refs = draftRefs(args._);
+    if (refs.length > 1) {
+      await removeDraftRefs("/api/ads/x/draft/remove", refs);
+      return;
+    }
+    try {
+      const chatId = requireChatId();
+      const response = await apiPost("/api/ads/x/draft/remove", {
+        chatId,
+        ref: String(args.ref)
+      });
+      writeJsonEnvelope(response);
+    } catch (err) {
+      handleDraftError(err);
+    }
+  }
+});
+registerSchema({
+  command: "ads.x.draft.clear",
+  description: "Drop every staged X op on this chat. Nothing reached X, so nothing needs reversing.",
+  args: {}
+});
+var clearCommand = defineCommand({
+  meta: { name: "clear", description: "Drop every staged X op on this chat. Example: baker ads x draft clear" },
+  args: {},
+  run: async () => {
+    try {
+      const chatId = requireChatId();
+      const response = await apiPost("/api/ads/x/draft/clear", { chatId });
+      writeJsonEnvelope(response);
+    } catch (err) {
+      handleDraftError(err);
+    }
+  }
+});
+var draftCommand = defineCommand({
+  meta: {
+    name: "draft",
+    description: `Review and edit the X Ads changes staged on this chat.
+
+Nothing staged has reached X. Everything applies when the chat is published,
+and discarding the chat reverses all of it.
+
+Examples:
+  baker ads x draft                       \u2014 the Campaign \u25B8 Ad group \u25B8 Ad tree
+  baker ads x draft show x_temp_abc123    \u2014 one op in full
+  baker ads x draft list --full           \u2014 every op in full, in one call
+  baker ads x draft amend x_temp_abc '{"name":"New"}'
+  baker ads x draft remove x_temp_abc123
+  baker ads x draft clear`
+  },
+  subCommands: {
+    list: listCommand,
+    show: showCommand,
+    amend: amendCommand,
+    remove: removeCommand,
+    clear: clearCommand
+  },
+  // A parent must never declare `run`: citty falls through to it AFTER running
+  // the matched subcommand, so every edit would also trigger a full list.
+  args: { json: { type: "boolean", description: "Raw JSON envelope" }, full: DRAFT_FULL_ARG, chat: CHAT_READ_ARG },
+  default: "list"
+});
+export {
+  draftCommand
+};
+//# sourceMappingURL=draft-3HRGCNWA.js.map