@koda-sl/baker-cli 0.512.0 → 0.514.0-dev.555f7007e

package/dist/chunk-AVYUFJQQ.js

@@ -0,0 +1,46 @@
+import {
+  RENDER_REVIEW_MODEL,
+  askAboutImages,
+  buildRulesReviewPrompt,
+  classifyRuleFindings,
+  reviewedRules,
+  rulesSystem
+} from "./chunk-FJZYOVSW.js";
+
+// src/engine/nodes/local/lib/confirm-blocking.ts
+var cutByFrame = (f) => f.kind?.defect === "cut";
+async function confirmBlocking(findings, stills, formats, ask) {
+  const claims = findings.filter((f) => f.severity === "blocking" && !cutByFrame(f));
+  if (claims.length === 0 || stills.length === 0) return [...findings];
+  const prompt = [
+    `These are the finished sizes of one ad, in order: ${formats.map((f, i) => `Image ${i + 1} is the ${f}`).join("; ")}.`,
+    "A reviewer reported each claim below. Look again at the size each one names (and, for a claim comparing sizes, at the others) and answer true only when the defect is plainly there for someone looking at it on a phone.",
+    "Answer false when the thing is not there, when it is an ordinary part of the scene (a second house, a neighbour's roof, a reflection), or when the sizes it compares show the same thing.",
+    ...claims.map((c, i) => `${i + 1}. ${c.what}`),
+    `Reply with only this JSON: {"answers":[true|false, ...]}, one answer per claim, in order.`
+  ].join("\n");
+  const answer = await ask([...stills], prompt).catch(() => null);
+  const answers = answer?.answers;
+  if (!Array.isArray(answers) || answers.length !== claims.length) return [...findings];
+  const unconfirmed = new Set(claims.filter((_, i) => answers[i] === false));
+  return findings.map((f) => unconfirmed.has(f) ? { ...f, severity: "warning" } : f);
+}
+
+// src/engine/nodes/local/lib/rules-review.ts
+var RULES_REVIEW_TIMEOUT_MS = 12e4;
+async function reviewAgainstRules(opts) {
+  const rules = reviewedRules(opts.rules);
+  if (rules.length === 0 || opts.stills.length === 0) return [];
+  const system = rulesSystem(rules);
+  const ask = (images, prompt) => askAboutImages(RENDER_REVIEW_MODEL, images, prompt, opts.onSpend, RULES_REVIEW_TIMEOUT_MS, void 0, system);
+  const answer = await ask([...opts.stills], buildRulesReviewPrompt({ formats: opts.formats, rules }));
+  if (answer === null) return null;
+  return await confirmBlocking(classifyRuleFindings(answer, rules), opts.stills, opts.formats, ask);
+}
+
+export {
+  cutByFrame,
+  confirmBlocking,
+  reviewAgainstRules
+};
+//# sourceMappingURL=chunk-AVYUFJQQ.js.map

package/dist/chunk-B4YF7VQF.js

