@koda-sl/baker-cli 0.384.0-dev.4699b7308 → 0.384.0-dev.557795bef

package/dist/chunk-FKOECEVC.js

@@ -0,0 +1,126 @@
+// src/commands/videos/videoPlatforms.ts
+var PLATFORM_DOMAINS = {
+  youtube: ["youtube.com", "youtu.be"],
+  instagram: ["instagram.com", "ddinstagram.com"],
+  tiktok: ["tiktok.com"],
+  twitter: ["twitter.com", "x.com", "vxtwitter.com", "fixvx.com"],
+  facebook: ["facebook.com", "fb.watch", "fb.com"],
+  linkedin: ["linkedin.com", "lnkd.in"],
+  reddit: ["reddit.com", "redd.it"],
+  vimeo: ["vimeo.com"],
+  dailymotion: ["dailymotion.com", "dai.ly"],
+  twitch: ["twitch.tv"],
+  bluesky: ["bsky.app"],
+  bilibili: ["bilibili.com", "bilibili.tv", "b23.tv"],
+  vk: ["vk.com", "vk.ru", "vkvideo.ru"],
+  ok: ["ok.ru"],
+  pinterest: ["pinterest.com", "pin.it"],
+  tumblr: ["tumblr.com"],
+  snapchat: ["snapchat.com"],
+  loom: ["loom.com"],
+  streamable: ["streamable.com"],
+  newgrounds: ["newgrounds.com"],
+  rutube: ["rutube.ru"]
+};
+var VIDEO_PLATFORMS = Object.keys(PLATFORM_DOMAINS);
+function platformFromUrl(rawUrl) {
+  let host;
+  try {
+    host = new URL(rawUrl).hostname.toLowerCase();
+  } catch {
+    return "url";
+  }
+  for (const [platform, domains] of Object.entries(PLATFORM_DOMAINS)) {
+    if (domains.some((domain) => host === domain || host.endsWith(`.${domain}`))) {
+      return platform;
+    }
+  }
+  return "url";
+}
+
+// src/commands/videos/ingestUrl.ts
+var MAX_VIDEO_INGEST_BYTES = 16 * 1024 * 1024 * 1024;
+var MAX_VIDEO_INGEST_SECONDS = 3 * 60 * 60;
+function refuseByDuration(seconds, maxSeconds) {
+  if (seconds === void 0 || seconds <= maxSeconds) return null;
+  return `That video is ${(seconds / 3600).toFixed(1)} hours long \u2014 the limit is ${Math.round(maxSeconds / 3600)} hours.`;
+}
+var DOWNLOAD_TIMEOUT_FLOOR_MS = 10 * 60 * 1e3;
+var DOWNLOAD_TIMEOUT_CEILING_MS = 15 * 60 * 1e3;
+function downloadTimeoutMs(seconds) {
+  if (seconds === void 0) return DOWNLOAD_TIMEOUT_FLOOR_MS;
+  const scaled = seconds * 2 * 1e3;
+  return Math.min(Math.max(scaled, DOWNLOAD_TIMEOUT_FLOOR_MS), DOWNLOAD_TIMEOUT_CEILING_MS);
+}
+var DIRECT_MEDIA_EXTENSIONS = [".mp4", ".mov", ".webm", ".m4v", ".mkv", ".avi"];
+function isDirectMediaUrl(rawUrl) {
+  const pathname = safePathname(rawUrl);
+  return DIRECT_MEDIA_EXTENSIONS.some((ext) => pathname.endsWith(ext));
+}
+function resolveIngestSource(explicit, rawUrl) {
+  if (explicit) return explicit;
+  return platformFromUrl(rawUrl);
+}
+var TOOLING_OR_BLOCK_SIGNATURES = [
+  "requested format is not available",
+  "only images are available",
+  "nsig",
+  "sign in to confirm",
+  // bot check — distinct from "Private video. Sign in if…"
+  "unable to download api page",
+  "http error 403",
+  // yt-dlp's own "the site changed under me" signature. It prints a GitHub issue
+  // link whenever a page parsed nothing like the shape the extractor expects —
+  // which is precisely a downloader that has aged out, not a bad link. Observed
+  // live on TikTok, which probed fine and then broke ninety minutes later from
+  // the same machine, identically through direct, datacenter and residential
+  // exits. Without this it fell through to "check the link is public", sending
+  // the reader to inspect a video that was never the problem.
+  "please report this issue"
+];
+function isToolingOrBlockFailure(detail) {
+  const haystack = detail.toLowerCase();
+  return TOOLING_OR_BLOCK_SIGNATURES.some((signature) => haystack.includes(signature));
+}
+var REGION_BLOCK_SIGNATURES = [
+  "in your country",
+  "geo-restricted",
+  "geo restricted",
+  "not available from your location",
+  "blocked in your country"
+];
+function isDrmProtected(detail) {
+  return detail.toLowerCase().includes("drm protected");
+}
+function isRegionBlocked(detail) {
+  const haystack = detail.toLowerCase();
+  return REGION_BLOCK_SIGNATURES.some((signature) => haystack.includes(signature));
+}
+function worthDownloadingInstead(errorCode) {
+  return errorCode === "VALIDATION_ERROR";
+}
+function directDedupeKey(source, rawUrl) {
+  return `${source}:${rawUrl}`;
+}
+function safePathname(rawUrl) {
+  try {
+    return new URL(rawUrl).pathname.toLowerCase();
+  } catch {
+    return "";
+  }
+}
+
+export {
+  MAX_VIDEO_INGEST_BYTES,
+  MAX_VIDEO_INGEST_SECONDS,
+  refuseByDuration,
+  downloadTimeoutMs,
+  isDirectMediaUrl,
+  resolveIngestSource,
+  isToolingOrBlockFailure,
+  isDrmProtected,
+  isRegionBlocked,
+  worthDownloadingInstead,
+  directDedupeKey
+};
+//# sourceMappingURL=chunk-FKOECEVC.js.map

