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

package/dist/demographics-DK5JDY6M.js

@@ -0,0 +1,141 @@
+import {
+  csvOrJson,
+  daysAgoIso,
+  handleLinkedinError,
+  todayIso
+} from "./chunk-MNOCC5AL.js";
+import {
+  writeAdsJson
+} from "./chunk-LV7EU6HM.js";
+import {
+  NO_CACHE_ARG
+} from "./chunk-NLW25WW3.js";
+import "./chunk-HVJJEQDQ.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-46YLDIQG.js";
+import {
+  apiPost
+} from "./chunk-CIW3Q7B2.js";
+import "./chunk-O7AMKMII.js";
+import "./chunk-VPF5A7CM.js";
+import "./chunk-HZPTQRX6.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/ads/linkedin/demographics.ts
+import { defineCommand } from "citty";
+var DEFAULT_PIVOTS = ["job-title", "company", "industry", "seniority", "job-function", "company-size"];
+function numberOf(v) {
+  if (typeof v === "number") return Number.isFinite(v) ? v : 0;
+  if (typeof v === "string") {
+    const n = Number(v);
+    return Number.isFinite(n) ? n : 0;
+  }
+  return 0;
+}
+function topByImpressions(rows, limit) {
+  return [...rows].sort((a, b) => numberOf(b.impressions) - numberOf(a.impressions)).slice(0, limit);
+}
+var demographicsCommand = defineCommand({
+  meta: {
+    name: "demographics",
+    description: `Sweep all firmographic pivots in one command \u2014 LinkedIn's superpower.
+
+Default pivots:
+  job-title, company, industry, seniority, job-function, company-size
+
+Use --pivots to narrow the sweep. Output is one section per pivot, each with
+top-N rows by impressions (configurable via --top-n).
+
+Demographic data is delayed 12-24h with a \u22653-event privacy floor \u2014 small
+buckets are silently dropped. The CLI surfaces this in 'warnings' when the
+result set comes back unexpectedly empty.
+
+Examples:
+  baker ads linkedin demographics --campaign-id 1234
+  baker ads linkedin demographics --campaign-id 1234 --pivots job-title,company
+  baker ads linkedin demographics --campaign-id 1234 --last-days 30 --top-n 25`
+  },
+  args: {
+    "campaign-id": { type: "string", description: "Comma-separated campaign IDs (required)" },
+    pivots: { type: "string", description: `CSV of pivots (default: ${DEFAULT_PIVOTS.join(",")})` },
+    "top-n": { type: "string", description: "Top rows per pivot (default: 10)" },
+    intent: { type: "string", description: "baseline | revenue | funnel | engagement | lead-gen (default: baseline)" },
+    start: { type: "string", description: "Start date YYYY-MM-DD" },
+    end: { type: "string", description: "End date YYYY-MM-DD" },
+    "last-days": { type: "string", description: "Window relative to today (default: 30)" },
+    "no-cache": NO_CACHE_ARG,
+    output: { type: "string", description: "json", default: "json" }
+  },
+  run: async ({ args }) => {
+    const fmt = csvOrJson(args);
+    if (fmt !== "json") {
+      writeAdsJson({
+        ok: false,
+        error: {
+          code: "UNSUPPORTED_FORMAT",
+          message: "demographics returns a structured per-pivot report \u2014 only --output json supported."
+        }
+      });
+      process.exit(1);
+    }
+    const campaignIdsRaw = args["campaign-id"];
+    if (!campaignIdsRaw) {
+      handleLinkedinError(new Error("--campaign-id is required (CSV for multi)."));
+    }
+    const ids = campaignIdsRaw.split(",").map((s) => s.trim()).filter(Boolean);
+    const pivotsRaw = args.pivots?.split(",").map((s) => s.trim().toLowerCase());
+    const pivots = pivotsRaw && pivotsRaw.length > 0 ? pivotsRaw : DEFAULT_PIVOTS;
+    const topN = args["top-n"] ? Number(args["top-n"]) : 10;
+    const intent = args.intent ?? "baseline";
+    const { start, end } = resolveRange(args);
+    try {
+      const results = [];
+      for (const pivot of pivots) {
+        const data = await apiPost("/api/ads/linkedin/analytics", {
+          request: {
+            level: "campaign",
+            ids,
+            intent,
+            pivot,
+            start,
+            end,
+            granularity: "ALL",
+            limit: 500
+          },
+          skipCache: Boolean(args["no-cache"])
+        });
+        results.push({ pivot, rows: topByImpressions(data.rows, topN), warnings: data.warnings });
+      }
+      writeAdsJson({
+        ok: true,
+        data: {
+          query: { campaigns: ids, start, end, intent, topN },
+          pivots: results
+        }
+      });
+    } catch (err) {
+      handleLinkedinError(err);
+    }
+  }
+});
+function resolveRange(args) {
+  const start = args.start;
+  const end = args.end;
+  if (start) {
+    return { start, end };
+  }
+  const days = args["last-days"] ? Number(args["last-days"]) : 30;
+  if (!Number.isFinite(days) || days < 1) {
+    handleLinkedinError(new Error("Invalid --last-days; must be a positive integer."));
+  }
+  return { start: daysAgoIso(days), end: todayIso() };
+}
+export {
+  demographicsCommand
+};
+//# sourceMappingURL=demographics-DK5JDY6M.js.map