@@ -0,0 +1,97 @@
+import {
+  claimNewCreativeInWorkspace,
+  creativeLimitRefusal
+} from "./chunk-XVFZDPEW.js";
+import {
+  leadVersion,
+  writeSeriesMemberCanvas
+} from "./chunk-XUXRA7IB.js";
+import {
+  definitionFieldsOf,
+  setDefinitionFields,
+  setSpecMessage
+} from "./chunk-I43ZEWJQ.js";
+import {
+  IDEAS_DIR
+} from "./chunk-KTZCLJ2D.js";
+
+// src/commands/creatives/make-series.ts
+import { mkdir, readFile, writeFile } from "fs/promises";
+import path from "path";
+import { parseDocument } from "yaml";
+var LEAD_ONLY = ["idea", "message", "evidence", "angle", "persona", "awareness", "hypothesis", "series", "title"];
+function withoutFields(raw, keys) {
+  const match = raw.match(/^---\r?\n([\s\S]*?\r?\n)?---/);
+  if (!match) return raw;
+  const doc = parseDocument(match[1] ?? "");
+  if (doc.errors.length > 0) return raw;
+  for (const key of keys) doc.delete(key);
+  return `---
+${doc.toString()}---${raw.slice(match[0].length)}`;
+}
+async function makeSeriesAd(root, idea, slug, lead, evidence, deps) {
+  if (slug === lead) {
+    return {
+      code: "series_of_itself",
+      message: `"${slug}" is the lead itself.`,
+      fix: "Give the new ad its own --slug."
+    };
+  }
+  const version = await leadVersion(root, lead);
+  if ("refused" in version) return version.refused;
+  const dir = path.join(root, "src", "creatives", slug);
+  const definitionPath = path.join(dir, "_definition.md");
+  const claim = await claimNewCreativeInWorkspace(path.join(root, "canvas"), slug, deps.chatId, definitionPath);
+  if (!claim.allowed) return creativeLimitRefusal(slug).error;
+  await mkdir(dir, { recursive: true });
+  await writeFile(path.join(dir, "prompt.json"), setSpecMessage(JSON.stringify(version.spec), idea.message), "utf8");
+  const leadDefinition = await readFile(path.join(root, "src", "creatives", lead, "_definition.md"), "utf8").catch(
+    () => "---\nkind: static\n---\n"
+  );
+  const definition = setDefinitionFields(withoutFields(leadDefinition, LEAD_ONLY), {
+    title: idea.message.slice(0, 120),
+    series: lead,
+    status: "draft",
+    ...definitionFieldsOf(idea, evidence)
+  });
+  await writeFile(definitionPath, definition, "utf8");
+  const made = await writeSeriesMemberCanvas(root, slug, { leadWords: true });
+  if (made === null || "refused" in made) {
+    return made?.refused ?? { code: "series_not_made", message: `"${slug}" could not be made in the series of "${lead}".` };
+  }
+  if (idea.status === "idea") {
+    const ideaPath = path.join(root, IDEAS_DIR, `${idea.id}.md`);
+    const raw = await readFile(ideaPath, "utf8").catch(() => null);
+    if (raw !== null) await writeFile(ideaPath, setDefinitionFields(raw, { status: "built" }), "utf8");
+  }
+  await deps.sync(dir);
+  return { slug, lead, leadRunId: version.lead.runId, canvasPath: made.canvasPath };
+}
+function seriesMadeEnvelope(made, idea) {
+  const lead = made.leadPlatforms ?? [];
+  const elsewhere = (idea.platforms ?? []).some((p) => !lead.includes(p));
+  return {
+    ok: true,
+    data: {
+      creative: made.slug,
+      idea: idea.id,
+      message: idea.message,
+      series: made.lead,
+      canvas_path: made.canvasPath
+    },
+    hints: [
+      `Write this ad's words in src/creatives/${made.slug}/prompt.json \`copy\`: one line for each of the lead's, in the same roles and about as long, saying this idea's message. Change nothing else: the picture, layout and colours are the lead's (${made.lead}), and every word you write replaces the lead's line in its place.`,
+      `When every ad of the series has its words: baker canvas run --series ${made.lead} (renders them all at once, each reviewed and corrected on its own).`,
+      ...elsewhere && lead.length > 0 ? [
+        `A series ad runs where its lead runs (${lead.join(", ")}), in its sizes; the idea names ${idea.platforms?.join(", ")}. To run it there, make it on its own: baker creatives make ${idea.id} --platforms ${idea.platforms?.join(",")}.`
+      ] : []
+    ]
+  };
+}
+
+export {
+  withoutFields,
+  makeSeriesAd,
+  seriesMadeEnvelope
+};
+//# sourceMappingURL=chunk-B4YF7VQF.js.map

package/dist/chunk-BDOYNGUL.js

