@koda-sl/baker-cli 0.515.0 → 0.517.0

package/dist/generate-VQTLPEYW.js

@@ -0,0 +1,263 @@
+import {
+  IMAGE_MODEL_IDS,
+  IMAGE_QUALITIES,
+  IMAGE_SIZES,
+  resolveLibraryImageIds
+} from "./chunk-BYNBZIHS.js";
+import {
+  awaitBatch,
+  batchHints,
+  projectBatch,
+  resolveMaxWaitMs,
+  waitingHint
+} from "./chunk-JNW5S4ET.js";
+import {
+  failStudioCommand
+} from "./chunk-NBXZHTSR.js";
+import "./chunk-OGGE57JI.js";
+import "./chunk-UYVCBTC5.js";
+import {
+  DEFAULT_IMAGE_GENERATE_MODEL,
+  MODEL_REGISTRY,
+  canonicalModelId,
+  maxInputReferences
+} from "./chunk-MCJ5I5LR.js";
+import "./chunk-WCJ3JTLF.js";
+import {
+  ApiError,
+  apiGet,
+  apiPost
+} from "./chunk-4U7HXXSA.js";
+import "./chunk-V6AAOAMM.js";
+import "./chunk-GGUQP6KI.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-L55PHMSR.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/studio/generate.ts
+import { defineCommand } from "citty";
+var MODEL_LIST = IMAGE_MODEL_IDS;
+var DEFAULT_MAX_WAIT_MS = 24e4;
+registerSchema({
+  command: "studio.generate",
+  description: "Start here to make an image. Opens a Studio batch: the images are ingested into the media library as they render and the whole batch shows up in the dashboard Studio for the client, labelled with this conversation. Default model google/gemini-3.1-flash-image \u2014 fast, reference editing, extreme aspect ratios. --reference is the biggest quality lever: pass library image ids, local file paths, and/or image URLs to ground the render in real imagery.",
+  args: {
+    prompt: {
+      type: "string",
+      description: "What to generate \u2014 full art direction, not a keyword. Length caps are per model (Recraft 10,000 characters, gpt-image 32,000, Gemini publishes none) and a --skill or --brand block counts toward them; `baker studio models` has the number.",
+      required: true
+    },
+    model: {
+      type: "string",
+      description: `Model (default google/gemini-3.1-flash-image). They accept genuinely different things \u2014 check with \`baker studio models\` rather than assuming. One of: ${MODEL_LIST.join(", ")}`,
+      required: false,
+      enum: MODEL_LIST
+    },
+    "aspect-ratio": {
+      type: "string",
+      // Snapped, not refused: ask for the ad shape you want and the backend
+      // moves it to the nearest one the chosen model renders (gpt-image-2 has no
+      // 4:5, so a 4:5 request becomes 3:4 rather than failing).
+      description: "Aspect ratio, e.g. 1:1 (default), 16:9, 9:16, 4:5, 3:2 \u2014 Gemini flash also does 1:4 / 8:1. Snapped to the nearest shape the chosen model renders, so ask for the ad format you want (4:5 on gpt-image-2 or Recraft becomes 3:4, neither renders it). Must be width:height.",
+      required: false
+    },
+    count: { type: "number", description: "Takes to render, 1-8 (default 1)", required: false, default: 1 },
+    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
+    },
+    reference: {
+      type: "string",
+      description: "Comma-separated visual references, in order: library image ids, local file paths, and/or image URLs. Paths and URLs are added to the media library first, so the reference is reusable and the client can see what grounded the render. How many are allowed is per model \u2014 Gemini takes 14, gpt-image 16, Recraft exactly 1.",
+      required: false
+    },
+    skill: {
+      type: "string",
+      description: "Craft direction by id (run `baker studio skills`), e.g. product-pack-shot, ugc-selfie-hook",
+      required: false
+    },
+    brand: {
+      type: "boolean",
+      description: "Append the company palette and visual style. Off by default \u2014 you are writing the art direction yourself and a brand block appended after it fights what you just specified.",
+      required: false,
+      default: false
+    },
+    "image-size": {
+      type: "string",
+      // No default: left unset the provider picks the pixels from the ratio.
+      // gpt-image-2 has no resolution setting at all and REFUSES this flag.
+      description: `Output resolution \u2014 only on models that have one (gpt-image-2 and Recraft have none and REFUSE this). The tiers differ per model: Lite renders 1K only, Pro 1K-4K, Gemini flash also 0.5K. One of: ${IMAGE_SIZES.join(", ")}`,
+      required: false,
+      enum: IMAGE_SIZES
+    },
+    quality: {
+      type: "string",
+      description: `Rendering quality \u2014 the OpenAI models only; every Gemini tier and Recraft REFUSE it. One of: ${IMAGE_QUALITIES.join(", ")}`,
+      required: false,
+      enum: IMAGE_QUALITIES
+    },
+    strength: { type: "number", description: "Recraft vector only: vectorization strength 0-1", required: false },
+    "rgb-colors": {
+      type: "string",
+      description: 'Recraft only: JSON array of [r,g,b] palette triples, each channel a whole number 0-255, e.g. "[[10,10,10],[255,80,0]]"',
+      required: false
+    },
+    "bg-rgb": {
+      type: "string",
+      description: 'Recraft only: JSON [r,g,b] background colour, e.g. "[255,255,255]"',
+      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 240000). 0 returns the id immediately.",
+      required: false,
+      default: DEFAULT_MAX_WAIT_MS
+    },
+    full: { type: "boolean", description: "Include settings, references and attribution", required: false }
+  }
+});
+function parseJsonArg(raw, flag) {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    throw new ApiError("VALIDATION_ERROR", `--${flag} must be valid JSON (got: ${raw})`);
+  }
+}
+function referenceLimitFor(model) {
+  const chosen = model ?? DEFAULT_IMAGE_GENERATE_MODEL;
+  const max = maxInputReferences("image_generate", chosen);
+  if (max === void 0) return void 0;
+  const label = MODEL_REGISTRY.image_generate[canonicalModelId(chosen)]?.label ?? chosen;
+  return {
+    max,
+    refuse: (count) => max === 1 ? `${label} takes exactly one reference image \u2014 you passed ${count}. Pick the one that matters, or switch to a model that reads several.` : `${label} takes up to ${max} reference images \u2014 you passed ${count}. Drop the weakest ones.`
+  };
+}
+async function effectiveModel(pinned, skillId, fetchSkills = () => apiGet("/api/studio/skills")) {
+  if (pinned || !skillId) return pinned;
+  try {
+    const { skills } = await fetchSkills();
+    return skills.find((skill) => skill.id === skillId)?.defaults.model;
+  } catch {
+    return void 0;
+  }
+}
+function buildGenerateBody(args, prompt) {
+  const body = { prompt };
+  if (args.model) body.model = args.model;
+  if (args["aspect-ratio"]) body.aspectRatio = args["aspect-ratio"];
+  if (args.count !== void 0 && args.count !== "") body.count = Number(args.count);
+  if (args.avatar) body.avatar = args.avatar;
+  if (args.skill) body.skillId = args.skill;
+  if (args.brand) body.useBrand = true;
+  if (args["image-size"]) body.imageSize = args["image-size"];
+  if (args.quality) body.quality = args.quality;
+  if (args.strength !== void 0 && args.strength !== "") body.strength = Number(args.strength);
+  if (args["rgb-colors"]) {
+    body.rgbColors = parseJsonArg(args["rgb-colors"], "rgb-colors");
+  }
+  if (args["bg-rgb"]) {
+    body.backgroundRgbColor = parseJsonArg(
+      args["bg-rgb"],
+      "bg-rgb"
+    );
+  }
+  return body;
+}
+var generateCommand = defineCommand({
+  meta: {
+    name: "generate",
+    description: "Start here to make an image. Renders 1-8 takes of one brief, ingests each into the media library as it lands, and shows the batch in the dashboard Studio next to the ones the client ran.\n\nModel choice: google/gemini-3.1-flash-image (default \u2014 fast, best at editing a reference and at extreme ratios), google/gemini-3-pro-image (highest fidelity, slower), openai/gpt-image-2 (photoreal and the cleanest in-image text \u2014 no --image-size, no 4:5 / 5:4), recraft/recraft-v4.1-pro-vector (vector/flat marks with palette control).\n\n--reference is the biggest quality lever there is: a real logo, product shot, Pinterest pin or sandbox screenshot beats any amount of adjectives.\n\nExamples:\n  baker studio generate 'matte black bottle on wet marble, hard studio light, 35mm' --aspect-ratio 3:2 --count 3\n  baker studio generate 'this bottle on a sunlit kitchen counter' --reference './src/brand/product.png,https://\u2026/kitchen.jpg'\n  baker studio generate 'founder-style selfie, kitchen background, natural light' --skill ugc-selfie-hook\n  baker studio generate 'flat geometric mascot, brand palette' --model recraft/recraft-v4.1-pro-vector --rgb-colors '[[10,10,10],[255,80,0]]'"
+  },
+  args: {
+    avatar: {
+      type: "string",
+      description: "Cast an avatar by short name \u2014 grounds the image on their identity sheet",
+      required: false
+    },
+    prompt: { type: "positional", description: "What to generate", required: false },
+    model: { type: "string", description: "Model id (default google/gemini-3.1-flash-image)", required: false },
+    "aspect-ratio": { type: "string", description: "Aspect ratio (default 1:1)", required: false },
+    count: { type: "string", description: "Takes to render, 1-8 (default 1)", required: false },
+    reference: {
+      type: "string",
+      description: "Comma-separated library image ids, local file paths, and/or image URLs",
+      required: false
+    },
+    skill: { type: "string", description: "Craft direction id (`baker studio skills`)", required: false },
+    brand: { type: "boolean", description: "Append the company palette and style", required: false },
+    "image-size": {
+      type: "string",
+      description: `Output resolution, models that have one only: ${IMAGE_SIZES.join(" | ")}`,
+      required: false
+    },
+    quality: {
+      type: "string",
+      description: `Rendering quality, models that honour it only: ${IMAGE_QUALITIES.join(" | ")}`,
+      required: false
+    },
+    strength: { type: "string", description: "Recraft vectorization strength 0-1", required: false },
+    "rgb-colors": { type: "string", description: "Recraft palette JSON", required: false },
+    "bg-rgb": { type: "string", description: "Recraft background JSON", 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 240000, 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);
+      }
+      const body = buildGenerateBody(args, prompt);
+      if (args.reference) {
+        const model = await effectiveModel(body.model, body.skillId);
+        const { imageIds } = await resolveLibraryImageIds(args.reference, referenceLimitFor(model));
+        if (imageIds.length > 0) body.referenceImageIds = imageIds;
+      }
+      const start = await apiPost("/api/studio/generate", 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}\`.`]
+        });
+        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)]
+        });
+        return;
+      }
+      writeJson({
+        ok: true,
+        data: projectBatch(outcome.generation, args.full === true),
+        hints: batchHints(outcome.generation)
+      });
+    } catch (error) {
+      failStudioCommand(error, { withFix: true });
+    }
+  }
+});
+export {
+  buildGenerateBody,
+  effectiveModel,
+  generateCommand,
+  referenceLimitFor
+};
+//# sourceMappingURL=generate-VQTLPEYW.js.map

