@koda-sl/baker-cli 0.532.0 → 0.534.0-dev.911a80433

package/dist/domain-JNNWJNQE.js

@@ -0,0 +1,101 @@
+import {
+  failSite
+} from "./chunk-JGOYO7I2.js";
+import "./chunk-DYOUJERF.js";
+import "./chunk-QV6AST5T.js";
+import "./chunk-WCU362Z6.js";
+import "./chunk-GIWHHCD6.js";
+import "./chunk-SOPVIIUW.js";
+import "./chunk-G4FG5EQO.js";
+import "./chunk-NSBNIPIW.js";
+import "./chunk-MUS2UTWU.js";
+import {
+  apiGet,
+  apiPost
+} from "./chunk-CIW3Q7B2.js";
+import "./chunk-O7AMKMII.js";
+import {
+  optionalChatId,
+  requireChatId
+} from "./chunk-VPF5A7CM.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-HZPTQRX6.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-JNNWJNQE.js.map

package/dist/download-3R5IHN5F.js

@@ -0,0 +1,172 @@
+import {
+  videosDownloadResponseSchema
+} from "./chunk-DYOUJERF.js";
+import "./chunk-QV6AST5T.js";
+import "./chunk-WCU362Z6.js";
+import "./chunk-GIWHHCD6.js";
+import "./chunk-SOPVIIUW.js";
+import "./chunk-G4FG5EQO.js";
+import "./chunk-NSBNIPIW.js";
+import "./chunk-MUS2UTWU.js";
+import {
+  ApiError,
+  apiPost,
+  validateConvexId
+} from "./chunk-CIW3Q7B2.js";
+import "./chunk-O7AMKMII.js";
+import "./chunk-VPF5A7CM.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-HZPTQRX6.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-3R5IHN5F.js.map

package/dist/draft-3L4SNDGO.js