@@ -0,0 +1,98 @@
+import {
+  isRemoteUrl
+} from "./chunk-B537ISAP.js";
+import {
+  detectImageContentType,
+  uploadLocalImage
+} from "./chunk-MKTLZCRJ.js";
+import {
+  IMAGE_GENERATE_MODELS,
+  MODEL_REGISTRY,
+  VIDEO_GENERATE_MODELS
+} from "./chunk-F3CZFUXZ.js";
+import {
+  ApiError,
+  apiPost
+} from "./chunk-X7VQFLHI.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-BDOYNGUL.js.map

package/dist/chunk-BJOK7QD4.js

@@ -0,0 +1,207 @@
+import {
+  handleConnectionError,
+  needsConnectionFix,
+  writeAdsJson
+} from "./chunk-ZRP7Y2DM.js";
+import {
+  LINKEDIN_SEARCH_STATUSES,
+  unsupportedLinkedinSearchStatuses
+} from "./chunk-NZ34KM46.js";
+import {
+  ApiError
+} from "./chunk-X7VQFLHI.js";
+import {
+  MissingChatIdError,
+  getEnv
+} from "./chunk-LGK7UWBN.js";
+
+// src/commands/ads/linkedin/shared.ts
+import { readFileSync } from "fs";
+var DAY_MS = 864e5;
+function handleLinkedinError(err) {
+  if (err instanceof ApiError) {
+    if (needsConnectionFix(err.code, err.message)) {
+      handleConnectionError("linkedin_ads", err.message);
+    }
+    if (isNoAccountsSelectedError(err.code, err.message)) {
+      handleConnectionError("linkedin_ads", err.message);
+    }
+    const explanation = explainLinkedinError(err);
+    const envelope = {
+      ok: false,
+      error: {
+        code: err.code,
+        message: err.message,
+        fix: {
+          action: explanation.action,
+          explanation: explanation.message,
+          correctedCommand: explanation.correctedCommand
+        },
+        retryable: err.code === "RATE_LIMITED" || err.code === "UNAVAILABLE" || err.code === "INTERNAL_ERROR"
+      }
+    };
+    writeAdsJson(envelope);
+    process.exit(1);
+  }
+  writeAdsJson(unexpectedErrorEnvelope(err));
+  process.exit(1);
+}
+function unexpectedErrorEnvelope(err) {
+  if (err instanceof MissingChatIdError) {
+    return {
+      ok: false,
+      error: {
+        code: err.code,
+        message: err.message,
+        fix: {
+          action: "reject",
+          explanation: "LinkedIn changes are staged in a chat and this run has none. Don't retry: carry on with the rest of the job and tell the user this change couldn't be staged from here."
+        },
+        retryable: false
+      }
+    };
+  }
+  const message = err instanceof Error ? err.message : "Unexpected error";
+  return { ok: false, error: { code: "NETWORK_ERROR", message } };
+}
+function isNoAccountsSelectedError(code, message) {
+  return code === "VALIDATION_ERROR" && /no linkedin ad accounts selected/i.test(message);
+}
+function explainLinkedinError(err) {
+  const lower = err.message.toLowerCase();
+  if (err.code === "VALIDATION_ERROR" && lower.includes("granularity") && lower.includes("daily")) {
+    return {
+      action: "retry_with_flag",
+      message: "LinkedIn rejects DAILY granularity when pivoting on demographic dims (job-title, company, etc.). Re-run with --granularity ALL or MONTHLY.",
+      correctedCommand: void 0
+    };
+  }
+  if (err.code === "RATE_LIMITED") {
+    return {
+      action: "wait_and_retry",
+      message: "LinkedIn asked Baker to wait. A short wait is already sat out for you, so this one is long \u2014 up to LinkedIn's daily limit, which resets at midnight UTC. Don't retry in a loop: carry on with the rest of the job without this LinkedIn data, and tell the user it can be read again later."
+    };
+  }
+  if (err.code === "INTERNAL_ERROR" && lower.includes("deprecat")) {
+    return {
+      action: "reject",
+      message: "LinkedIn-Version header is deprecated. The backend constant LINKEDIN_API_VERSION needs to be bumped \u2014 file an issue or update the constant."
+    };
+  }
+  return { action: "reject", message: err.message };
+}
+var LI_ACCOUNT_ID_RE = /^(urn:li:sponsoredAccount:)?\d+$/;
+function resolveAccountIdArg(args) {
+  const fromArgs = args["account-id"] ?? args["account-urn"];
+  const id = fromArgs || getEnv().BAKER_LINKEDIN_AD_ACCOUNT_ID;
+  if (!id) {
+    writeAdsJson({
+      ok: false,
+      error: {
+        code: "MISSING_ACCOUNT_ID",
+        message: "Pass --account-id (numeric) or --account-urn (urn:li:sponsoredAccount:N), or set BAKER_LINKEDIN_AD_ACCOUNT_ID. Run `baker ads linkedin accounts` to find IDs."
+      }
+    });
+    process.exit(1);
+  }
+  if (!LI_ACCOUNT_ID_RE.test(id)) {
+    writeAdsJson({
+      ok: false,
+      error: {
+        code: "INVALID_ACCOUNT_ID",
+        message: `Invalid LinkedIn account ID "${id}". Expected numeric or urn:li:sponsoredAccount:N.`
+      }
+    });
+    process.exit(1);
+  }
+  return id.startsWith("urn:") ? id.split(":").pop() ?? id : id;
+}
+function todayIso() {
+  return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+}
+function daysAgoIso(days) {
+  return new Date(Date.now() - days * DAY_MS).toISOString().slice(0, 10);
+}
+function csvOrJson(args) {
+  return args.output ?? "json";
+}
+function statusesArgDescription(level) {
+  return `CSV of statuses (${LINKEDIN_SEARCH_STATUSES[level].join(",")})`;
+}
+function statusFilterError(level, statuses) {
+  const unsupported = unsupportedLinkedinSearchStatuses(level, statuses);
+  if (unsupported.length === 0) {
+    return null;
+  }
+  const accepted = LINKEDIN_SEARCH_STATUSES[level].join(",");
+  return {
+    ok: false,
+    error: {
+      code: "INVALID_STATUS",
+      message: `LinkedIn does not accept status ${unsupported.join(", ")} for this listing.`,
+      fix: {
+        action: "retry_with_flag",
+        explanation: `Re-run with --statuses from ${accepted}, or --all-statuses to drop the filter.`
+      },
+      retryable: false
+    }
+  };
+}
+function resolveStatusFilter(args, level) {
+  if (args["all-statuses"]) {
+    return void 0;
+  }
+  const explicit = args.statuses;
+  if (!explicit) {
+    return ["ACTIVE"];
+  }
+  const statuses = explicit.split(",").map((s) => s.trim().toUpperCase()).filter(Boolean);
+  const error = statusFilterError(level, statuses);
+  if (error) {
+    writeAdsJson(error);
+    process.exit(1);
+  }
+  return statuses;
+}
+function loadTargetingArg(args) {
+  const inline = args.targeting;
+  if (inline) {
+    try {
+      return JSON.parse(inline);
+    } catch {
+      handleLinkedinError(new Error("--targeting must be valid JSON. See LinkedIn 'targetingCriteria' shape."));
+    }
+  }
+  const file = args["targeting-file"];
+  if (file) {
+    try {
+      return JSON.parse(readFileSync(file, "utf-8"));
+    } catch (e) {
+      handleLinkedinError(
+        new Error(`Failed to read --targeting-file: ${e instanceof Error ? e.message : "I/O error"}`)
+      );
+    }
+  }
+  handleLinkedinError(new Error("Pass --targeting-file <path> or --targeting '{...JSON...}'"));
+}
+function exitOnInvalidArgs(issues, flagByField) {
+  const messages = issues.map((issue) => {
+    const field = String(issue.path[0] ?? "");
+    return `${flagByField[field] ?? (field || "args")}: ${issue.message}`;
+  });
+  writeAdsJson({ ok: false, error: { code: "INVALID_ARGS", message: messages.join("; ") } });
+  process.exit(1);
+}
+
+export {
+  handleLinkedinError,
+  resolveAccountIdArg,
+  todayIso,
+  daysAgoIso,
+  csvOrJson,
+  statusesArgDescription,
+  resolveStatusFilter,
+  loadTargetingArg,
+  exitOnInvalidArgs
+};
+//# sourceMappingURL=chunk-BJOK7QD4.js.map