package/dist/get-EEBGRH4P.js

@@ -0,0 +1,61 @@
+import {
+  ApiError,
+  apiGet,
+  validateConvexId
+} from "./chunk-4U7HXXSA.js";
+import "./chunk-V6AAOAMM.js";
+import "./chunk-GGUQP6KI.js";
+import {
+  registerSchema,
+  writeJson,
+  writeOutput
+} from "./chunk-L55PHMSR.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/images/get.ts
+import { defineCommand } from "citty";
+registerSchema({
+  command: "images.get",
+  description: "Get a single image by ID",
+  args: {
+    id: { type: "string", description: "Image ID", required: true }
+  }
+});
+var getCommand = defineCommand({
+  meta: { name: "get", description: "Get a single image by ID. Example: baker images get j571abc123" },
+  args: {
+    id: { type: "positional", description: "Image ID", required: false },
+    "image-id": { type: "string", description: "Image ID (alternative to positional)", required: false },
+    output: { type: "string", description: "Output format: json|files|md", required: false, default: "json" },
+    fields: { type: "string", description: "Comma-separated field names to include", required: false },
+    full: { type: "boolean", description: "Include full metadata", required: false, default: false }
+  },
+  run: async ({ args }) => {
+    try {
+      const id = args.id || args["image-id"];
+      if (!id) {
+        writeJson({ ok: false, error: { code: "VALIDATION_ERROR", message: "Image ID is required" } });
+        process.exit(1);
+      }
+      validateConvexId(id);
+      const data = await apiGet("/api/images/get", { id });
+      writeOutput(
+        { ok: true, data },
+        args.output || "json",
+        args.fields ? args.fields.split(",") : void 0,
+        args.full
+      );
+    } catch (err) {
+      if (err instanceof ApiError) {
+        writeJson({ ok: false, error: { code: err.code, message: err.message } });
+        process.exit(1);
+      }
+      writeJson({ ok: false, error: { code: "INTERNAL_ERROR", message: "Unexpected error" } });
+      process.exit(1);
+    }
+  }
+});
+export {
+  getCommand
+};
+//# sourceMappingURL=get-EEBGRH4P.js.map

