@koda-sl/baker-cli 0.99.0 → 0.99.1-dev.5b1957cc

package/dist/cli.js

@@ -9,7 +9,7 @@ import {
   defaultRegistry,
   generateCatalog,
   validateCanvasDeep
-} from "./chunk-3JVYU72O.js";
+} from "./chunk-26K7V346.js";
 
 // src/cli.ts
 import { defineCommand as defineCommand152, runMain } from "citty";
@@ -11969,6 +11969,7 @@ Subcommands:
 import { defineCommand as defineCommand88 } from "citty";
 
 // src/commands/creatives/publish.ts
+import { extname as extname2 } from "path";
 import { defineCommand as defineCommand87 } from "citty";
 
 // src/commands/images/api.ts
@@ -12015,9 +12016,6 @@ async function uploadLocalImage(args, deps = defaultImageApiDeps) {
 function getImage(deps, imageId) {
   return deps.get("/api/images/get", { id: imageId });
 }
-function updateImageTags(deps, args) {
-  return deps.post("/api/images/tag", args);
-}
 async function waitForReadyImage(deps, imageId, opts = {}) {
   const timeoutMs = opts.timeoutMs ?? imageProcessingTimeoutMs;
   const pollIntervalMs = opts.pollIntervalMs ?? imageReadyPollIntervalMs;
@@ -12039,31 +12037,68 @@ async function waitForReadyImage(deps, imageId, opts = {}) {
 
 // src/commands/creatives/publish.ts
 var creativeTag = "creative";
-var creativeContentTypes = ["image/png", "image/jpeg", "image/webp"];
+var winningAdsTag = "winning-ads";
+var creativeTags = [creativeTag, winningAdsTag];
+var creativeImageContentTypes = ["image/png", "image/jpeg", "image/webp"];
+var creativeVideoContentTypesByExtension = {
+  ".mp4": "video/mp4",
+  ".mov": "video/quicktime",
+  ".webm": "video/webm"
+};
+var videoProcessingTimeoutMs = 5 * 60 * 1e3;
+var videoReadyPollIntervalMs = 5e3;
+var defaultCreativePublishDeps = {
+  ...defaultImageApiDeps,
+  fetch
+};
 registerSchema({
   command: "creatives.publish",
-  description: "Publish a final static creative image to Baker Images, apply the official creative tag, and return an image reference.",
+  description: "Publish a final creative image or video, apply creative and winning-ads tags, and return an asset reference.",
   args: {
-    file: { type: "string", description: "Local PNG/JPG/WebP creative image path", required: true },
+    file: { type: "string", description: "Local PNG/JPG/WebP/MP4/MOV/WebM creative path", required: true },
     title: { type: "string", description: "Human title for the creative output", required: true },
-    context: { type: "string", description: "Optional describe context for the image row", required: false }
+    body: { type: "string", description: "Reference traceability body for the creative output", required: true }
   }
 });
+function uniqueTags(tags) {
+  return [...new Set(tags.map((tag) => tag.trim()).filter(Boolean))];
+}
+function requiredMetadata(args) {
+  const title = args.title.trim();
+  const body = args.body.trim();
+  if (!title) {
+    throw new ApiError("VALIDATION_ERROR", "--title is required");
+  }
+  if (!body) {
+    throw new ApiError("VALIDATION_ERROR", "--body is required");
+  }
+  return { title, body };
+}
 function detectCreativeContentType(filePath) {
+  const ext = extname2(filePath).toLowerCase();
+  const videoContentType = creativeVideoContentTypesByExtension[ext];
+  if (videoContentType) {
+    return videoContentType;
+  }
   return detectImageContentType(filePath, {
-    allowedContentTypes: creativeContentTypes,
-    unsupportedMessage: "Unsupported creative image extension. Use PNG, JPG, or WebP."
+    allowedContentTypes: creativeImageContentTypes,
+    unsupportedMessage: "Unsupported creative extension. Use PNG, JPG, WebP, MP4, MOV, or WebM."
   });
 }
+function isVideoContentType(contentType) {
+  return contentType.startsWith("video/");
+}
 function imageToCreativeReference(image, title) {
   if (!image.imageUrl) {
     throw new ApiError("IMAGE_PROCESSING_ERROR", "Published image is missing imageUrl");
   }
+  const tags = uniqueTags([...image.tags ?? [], ...creativeTags]);
   return {
     type: "image",
     slug: image._id,
     title,
-    tags: image.tags?.includes(creativeTag) ? image.tags : [...image.tags ?? [], creativeTag],
+    body: image.description,
+    tags,
     imageUrl: image.imageUrl,
     thumbnailUrl: image.thumbnailUrl ?? image.imageUrl,
     storageKey: image.storageKey,
@@ -12073,53 +12108,150 @@ function imageToCreativeReference(image, title) {
     source: image.source
   };
 }
-async function publishCreative(args, deps = defaultImageApiDeps) {
-  const title = args.title.trim();
-  if (!title) {
-    throw new ApiError("VALIDATION_ERROR", "--title is required");
+function videoToCreativeReference(video, title) {
+  const tags = uniqueTags([...video.tags, ...creativeTags]);
+  return {
+    type: "video",
+    slug: video._id,
+    title,
+    body: video.description,
+    tags,
+    thumbnailUrl: video.thumbnailUrl,
+    muxPlaybackId: video.muxPlaybackId,
+    playbackUrl: video.muxPlaybackId ? `https://stream.mux.com/${video.muxPlaybackId}.m3u8` : void 0,
+    duration: video.duration,
+    width: video.width,
+    height: video.height,
+    aspectRatio: video.aspectRatio,
+    source: video.source
+  };
+}
+async function updateImageMetadata(deps, args) {
+  await deps.post("/api/images/update-description", {
+    imageId: args.imageId,
+    name: args.title,
+    description: args.body,
+    tags: args.tags
+  });
+}
+function createVideoUpload(deps) {
+  return deps.post("/api/videos/upload", {});
+}
+function getVideo(deps, videoId) {
+  return deps.get("/api/videos/get", { id: videoId });
+}
+async function updateVideoMetadata(deps, args) {
+  await deps.post("/api/videos/update-description", {
+    videoId: args.videoId,
+    name: args.title,
+    description: args.body,
+    tags: args.tags
+  });
+}
+async function waitForReadyVideo(deps, videoId, opts = {}) {
+  const timeoutMs = opts.timeoutMs ?? videoProcessingTimeoutMs;
+  const pollIntervalMs = opts.pollIntervalMs ?? videoReadyPollIntervalMs;
+  const deadline = Date.now() + timeoutMs;
+  let lastStatus = "unknown";
+  while (Date.now() <= deadline) {
+    const video = await getVideo(deps, videoId);
+    lastStatus = video.status ?? "unknown";
+    if (video.status === "ready") {
+      return video;
+    }
+    if (video.status === "error") {
+      throw new ApiError(
+        "INTERNAL_ERROR",
+        `Video processing failed for videoId ${videoId}: ${video.errorMessage ?? "unknown error"}`
+      );
+    }
+    await deps.sleep(pollIntervalMs);
+  }
+  throw new ApiError("TIMEOUT", `Video was not ready before timeout; videoId: ${videoId}; last status: ${lastStatus}`);
+}
+async function uploadLocalVideo(args, deps) {
+  const { uploadUrl, videoId } = await createVideoUpload(deps);
+  const fileBuffer = await deps.readFile(args.file);
+  const uploadResponse = await deps.fetch(uploadUrl, {
+    method: "PUT",
+    headers: { "Content-Type": args.contentType },
+    body: fileBuffer
+  });
+  if (!uploadResponse.ok) {
+    throw new ApiError(
+      "INTERNAL_ERROR",
+      `Mux upload failed: HTTP ${uploadResponse.status} ${uploadResponse.statusText}`
+    );
   }
-  const contentType = detectCreativeContentType(args.file);
+  return { videoId };
+}
+async function publishCreativeImage(args, deps) {
   const upload = await uploadLocalImage(
     {
       file: args.file,
-      contentType,
+      contentType: args.contentType,
       source: "ai_generated",
-      descriptionContext: args.context ?? `Static ad creative: ${title}`
+      descriptionContext: args.body
     },
     deps
   );
   const readyImage = await waitForReadyImage(deps, upload.imageId, { timeoutMs: imageProcessingTimeoutMs });
-  await updateImageTags(deps, {
-    imageIds: [upload.imageId],
-    addTags: [creativeTag],
-    removeTags: []
-  });
+  const tags = uniqueTags([...readyImage.tags ?? [], ...creativeTags]);
+  await updateImageMetadata(deps, { imageId: upload.imageId, title: args.title, body: args.body, tags });
   const taggedImage = await getImage(deps, upload.imageId);
-  return { imageId: upload.imageId, reference: imageToCreativeReference({ ...readyImage, ...taggedImage }, title) };
+  return {
+    imageId: upload.imageId,
+    reference: imageToCreativeReference({ ...readyImage, ...taggedImage }, args.title)
+  };
+}
+async function publishCreativeVideo(args, deps) {
+  const { videoId } = await uploadLocalVideo({ file: args.file, contentType: args.contentType }, deps);
+  const readyVideo = await waitForReadyVideo(deps, videoId);
+  const tags = uniqueTags([...readyVideo.tags, ...creativeTags]);
+  await updateVideoMetadata(deps, { videoId, title: args.title, body: args.body, tags });
+  const taggedVideo = await getVideo(deps, videoId);
+  return { videoId, reference: videoToCreativeReference(taggedVideo, args.title) };
+}
+function publishCreative(args, deps = defaultCreativePublishDeps) {
+  try {
+    const metadata = requiredMetadata(args);
+    const contentType = detectCreativeContentType(args.file);
+    if (isVideoContentType(contentType)) {
+      return publishCreativeVideo({ file: args.file, ...metadata, contentType }, deps);
+    }
+    return publishCreativeImage({ file: args.file, ...metadata, contentType }, deps);
+  } catch (error) {
+    return Promise.reject(error);
+  }
 }
 var publishCommand = defineCommand87({
   meta: {
     name: "publish",
-    description: "Publish a final static creative image to Baker Images, deterministically tag it as creative, and print the image reference JSON."
+    description: "Publish a final creative image or video, tag it as creative and winning-ads, and print the asset reference JSON."
   },
   args: {
-    file: { type: "positional", description: "Local PNG/JPG/WebP creative image path", required: false },
+    file: { type: "positional", description: "Local PNG/JPG/WebP/MP4/MOV/WebM creative path", required: false },
     title: { type: "string", description: "Human title for the creative output", required: false },
-    context: { type: "string", description: "Optional describe context for the image row", required: false }
+    body: { type: "string", description: "Reference traceability body for the creative output", required: false }
   },
   run: async ({ args }) => {
     try {
       const file = args.file;
       const title = args.title;
+      const body = args.body;
       if (!file) {
-        writeJson({ ok: false, error: { code: "VALIDATION_ERROR", message: "Image path is required" } });
+        writeJson({ ok: false, error: { code: "VALIDATION_ERROR", message: "File path is required" } });
         process.exit(1);
       }
       if (!title) {
         writeJson({ ok: false, error: { code: "VALIDATION_ERROR", message: "--title is required" } });
         process.exit(1);
       }
-      const data = await publishCreative({ file, title, context: args.context });
+      if (!body) {
+        writeJson({ ok: false, error: { code: "VALIDATION_ERROR", message: "--body is required" } });
+        process.exit(1);
+      }
+      const data = await publishCreative({ file, title, body });
       writeJson({ ok: true, data });
     } catch (err) {
       if (err instanceof ApiError) {
@@ -12136,12 +12268,13 @@ var publishCommand = defineCommand87({
 var creativesCommand3 = defineCommand88({
   meta: {
     name: "creatives",
-    description: `Publish static ad creatives as first-class Baker outputs.
+    description: `Publish ad creatives as first-class Baker outputs.
 
-Static creative handoff:
-  baker creatives publish ./canvas/run/final.png --title "Spring Offer Static Ad"
+Creative handoff:
+  baker creatives publish ./canvas/run/final.png --title "Winning Ads: Offer + Meta 4:5 + Angle" --body "Reference: Advertiser[ad_id]: https://example.com/ad.mp4
+Angle adapted: Client-safe angle"
 
-Publishing uploads the image to the Company image library, applies the official creative tag, and returns an image reference for chat previews.`
+Publishing routes images to Images and videos to the video library, applies creative + winning-ads tags, and returns an asset reference for chat previews.`
   },
   subCommands: {
     publish: publishCommand
@@ -12979,7 +13112,7 @@ function cropSprite(input, region) {
 // src/lib/image/io.ts
 import { randomBytes } from "crypto";
 import { glob as fsGlob, readFile as readFile10, rename, stat as stat2, writeFile as writeFile4 } from "fs/promises";
-import { dirname, extname as extname2, join as join3, resolve as resolve4 } from "path";
+import { dirname, extname as extname3, join as join3, resolve as resolve4 } from "path";
 var REMOTE_RE = /^https?:\/\//i;
 var GLOB_RE = /[*?[\]{}]/;
 function isRemoteUrl(value) {
@@ -13025,7 +13158,7 @@ async function isDirectory(path11) {
   }
 }
 async function resolveOutputPath(inputPath, outputArg, options) {
-  const base = options.newExtension ? inputPath.slice(0, -extname2(inputPath).length) + options.newExtension : inputPath;
+  const base = options.newExtension ? inputPath.slice(0, -extname3(inputPath).length) + options.newExtension : inputPath;
   if (!outputArg) return base;
   if (options.multipleInputs || await isDirectory(outputArg)) {
     const filename = base.split("/").pop() ?? "out.png";
@@ -16485,6 +16618,16 @@ function validateScheduledActionRef(ref) {
 function isNoSpawnAgentFlagSet(args) {
   return args["no-spawn-agent"] === true || args.noSpawnAgent === true || args.spawnAgent === false;
 }
+function isPromptWithoutAgent(args, agentDisabled) {
+  return agentDisabled && typeof args.prompt === "string";
+}
+function failIfPromptWithoutAgent(args, agentDisabled) {
+  if (isPromptWithoutAgent(args, agentDisabled)) {
+    failValidation2(
+      "--prompt only applies when an agent is spawned; it has no effect with --no-spawn-agent or --spawn-agent false."
+    );
+  }
+}
 function parseBooleanFlag(raw, flagName) {
   if (raw === void 0) {
     return void 0;
@@ -16577,6 +16720,7 @@ var createCommand2 = defineCommand132({
       const schedule = buildScheduleBody(args, { required: true });
       const chatId = requireChatId();
       const noSpawnAgent = isNoSpawnAgentFlagSet(args);
+      failIfPromptWithoutAgent(args, noSpawnAgent);
       const body = {
         chatId,
         name,
@@ -16827,6 +16971,7 @@ var updateCommand2 = defineCommand137({
         body.spawnAgent = spawnAgent;
         hasPatch = true;
       }
+      failIfPromptWithoutAgent(args, spawnAgent === false);
       if (typeof args.prompt === "string") {
         body.agentPrompt = args.prompt;
         hasPatch = true;
@@ -17326,7 +17471,7 @@ var tagsCommand4 = makeTagsCommand("videos", "video", "/api/videos/tags");
 
 // src/commands/videos/upload.ts
 import { readFile as readFile12, stat as stat3 } from "fs/promises";
-import { extname as extname3 } from "path";
+import { extname as extname4 } from "path";
 import { defineCommand as defineCommand147 } from "citty";
 var MIME_MAP = {
   ".mp4": "video/mp4",
@@ -17354,7 +17499,7 @@ registerSchema({
   }
 });
 function detectContentType(filePath) {
-  const ext = extname3(filePath).toLowerCase();
+  const ext = extname4(filePath).toLowerCase();
   const mime = MIME_MAP[ext];
   if (!mime) {
     throw new ApiError("VALIDATION_ERROR", `Cannot detect content type for extension "${ext}". Use --content-type.`);
@@ -17506,6 +17651,7 @@ var advertisersCommand2 = defineCommand149({
 
 // src/commands/winning-ads/search.ts
 import { defineCommand as defineCommand150 } from "citty";
+import { z as z4 } from "zod";
 registerSchema({
   command: "winning-ads.search",
   description: "Search the ad-dna corpus of scored winning ads. Returns a lean shortlist (advertiser, summary, scores, media_url) to pick a reference to reproduce.",
@@ -17613,6 +17759,38 @@ function buildSearchBody(args) {
   }
   return body;
 }
+function toOutputRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return {};
+  }
+  return Object.fromEntries(Object.entries(value));
+}
+var winningAdsSearchResponseSchema = z4.object({
+  results: z4.array(z4.unknown()).optional(),
+  pool_size: z4.number().nullable().optional(),
+  match_confidence: z4.string().nullable().optional(),
+  ownAdvertiserExclusion: z4.object({
+    status: z4.enum(["applied", "unresolved", "skipped"]),
+    excludedIds: z4.array(z4.string())
+  }).nullable().optional()
+});
+function parseWinningAdsSearchResponse(data) {
+  const parsed = winningAdsSearchResponseSchema.safeParse(data);
+  if (!parsed.success) {
+    throw new ApiError("INTERNAL_ERROR", "Invalid winning ads search response");
+  }
+  return parsed.data;
+}
+function buildSearchOutputData(data, options) {
+  const rawResults = Array.isArray(data?.results) ? data.results : [];
+  const results = rawResults.map((r) => winningAdNormalizer(toOutputRecord(r), options.full));
+  return {
+    results,
+    pool_size: data?.pool_size ?? null,
+    match_confidence: data?.match_confidence ?? null,
+    ownAdvertiserExclusion: data?.ownAdvertiserExclusion ?? null
+  };
+}
 var searchCommand4 = defineCommand150({
   meta: {
     name: "search",
@@ -17691,19 +17869,12 @@ var searchCommand4 = defineCommand150({
         });
         process.exit(1);
       }
-      const data = await apiPost(
-        "/api/winning-ads/search",
-        body
-      );
+      const data = parseWinningAdsSearchResponse(await apiPost("/api/winning-ads/search", body));
       const output = args.output || "json";
       const full = args.full;
       const rawResults = Array.isArray(data?.results) ? data.results : [];
       if (output === "json") {
-        const results = rawResults.map((r) => winningAdNormalizer(r, full));
-        writeJson({
-          ok: true,
-          data: { results, pool_size: data?.pool_size ?? null, match_confidence: data?.match_confidence ?? null }
-        });
+        writeJson({ ok: true, data: buildSearchOutputData(data, { full }) });
         return;
       }
       writeOutput(