package/dist/chunk-CMCGFSUS.js

@@ -0,0 +1,197 @@
+import {
+  mediaTagsCreateRequestSchema,
+  mediaTagsDeleteRequestSchema,
+  mediaTagsUpdateRequestSchema
+} from "./chunk-NZ34KM46.js";
+import {
+  ApiError,
+  apiGet,
+  apiPost
+} from "./chunk-X7VQFLHI.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-Q7US4OOA.js";
+
+// src/lib/tags-command.ts
+import { defineCommand } from "citty";
+var OUTPUT_ARG = {
+  output: { type: "string", description: "Output format: md|json", required: false, default: "md" }
+};
+var SHARED_POOL_HINT = "Custom tags are one pool shared by images, videos and testimonials \u2014 this change shows up in all three. Already applied: publishing or discarding this chat does not undo it.";
+function fail(err) {
+  const code = err instanceof ApiError ? err.code : "INTERNAL_ERROR";
+  const message = err instanceof ApiError ? err.message : "Unexpected error";
+  writeJson({ ok: false, error: { code, message } });
+  process.exit(1);
+}
+function failInvalid(issue) {
+  writeJson({ ok: false, error: { code: "VALIDATION_ERROR", message: issue?.message ?? "Invalid request" } });
+  process.exit(1);
+}
+function makeTagsCommand(command, label, endpoint) {
+  registerSchema({
+    command: `${command}.tags.list`,
+    description: `List the available ${label} tag taxonomy (built-in defaults + this company's custom tags).`,
+    args: OUTPUT_ARG
+  });
+  const listCommand = defineCommand({
+    meta: {
+      name: "list",
+      description: `List the available ${label} tag names (defaults + company custom tags). Use before filtering with --tags. Example: baker ${command} tags`
+    },
+    args: OUTPUT_ARG,
+    run: async ({ args }) => {
+      try {
+        const { markdown } = await apiGet(endpoint);
+        if (args.output === "json") {
+          writeJson({ ok: true, data: { markdown } });
+          return;
+        }
+        process.stdout.write(`${markdown.trimEnd()}
+`);
+      } catch (err) {
+        const code = err instanceof ApiError ? err.code : "INTERNAL_ERROR";
+        const message = err instanceof ApiError ? err.message : "Unexpected error";
+        if (args.output === "json") {
+          writeJson({ ok: false, error: { code, message } });
+        } else {
+          process.stderr.write(`Error: ${message}
+`);
+        }
+        process.exit(1);
+      }
+    }
+  });
+  const createArgs = {
+    name: { type: "positional", description: "Tag name (stored lowercased, spaces \u2192 hyphens)", required: true },
+    description: {
+      type: "string",
+      description: "What the tag means, so it gets applied consistently",
+      required: false
+    }
+  };
+  registerSchema({
+    command: `${command}.tags.create`,
+    description: "Create a custom media tag in the company's shared pool (images, videos and testimonials). Applies immediately. Use when no built-in or custom tag fits.",
+    args: {
+      name: { type: "string", description: "Tag name (stored lowercased, spaces \u2192 hyphens)", required: true },
+      description: createArgs.description
+    }
+  });
+  const createCommand = defineCommand({
+    meta: {
+      name: "create",
+      description: `Create a custom tag (shared by images, videos and testimonials). Applies immediately.
+
+Example: baker ${command} tags create "summer sale" --description "Assets for the summer sale campaign"`
+    },
+    args: createArgs,
+    run: async ({ args }) => {
+      const parsed = mediaTagsCreateRequestSchema.safeParse({
+        name: String(args.name ?? ""),
+        ...args.description ? { description: String(args.description) } : {}
+      });
+      if (!parsed.success) failInvalid(parsed.error.issues[0]);
+      try {
+        const data = await apiPost("/api/media-tags/create", parsed.data);
+        writeJson({
+          ok: true,
+          data,
+          hints: [
+            SHARED_POOL_HINT,
+            `Use it as \`--tags ${data.name}\`.`,
+            ...data.description ? [] : ["MISSING --description: add one with `tags update` so the tag is applied consistently."]
+          ]
+        });
+      } catch (err) {
+        fail(err);
+      }
+    }
+  });
+  registerSchema({
+    command: `${command}.tags.update`,
+    description: "Change what a custom tag means (its description). Built-in tags cannot be changed. Applies immediately.",
+    args: {
+      slug: { type: "string", description: "Custom tag name, as `tags` lists it", required: true },
+      description: { type: "string", description: "New description", required: true }
+    }
+  });
+  const updateCommand = defineCommand({
+    meta: {
+      name: "update",
+      description: `Change a custom tag's description. Built-in tags cannot be changed. Applies immediately.
+
+Example: baker ${command} tags update summer-sale --description "Assets for the 2026 summer sale"`
+    },
+    args: {
+      slug: { type: "positional", description: "Custom tag name, as `tags` lists it", required: true },
+      description: { type: "string", description: "New description", required: true }
+    },
+    run: async ({ args }) => {
+      const parsed = mediaTagsUpdateRequestSchema.safeParse({
+        slug: String(args.slug ?? ""),
+        description: String(args.description ?? "")
+      });
+      if (!parsed.success) failInvalid(parsed.error.issues[0]);
+      try {
+        const data = await apiPost("/api/media-tags/update", parsed.data);
+        writeJson({ ok: true, data, hints: [SHARED_POOL_HINT] });
+      } catch (err) {
+        fail(err);
+      }
+    }
+  });
+  registerSchema({
+    command: `${command}.tags.delete`,
+    description: "Delete a custom tag from the company's shared pool. Built-in tags cannot be deleted. Applies immediately. Confirm with the user first.",
+    args: { slug: { type: "string", description: "Custom tag name, as `tags` lists it", required: true } }
+  });
+  const deleteCommand = defineCommand({
+    meta: {
+      name: "delete",
+      description: `Delete a custom tag (shared by images, videos and testimonials). Built-in tags cannot be deleted. Applies immediately \u2014 confirm with the user first.
+
+Example: baker ${command} tags delete summer-sale`
+    },
+    args: { slug: { type: "positional", description: "Custom tag name, as `tags` lists it", required: true } },
+    run: async ({ args }) => {
+      const parsed = mediaTagsDeleteRequestSchema.safeParse({ slug: String(args.slug ?? "") });
+      if (!parsed.success) failInvalid(parsed.error.issues[0]);
+      try {
+        const data = await apiPost("/api/media-tags/delete", parsed.data);
+        writeJson({ ok: true, data, hints: [SHARED_POOL_HINT] });
+      } catch (err) {
+        fail(err);
+      }
+    }
+  });
+  return defineCommand({
+    meta: {
+      name: "tags",
+      description: `The ${label} tag taxonomy: built-in defaults plus the company's custom tags (one pool shared by images, videos and testimonials). Subcommands: list (default), create, update, delete.
+
+Examples:
+  baker ${command} tags                                   # list available tags
+  baker ${command} tags create "summer sale" --description "\u2026"
+  baker ${command} tags update summer-sale --description "\u2026"
+  baker ${command} tags delete summer-sale`
+    },
+    // Declared on the parent too: `default: "list"` dispatches the bare `tags --output json`
+    // form, and citty reads an undeclared flag's value as a subcommand name.
+    args: OUTPUT_ARG,
+    subCommands: {
+      list: listCommand,
+      create: createCommand,
+      update: updateCommand,
+      delete: deleteCommand
+    },
+    // `default`, never `run`: citty falls through to the parent's `run` after a subcommand.
+    default: "list"
+  });
+}
+
+export {
+  makeTagsCommand
+};
+//# sourceMappingURL=chunk-CMCGFSUS.js.map