package/dist/get-GD5MRH7N.js

@@ -0,0 +1,59 @@
+import {
+  batchHints,
+  projectBatch
+} from "./chunk-JNW5S4ET.js";
+import {
+  failStudioCommand
+} from "./chunk-NBXZHTSR.js";
+import {
+  apiGet
+} from "./chunk-4U7HXXSA.js";
+import "./chunk-V6AAOAMM.js";
+import "./chunk-GGUQP6KI.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-L55PHMSR.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/studio/get.ts
+import { defineCommand } from "citty";
+registerSchema({
+  command: "studio.get",
+  description: "Read one Studio batch: every take, where it lives, and why a take is missing. This is how you pick up a batch that was still rendering when the start command returned.",
+  args: {
+    "generation-id": { type: "string", description: "Batch id from `generate` / `animate`", required: true },
+    full: { type: "boolean", description: "Include settings, references and attribution", required: false }
+  }
+});
+var getCommand = defineCommand({
+  meta: {
+    name: "get",
+    description: "Read one Studio batch \u2014 the takes, their urls, whether each is in the library, and the reason for any that failed.\n\nExample: baker studio get j57abc123def456ghi789\nExample: baker studio get j57abc123def456ghi789 --full"
+  },
+  args: {
+    "generation-id": { type: "positional", description: "Batch id", required: false },
+    full: { type: "boolean", description: "Include settings, references and attribution", required: false }
+  },
+  run: async ({ args }) => {
+    try {
+      const generationId = args["generation-id"];
+      if (!generationId) {
+        writeJson({ ok: false, error: { code: "VALIDATION_ERROR", message: "A batch id is required" } });
+        process.exit(1);
+      }
+      const { generation } = await apiGet(`/api/studio/generations/${generationId}`);
+      writeJson({
+        ok: true,
+        data: projectBatch(generation, args.full === true),
+        hints: batchHints(generation)
+      });
+    } catch (error) {
+      failStudioCommand(error);
+    }
+  }
+});
+export {
+  getCommand
+};
+//# sourceMappingURL=get-GD5MRH7N.js.map

