@koda-sl/baker-cli 0.573.0 → 0.574.0

package/dist/animate-MBNFCDUZ.js

@@ -0,0 +1,480 @@
+import {
+  pinnedModelHint,
+  silentModelHint
+} from "./chunk-JAC6JVCI.js";
+import {
+  CLIP_DURATIONS,
+  CLIP_PERSON_GENERATION,
+  CLIP_RESOLUTIONS,
+  VIDEO_MODEL_IDS,
+  resolveLibraryImageIds
+} from "./chunk-DCBCEYSH.js";
+import {
+  awaitBatch,
+  batchHints,
+  projectBatch,
+  resolveMaxWaitMs,
+  waitingHint
+} from "./chunk-ROWUTQFG.js";
+import {
+  failStudioCommand
+} from "./chunk-SULQZX5W.js";
+import "./chunk-CP5IVVYM.js";
+import "./chunk-VVITBZKP.js";
+import {
+  DEFAULT_CLIP_DURATION_S,
+  DEFAULT_VIDEO_GENERATE_MODEL,
+  MODEL_REGISTRY,
+  SPOKEN_WORDS_PER_SECOND,
+  estimateVideoCredits,
+  maxInputReferences,
+  nearestClipDuration,
+  splitScriptFor,
+  spokenWordsIn,
+  supportsReferenceToVideo
+} from "./chunk-MCJ5I5LR.js";
+import "./chunk-TJTCHTR4.js";
+import {
+  apiGet,
+  apiPost
+} from "./chunk-JCFZ7ECN.js";
+import "./chunk-OFSUVUXT.js";
+import "./chunk-OMLZ35HJ.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-NXNOXZGB.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/studio/animate.ts
+import { defineCommand } from "citty";
+
+// src/commands/studio/spokenPace.ts
+var WORDS_PER_SECOND = SPOKEN_WORDS_PER_SECOND;
+var spokenWords = spokenWordsIn;
+function wordsThatFit(seconds) {
+  return Math.floor(seconds * WORDS_PER_SECOND);
+}
+function spokenPaceHint(prompt, seconds, model) {
+  const words = spokenWords(prompt);
+  if (words === 0) return null;
+  const split = model ? splitScriptFor(words, model) : null;
+  if (split) {
+    return `The line is ${words} words \u2014 about ${Math.ceil(words / WORDS_PER_SECOND)}s of speech \u2014 and ${model} renders at most ${split.maxSeconds}s (~${Math.floor(split.maxSeconds * WORDS_PER_SECOND)} words). It will not refuse and it will not cut: it will RUSH, swallowing syllables. Split the script into ${split.clips} takes of roughly ${split.wordsPerClip} words each, rendered separately and cut together \u2014 break it where the thought breaks, not mid-sentence. Or move to a model that renders longer (bytedance/seedance-2.5 goes to 30s).`;
+  }
+  if (!seconds) return null;
+  const fits = wordsThatFit(seconds);
+  if (words <= fits) return null;
+  const rate = (words / seconds).toFixed(1);
+  return `The line is ${words} words and this clip is ${seconds}s \u2014 that is ${rate} words a second against a natural ${WORDS_PER_SECOND}. The model will not run over, it will RUSH: syllables swallowed, endings clipped, and the take unusable however good the picture. Cut the line to about ${fits} words, or give it the length it needs (${Math.ceil(words / WORDS_PER_SECOND)}s). Do not re-render the same line at the same length and hope.`;
+}
+
+// src/commands/studio/adByHand.ts
+function priorScriptedTakes(batches) {
+  return batches.filter(
+    (batch) => batch.kind === "video" && spokenWords(batch.prompt) > 0 && batch.variants.some((variant) => variant.status !== "failed")
+  ).length;
+}
+function ordinal(n) {
+  const suffix = n % 100 >= 11 && n % 100 <= 13 ? "th" : ["th", "st", "nd", "rd"][n % 10] ?? "th";
+  return `${n}${suffix}`;
+}
+function adByHandHint(input) {
+  if (!input.thisTakeIsScripted || input.buildsOnAClip) return null;
+  if (input.priorScriptedTakes < 1) return null;
+  const which = ordinal(input.priorScriptedTakes + 1);
+  return `This is the ${which} clip with a scripted line in this conversation. Separate takes stay separate \u2014 nothing cuts them together, the audio stops and restarts at every join, and there are no captions and no closing card \u2014 so ${input.priorScriptedTakes + 1} takes of a presenter are ${input.priorScriptedTakes + 1} clips and never one ad. If these are the beats of one ad, stop rendering them one at a time: write them as beats (one line the voice says plus one shot on screen while it is said) and \`baker canvas scaffold-ad\` emits the whole ad \u2014 one canvas, one render, continuous read, synced captions and a brand end card. If they really are consecutive parts of ONE long read you will cut together yourself, carry on.`;
+}
+
+// src/commands/studio/animate.ts
+var MODEL_LIST = VIDEO_MODEL_IDS;
+var DEFAULT_MAX_WAIT_MS = 6e5;
+registerSchema({
+  command: "studio.animate",
+  description: "Render a clip. With --image the look is already fixed, so the prompt describes MOVEMENT \u2014 camera, subject, timing; with --from text there is no image and the prompt is the whole shot. --image takes library image ids, local file paths and/or image URLs (paths and URLs are added to the media library first). A rendered clip is NOT in the video library until `baker studio keep` approves it.",
+  args: {
+    prompt: {
+      type: "string",
+      description: "What MOVES \u2014 camera, subject, timing. Kling reads 2,500 characters and Seedance 2.0 4,000; over the cap the request is refused rather than trimmed. Seedance 2.5 publishes no cap, which is why it is the one to reach for when the brief is a whole multi-shot sequence.",
+      required: true
+    },
+    avatar: {
+      type: "string",
+      description: "Cast one of the company's avatars by short name (e.g. marta). Grounds the render on their identity sheet and reuses their subject description verbatim \u2014 do this instead of passing the sheet through --reference, which skips both and leaves the batch unattributed. `baker avatars list` shows who there is.",
+      required: false
+    },
+    image: {
+      type: "string",
+      description: "Comma-separated source images: library image ids, local file paths, and/or image URLs. Required unless --from text or --avatar (the avatar is the source). With the default --from frame this must be exactly ONE image (the opening frame) \u2014 several are refused rather than silently reduced to the first. With --from references, up to 9 on Seedance 2.0 and 30 on Seedance 2.5.",
+      required: false
+    },
+    from: {
+      type: "string",
+      description: "What the clip is built FROM. frame (default) animates a single image as the opening frame; references uses several assets as visual guidance; text renders the prompt with no image at all. frame and references are mutually exclusive at every provider, and reference mode is Seedance/Gemini Omni only \u2014 Veo and Kling are frame-only. Every model does text.",
+      required: false,
+      enum: ["frame", "references", "text"]
+    },
+    "from-clip": {
+      type: "string",
+      description: "Comma-separated Studio takes to BUILD ON, each written batchId:slot (e.g. j57abc\u2026:0) \u2014 this is how you extend a clip, edit one, or carry its motion into a new shot. Seedance 2.5 only, up to 10 source clips in total, and requires --from references.",
+      required: false
+    },
+    "from-video": {
+      type: "string",
+      description: "The same, but from the VIDEO LIBRARY: comma-separated video ids (see `baker videos search`) to build on. Use this for footage the client uploaded or synced rather than something the Studio rendered. Counts against the same 10 source clips as --from-clip. The first use of a given video spends a minute encoding a reusable copy and is refused with a 'try again shortly' message; every use after that is instant.",
+      required: false
+    },
+    model: {
+      type: "string",
+      description: `Model (default ${DEFAULT_VIDEO_GENERATE_MODEL}). Check what each accepts with \`baker studio models --kind video\`. One of: ${MODEL_LIST.join(", ")}`,
+      required: false,
+      enum: MODEL_LIST
+    },
+    "aspect-ratio": {
+      type: "string",
+      description: "Aspect ratio, e.g. 9:16 (default), 16:9, 1:1 \u2014 snapped to the nearest shape the chosen model renders (Veo and Gemini Omni do 16:9 and 9:16 only). Must be width:height.",
+      required: false
+    },
+    duration: {
+      type: "number",
+      // Left unset this SNAPS onto the model's set rather than failing: Veo renders
+      // only 4/6/8, so an unstated length lands on the nearest of those. An explicit
+      // length the model cannot render is refused by name.
+      description: `Clip length in seconds \u2014 per-model. LEAVE IT OFF when someone speaks: the line sizes the clip itself, at ~2.5 words a second (40 words needs 16s), because a model handed more words than fit does not run over, it rushes and swallows syllables. Unset with nobody speaking is 5s. Past 15s only bytedance/seedance-2.5 will do it, out to 30. Across the roster: ${CLIP_DURATIONS.join(", ")}`,
+      required: false
+    },
+    quality: {
+      type: "string",
+      description: `Resolution (default 720p, the one every model has). Per-model \u2014 Kling renders 720p only. Across the roster: ${CLIP_RESOLUTIONS.join(", ")}`,
+      required: false,
+      enum: CLIP_RESOLUTIONS
+    },
+    count: { type: "number", description: "Takes to render, 1-3 (default 1)", required: false, default: 1 },
+    sound: {
+      type: "boolean",
+      description: "Let the model generate audio. Off by default \u2014 billed on top and most ad beats get audio from the mix.",
+      required: false,
+      default: false
+    },
+    // Tri-state on purpose: unset leaves the provider's own default alone, which
+    // for Veo is prompt expansion ON. `--enhance-prompt` and `--no-enhance-prompt`
+    // are therefore different requests, and collapsing them to a plain flag made
+    // "render exactly what I wrote" impossible to ask for.
+    negative: {
+      type: "string",
+      description: "What to avoid. Not on Seedance, which takes no negative prompt at all. Kling reads 2,500 characters.",
+      required: false
+    },
+    seed: {
+      type: "number",
+      description: "Seed, to reproduce a take. A whole number 0-4294967295; Kling has no seed and refuses one. Same seed plus same settings, same clip.",
+      required: false
+    },
+    people: {
+      type: "string",
+      // Veo only. Image-to-video and the EU/UK/CH/MENA regions cap this at
+      // `allow_adult`; `allow_all` is text-to-video only.
+      description: `Whether the model may render people \u2014 Veo only. One of: ${CLIP_PERSON_GENERATION.join(", ")}`,
+      required: false,
+      enum: CLIP_PERSON_GENERATION
+    },
+    "enhance-prompt": {
+      type: "boolean",
+      description: "Let the model rewrite your prompt before rendering. Leave it unset to keep the model's own default (Veo expands by default); pass --no-enhance-prompt to render exactly what you wrote.",
+      required: false
+    },
+    "conditioning-scale": {
+      type: "number",
+      description: "How closely the clip holds the frame \u2014 Veo only",
+      required: false
+    },
+    "cfg-scale": {
+      type: "number",
+      description: "How closely the clip follows the prompt, 0-1 (Kling only; higher = closer to the prompt)",
+      required: false
+    },
+    watermark: {
+      type: "boolean",
+      description: "Burn the provider's watermark into the picture. Seedance 2.5 only, and OFF by default because it cannot be removed after the render \u2014 pass it only if a client actually wants the mark.",
+      required: false
+    },
+    wait: {
+      type: "string",
+      description: "Pass false to get the batch id back immediately instead of waiting for the takes",
+      required: false,
+      default: "true"
+    },
+    "max-wait": {
+      type: "number",
+      description: "Max ms to wait for the takes (default 600000). 0 returns the id immediately.",
+      required: false,
+      default: DEFAULT_MAX_WAIT_MS
+    },
+    full: { type: "boolean", description: "Include settings, references and attribution", required: false }
+  }
+});
+function num(value) {
+  return value === void 0 || value === "" ? void 0 : Number(value);
+}
+function clipKnobs(args) {
+  const knobs = {};
+  if (args.negative) knobs.negativePrompt = args.negative;
+  knobs.seed = num(args.seed);
+  if (args.people) knobs.personGeneration = args.people;
+  if (typeof args["enhance-prompt"] === "boolean") knobs.enhancePrompt = args["enhance-prompt"];
+  knobs.conditioningScale = num(args["conditioning-scale"]);
+  knobs.cfgScale = num(args["cfg-scale"]);
+  if (args.watermark === true) knobs.watermark = true;
+  return knobs;
+}
+function parseVideoIds(value) {
+  if (typeof value !== "string") return void 0;
+  const ids = value.split(",").map((part) => part.trim()).filter(Boolean);
+  return ids.length > 0 ? ids : void 0;
+}
+function parseClipRefs(value) {
+  if (typeof value !== "string" || value.trim() === "") return void 0;
+  const refs = [];
+  for (const entry of value.split(",").map((part) => part.trim())) {
+    if (!entry) continue;
+    const separator = entry.lastIndexOf(":");
+    const generationId = separator === -1 ? "" : entry.slice(0, separator);
+    const slot = Number(entry.slice(separator + 1));
+    if (!generationId || !Number.isInteger(slot) || slot < 0) {
+      throw new Error(
+        `--from-clip takes batchId:slot pairs \u2014 "${entry}" is not one. Read a batch with \`baker studio get <id>\` to see its slots.`
+      );
+    }
+    refs.push({ generationId, slot });
+  }
+  return refs.length > 0 ? refs : void 0;
+}
+function clipImageLimitFor(args) {
+  const model = args.model ?? DEFAULT_VIDEO_GENERATE_MODEL;
+  const label = MODEL_REGISTRY.video_generate[model]?.label ?? model;
+  if (args.from !== "references") {
+    return {
+      max: 1,
+      refuse: (count) => `Animating one exact frame uses a single image \u2014 you passed ${count}. Pick one, or switch --from references to guide the shot with all of them.`
+    };
+  }
+  if (!supportsReferenceToVideo(model)) {
+    return {
+      max: 1,
+      refuse: () => `${label} can only start from one exact frame \u2014 it does not read reference images. Drop --from references, or switch to Seedance.`
+    };
+  }
+  const max = maxInputReferences("video_generate", model);
+  if (max === void 0) return void 0;
+  return {
+    max,
+    refuse: (count) => `${label} takes up to ${max} reference images \u2014 you passed ${count}. Drop the weakest ones.`
+  };
+}
+function clipModeFor(from) {
+  if (from === "references") return "references";
+  if (from === "text") return "text";
+  return "first_frame";
+}
+function buildAnimateBody(args, prompt, imageIds) {
+  const body = { prompt, imageIds, ...clipKnobs(args) };
+  if (args.avatar) body.avatar = args.avatar;
+  const clipRefs = parseClipRefs(args["from-clip"]);
+  if (clipRefs) body.clipRefs = clipRefs;
+  const videoIds = parseVideoIds(args["from-video"]);
+  if (videoIds) body.videoIds = videoIds;
+  if (args.from) body.clipMode = clipModeFor(args.from);
+  if (args.model) body.model = args.model;
+  if (args["aspect-ratio"]) body.aspectRatio = args["aspect-ratio"];
+  body.duration = num(args.duration);
+  if (args.quality) body.resolution = args.quality;
+  body.count = num(args.count);
+  if (args.sound) body.generateAudio = true;
+  return body;
+}
+function costHintsFor(body) {
+  const count = body.count ?? 1;
+  const model = body.model ?? DEFAULT_VIDEO_GENERATE_MODEL;
+  const perTake = estimateVideoCredits({
+    model,
+    // Resolved, never left unset: an unpinned length is SNAPPED onto the model's
+    // set and sent explicitly, so quoting the estimator's own fallback prices a
+    // clip nobody asked for. On the default model that fallback is its 10s
+    // ceiling against an actual 5s — exactly double.
+    duration: body.duration ?? nearestClipDuration(model, DEFAULT_CLIP_DURATION_S),
+    resolution: body.resolution,
+    generateAudio: body.generateAudio,
+    buildsOnSourceClip: (body.clipRefs?.length ?? 0) + (body.videoIds?.length ?? 0) > 0,
+    // Reference images might carry a face, and a face sends the render to the
+    // dearer provider. Scoped to reference mode because that is the only shape
+    // that gets re-routed — a frame-started clip never does.
+    mayRouteToFal: body.clipMode === "references" && body.imageIds.length > 0
+  });
+  const total = perTake * count;
+  const hints = [
+    count === 1 ? `This clip costs about ${total} credits \u2014 roughly 45x an image.` : `${count} takes at about ${perTake} credits each \u2014 about ${total} credits.`
+  ];
+  const pinned = pinnedModelHint({ avatar: body.avatar, model: body.model, generateAudio: body.generateAudio });
+  if (pinned) hints.push(pinned);
+  const pace = spokenPaceHint(body.prompt, body.duration, model);
+  if (pace) hints.push(pace);
+  const silent = silentModelHint(model, body.prompt);
+  if (silent) hints.push(silent);
+  if (count > 1) {
+    hints.push(
+      "Ask for more than one take only when the MOTION is the risk \u2014 for a look you are unsure about, iterate on the still first."
+    );
+  }
+  return hints;
+}
+var PRIOR_TAKE_WINDOW = 20;
+async function adByHandHintFor(body) {
+  const thisTakeIsScripted = spokenWords(body.prompt) > 0;
+  const buildsOnAClip = (body.clipRefs?.length ?? 0) + (body.videoIds?.length ?? 0) > 0;
+  if (!thisTakeIsScripted || buildsOnAClip) return null;
+  try {
+    const { generations } = await apiGet("/api/studio/generations", {
+      kind: "video",
+      limit: String(PRIOR_TAKE_WINDOW)
+    });
+    return adByHandHint({
+      priorScriptedTakes: priorScriptedTakes(generations),
+      thisTakeIsScripted,
+      buildsOnAClip
+    });
+  } catch {
+    return null;
+  }
+}
+var animateCommand = defineCommand({
+  meta: {
+    name: "animate",
+    description: "Render a clip. With an image the look is already fixed, so the prompt describes MOVEMENT \u2014 what the camera does, what the subject does, in what order. With --from text there is no image and the prompt is the whole shot.\n\nA rendered clip is NOT usable anywhere until you keep it: `baker studio keep <id> --slot N` is what puts it in the video library. Takes nobody keeps are never ingested, which is what makes a rejected batch cheap.\n\nFor anything longer than 15 seconds, or to build on footage that already exists, use --model bytedance/seedance-2.5: it renders 4-30s and is the only model that reads an existing clip or an existing soundtrack.\n\nExamples:\n  baker studio animate 'slow push in, model turns to camera and smiles' --image j57abc123def456ghi789\n  baker studio animate 'she looks to camera and says: \"Hola, soy Elena\"' --avatar elena --quality 720p --aspect-ratio 9:16\n  baker studio animate 'handheld drift right, steam rising from the cup' --image './out/hero.png' --duration 6 --quality 1080p\n  baker studio animate 'product rotates once on a turntable' --image j57abc\u2026,j57def\u2026 --from references\n  baker studio animate 'she keeps walking, camera stays with her, then she stops and looks up' --image j57abc\u2026 --from references --from-clip j57batch\u2026:0 --model bytedance/seedance-2.5 --duration 20\n  baker studio animate 'hold on the product, then a slow push-in' --from references --from-video j57vid\u2026 --model bytedance/seedance-2.5\n  baker studio animate 'slow drone pull-back over a solar farm at golden hour, no people' --from text --model bytedance/seedance-2.5 --duration 12"
+  },
+  args: {
+    prompt: { type: "positional", description: "What MOVES", required: false },
+    avatar: {
+      type: "string",
+      description: "Cast an avatar by short name \u2014 grounds the clip on their identity sheet AND gives it their voice",
+      required: false
+    },
+    image: {
+      type: "string",
+      description: "Comma-separated library image ids, local file paths, and/or image URLs",
+      required: false
+    },
+    from: { type: "string", description: "frame (default) | references | text", required: false },
+    "from-clip": {
+      type: "string",
+      description: "Studio takes to build on, batchId:slot (Seedance 2.5, needs --from references)",
+      required: false
+    },
+    "from-video": {
+      type: "string",
+      description: "Library video ids to build on (Seedance 2.5, needs --from references)",
+      required: false
+    },
+    model: {
+      type: "string",
+      description: `Model id (default ${DEFAULT_VIDEO_GENERATE_MODEL})`,
+      required: false
+    },
+    "aspect-ratio": { type: "string", description: "Aspect ratio (default 9:16)", required: false },
+    duration: {
+      type: "string",
+      description: `Seconds, per-model \u2014 leave it off when someone speaks and the line sizes it (~2.5 words/s); 5s when nobody does. Roster: ${CLIP_DURATIONS.join(" | ")}`,
+      required: false
+    },
+    quality: {
+      type: "string",
+      description: `Resolution (default 720p), per-model. Roster: ${CLIP_RESOLUTIONS.join(" | ")}`,
+      required: false
+    },
+    count: { type: "string", description: "Takes to render, 1-3 (default 1)", required: false },
+    sound: { type: "boolean", description: "Generate audio (off by default)", required: false },
+    negative: { type: "string", description: "What to avoid", required: false },
+    seed: { type: "string", description: "Seed", required: false },
+    people: {
+      type: "string",
+      description: `Render people, Veo only: ${CLIP_PERSON_GENERATION.join(" | ")}`,
+      required: false
+    },
+    "enhance-prompt": {
+      type: "boolean",
+      description: "Let the model rewrite your prompt (--no-enhance-prompt renders exactly what you wrote)",
+      required: false
+    },
+    "conditioning-scale": { type: "string", description: "Frame adherence", required: false },
+    "cfg-scale": { type: "string", description: "Prompt adherence 0-1", required: false },
+    watermark: {
+      type: "boolean",
+      description: "Burn in the provider watermark (Seedance 2.5, off by default)",
+      required: false
+    },
+    wait: { type: "string", description: "false to return the batch id immediately", required: false },
+    "max-wait": { type: "string", description: "Max ms to wait (default 600000, 0 = no wait)", required: false },
+    full: { type: "boolean", description: "Include settings, references and attribution", required: false }
+  },
+  run: async ({ args }) => {
+    try {
+      const prompt = args.prompt;
+      if (!prompt) {
+        writeJson({ ok: false, error: { code: "VALIDATION_ERROR", message: "A prompt is required" } });
+        process.exit(1);
+      }
+      if (!args.image && !args.avatar && args.from !== "text") {
+        writeJson({
+          ok: false,
+          error: {
+            code: "VALIDATION_ERROR",
+            message: "--image is required unless you pass --from text or --avatar: a clip normally animates a still, so it needs the image to start from",
+            fix: "Pass --image <id|path|url>, --avatar <handle> to build the shot around one of your avatars, or --from text to render from the prompt alone."
+          }
+        });
+        process.exit(1);
+      }
+      const { imageIds } = args.image ? await resolveLibraryImageIds(args.image, clipImageLimitFor(args)) : { imageIds: [] };
+      const body = buildAnimateBody(args, prompt, imageIds);
+      const assembling = await adByHandHintFor(body);
+      const preflightHints = [...assembling ? [assembling] : [], ...costHintsFor(body)];
+      const start = await apiPost("/api/studio/animate", body);
+      const maxWaitMs = resolveMaxWaitMs(args.wait, args["max-wait"], DEFAULT_MAX_WAIT_MS);
+      if (maxWaitMs === 0) {
+        writeJson({
+          ok: true,
+          data: start,
+          hints: [
+            `Rendering ${start.count} take(s). Read them with \`baker studio get ${start.generationId}\`, then keep the one you want.`,
+            ...preflightHints
+          ]
+        });
+        return;
+      }
+      const outcome = await awaitBatch(start.generationId, maxWaitMs);
+      if (outcome.kind !== "settled") {
+        writeJson({
+          ok: true,
+          data: { ...start, status: "running" },
+          hints: [waitingHint(outcome, start.generationId, maxWaitMs), ...preflightHints]
+        });
+        return;
+      }
+      writeJson({
+        ok: true,
+        data: projectBatch(outcome.generation, args.full === true),
+        hints: [...batchHints(outcome.generation), ...preflightHints]
+      });
+    } catch (error) {
+      failStudioCommand(error, { withFix: true });
+    }
+  }
+});
+export {
+  adByHandHintFor,
+  animateCommand,
+  buildAnimateBody,
+  clipImageLimitFor,
+  parseClipRefs,
+  parseVideoIds
+};
+//# sourceMappingURL=animate-MBNFCDUZ.js.map