@@ -0,0 +1,283 @@
+import {
+  failWriteValidation,
+  schemaArgs
+} from "./chunk-XPIBSDG4.js";
+import {
+  CHATGPT_ADS_REFERENCE,
+  chatgptFailure
+} from "./chunk-DBPPTM3W.js";
+import {
+  writeJsonEnvelope
+} from "./chunk-LV7EU6HM.js";
+import {
+  CHAT_READ_ARG
+} from "./chunk-PFBQERWX.js";
+import "./chunk-SOPVIIUW.js";
+import "./chunk-G4FG5EQO.js";
+import {
+  apiPost
+} from "./chunk-CIW3Q7B2.js";
+import "./chunk-O7AMKMII.js";
+import {
+  requireChatId,
+  resolveChatId
+} from "./chunk-VPF5A7CM.js";
+import {
+  registerSchema
+} from "./chunk-HZPTQRX6.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/ads/chatgpt/draft.ts
+import { readFileSync } from "fs";
+import { defineCommand } from "citty";
+
+// src/commands/ads/chatgpt/draft-status.ts
+var OPERATION_LABELS = {
+  create: { staged: "Creating", done: "Created", notDone: "Not created" },
+  update: { staged: "Updating", done: "Updated", notDone: "Not updated" },
+  pause: { staged: "Pausing", done: "Paused", notDone: "Not paused" },
+  resume: { staged: "Resuming", done: "Resumed", notDone: "Not resumed" },
+  archive: { staged: "Archiving", done: "Archived", notDone: "Not archived" }
+};
+var STATUS_HEADINGS = {
+  active: "staged",
+  publishing: "publishing",
+  applied: "published",
+  discarded: "discarded"
+};
+function badge(node) {
+  const label = node.operation ? OPERATION_LABELS[node.operation] : void 0;
+  if (!label) {
+    return node.existing ? "on ChatGPT Ads" : "staged";
+  }
+  if (node.outcome === "applied") {
+    return label.done;
+  }
+  return node.outcome ? `${label.notDone} (${node.outcome})` : label.staged;
+}
+function renderNode(node, depth, out) {
+  const indent = "  ".repeat(depth);
+  out.push(`${indent}${node.entity}: ${node.name} \u2014 ${badge(node)}`);
+  for (const warning of node.warnings ?? []) {
+    out.push(`${indent}  ! ${warning}`);
+  }
+  for (const child of node.children) {
+    renderNode(child, depth + 1, out);
+  }
+}
+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 `ChatGPT Ads: ${draft.count} change${draft.count === 1 ? "" : "s"} ${heading}`;
+  }
+  const applied = draft.ops.filter(didApply).length;
+  const failed = draft.ops.filter(didNotApply).length;
+  return `ChatGPT Ads: ${heading} \xB7 ${applied} applied${failed > 0 ? `, ${failed} failed` : ""}`;
+}
+function renderChatgptDraftStatus(draft) {
+  if (draft.status === "none" || draft.count === 0) {
+    return "No ChatGPT Ads changes staged";
+  }
+  const out = [headingLine(draft), ""];
+  for (const node of draft.tree ?? []) {
+    renderNode(node, 0, out);
+  }
+  const summaryByRef = new Map(draft.ops.map((op) => [op.ref, op.summary]));
+  const problems = draft.ops.filter(didNotApply).map((op) => {
+    if (op.result?.status === "failed") {
+      return `\u2717 ${op.summary} \u2014 failed: ${op.result.error ?? "ChatGPT Ads gave no reason"}`;
+    }
+    const waitedOn = op.result?.skippedBecause;
+    const parent = (waitedOn && summaryByRef.get(waitedOn)) ?? "a change that did not apply";
+    return `\u2717 ${op.summary} \u2014 skipped: waiting on ${parent}, which did not apply`;
+  });
+  if (problems.length > 0) {
+    out.push("", ...problems);
+  }
+  return out.join("\n");
+}
+
+// src/commands/ads/chatgpt/draft.ts
+async function run(call) {
+  try {
+    writeJsonEnvelope({ ok: true, data: await call() });
+  } catch (err) {
+    writeJsonEnvelope({ ...chatgptFailure(err, CHATGPT_ADS_REFERENCE.overview) });
+    process.exit(1);
+  }
+}
+var LIST_ARGS = {
+  json: { type: "boolean", description: "Print the raw JSON envelope instead of the readable tree" },
+  chat: CHAT_READ_ARG
+};
+registerSchema({
+  command: "ads.chatgpt.draft",
+  description: "Review everything staged for ChatGPT 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 change that did not land, with ChatGPT Ads' reason.",
+  args: schemaArgs(LIST_ARGS)
+});
+var listCommand = defineCommand({
+  meta: {
+    name: "list",
+    description: "Review everything staged as a Campaign \u25B8 Ad group \u25B8 Ad tree. Example: baker ads chatgpt draft"
+  },
+  args: LIST_ARGS,
+  run: async ({ args }) => {
+    try {
+      const draft = await apiPost("/api/ads/chatgpt/draft", {
+        chatId: resolveChatId(args.chat)
+      });
+      if (args.json === true) {
+        writeJsonEnvelope({ ok: true, data: draft });
+        return;
+      }
+      process.stdout.write(`${renderChatgptDraftStatus(draft)}
+`);
+    } catch (err) {
+      writeJsonEnvelope({ ...chatgptFailure(err, CHATGPT_ADS_REFERENCE.overview) });
+      process.exit(1);
+    }
+  }
+});
+var SHOW_ARGS = {
+  ref: {
+    type: "positional",
+    description: "Op ref (chatgpt_temp_* for creates), or the target id for a staged update",
+    required: true
+  },
+  chat: CHAT_READ_ARG
+};
+registerSchema({
+  command: "ads.chatgpt.draft.show",
+  description: "The full staged payload, warnings and before-snapshot for one change \u2014 the receipt to check before publishing.",
+  args: schemaArgs(SHOW_ARGS)
+});
+var showCommand = defineCommand({
+  meta: {
+    name: "show",
+    description: "Show one staged change in full. Example: baker ads chatgpt draft show chatgpt_temp_ab12"
+  },
+  args: SHOW_ARGS,
+  run: async ({ args }) => {
+    await run(
+      () => apiPost("/api/ads/chatgpt/draft/show", {
+        chatId: resolveChatId(args.chat),
+        ref: String(args.ref)
+      })
+    );
+  }
+});
+var AMEND_ARGS = {
+  ref: { type: "positional", description: "Op ref or target id", required: true },
+  patch: { type: "positional", description: "JSON object, or @path to a file holding one", required: true }
+};
+registerSchema({
+  command: "ads.chatgpt.draft.amend",
+  description: "Change a staged op in place instead of removing and re-staging it. The patch merges into the payload (JSON merge-patch: `null` deletes a key; money is in micros) and the whole op re-validates.",
+  args: schemaArgs(AMEND_ARGS)
+});
+var amendCommand = defineCommand({
+  meta: {
+    name: "amend",
+    description: `Change a staged op in place. Money in the payload is micros: 20 = 20000000.
+
+Example:
+  baker ads chatgpt draft amend chatgpt_temp_ab12 '{"dailyBudgetMicros": 30000000}'`
+  },
+  args: AMEND_ARGS,
+  run: async ({ args }) => {
+    const raw = String(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");
+    }
+    await run(
+      () => apiPost("/api/ads/chatgpt/draft/amend", {
+        chatId: requireChatId(),
+        ref: String(args.ref),
+        patch
+      })
+    );
+  }
+});
+var REMOVE_ARGS = { ref: { type: "positional", description: "Op ref or target id", required: true } };
+registerSchema({
+  command: "ads.chatgpt.draft.remove",
+  description: "Drop one staged ChatGPT Ads change. Removing a create also drops everything staged under it.",
+  args: schemaArgs(REMOVE_ARGS)
+});
+var removeCommand = defineCommand({
+  meta: {
+    name: "remove",
+    description: "Drop one staged change (and what depends on it). Example: baker ads chatgpt draft remove chatgpt_temp_ab12"
+  },
+  args: REMOVE_ARGS,
+  run: async ({ args }) => {
+    await run(
+      () => apiPost("/api/ads/chatgpt/draft/remove", {
+        chatId: requireChatId(),
+        ref: String(args.ref)
+      })
+    );
+  }
+});
+registerSchema({
+  command: "ads.chatgpt.draft.clear",
+  description: "Drop every staged ChatGPT Ads change on this chat. Nothing reached ChatGPT Ads, so nothing needs reversing.",
+  args: {}
+});
+var clearCommand = defineCommand({
+  meta: {
+    name: "clear",
+    description: "Drop every staged ChatGPT Ads change on this chat. Example: baker ads chatgpt draft clear"
+  },
+  args: {},
+  run: async () => {
+    await run(
+      () => apiPost("/api/ads/chatgpt/draft/clear", {
+        chatId: requireChatId()
+      })
+    );
+  }
+});
+var draftCommand = defineCommand({
+  meta: {
+    name: "draft",
+    description: `Review and edit the ChatGPT Ads changes staged on this chat.
+
+Nothing staged has reached ChatGPT Ads. Everything applies when the chat is
+published, and discarding the chat drops all of it.
+
+Examples:
+  baker ads chatgpt draft                               \u2014 the Campaign \u25B8 Ad group \u25B8 Ad tree
+  baker ads chatgpt draft show chatgpt_temp_ab12        \u2014 one change in full
+  baker ads chatgpt draft amend chatgpt_temp_ab12 '{"name":"New"}'
+  baker ads chatgpt draft remove chatgpt_temp_ab12
+  baker ads chatgpt 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 the
+  // matched subcommand, so every edit would also print the whole draft.
+  args: LIST_ARGS,
+  default: "list"
+});
+export {
+  draftCommand
+};
+//# sourceMappingURL=draft-3L4SNDGO.js.map