package/dist/get-L72Z4EPU.js

@@ -0,0 +1,59 @@
+import {
+  buildGetHints,
+  failApi,
+  failValidation
+} from "./chunk-S63QUIAF.js";
+import "./chunk-PC3FJEZH.js";
+import "./chunk-CAZGM2NX.js";
+import "./chunk-NZS3KEQ2.js";
+import "./chunk-GIWHHCD6.js";
+import "./chunk-SOPVIIUW.js";
+import "./chunk-G4FG5EQO.js";
+import "./chunk-NSBNIPIW.js";
+import "./chunk-46YLDIQG.js";
+import {
+  apiPost,
+  validateConvexId
+} from "./chunk-4U7HXXSA.js";
+import "./chunk-V6AAOAMM.js";
+import "./chunk-GGUQP6KI.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-L55PHMSR.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/actions/get.ts
+import { defineCommand } from "citty";
+registerSchema({
+  command: "actions.get",
+  description: "Get a single action with tags, blockers, blocked-by, and active-chat info.",
+  args: {
+    id: { type: "string", description: "Action ID", required: true }
+  }
+});
+var getCommand = defineCommand({
+  meta: { name: "get", description: "Get a single action by ID. Example: baker actions get <action-id>" },
+  args: {
+    id: { type: "positional", description: "Action ID", required: false },
+    "action-id": { type: "string", description: "Action ID (alternative to positional)", required: false }
+  },
+  run: async ({ args }) => {
+    try {
+      const id = args.id || args["action-id"];
+      if (!id) {
+        failValidation("Action ID is required.");
+      }
+      validateConvexId(id);
+      const response = await apiPost("/api/actions/get", { actionId: id });
+      const hints = buildGetHints(response.data);
+      writeJson(hints.length > 0 ? { ...response, hints } : response);
+    } catch (err) {
+      failApi(err);
+    }
+  }
+});
+export {
+  getCommand
+};
+//# sourceMappingURL=get-L72Z4EPU.js.map

package/dist/get-LHHYARGV.js