package/dist/approved-3W56YTOZ.js

@@ -0,0 +1,73 @@
+import {
+  reportError,
+  validationError
+} from "./chunk-Z6RTEOEY.js";
+import {
+  postsApprovedRequestSchema
+} from "./chunk-WCU362Z6.js";
+import {
+  apiPost
+} from "./chunk-JCFZ7ECN.js";
+import "./chunk-OFSUVUXT.js";
+import "./chunk-OMLZ35HJ.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-NXNOXZGB.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/posts/approved.ts
+import { defineCommand } from "citty";
+var DESCRIPTION = "Record that a person's LinkedIn post already has its author's OK for an ad account (a Thought Leader ad's approval). LinkedIn has no way to read that approval, so staging an ad of the post keeps reminding the user until it is recorded. Run it only when the user says the author approved it \u2014 never on a guess. It clears the reminder on the ads of that post already staged. If LinkedIn still refuses the post at publish, Baker records that and the reminder comes back with the date.";
+registerSchema({
+  command: "posts.approved",
+  description: DESCRIPTION,
+  args: {
+    id: { type: "string", description: "Post id", required: true },
+    "account-id": {
+      type: "string",
+      description: "The LinkedIn ad account id the author approved it for",
+      required: true
+    }
+  }
+});
+var approvedCommand = defineCommand({
+  meta: {
+    name: "approved",
+    description: `${DESCRIPTION}
+
+Example:
+  baker posts approved <post-id> --account-id 513852526`
+  },
+  args: {
+    id: { type: "positional", description: "Post id", required: true },
+    "account-id": { type: "string", description: "LinkedIn ad account id", required: true }
+  },
+  run: async ({ args }) => {
+    const parsed = postsApprovedRequestSchema.safeParse({
+      id: String(args.id ?? ""),
+      accountId: String(args["account-id"] ?? "")
+    });
+    if (!parsed.success) validationError(parsed.error.issues[0]?.message ?? "Invalid approval");
+    try {
+      const data = await apiPost(
+        "/api/posts/approved",
+        parsed.data
+      );
+      const cleared = data.stagedAdsUpdated ?? 0;
+      writeJson({
+        ok: true,
+        data,
+        hints: [
+          `Recorded. Staging an ad of this post in that ad account no longer reminds the user${cleared > 0 ? `, and the reminder left ${cleared} ad${cleared === 1 ? "" : "s"} already staged` : ""}.`
+        ]
+      });
+    } catch (err) {
+      reportError(err);
+    }
+  }
+});
+export {
+  approvedCommand
+};
+//# sourceMappingURL=approved-3W56YTOZ.js.map