package/dist/chunk-FKOECEVC.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/commands/videos/videoPlatforms.ts","../src/commands/videos/ingestUrl.ts"],"sourcesContent":["/**\n * Which platform a video link came from.\n *\n * This exists for provenance, not for capability. The downloader already reaches\n * far more sites than are named here, so a platform missing from this table\n * still ingests — it is simply recorded as `url`. What the table buys is the\n * ability to answer \"where did this clip come from\" later: a competitor's TikTok,\n * a supplier's Vimeo and the client's own YouTube are different things to a\n * marketer, and collapsing all three into \"url\" throws that away at the only\n * moment it is knowable.\n *\n * Kept deliberately small. Naming every site the downloader supports would be a\n * list nobody can maintain and would still be missing the next one; these are the\n * platforms whose provenance actually changes how a clip gets used.\n */\n\n/** Registrable domains per platform. Subdomains match; lookalikes must not. */\nconst PLATFORM_DOMAINS = {\n  youtube: [\"youtube.com\", \"youtu.be\"],\n  instagram: [\"instagram.com\", \"ddinstagram.com\"],\n  tiktok: [\"tiktok.com\"],\n  twitter: [\"twitter.com\", \"x.com\", \"vxtwitter.com\", \"fixvx.com\"],\n  facebook: [\"facebook.com\", \"fb.watch\", \"fb.com\"],\n  linkedin: [\"linkedin.com\", \"lnkd.in\"],\n  reddit: [\"reddit.com\", \"redd.it\"],\n  vimeo: [\"vimeo.com\"],\n  dailymotion: [\"dailymotion.com\", \"dai.ly\"],\n  twitch: [\"twitch.tv\"],\n  bluesky: [\"bsky.app\"],\n  bilibili: [\"bilibili.com\", \"bilibili.tv\", \"b23.tv\"],\n  vk: [\"vk.com\", \"vk.ru\", \"vkvideo.ru\"],\n  ok: [\"ok.ru\"],\n  pinterest: [\"pinterest.com\", \"pin.it\"],\n  tumblr: [\"tumblr.com\"],\n  snapchat: [\"snapchat.com\"],\n  loom: [\"loom.com\"],\n  streamable: [\"streamable.com\"],\n  newgrounds: [\"newgrounds.com\"],\n  rutube: [\"rutube.ru\"],\n} as const satisfies Record<string, readonly string[]>;\n\nexport type VideoPlatform = keyof typeof PLATFORM_DOMAINS;\n\n/** Every platform this can name; `platformFromUrl` returns one of these or `url`. */\nexport const VIDEO_PLATFORMS = Object.keys(PLATFORM_DOMAINS) as readonly VideoPlatform[];\n\n/**\n * The platform a URL belongs to, or `url` when it is not one we name.\n *\n * Matching is on the host, anchored at a dot boundary — never `includes`. That\n * is the whole security property of this function: `youtube.com.evil.test` and\n * `notyoutube.com` are attacker-controlled hosts that would otherwise inherit\n * YouTube's identity, and provenance that can be spoofed is worse than none,\n * because it is trusted.\n *\n * Pinterest is a deliberate omission from the country-mirror handling: cobalt\n * collapses `pinterest.co.uk` and friends, and doing the same here would mean\n * carrying a list of every ccTLD a platform has ever used. Those links resolve\n * as `url` and still ingest.\n */\nexport function platformFromUrl(rawUrl: string): VideoPlatform | \"url\" {\n  let host: string;\n  try {\n    host = new URL(rawUrl).hostname.toLowerCase();\n  } catch {\n    return \"url\";\n  }\n\n  for (const [platform, domains] of Object.entries(PLATFORM_DOMAINS)) {\n    if (domains.some((domain) => host === domain || host.endsWith(`.${domain}`))) {\n      return platform as VideoPlatform;\n    }\n  }\n  return \"url\";\n}\n","import { platformFromUrl } from \"./videoPlatforms.ts\";\n/**\n * URL classification for `baker videos ingest`. Pure so the routing decision —\n * hand the URL to Baker, or download it here first — is testable without a\n * network, a sandbox, or yt-dlp installed.\n */\n\n/**\n * Ceiling on the download path only. The direct path has no equivalent: Mux\n * fetches the file itself, so nothing is held in the Runtime's memory or disk.\n *\n * This was 2 GB, and it was never really a policy — it was a memory limit\n * wearing a policy's clothes. The upload read the whole file into a Buffer and\n * then copied it again into a `Uint8Array` (measured: that constructor does not\n * alias), so peak RAM was twice the file and an 8 GB Runtime would be OOM-killed\n * before the check ever fired. The file now streams from disk\n * (`lib/streamUpload.ts`), peak memory is one chunk regardless of length, and\n * this bounds the Runtime's *disk* — the last resource a download still spends\n * in proportion to how long the video is.\n *\n * The gate that does the real work is `refuseByDuration`, below: it turns away a\n * too-long video from its metadata, before a single byte is fetched.\n */\nexport const MAX_VIDEO_INGEST_BYTES = 16 * 1024 * 1024 * 1024;\n\n/** The longest video we will pull down, in seconds. */\nexport const MAX_VIDEO_INGEST_SECONDS = 3 * 60 * 60;\n\n/**\n * Whether a video is too long to ingest, phrased for whoever pasted the link.\n *\n * Duration rather than bytes, because duration is knowable *before* downloading\n * and a byte count is not: a watch page carries no `content-length`, an adaptive\n * stream has one per segment, and the merged file does not exist until it has\n * been muxed. So a byte cap can only be enforced after paying for the very\n * download it was supposed to avoid, while a duration cap costs one metadata\n * probe.\n *\n * An unknown duration is accepted, not refused. A live stream, or a site that\n * publishes no metadata, reports nothing — and treating silence as \"too long\"\n * would turn a missing field into a blocked ingest. The byte ceiling still\n * catches those on the way out.\n */\nexport function refuseByDuration(seconds: number | undefined, maxSeconds: number): string | null {\n  if (seconds === undefined || seconds <= maxSeconds) return null;\n  return `That video is ${(seconds / 3600).toFixed(1)} hours long — the limit is ${Math.round(maxSeconds / 3600)} hours.`;\n}\n\n/** Floor, and what an unknown duration gets: enough for any ordinary clip. */\nconst DOWNLOAD_TIMEOUT_FLOOR_MS = 10 * 60 * 1000;\n/**\n * Ceiling, and the binding constraint in practice.\n *\n * Set by what a person waiting in a chat will tolerate, not by what a download\n * might need: the turn is blocked for this whole time, and a chat that appears\n * frozen for three quarters of an hour is a worse outcome than a clip that did\n * not import. Fifteen minutes covers any ordinary clip even from a slow CDN,\n * and a video that cannot make it says so and points at `upload`.\n */\nconst DOWNLOAD_TIMEOUT_CEILING_MS = 15 * 60 * 1000;\n\n/**\n * How long a download may take, derived from how long the video is.\n *\n * These two numbers have to be related or they quietly contradict each other,\n * which is exactly what happened: the duration gate accepted up to three hours\n * while every download got a flat ten-minute window, so a 33-minute VK video —\n * served slowly, still transferring at 137 MB when the clock ran out — was\n * accepted by one rule and made impossible by another. It surfaced as\n * \"Unexpected error\", because a timeout throws a plain `Error` that the caller\n * discarded.\n *\n * Twice real-time is the budget: generous for a CDN serving faster than\n * playback, and still finite for one that is not. The ceiling matters more than\n * the ratio — without it a three-hour video would license a six-hour download.\n */\nexport function downloadTimeoutMs(seconds: number | undefined): number {\n  if (seconds === undefined) return DOWNLOAD_TIMEOUT_FLOOR_MS;\n  const scaled = seconds * 2 * 1000;\n  return Math.min(Math.max(scaled, DOWNLOAD_TIMEOUT_FLOOR_MS), DOWNLOAD_TIMEOUT_CEILING_MS);\n}\n\nconst DIRECT_MEDIA_EXTENSIONS = [\".mp4\", \".mov\", \".webm\", \".m4v\", \".mkv\", \".avi\"] as const;\n\n/**\n * True when the URL's path ends in a media extension, which is the signal that\n * Mux can pull it directly. Deliberately conservative: a false negative only\n * costs an unnecessary download, while a false positive hands Mux a web page.\n */\nexport function isDirectMediaUrl(rawUrl: string): boolean {\n  const pathname = safePathname(rawUrl);\n  return DIRECT_MEDIA_EXTENSIONS.some((ext) => pathname.endsWith(ext));\n}\n\n/** Explicit `--source` always wins; otherwise infer provenance from the host. */\nexport function resolveIngestSource(explicit: string | undefined, rawUrl: string): string {\n  if (explicit) return explicit;\n  return platformFromUrl(rawUrl);\n}\n\n/**\n * Signatures of \"the site wouldn't hand over the video\", as opposed to \"this\n * link is private or gone\".\n *\n * They matter because the remediation is opposite. These all mean the downloader\n * could not read the page — nearly always because it has aged out against a site\n * that changed (YouTube rewrites its player every few weeks) or because the\n * request was blocked. Retrying is useless and the user's link is fine, so\n * telling them to check whether their public video is \"private\" sends them after\n * a problem that isn't theirs.\n */\nconst TOOLING_OR_BLOCK_SIGNATURES = [\n  \"requested format is not available\",\n  \"only images are available\",\n  \"nsig\",\n  \"sign in to confirm\", // bot check — distinct from \"Private video. Sign in if…\"\n  \"unable to download api page\",\n  \"http error 403\",\n  // yt-dlp's own \"the site changed under me\" signature. It prints a GitHub issue\n  // link whenever a page parsed nothing like the shape the extractor expects —\n  // which is precisely a downloader that has aged out, not a bad link. Observed\n  // live on TikTok, which probed fine and then broke ninety minutes later from\n  // the same machine, identically through direct, datacenter and residential\n  // exits. Without this it fell through to \"check the link is public\", sending\n  // the reader to inspect a video that was never the problem.\n  \"please report this issue\",\n] as const;\n\nexport function isToolingOrBlockFailure(detail: string): boolean {\n  const haystack = detail.toLowerCase();\n  return TOOLING_OR_BLOCK_SIGNATURES.some((signature) => haystack.includes(signature));\n}\n\n/**\n * Failures a *different country* could plausibly open — the only ones where\n * retrying with `--country` is worth suggesting.\n *\n * Deliberately narrow, and it is the narrowness that matters. Every rung of the\n * ladder already tries a different IP, so \"we were refused\" is not evidence that\n * geography was the reason; it is only evidence that geography *might* be. These\n * phrases are the ones where the site itself named the country.\n *\n * TikTok is the worked counter-example and the reason this is not a loose match\n * on \"blocked\": it answers with \"Your IP address is blocked from accessing this\n * post\", which reads exactly like a geo problem. Measured across six exits in\n * four countries — Spain direct, Spain datacenter, US, DE, SG, BR — that post\n * failed identically from all of them, while a different post succeeded from the\n * plain direct IP. Treating that string as regional would sell the agent a retry\n * that cannot work, once per country it thinks to try.\n */\nconst REGION_BLOCK_SIGNATURES = [\n  \"in your country\",\n  \"geo-restricted\",\n  \"geo restricted\",\n  \"not available from your location\",\n  \"blocked in your country\",\n] as const;\n\n/**\n * The video's own encryption refusing us — a hard stop, not a hurdle.\n *\n * Kept separate from every other failure because it is the only one where the\n * honest answer is \"no, and no amount of retrying, signing in or changing\n * country will alter that\". Removing DRM is a different act from downloading\n * something published openly, so this never suggests a workaround.\n *\n * Checked *before* the tooling signatures, because a DRM video also emits\n * \"Requested format is not available\" as its second line — and that phrase is\n * read as a stale downloader, which would file a permanent property of the video\n * as a bug in our tooling. Measured: `--check-formats`, the remedy yt-dlp's own\n * message suggests, does not help when the audio track is the encrypted part.\n */\nexport function isDrmProtected(detail: string): boolean {\n  return detail.toLowerCase().includes(\"drm protected\");\n}\n\nexport function isRegionBlocked(detail: string): boolean {\n  const haystack = detail.toLowerCase();\n  return REGION_BLOCK_SIGNATURES.some((signature) => haystack.includes(signature));\n}\n\n/**\n * Whether a failed direct ingest is worth retrying by downloading the file\n * ourselves.\n *\n * The subtlety that makes this necessary: the download route finishes by posting\n * to the *same* endpoint, with the same API key and the same `source`. So a\n * failure about the request rather than about the URL is guaranteed to fail\n * again identically, except now after pulling the whole video down first.\n *\n * An allow-list of one, and it has to be, because the codes here are the CLI's\n * (`mapHttpError`), not the backend's. That distinction was previously missed:\n * this listed backend names, so `apiError(\"BAD_REQUEST\")` — the code the route\n * raises when Mux refuses the source, and the only case this exists for —\n * arrived as `VALIDATION_ERROR` and was refused, while a backend 500 arrived as\n * `INTERNAL_ERROR`, matched nothing, and downloaded a whole video to replay the\n * identical failing request. Naming the outcome we want, rather than the ones we\n * don't, means a code nobody anticipated costs a missed retry instead of a\n * wasted download.\n *\n * `VALIDATION_ERROR` is unambiguous *here* only because the request body is zod\n * validated client-side before it is ever sent, so a 400 from this route is not\n * a malformed request — it is Baker saying it could not fetch that URL.\n */\nexport function worthDownloadingInstead(errorCode: string): boolean {\n  return errorCode === \"VALIDATION_ERROR\";\n}\n\n/**\n * The dedupe key for a URL handed straight to Baker.\n *\n * The direct path never probes — that is the whole point of it — so there is no\n * provider id to key on and the URL is the only identifier available. That is\n * the same position the download path's *generic* extractor branch is in, and it\n * resolves it the same way, so a link filed directly and the same link filed via\n * the download fallback agree on one row instead of producing two.\n *\n * Keyed on the full URL rather than the filename: two unrelated clips are very\n * often both called `demo.mp4`, and a collision silently returns the wrong video\n * under a successful-looking response, which is far worse than a missed dedupe.\n * A signed URL carrying an expiring token simply never dedupes, which is the\n * harmless direction to fail in.\n */\nexport function directDedupeKey(source: string, rawUrl: string): string {\n  return `${source}:${rawUrl}`;\n}\n\nfunction safePathname(rawUrl: string): string {\n  try {\n    return new URL(rawUrl).pathname.toLowerCase();\n  } catch {\n    return \"\";\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-FMGW2NZI.js

@@ -0,0 +1,106 @@
+import {
+  cacheGet,
+  cacheSet,
+  handleConnectionError,
+  needsConnectionFix,
+  writeAdsJson
+} from "./chunk-EIGXX6KI.js";
+import {
+  ApiError,
+  apiGet
+} from "./chunk-CUL3VB4L.js";
+import {
+  getEnv
+} from "./chunk-I4FTS5EE.js";
+
+// src/commands/ads/x/output.ts
+var ACCOUNTS_CACHE_TTL_MS = 60 * 60 * 1e3;
+var NO_X_ACCOUNTS_EXPLANATION = "The X Ads connection is live, but X lists no ads accounts for it. That is usually an account X has not activated for advertising yet \u2014 most often one with no billing set up. It does not mean the connection failed, and reconnecting will not change it. An account X omits here still works everywhere else: take its id from the ads.x.com URL (ads.x.com/manager/<id>/\u2026) and pass --account-id <id>, or set BAKER_X_ADS_ACCOUNT_ID.";
+async function fetchXAccounts(useCache) {
+  if (useCache) {
+    const cached = cacheGet("x-accounts", "list");
+    if (cached) return cached.data;
+  }
+  const params = !useCache ? { "skip-cache": "true" } : void 0;
+  const data = await apiGet("/api/ads/x/accounts", params);
+  if (useCache) {
+    cacheSet("x-accounts", "list", data, ACCOUNTS_CACHE_TTL_MS);
+  }
+  return data;
+}
+async function resolveXAccountId(args) {
+  const fromArgs = args["account-id"];
+  const accountId = fromArgs || getEnv().BAKER_X_ADS_ACCOUNT_ID;
+  if (accountId) {
+    if (!/^[a-z0-9]+$/.test(accountId)) {
+      writeAdsJson({
+        ok: false,
+        error: {
+          code: "INVALID_ACCOUNT_ID",
+          message: "X Ads account ID must be a base36 string (lowercase letters and digits). Pass --account-id or set BAKER_X_ADS_ACCOUNT_ID."
+        }
+      });
+      process.exit(1);
+    }
+    return accountId;
+  }
+  const useCache = !args["no-cache"];
+  try {
+    const accounts = await fetchXAccounts(useCache);
+    const [single] = accounts;
+    if (accounts.length === 1 && single) {
+      process.stderr.write(`Using account "${single.name}" (${single.id})
+`);
+      return single.id;
+    }
+    if (accounts.length === 0) {
+      writeAdsJson({
+        ok: false,
+        error: {
+          code: "INVALID_ACCOUNT_ID",
+          message: NO_X_ACCOUNTS_EXPLANATION,
+          fix: { action: "reject", explanation: NO_X_ACCOUNTS_EXPLANATION },
+          retryable: false
+        }
+      });
+      process.exit(1);
+    }
+    const list = accounts.map((a) => `  ${a.id}  ${a.name}`).join("\n");
+    writeAdsJson({
+      ok: false,
+      error: {
+        code: "MULTIPLE_ACCOUNTS",
+        message: `Multiple X Ads accounts found. Pass --account-id or set BAKER_X_ADS_ACCOUNT_ID:
+${list}`
+      }
+    });
+    process.exit(1);
+  } catch (err) {
+    if (err instanceof ApiError && needsConnectionFix(err.code, err.message)) {
+      handleConnectionError("x_ads", err.message);
+    }
+    writeAdsJson({
+      ok: false,
+      error: {
+        code: "INVALID_ACCOUNT_ID",
+        message: "Could not auto-detect account. Pass --account-id or set BAKER_X_ADS_ACCOUNT_ID."
+      }
+    });
+    process.exit(1);
+  }
+}
+async function resolveXAccountTimezone(accountId, args) {
+  try {
+    const accounts = await fetchXAccounts(!args["no-cache"]);
+    return accounts.find((a) => a.id === accountId)?.timezone || "UTC";
+  } catch {
+    return "UTC";
+  }
+}
+
+export {
+  NO_X_ACCOUNTS_EXPLANATION,
+  resolveXAccountId,
+  resolveXAccountTimezone
+};
+//# sourceMappingURL=chunk-FMGW2NZI.js.map

package/dist/chunk-FMGW2NZI.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/commands/ads/x/output.ts"],"sourcesContent":["import { ApiError, apiGet } from \"../../../client.ts\";\nimport { getEnv } from \"../../../env.ts\";\nimport { handleConnectionError, needsConnectionFix } from \"../../../error-handler.ts\";\nimport { cacheGet, cacheSet } from \"../cache.ts\";\nimport { writeAdsJson } from \"../output.ts\";\n\nexport interface XAccountInfo {\n  id: string;\n  name: string;\n  approval_status?: string;\n  timezone?: string;\n  currency?: string;\n}\n\nconst ACCOUNTS_CACHE_TTL_MS = 60 * 60 * 1000;\n\n/**\n * X serves `/accounts` from its own idea of an active advertiser account, and an account it\n * leaves out of that list still answers every child endpoint — campaigns, media, funding and\n * the rest all work when the id is named. So an empty list is a discovery problem, never a\n * broken grant, and telling the user to reconnect sends them round a loop that cannot help.\n */\nexport const NO_X_ACCOUNTS_EXPLANATION =\n  \"The X Ads connection is live, but X lists no ads accounts for it. That is usually an account \" +\n  \"X has not activated for advertising yet — most often one with no billing set up. It does not \" +\n  \"mean the connection failed, and reconnecting will not change it. An account X omits here still \" +\n  \"works everywhere else: take its id from the ads.x.com URL (ads.x.com/manager/<id>/…) and pass \" +\n  \"--account-id <id>, or set BAKER_X_ADS_ACCOUNT_ID.\";\n\nasync function fetchXAccounts(useCache: boolean): Promise<XAccountInfo[]> {\n  if (useCache) {\n    const cached = cacheGet<XAccountInfo[]>(\"x-accounts\", \"list\");\n    if (cached) return cached.data;\n  }\n  const params = !useCache ? { \"skip-cache\": \"true\" } : undefined;\n  const data = await apiGet<XAccountInfo[]>(\"/api/ads/x/accounts\", params);\n  if (useCache) {\n    cacheSet(\"x-accounts\", \"list\", data, ACCOUNTS_CACHE_TTL_MS);\n  }\n  return data;\n}\n\n/**\n * Resolve an X Ads account_id from either --account-id, BAKER_X_ADS_ACCOUNT_ID, or\n * (if exactly one account is connected) auto-detect.\n */\nexport async function resolveXAccountId(args: Record<string, unknown>): Promise<string> {\n  const fromArgs = args[\"account-id\"] as string | undefined;\n  const accountId = fromArgs || getEnv().BAKER_X_ADS_ACCOUNT_ID;\n  if (accountId) {\n    if (!/^[a-z0-9]+$/.test(accountId)) {\n      writeAdsJson({\n        ok: false,\n        error: {\n          code: \"INVALID_ACCOUNT_ID\",\n          message:\n            \"X Ads account ID must be a base36 string (lowercase letters and digits). Pass --account-id or set BAKER_X_ADS_ACCOUNT_ID.\",\n        },\n      });\n      process.exit(1);\n    }\n    return accountId;\n  }\n\n  const useCache = !args[\"no-cache\"];\n  try {\n    const accounts = await fetchXAccounts(useCache);\n    const [single] = accounts;\n    if (accounts.length === 1 && single) {\n      process.stderr.write(`Using account \"${single.name}\" (${single.id})\\n`);\n      return single.id;\n    }\n    if (accounts.length === 0) {\n      // Not a connection failure — see NO_X_ACCOUNTS_EXPLANATION.\n      writeAdsJson({\n        ok: false,\n        error: {\n          code: \"INVALID_ACCOUNT_ID\",\n          message: NO_X_ACCOUNTS_EXPLANATION,\n          fix: { action: \"reject\", explanation: NO_X_ACCOUNTS_EXPLANATION },\n          retryable: false,\n        },\n      });\n      process.exit(1);\n    }\n    const list = accounts.map((a) => `  ${a.id}  ${a.name}`).join(\"\\n\");\n    writeAdsJson({\n      ok: false,\n      error: {\n        code: \"MULTIPLE_ACCOUNTS\",\n        message: `Multiple X Ads accounts found. Pass --account-id or set BAKER_X_ADS_ACCOUNT_ID:\\n${list}`,\n      },\n    });\n    process.exit(1);\n  } catch (err) {\n    if (err instanceof ApiError && needsConnectionFix(err.code, err.message)) {\n      handleConnectionError(\"x_ads\", err.message);\n    }\n    writeAdsJson({\n      ok: false,\n      error: {\n        code: \"INVALID_ACCOUNT_ID\",\n        message: \"Could not auto-detect account. Pass --account-id or set BAKER_X_ADS_ACCOUNT_ID.\",\n      },\n    });\n    process.exit(1);\n  }\n}\n\n/**\n * The account's own timezone, which X Ads measures a DAY-granularity window against.\n * Falls back to UTC when the account cannot be read — X names the mismatch clearly enough.\n */\nexport async function resolveXAccountTimezone(accountId: string, args: Record<string, unknown>): Promise<string> {\n  try {\n    const accounts = await fetchXAccounts(!args[\"no-cache\"]);\n    return accounts.find((a) => a.id === accountId)?.timezone || \"UTC\";\n  } catch {\n    return \"UTC\";\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAcA,IAAM,wBAAwB,KAAK,KAAK;AAQjC,IAAM,4BACX;AAMF,eAAe,eAAe,UAA4C;AACxE,MAAI,UAAU;AACZ,UAAM,SAAS,SAAyB,cAAc,MAAM;AAC5D,QAAI,OAAQ,QAAO,OAAO;AAAA,EAC5B;AACA,QAAM,SAAS,CAAC,WAAW,EAAE,cAAc,OAAO,IAAI;AACtD,QAAM,OAAO,MAAM,OAAuB,uBAAuB,MAAM;AACvE,MAAI,UAAU;AACZ,aAAS,cAAc,QAAQ,MAAM,qBAAqB;AAAA,EAC5D;AACA,SAAO;AACT;AAMA,eAAsB,kBAAkB,MAAgD;AACtF,QAAM,WAAW,KAAK,YAAY;AAClC,QAAM,YAAY,YAAY,OAAO,EAAE;AACvC,MAAI,WAAW;AACb,QAAI,CAAC,cAAc,KAAK,SAAS,GAAG;AAClC,mBAAa;AAAA,QACX,IAAI;AAAA,QACJ,OAAO;AAAA,UACL,MAAM;AAAA,UACN,SACE;AAAA,QACJ;AAAA,MACF,CAAC;AACD,cAAQ,KAAK,CAAC;AAAA,IAChB;AACA,WAAO;AAAA,EACT;AAEA,QAAM,WAAW,CAAC,KAAK,UAAU;AACjC,MAAI;AACF,UAAM,WAAW,MAAM,eAAe,QAAQ;AAC9C,UAAM,CAAC,MAAM,IAAI;AACjB,QAAI,SAAS,WAAW,KAAK,QAAQ;AACnC,cAAQ,OAAO,MAAM,kBAAkB,OAAO,IAAI,MAAM,OAAO,EAAE;AAAA,CAAK;AACtE,aAAO,OAAO;AAAA,IAChB;AACA,QAAI,SAAS,WAAW,GAAG;AAEzB,mBAAa;AAAA,QACX,IAAI;AAAA,QACJ,OAAO;AAAA,UACL,MAAM;AAAA,UACN,SAAS;AAAA,UACT,KAAK,EAAE,QAAQ,UAAU,aAAa,0BAA0B;AAAA,UAChE,WAAW;AAAA,QACb;AAAA,MACF,CAAC;AACD,cAAQ,KAAK,CAAC;AAAA,IAChB;AACA,UAAM,OAAO,SAAS,IAAI,CAAC,MAAM,KAAK,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,EAAE,KAAK,IAAI;AAClE,iBAAa;AAAA,MACX,IAAI;AAAA,MACJ,OAAO;AAAA,QACL,MAAM;AAAA,QACN,SAAS;AAAA,EAAoF,IAAI;AAAA,MACnG;AAAA,IACF,CAAC;AACD,YAAQ,KAAK,CAAC;AAAA,EAChB,SAAS,KAAK;AACZ,QAAI,eAAe,YAAY,mBAAmB,IAAI,MAAM,IAAI,OAAO,GAAG;AACxE,4BAAsB,SAAS,IAAI,OAAO;AAAA,IAC5C;AACA,iBAAa;AAAA,MACX,IAAI;AAAA,MACJ,OAAO;AAAA,QACL,MAAM;AAAA,QACN,SAAS;AAAA,MACX;AAAA,IACF,CAAC;AACD,YAAQ,KAAK,CAAC;AAAA,EAChB;AACF;AAMA,eAAsB,wBAAwB,WAAmB,MAAgD;AAC/G,MAAI;AACF,UAAM,WAAW,MAAM,eAAe,CAAC,KAAK,UAAU,CAAC;AACvD,WAAO,SAAS,KAAK,CAAC,MAAM,EAAE,OAAO,SAAS,GAAG,YAAY;AAAA,EAC/D,QAAQ;AACN,WAAO;AAAA,EACT;AACF;","names":[]}

package/dist/chunk-FPZKKNDK.js

@@ -0,0 +1,98 @@
+import {
+  isRemoteUrl
+} from "./chunk-VSU5R34H.js";
+import {
+  detectImageContentType,
+  uploadLocalImage
+} from "./chunk-AG62YO7C.js";
+import {
+  IMAGE_GENERATE_MODELS,
+  MODEL_REGISTRY,
+  VIDEO_GENERATE_MODELS
+} from "./chunk-CAMX6OHF.js";
+import {
+  ApiError,
+  apiPost
+} from "./chunk-CUL3VB4L.js";
+
+// src/commands/studio/modelOptions.ts
+function unionOfStringEnum(node, models, param) {
+  const values = /* @__PURE__ */ new Set();
+  for (const model of models) {
+    const schema = MODEL_REGISTRY[node][model]?.params[param];
+    if (schema?.kind === "string") for (const value of schema.enum ?? []) values.add(value);
+  }
+  return [...values];
+}
+function unionOfNumberEnum(node, models, param) {
+  const values = /* @__PURE__ */ new Set();
+  for (const model of models) {
+    const schema = MODEL_REGISTRY[node][model]?.params[param];
+    if (schema?.kind === "number") for (const value of schema.enum ?? []) values.add(value);
+  }
+  return [...values].sort((a, b) => a - b);
+}
+var IMAGE_MODEL_IDS = [...IMAGE_GENERATE_MODELS];
+var VIDEO_MODEL_IDS = [...VIDEO_GENERATE_MODELS];
+var IMAGE_SIZES = unionOfStringEnum("image_generate", IMAGE_GENERATE_MODELS, "image_size");
+var IMAGE_QUALITIES = unionOfStringEnum("image_generate", IMAGE_GENERATE_MODELS, "quality");
+var CLIP_RESOLUTIONS = unionOfStringEnum("video_generate", VIDEO_GENERATE_MODELS, "resolution");
+var CLIP_DURATIONS = unionOfNumberEnum("video_generate", VIDEO_GENERATE_MODELS, "duration");
+var CLIP_PERSON_GENERATION = unionOfStringEnum("video_generate", VIDEO_GENERATE_MODELS, "person_generation");
+
+// src/commands/studio/references.ts
+var LIBRARY_ID_RE = /^[a-z0-9]{16,}$/i;
+var FILE_EXTENSION_RE = /\.[a-z0-9]{2,5}$/i;
+var PATH_HINT_RE = /[/\\]/;
+function classify(entry) {
+  if (isRemoteUrl(entry)) return { kind: "url", value: entry };
+  if (PATH_HINT_RE.test(entry) || FILE_EXTENSION_RE.test(entry)) return { kind: "path", value: entry };
+  if (LIBRARY_ID_RE.test(entry)) return { kind: "id", value: entry };
+  throw new ApiError(
+    "VALIDATION_ERROR",
+    `"${entry}" is not a library image id, a file path, or an image URL. Pass a comma-separated mix of those.`
+  );
+}
+function parseImageRefs(spec) {
+  return spec.split(",").map((entry) => entry.trim()).filter(Boolean).map(classify);
+}
+var defaultDeps = {
+  ingest: (url) => apiPost("/api/images/ingest", { url, source: "uploaded" }),
+  upload: (path) => uploadLocalImage({ file: path, contentType: detectImageContentType(path), source: "uploaded" })
+};
+async function resolveLibraryImageIds(spec, limit, deps = defaultDeps) {
+  const refs = parseImageRefs(spec);
+  if (limit && refs.length > limit.max) {
+    throw new ApiError("VALIDATION_ERROR", limit.refuse(refs.length));
+  }
+  const imageIds = [];
+  const added = [];
+  for (const ref of refs) {
+    if (ref.kind === "id") {
+      imageIds.push(ref.value);
+      continue;
+    }
+    const { imageId } = ref.kind === "url" ? await deps.ingest(ref.value) : await deps.upload(ref.value).catch(uploadFailure(ref.value));
+    imageIds.push(imageId);
+    added.push(imageId);
+  }
+  return { imageIds, added };
+}
+function uploadFailure(path) {
+  return (error) => {
+    if (error instanceof ApiError) throw error;
+    throw new ApiError("VALIDATION_ERROR", `Could not read "${path}" as an image.`);
+  };
+}
+
+export {
+  IMAGE_MODEL_IDS,
+  VIDEO_MODEL_IDS,
+  IMAGE_SIZES,
+  IMAGE_QUALITIES,
+  CLIP_RESOLUTIONS,
+  CLIP_DURATIONS,
+  CLIP_PERSON_GENERATION,
+  resolveLibraryImageIds
+};
+//# sourceMappingURL=chunk-FPZKKNDK.js.map

package/dist/chunk-FPZKKNDK.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/commands/studio/modelOptions.ts","../src/commands/studio/references.ts"],"sourcesContent":["import { IMAGE_GENERATE_MODELS, MODEL_REGISTRY, VIDEO_GENERATE_MODELS } from \"@baker/canvas-contract\";\n\n/**\n * What the curated roster accepts for one param, across every model that has it.\n *\n * Derived, never hand-copied: the contract registry is the source of truth for\n * which model takes which value, and a hand-written list in the CLI is a second\n * copy that goes stale the first time a model is added. `baker schema` reads\n * these, so the agent's picture of what is allowed comes from the same place the\n * backend's refusal does.\n *\n * The union is deliberately WIDER than any single model: `--quality 4k` is valid\n * on Seedance and `4K` on Veo (different providers, different casing), and both\n * belong in the advertised set. Whether the chosen model accepts the value the\n * caller picked is settled server-side, per model, with a message that names it.\n */\nfunction unionOfStringEnum(\n  node: \"image_generate\" | \"video_generate\",\n  models: readonly string[],\n  param: string,\n): string[] {\n  const values = new Set<string>();\n  for (const model of models) {\n    const schema = MODEL_REGISTRY[node][model]?.params[param];\n    if (schema?.kind === \"string\") for (const value of schema.enum ?? []) values.add(value);\n  }\n  return [...values];\n}\n\n/** Every number the roster accepts for a param, ascending. */\nfunction unionOfNumberEnum(\n  node: \"image_generate\" | \"video_generate\",\n  models: readonly string[],\n  param: string,\n): number[] {\n  const values = new Set<number>();\n  for (const model of models) {\n    const schema = MODEL_REGISTRY[node][model]?.params[param];\n    if (schema?.kind === \"number\") for (const value of schema.enum ?? []) values.add(value);\n  }\n  return [...values].sort((a, b) => a - b);\n}\n\nexport const IMAGE_MODEL_IDS = [...IMAGE_GENERATE_MODELS];\nexport const VIDEO_MODEL_IDS = [...VIDEO_GENERATE_MODELS];\n\nexport const IMAGE_SIZES = unionOfStringEnum(\"image_generate\", IMAGE_GENERATE_MODELS, \"image_size\");\nexport const IMAGE_QUALITIES = unionOfStringEnum(\"image_generate\", IMAGE_GENERATE_MODELS, \"quality\");\n\nexport const CLIP_RESOLUTIONS = unionOfStringEnum(\"video_generate\", VIDEO_GENERATE_MODELS, \"resolution\");\nexport const CLIP_DURATIONS = unionOfNumberEnum(\"video_generate\", VIDEO_GENERATE_MODELS, \"duration\");\nexport const CLIP_PERSON_GENERATION = unionOfStringEnum(\"video_generate\", VIDEO_GENERATE_MODELS, \"person_generation\");\n","import type { ImagesIngestResponse } from \"@baker/api\";\nimport { ApiError, apiPost } from \"../../client.ts\";\nimport { isRemoteUrl } from \"../../lib/image/io.ts\";\nimport { detectImageContentType, uploadLocalImage } from \"../images/api.ts\";\n\n/**\n * One entry of a `--reference` / `--image` spec, after classification.\n *\n * The studio takes LIBRARY image ids and nothing else: a reference has to be an\n * asset the dashboard can show next to the batch that used it, and inlined bytes\n * would put megabytes of base64 on a row the live feed reads. So the CLI accepts\n * the three things an agent actually has — an id it already knows, a file it just\n * wrote in the workspace, a URL it just found — and turns the last two into\n * library images before starting the batch. That also makes the reference\n * reusable: the next prompt can name the id.\n */\nexport type ImageRef = { kind: \"id\" | \"url\" | \"path\"; value: string };\n\n// Convex ids are long, unpadded alphanumerics with no separators and no\n// extension — distinguishable from both a filename and a prose fragment.\nconst LIBRARY_ID_RE = /^[a-z0-9]{16,}$/i;\nconst FILE_EXTENSION_RE = /\\.[a-z0-9]{2,5}$/i;\nconst PATH_HINT_RE = /[/\\\\]/;\n\nfunction classify(entry: string): ImageRef {\n  if (isRemoteUrl(entry)) return { kind: \"url\", value: entry };\n  if (PATH_HINT_RE.test(entry) || FILE_EXTENSION_RE.test(entry)) return { kind: \"path\", value: entry };\n  if (LIBRARY_ID_RE.test(entry)) return { kind: \"id\", value: entry };\n  throw new ApiError(\n    \"VALIDATION_ERROR\",\n    `\"${entry}\" is not a library image id, a file path, or an image URL. Pass a comma-separated mix of those.`,\n  );\n}\n\n/**\n * Split a comma-separated spec and classify each entry. Order is preserved —\n * models read references positionally, and the first image is the frame a clip\n * starts from.\n */\nexport function parseImageRefs(spec: string): ImageRef[] {\n  return spec\n    .split(\",\")\n    .map((entry) => entry.trim())\n    .filter(Boolean)\n    .map(classify);\n}\n\nexport type ResolveLibraryImageDeps = {\n  ingest: (url: string) => Promise<ImagesIngestResponse>;\n  upload: (path: string) => Promise<{ imageId: string }>;\n};\n\nconst defaultDeps: ResolveLibraryImageDeps = {\n  ingest: (url) => apiPost<ImagesIngestResponse>(\"/api/images/ingest\", { url, source: \"uploaded\" }),\n  upload: (path) => uploadLocalImage({ file: path, contentType: detectImageContentType(path), source: \"uploaded\" }),\n};\n\n/** How many images the chosen model will take, and what to call them when it won't. */\nexport type ReferenceLimit = { max: number; refuse: (count: number) => string };\n\n/**\n * Turn a `--reference` / `--image` spec into the library image ids the studio\n * takes, adding anything that isn't already in the library.\n *\n * The batch is not started until every entry resolves: half a reference set is\n * a different brief, and paying for it is worse than failing the call.\n *\n * The count is checked FIRST, before a single upload or ingest. The backend\n * checks it too, but by the time it does the CLI has already downloaded and\n * described every image in a set it was always going to refuse — work the\n * caller pays for and then throws away.\n */\nexport async function resolveLibraryImageIds(\n  spec: string,\n  limit?: ReferenceLimit,\n  deps: ResolveLibraryImageDeps = defaultDeps,\n): Promise<{ imageIds: string[]; added: string[] }> {\n  const refs = parseImageRefs(spec);\n  if (limit && refs.length > limit.max) {\n    throw new ApiError(\"VALIDATION_ERROR\", limit.refuse(refs.length));\n  }\n  const imageIds: string[] = [];\n  const added: string[] = [];\n  for (const ref of refs) {\n    if (ref.kind === \"id\") {\n      imageIds.push(ref.value);\n      continue;\n    }\n    const { imageId } =\n      ref.kind === \"url\" ? await deps.ingest(ref.value) : await deps.upload(ref.value).catch(uploadFailure(ref.value));\n    imageIds.push(imageId);\n    added.push(imageId);\n  }\n  return { imageIds, added };\n}\n\nfunction uploadFailure(path: string): (error: unknown) => never {\n  return (error) => {\n    if (error instanceof ApiError) throw error;\n    throw new ApiError(\"VALIDATION_ERROR\", `Could not read \"${path}\" as an image.`);\n  };\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-FUVCY63N.js

@@ -0,0 +1,169 @@
+import {
+  parseXApiError
+} from "./chunk-M6UNISGO.js";
+import {
+  resolveXAccountId
+} from "./chunk-FMGW2NZI.js";
+import {
+  writeAdsJson,
+  writeJsonEnvelope
+} from "./chunk-EIGXX6KI.js";
+import {
+  X_DRAFT_BATCH_MAX,
+  xDraftOpInputSchema
+} from "./chunk-O6XZIQXZ.js";
+import {
+  ApiError,
+  apiPost
+} from "./chunk-CUL3VB4L.js";
+import {
+  requireChatId
+} from "./chunk-I4FTS5EE.js";
+
+// src/commands/ads/x/write-shared.ts
+function failWriteValidation(message) {
+  writeJsonEnvelope({ ok: false, error: { code: "VALIDATION_ERROR", message } });
+  process.exit(1);
+}
+function failPreflight(fields) {
+  writeJsonEnvelope({
+    ok: false,
+    error: {
+      code: "VALIDATION_ERROR",
+      message: fields.map((f) => f.path ? `${f.path}: ${f.message}` : f.message).join("; "),
+      fields,
+      fix: {
+        action: "reject",
+        explanation: "Fix the named fields and stage again. Nothing was staged \u2014 the draft is exactly as it was before this call."
+      }
+    }
+  });
+  process.exit(1);
+}
+function handleXWriteError(err, accountId) {
+  if (err instanceof ApiError) {
+    writeAdsJson(parseXApiError(err.message, accountId));
+    process.exit(1);
+  }
+  writeAdsJson({ ok: false, error: { code: "NETWORK_ERROR", message: "Unexpected error" } });
+  process.exit(1);
+}
+function decimalPlaces(value) {
+  const [mantissa, exponent] = String(value).trim().split(/e/i);
+  const written = (mantissa?.split(".")[1] ?? "").length;
+  return Math.max(0, written - (exponent ? Number(exponent) : 0));
+}
+function parseXMoney(value) {
+  if (value === void 0 || value === "") {
+    return { ok: true, micros: void 0 };
+  }
+  const amount = Number(value);
+  if (!Number.isFinite(amount) || amount <= 0) {
+    return { ok: false, reason: "must be a positive amount, for example 12.50" };
+  }
+  if (decimalPlaces(value) > 6) {
+    return { ok: false, reason: "is finer than X can express \u2014 it takes whole micros" };
+  }
+  return { ok: true, micros: Math.round(amount * 1e6) };
+}
+function microsFromArg(value, flag) {
+  const parsed = parseXMoney(value);
+  if (!parsed.ok) {
+    failWriteValidation(`${flag} ${parsed.reason}`);
+  }
+  return parsed.micros;
+}
+function csvArg(value) {
+  if (typeof value !== "string" || value.length === 0) {
+    return void 0;
+  }
+  const parts = value.split(",").map((s) => s.trim()).filter(Boolean);
+  return parts.length > 0 ? parts : void 0;
+}
+function compact(payload) {
+  return Object.fromEntries(Object.entries(payload).filter(([, value]) => value !== void 0));
+}
+function batchNudge(data) {
+  const count = data?.sameKindStaged;
+  if (!count) {
+    return [];
+  }
+  return [
+    `${count} other change${count === 1 ? "" : "s"} of this kind and payload ${count === 1 ? "is" : "are"} already staged \u2014 pass every id to one call (\`--ids a,b,c\`) instead of one call each.`
+  ];
+}
+async function stageXOp(raw, hints) {
+  const preflight = xDraftOpInputSchema.safeParse(raw);
+  if (!preflight.success) {
+    failPreflight(preflight.error.issues.map((issue) => ({ path: issue.path.join("."), message: issue.message })));
+  }
+  const accountId = String(raw.accountId ?? "\u2014");
+  try {
+    const chatId = requireChatId();
+    const response = await apiPost("/api/ads/x/draft/stage", { chatId, op: preflight.data });
+    const allHints = [...batchNudge(response.data), ...hints ?? []];
+    writeJsonEnvelope(allHints.length > 0 ? { ...response, hints: allHints } : response);
+  } catch (err) {
+    handleXWriteError(err, accountId);
+  }
+}
+async function stageXOps(rawOps, hints) {
+  if (rawOps.length === 1 && rawOps[0]) {
+    await stageXOp(rawOps[0], hints);
+    return;
+  }
+  if (rawOps.length > X_DRAFT_BATCH_MAX) {
+    failWriteValidation(`at most ${X_DRAFT_BATCH_MAX} changes can be staged in one call`);
+  }
+  const ops = [];
+  for (const [index, raw] of rawOps.entries()) {
+    const preflight = xDraftOpInputSchema.safeParse(raw);
+    if (!preflight.success) {
+      failPreflight(
+        preflight.error.issues.map((issue) => ({
+          path: `ops[${index}]${issue.path.length > 0 ? `.${issue.path.join(".")}` : ""}`,
+          message: issue.message
+        }))
+      );
+    }
+    ops.push(preflight.data);
+  }
+  const accountId = String(rawOps[0]?.accountId ?? "\u2014");
+  try {
+    const chatId = requireChatId();
+    const response = await apiPost("/api/ads/x/draft/stage-batch", { chatId, ops });
+    writeJsonEnvelope(hints && hints.length > 0 ? { ...response, hints } : response);
+  } catch (err) {
+    handleXWriteError(err, accountId);
+  }
+}
+async function stageAccountId(args) {
+  return await resolveXAccountId(args);
+}
+function requireTarget(args, name) {
+  const value = args[name];
+  if (typeof value !== "string" || value.length === 0) {
+    failWriteValidation(`${name} is required`);
+  }
+  return value;
+}
+function requireTargets(args, name) {
+  const ids = csvArg(args[name]);
+  if (!ids) {
+    failWriteValidation(`${name} is required \u2014 pass one or more ids, comma-separated`);
+  }
+  return ids;
+}
+
+export {
+  failWriteValidation,
+  microsFromArg,
+  csvArg,
+  compact,
+  stageXOp,
+  stageXOps,
+  stageAccountId,
+  requireTarget,
+  requireTargets
+};
+//# sourceMappingURL=chunk-FUVCY63N.js.map

package/dist/chunk-FUVCY63N.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/commands/ads/x/write-shared.ts"],"sourcesContent":["import {\n  X_DRAFT_BATCH_MAX,\n  type XDraftStageBatchResponse,\n  type XDraftStageResponse,\n  xDraftOpInputSchema,\n} from \"@baker/api\";\nimport { ApiError, apiPost } from \"../../../client.ts\";\nimport { requireChatId } from \"../../../env.ts\";\nimport { writeAdsJson, writeJsonEnvelope } from \"../output.ts\";\nimport { parseXApiError } from \"./error-parser.ts\";\nimport { resolveXAccountId } from \"./output.ts\";\n\n/**\n * Shared plumbing for the staged X write commands.\n *\n * Writes NEVER reach X directly: every command stages an op against this chat's\n * draft (`/api/ads/x/draft/stage`), the dashboard shows it as a pending X\n * change, and it applies only when the chat is published.\n */\n\nexport function failWriteValidation(message: string): never {\n  writeJsonEnvelope({ ok: false, error: { code: \"VALIDATION_ERROR\", message } });\n  process.exit(1);\n}\n\nfunction failPreflight(fields: Array<{ path: string; message: string }>): never {\n  writeJsonEnvelope({\n    ok: false,\n    error: {\n      code: \"VALIDATION_ERROR\",\n      message: fields.map((f) => (f.path ? `${f.path}: ${f.message}` : f.message)).join(\"; \"),\n      fields,\n      fix: {\n        action: \"reject\",\n        explanation:\n          \"Fix the named fields and stage again. Nothing was staged — the draft is exactly as it was before this call.\",\n      },\n    },\n  });\n  process.exit(1);\n}\n\nexport function handleXWriteError(err: unknown, accountId: string): never {\n  if (err instanceof ApiError) {\n    writeAdsJson(parseXApiError(err.message, accountId));\n    process.exit(1);\n  }\n  writeAdsJson({ ok: false, error: { code: \"NETWORK_ERROR\", message: \"Unexpected error\" } });\n  process.exit(1);\n}\n\n/**\n * Digits after the decimal point, read off the written amount rather than\n * measured on the product.\n *\n * Exponent form is what makes this worth a helper: `String(0.0000005)` is\n * `\"5e-7\"`, whose mantissa has no decimals at all.\n */\nfunction decimalPlaces(value: unknown): number {\n  const [mantissa, exponent] = String(value).trim().split(/e/i);\n  const written = (mantissa?.split(\".\")[1] ?? \"\").length;\n  return Math.max(0, written - (exponent ? Number(exponent) : 0));\n}\n\nexport type XMoneyParse = { ok: true; micros: number | undefined } | { ok: false; reason: string };\n\n/**\n * Money on X is integer micros of the account currency, and the CLI takes the\n * human amount so nobody has to count zeros. Rejecting a fraction of a micro\n * here is what keeps the staged payload byte-identical to the request X gets.\n *\n * The precision test counts the decimals the caller wrote instead of comparing\n * `amount * 1e6` against its rounding. That comparison needed a tolerance, and\n * any absolute one is wrong somewhere: `1e-6` is finer than a double's own\n * spacing once the product passes 2^34, so `--total-budget 16384.01` — a whole\n * number of cents — was refused as finer than X can express. Counting decimals\n * is exact at every magnitude and needs no tolerance at all.\n */\nexport function parseXMoney(value: unknown): XMoneyParse {\n  if (value === undefined || value === \"\") {\n    return { ok: true, micros: undefined };\n  }\n  const amount = Number(value);\n  if (!Number.isFinite(amount) || amount <= 0) {\n    return { ok: false, reason: \"must be a positive amount, for example 12.50\" };\n  }\n  if (decimalPlaces(value) > 6) {\n    return { ok: false, reason: \"is finer than X can express — it takes whole micros\" };\n  }\n  return { ok: true, micros: Math.round(amount * 1_000_000) };\n}\n\nexport function microsFromArg(value: unknown, flag: string): number | undefined {\n  const parsed = parseXMoney(value);\n  if (!parsed.ok) {\n    failWriteValidation(`${flag} ${parsed.reason}`);\n  }\n  return parsed.micros;\n}\n\nexport function csvArg(value: unknown): string[] | undefined {\n  if (typeof value !== \"string\" || value.length === 0) {\n    return undefined;\n  }\n  const parts = value\n    .split(\",\")\n    .map((s) => s.trim())\n    .filter(Boolean);\n  return parts.length > 0 ? parts : undefined;\n}\n\n/** Drop undefined keys so an omitted flag never stages as an explicit value. */\nexport function compact(payload: Record<string, unknown>): Record<string, unknown> {\n  return Object.fromEntries(Object.entries(payload).filter(([, value]) => value !== undefined));\n}\n\ninterface StageEnvelope extends Record<string, unknown> {\n  ok: true;\n  data: XDraftStageResponse;\n}\n\n/**\n * The nudge to pass every id in one call instead of looping. Gated on\n * `sameKindStaged`, which the backend only sets for a command that really does\n * take an id list — a nudge pointed at a single-id command fails when obeyed.\n */\nfunction batchNudge(data: XDraftStageResponse | undefined): string[] {\n  const count = data?.sameKindStaged;\n  if (!count) {\n    return [];\n  }\n  return [\n    `${count} other change${count === 1 ? \"\" : \"s\"} of this kind and payload ${count === 1 ? \"is\" : \"are\"} already staged — pass every id to one call (\\`--ids a,b,c\\`) instead of one call each.`,\n  ];\n}\n\nexport async function stageXOp(raw: Record<string, unknown>, hints?: string[]): Promise<void> {\n  const preflight = xDraftOpInputSchema.safeParse(raw);\n  if (!preflight.success) {\n    failPreflight(preflight.error.issues.map((issue) => ({ path: issue.path.join(\".\"), message: issue.message })));\n  }\n  const accountId = String(raw.accountId ?? \"—\");\n  try {\n    const chatId = requireChatId();\n    const response = await apiPost<StageEnvelope>(\"/api/ads/x/draft/stage\", { chatId, op: preflight.data });\n    const allHints = [...batchNudge(response.data), ...(hints ?? [])];\n    writeJsonEnvelope(allHints.length > 0 ? { ...response, hints: allHints } : response);\n  } catch (err) {\n    handleXWriteError(err, accountId);\n  }\n}\n\ninterface StageBatchEnvelope extends Record<string, unknown> {\n  ok: true;\n  data: XDraftStageBatchResponse;\n}\n\n/**\n * Stage several ops as ONE request — all-or-nothing on the backend, one\n * rate-limit hit instead of one per id. A single op falls through to the plain\n * stage path so its envelope, amend behaviour and hints stay identical.\n */\nexport async function stageXOps(rawOps: Array<Record<string, unknown>>, hints?: string[]): Promise<void> {\n  if (rawOps.length === 1 && rawOps[0]) {\n    await stageXOp(rawOps[0], hints);\n    return;\n  }\n  if (rawOps.length > X_DRAFT_BATCH_MAX) {\n    failWriteValidation(`at most ${X_DRAFT_BATCH_MAX} changes can be staged in one call`);\n  }\n  const ops: unknown[] = [];\n  for (const [index, raw] of rawOps.entries()) {\n    const preflight = xDraftOpInputSchema.safeParse(raw);\n    if (!preflight.success) {\n      failPreflight(\n        preflight.error.issues.map((issue) => ({\n          path: `ops[${index}]${issue.path.length > 0 ? `.${issue.path.join(\".\")}` : \"\"}`,\n          message: issue.message,\n        })),\n      );\n    }\n    ops.push(preflight.data);\n  }\n  const accountId = String(rawOps[0]?.accountId ?? \"—\");\n  try {\n    const chatId = requireChatId();\n    const response = await apiPost<StageBatchEnvelope>(\"/api/ads/x/draft/stage-batch\", { chatId, ops });\n    writeJsonEnvelope(hints && hints.length > 0 ? { ...response, hints } : response);\n  } catch (err) {\n    handleXWriteError(err, accountId);\n  }\n}\n\n/** The account every staged write is scoped to. */\nexport async function stageAccountId(args: Record<string, unknown>): Promise<string> {\n  return await resolveXAccountId(args);\n}\n\n/** One required positional id. */\nexport function requireTarget(args: Record<string, unknown>, name: string): string {\n  const value = args[name];\n  if (typeof value !== \"string\" || value.length === 0) {\n    failWriteValidation(`${name} is required`);\n  }\n  return value;\n}\n\n/**\n * A comma-separated list of ids, for the commands that apply one payload to\n * many entities. Reading `process.argv` is deliberate for repeated flags\n * elsewhere in this CLI; here a single `--ids a,b,c` is the contract, so the\n * citty value is enough and there is nothing to lose.\n */\nexport function requireTargets(args: Record<string, unknown>, name: string): string[] {\n  const ids = csvArg(args[name]);\n  if (!ids) {\n    failWriteValidation(`${name} is required — pass one or more ids, comma-separated`);\n  }\n  return ids;\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-GBNJQNDS.js

@@ -0,0 +1,19 @@
+import {
+  latestVersion
+} from "./chunk-5UCP4EEQ.js";
+import {
+  canvasOutputsRoot
+} from "./chunk-TNOSX3PJ.js";
+
+// src/commands/creatives/version-of.ts
+import path from "path";
+async function versionOf(slug, run) {
+  if (typeof run === "string" && run.trim()) return run.trim();
+  const canvas = path.join("src", "creatives", slug, `${slug}.canvas.json`);
+  return await latestVersion(canvasOutputsRoot(canvas), slug) ?? void 0;
+}
+
+export {
+  versionOf
+};
+//# sourceMappingURL=chunk-GBNJQNDS.js.map

package/dist/chunk-GBNJQNDS.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/commands/creatives/version-of.ts"],"sourcesContent":["import path from \"node:path\";\nimport { canvasOutputsRoot } from \"../canvas/normalize-paths.ts\";\nimport { latestVersion } from \"../canvas/render-state.ts\";\n\n/** The version a command names: `--run` when given, else the one the creative shows now (`latestVersion`). */\nexport async function versionOf(slug: string, run: unknown): Promise<string | undefined> {\n  if (typeof run === \"string\" && run.trim()) return run.trim();\n  const canvas = path.join(\"src\", \"creatives\", slug, `${slug}.canvas.json`);\n  return (await latestVersion(canvasOutputsRoot(canvas), slug)) ?? undefined;\n}\n"],"mappings":";;;;;;;;AAAA,OAAO,UAAU;AAKjB,eAAsB,UAAU,MAAc,KAA2C;AACvF,MAAI,OAAO,QAAQ,YAAY,IAAI,KAAK,EAAG,QAAO,IAAI,KAAK;AAC3D,QAAM,SAAS,KAAK,KAAK,OAAO,aAAa,MAAM,GAAG,IAAI,cAAc;AACxE,SAAQ,MAAM,cAAc,kBAAkB,MAAM,GAAG,IAAI,KAAM;AACnE;","names":[]}