@@ -0,0 +1,63 @@
+import {
+  ApiError,
+  apiGet,
+  validateConvexId
+} from "./chunk-4U7HXXSA.js";
+import "./chunk-V6AAOAMM.js";
+import "./chunk-GGUQP6KI.js";
+import {
+  registerSchema,
+  testimonialNormalizer,
+  writeJson,
+  writeOutput
+} from "./chunk-L55PHMSR.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/testimonials/get.ts
+import { defineCommand } from "citty";
+registerSchema({
+  command: "testimonials.get",
+  description: "Get a single testimonial by ID",
+  args: {
+    id: { type: "string", description: "Testimonial ID", required: true }
+  }
+});
+var getCommand = defineCommand({
+  meta: { name: "get", description: "Get a single testimonial by ID. Example: baker testimonials get j571abc123" },
+  args: {
+    id: { type: "positional", description: "Testimonial ID", required: false },
+    "testimonial-id": { type: "string", description: "Testimonial ID (alternative to positional)", required: false },
+    output: { type: "string", description: "Output format: json|files|md", required: false, default: "json" },
+    fields: { type: "string", description: "Comma-separated field names to include", required: false },
+    full: { type: "boolean", description: "Include full metadata", required: false, default: false }
+  },
+  run: async ({ args }) => {
+    try {
+      const id = args.id || args["testimonial-id"];
+      if (!id) {
+        writeJson({ ok: false, error: { code: "VALIDATION_ERROR", message: "Testimonial ID is required" } });
+        process.exit(1);
+      }
+      validateConvexId(id);
+      const data = await apiGet("/api/testimonials/get", { id });
+      writeOutput(
+        { ok: true, data },
+        args.output || "json",
+        args.fields ? args.fields.split(",") : void 0,
+        args.full,
+        testimonialNormalizer
+      );
+    } catch (err) {
+      if (err instanceof ApiError) {
+        writeJson({ ok: false, error: { code: err.code, message: err.message } });
+        process.exit(1);
+      }
+      writeJson({ ok: false, error: { code: "INTERNAL_ERROR", message: "Unexpected error" } });
+      process.exit(1);
+    }
+  }
+});
+export {
+  getCommand
+};
+//# sourceMappingURL=get-LHHYARGV.js.map

package/dist/get-N6IMHWZE.js

@@ -0,0 +1,92 @@
+import {
+  waitForSheet
+} from "./chunk-WN4KX7GE.js";
+import {
+  avatarRowNormalizer,
+  castingHints,
+  failAvatarApi,
+  failValidation
+} from "./chunk-NDFLI64C.js";
+import {
+  readAvatars
+} from "./chunk-UTFSUMLU.js";
+import "./chunk-4U7HXXSA.js";
+import "./chunk-V6AAOAMM.js";
+import "./chunk-GGUQP6KI.js";
+import {
+  registerSchema,
+  writeJson,
+  writeOutput
+} from "./chunk-L55PHMSR.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/avatars/get.ts
+import { defineCommand } from "citty";
+registerSchema({
+  command: "avatars.get",
+  description: "Read one avatar by handle \u2014 the command you run before casting it. Returns its status (only `ready` can be cast), the identity sheet URL every render must be grounded on via --reference, and the subject description that goes into the prompt verbatim. Add --full for the whole written profile (persona, speech, motion, wardrobe, setting, guardrails, voice, source photos).",
+  args: {
+    handle: { type: "string", description: 'Avatar handle, e.g. "marta" (lowercase, dashes)', required: true },
+    full: {
+      type: "boolean",
+      description: "Return the whole written profile, not just the casting essentials",
+      required: false,
+      default: false
+    }
+  }
+});
+var getCommand = defineCommand({
+  meta: {
+    name: "get",
+    description: "Read one avatar by handle: status, identity sheet URL for --reference, and the subject description to reuse verbatim. Example: baker avatars get marta --full"
+  },
+  args: {
+    handle: { type: "positional", description: "Avatar handle", required: false },
+    "avatar-handle": { type: "string", description: "Avatar handle (alternative to positional)", required: false },
+    full: { type: "boolean", description: "Include the whole written profile", required: false, default: false },
+    output: { type: "string", description: "Output format: json|files|md", required: false, default: "json" },
+    fields: { type: "string", description: "Comma-separated field names to include", required: false },
+    wait: {
+      type: "boolean",
+      description: "Block until the identity sheet has settled (up to 90s), instead of returning while it is still building. Use it when the NEXT thing you do needs this avatar \u2014 a clip, a still, anything with --avatar. Without it you get the current status and have to come back; with it the command returns the moment it is ready. Never write your own sleep/poll loop around this.",
+      required: false,
+      default: false
+    }
+  },
+  run: async ({ args }) => {
+    const handle = (args.handle || args["avatar-handle"])?.trim();
+    if (!handle) {
+      failValidation("An avatar handle is required, e.g. `baker avatars get marta`. Run `baker avatars list` first.");
+    }
+    try {
+      const params = { handle };
+      if (args.full) params.full = "1";
+      let avatar = await readAvatars("/api/avatars/get", params);
+      if (args.wait) {
+        avatar = await waitForSheet(
+          avatar,
+          () => readAvatars("/api/avatars/get", params)
+        );
+      }
+      const hints = castingHints(avatar);
+      const format = args.output || "json";
+      if (format === "json") {
+        writeJson({ ok: true, data: avatar, hints });
+        return;
+      }
+      writeOutput(
+        { ok: true, data: avatar },
+        format,
+        args.fields ? args.fields.split(",") : void 0,
+        Boolean(args.full),
+        avatarRowNormalizer
+      );
+    } catch (err) {
+      failAvatarApi(err, handle);
+    }
+  }
+});
+export {
+  getCommand
+};
+//# sourceMappingURL=get-N6IMHWZE.js.map