package/dist/asset-writes-2CYNDRPU.js

@@ -0,0 +1,50 @@
+import {
+  command,
+  creativesDeleteCommand,
+  customConversionsDeleteCommand,
+  customConversionsUpdateCommand,
+  labelsAttachCommand,
+  labelsCreateCommand,
+  labelsDeleteCommand,
+  labelsDetachCommand,
+  labelsRenameCommand,
+  mediaDeleteCommand
+} from "./chunk-TUS2VOMZ.js";
+import "./chunk-WFTTF2MP.js";
+import "./chunk-GC5P4KWY.js";
+import "./chunk-GDFJOCDO.js";
+import "./chunk-FCD5BPC5.js";
+import "./chunk-ERSX3MKH.js";
+import "./chunk-YT6YI47O.js";
+import "./chunk-4NZ47VXO.js";
+import "./chunk-D5FY4FAK.js";
+import "./chunk-HZ7QUFUW.js";
+import "./chunk-QALAJNBG.js";
+import "./chunk-VJUVTMHY.js";
+import "./chunk-T4HIFVNK.js";
+import "./chunk-CGLNCFAG.js";
+import "./chunk-E2G2USTA.js";
+import "./chunk-EFZVDV7F.js";
+import "./chunk-U3LO5TDH.js";
+import "./chunk-TJTCHTR4.js";
+import "./chunk-SOPVIIUW.js";
+import "./chunk-G4FG5EQO.js";
+import "./chunk-3WOFZTGC.js";
+import "./chunk-JCFZ7ECN.js";
+import "./chunk-OFSUVUXT.js";
+import "./chunk-OMLZ35HJ.js";
+import "./chunk-NXNOXZGB.js";
+import "./chunk-YQSBHWOI.js";
+export {
+  command,
+  creativesDeleteCommand,
+  customConversionsDeleteCommand,
+  customConversionsUpdateCommand,
+  labelsAttachCommand,
+  labelsCreateCommand,
+  labelsDeleteCommand,
+  labelsDetachCommand,
+  labelsRenameCommand,
+  mediaDeleteCommand
+};
+//# sourceMappingURL=asset-writes-2CYNDRPU.js.map