package/dist/discard-DEJOM62Y.js

@@ -0,0 +1,69 @@
+import {
+  failApi,
+  failValidation,
+  writeOk
+} from "./chunk-L5VVKIMB.js";
+import "./chunk-HVJJEQDQ.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-46YLDIQG.js";
+import {
+  apiPost,
+  validateConvexId
+} from "./chunk-CIW3Q7B2.js";
+import "./chunk-O7AMKMII.js";
+import {
+  requireChatId
+} from "./chunk-VPF5A7CM.js";
+import {
+  registerSchema
+} from "./chunk-HZPTQRX6.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/actions/discard.ts
+import { defineCommand } from "citty";
+registerSchema({
+  command: "actions.discard",
+  description: "Stage discard of an action \u2014 no claim needed; retire any action you're not working on. Applies on chat publish. Blocked only if another chat currently has it claimed.",
+  args: {
+    id: { type: "string", description: "Action ID", required: true },
+    reason: { type: "string", description: "Optional reason", required: false }
+  }
+});
+var discardCommand = defineCommand({
+  meta: {
+    name: "discard",
+    description: 'Stage discard of an action (no claim needed). Example: baker actions discard <id> --reason "obsolete"'
+  },
+  args: {
+    id: { type: "positional", description: "Action ID", required: false },
+    "action-id": { type: "string", description: "Action ID", required: false },
+    reason: { type: "string", description: "Reason for discarding", required: false }
+  },
+  run: async ({ args }) => {
+    try {
+      const id = args.id || args["action-id"];
+      if (!id) {
+        failValidation("Action ID is required.");
+      }
+      validateConvexId(id);
+      const chatId = requireChatId();
+      await apiPost("/api/actions/discard", {
+        chatId,
+        actionId: id,
+        reason: args.reason
+      });
+      writeOk();
+    } catch (err) {
+      failApi(err);
+    }
+  }
+});
+export {
+  discardCommand
+};
+//# sourceMappingURL=discard-DEJOM62Y.js.map

package/dist/discover-U6YLVLTF.js

@@ -0,0 +1,172 @@
+import {
+  PLANNER_FIELD_DESCRIPTIONS,
+  PLANNER_SOURCE,
+  stampPlannerRows
+} from "./chunk-2Y5V23PU.js";
+import {
+  buildAdsQueryContext,
+  warnDefaults
+} from "./chunk-SG2TDQEE.js";
+import "./chunk-44ZRCSR7.js";
+import {
+  buildQueryCacheKey,
+  cacheGet,
+  cacheSet,
+  getManagerIdForCustomer,
+  handleConnectionError,
+  isNotConnectedError,
+  resolveCustomerId,
+  writeAdsJson,
+  writeAdsOutput
+} from "./chunk-LV7EU6HM.js";
+import "./chunk-46YLDIQG.js";
+import {
+  ApiError,
+  apiPost
+} from "./chunk-CIW3Q7B2.js";
+import "./chunk-O7AMKMII.js";
+import "./chunk-VPF5A7CM.js";
+import {
+  registerSchema
+} from "./chunk-HZPTQRX6.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-U6YLVLTF.js.map

package/dist/domain-MBOMV3CQ.js

@@ -0,0 +1,101 @@
+import {
+  failSite
+} from "./chunk-2XRFWXSA.js";
+import "./chunk-HVJJEQDQ.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-46YLDIQG.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-MBOMV3CQ.js.map

package/dist/download-KN2I55SA.js

@@ -0,0 +1,172 @@
+import {
+  videosDownloadResponseSchema
+} from "./chunk-HVJJEQDQ.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-46YLDIQG.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-KN2I55SA.js.map