package/dist/get-N7W4E3S3.js

@@ -0,0 +1,82 @@
+import {
+  failApi,
+  failValidation,
+  isTempScheduledAgentId,
+  validateScheduledAgentRef
+} from "./chunk-ERJZS5OP.js";
+import "./chunk-MJ4MJZV3.js";
+import {
+  CHAT_READ_ARG
+} from "./chunk-PFBQERWX.js";
+import "./chunk-PC3FJEZH.js";
+import "./chunk-CAZGM2NX.js";
+import "./chunk-NZS3KEQ2.js";
+import "./chunk-GIWHHCD6.js";
+import "./chunk-SOPVIIUW.js";
+import "./chunk-G4FG5EQO.js";
+import "./chunk-NSBNIPIW.js";
+import "./chunk-46YLDIQG.js";
+import {
+  apiPost
+} from "./chunk-4U7HXXSA.js";
+import "./chunk-V6AAOAMM.js";
+import {
+  getEnv
+} from "./chunk-GGUQP6KI.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-L55PHMSR.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/scheduled-agents/get.ts
+import { defineCommand } from "citty";
+registerSchema({
+  command: "scheduled-agents.get",
+  description: "Get a published scheduled agent, or one this chat has staged (temp_agent_*). A published one comes with runsAs: who each run acts as ({ name, personalTools, companyTools, notSignedIn? }) \u2014 the tools a run loads, which decides whether a job like reading someone's inbox can work. Its recentRuns and any draftOps this chat staged on it come with it.",
+  args: {
+    id: { type: "string", description: "Published scheduled agent ID or temp_agent_* draft ID", required: true },
+    chat: { type: "string", description: CHAT_READ_ARG.description, required: false }
+  }
+});
+var getCommand = defineCommand({
+  meta: {
+    name: "get",
+    description: "Get a scheduled agent. Example: baker scheduled-agents get <id-or-temp_agent_id>"
+  },
+  args: {
+    id: { type: "positional", description: "Scheduled agent ID or temp_agent_* draft ID", required: false },
+    "scheduled-agent-id": {
+      type: "string",
+      description: "Scheduled agent ID (alternative to positional)",
+      required: false
+    },
+    chat: CHAT_READ_ARG
+  },
+  run: async ({ args }) => {
+    try {
+      const id = args.id || args["scheduled-agent-id"];
+      if (!id) {
+        failValidation("Scheduled agent ID is required.");
+      }
+      validateScheduledAgentRef(id);
+      const env = getEnv();
+      const chatId = typeof args.chat === "string" && args.chat.length > 0 ? args.chat : env.BAKER_CHAT_ID;
+      if (isTempScheduledAgentId(id) && !chatId) {
+        failValidation("BAKER_CHAT_ID or --chat is required to get a staged scheduled agent ID.");
+      }
+      const body = { id };
+      if (chatId) {
+        body.chatId = chatId;
+      }
+      const response = await apiPost("/api/scheduled-agents/get", body);
+      writeJson(response);
+    } catch (err) {
+      failApi(err);
+    }
+  }
+});
+export {
+  getCommand
+};
+//# sourceMappingURL=get-N7W4E3S3.js.map