package/dist/assign-JC5BK5XE.js

@@ -0,0 +1,80 @@
+import {
+  failApi,
+  failValidation,
+  isTempId
+} from "./chunk-MUU27AJF.js";
+import "./chunk-AJ4OO3CV.js";
+import "./chunk-QV6AST5T.js";
+import "./chunk-WCU362Z6.js";
+import "./chunk-GIWHHCD6.js";
+import "./chunk-SOPVIIUW.js";
+import "./chunk-G4FG5EQO.js";
+import "./chunk-3WOFZTGC.js";
+import "./chunk-XHWHBGKX.js";
+import {
+  apiPost,
+  validateConvexId
+} from "./chunk-JCFZ7ECN.js";
+import "./chunk-OFSUVUXT.js";
+import {
+  requireChatId
+} from "./chunk-OMLZ35HJ.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-NXNOXZGB.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/actions/assign.ts
+import { defineCommand } from "citty";
+registerSchema({
+  command: "actions.assign",
+  description: "Stage who a Task is assigned to \u2014 applies when the chat is published, like every other Task change. --to takes a userId or email from `baker actions members` (only those teammates can be named), or `none` to unassign. Works on a published Task by id or on one this chat is creating by its tempId. Restaging replaces the earlier assignment; drop it with `baker actions draft remove <id> --op assign`. No claim needed; blocked only while another chat has the Task claimed.",
+  args: {
+    id: { type: "string", description: "Action ID, or tempId (temp_*) of a Task staged in this chat", required: true },
+    to: {
+      type: "string",
+      description: "userId or email from `baker actions members`, or `none` to unassign",
+      required: true
+    }
+  }
+});
+function assignBody(args, chatId) {
+  const to = args.to?.trim();
+  if (!to) {
+    failValidation("--to is required: a userId or email from `baker actions members`, or `none` to unassign the Task.");
+  }
+  if (!isTempId(args.ref)) {
+    validateConvexId(args.ref);
+  }
+  return { chatId, actionRef: args.ref, to };
+}
+var assignCommand = defineCommand({
+  meta: {
+    name: "assign",
+    description: "Stage who a Task is assigned to (applies on publish). Examples: baker actions assign <id> --to maria@empresa.com | baker actions assign temp_brief --to <userId> | baker actions assign <id> --to none"
+  },
+  args: {
+    id: { type: "positional", description: "Action ID or tempId (temp_*)", required: false },
+    "action-id": { type: "string", description: "Action ID or tempId (temp_*)", required: false },
+    to: { type: "string", description: "userId or email from `baker actions members`, or none", required: false }
+  },
+  run: async ({ args }) => {
+    try {
+      const ref = args.id || args["action-id"];
+      if (!ref) {
+        failValidation("Action ID is required.");
+      }
+      const body = assignBody({ ref, ...typeof args.to === "string" ? { to: args.to } : {} }, requireChatId());
+      const response = await apiPost("/api/actions/assign", body);
+      writeJson({ ...response, hints: ["Staged: the Task changes hands when the chat is published."] });
+    } catch (err) {
+      failApi(err);
+    }
+  }
+});
+export {
+  assignBody,
+  assignCommand
+};
+//# sourceMappingURL=assign-JC5BK5XE.js.map