@koda-sl/baker-cli 0.468.0 → 0.469.0

package/dist/sync-W3XDDTRG.js

@@ -0,0 +1,265 @@
+import {
+  parseXApiError
+} from "./chunk-M6UNISGO.js";
+import {
+  resolveXAccountId,
+  resolveXAccountTimezone
+} from "./chunk-QW7VPZBA.js";
+import {
+  cacheGet,
+  cacheSet,
+  writeAdsJson
+} from "./chunk-JM7C6OHU.js";
+import {
+  ApiError,
+  apiPost
+} from "./chunk-CK5ZNZ3I.js";
+import "./chunk-7QDVAEB6.js";
+import "./chunk-NVBBZPJP.js";
+import {
+  registerSchema
+} from "./chunk-KCA5CDCU.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/ads/x/stats/sync.ts
+import { defineCommand } from "citty";
+
+// src/commands/ads/x/presets.ts
+var X_STATS_PRESETS = [
+  {
+    name: "campaign-engagement-7d",
+    description: "Campaign-level engagements + impressions over the last 7 days, daily granularity",
+    entity: "CAMPAIGN",
+    metricGroups: ["ENGAGEMENT"],
+    granularity: "DAY",
+    defaultDays: 7,
+    placement: "ALL_ON_TWITTER"
+  },
+  {
+    name: "campaign-spend-30d",
+    description: "Campaign-level billed engagements + spend over the last 30 days, daily",
+    entity: "CAMPAIGN",
+    metricGroups: ["BILLING"],
+    granularity: "DAY",
+    defaultDays: 30,
+    placement: "ALL_ON_TWITTER"
+  },
+  {
+    name: "tweet-performance-7d",
+    description: "Promoted tweet engagement + media metrics over the last 7 days, daily",
+    entity: "PROMOTED_TWEET",
+    metricGroups: ["ENGAGEMENT", "MEDIA"],
+    granularity: "DAY",
+    defaultDays: 7,
+    placement: "ALL_ON_TWITTER"
+  },
+  {
+    name: "video-performance-30d",
+    description: "Promoted tweet video views/CTAs + engagement over the last 30 days, daily",
+    entity: "PROMOTED_TWEET",
+    metricGroups: ["VIDEO", "ENGAGEMENT"],
+    granularity: "DAY",
+    defaultDays: 30,
+    placement: "ALL_ON_TWITTER"
+  },
+  {
+    name: "line-item-conversions-30d",
+    description: "Line item web conversions + billing over the last 30 days, daily",
+    entity: "LINE_ITEM",
+    metricGroups: ["WEB_CONVERSION", "BILLING"],
+    granularity: "DAY",
+    defaultDays: 30,
+    placement: "ALL_ON_TWITTER"
+  }
+];
+function getPreset(name) {
+  return X_STATS_PRESETS.find((p) => p.name === name);
+}
+function isoSeconds(d) {
+  return `${d.toISOString().slice(0, 19)}Z`;
+}
+function isoHourFloor(daysAgo, now = /* @__PURE__ */ new Date()) {
+  const d = new Date(now);
+  d.setUTCMilliseconds(0);
+  d.setUTCSeconds(0);
+  d.setUTCMinutes(0);
+  d.setUTCDate(d.getUTCDate() - daysAgo);
+  return isoSeconds(d);
+}
+function wallClockAsUtc(instant, timeZone) {
+  const parts = new Intl.DateTimeFormat("en-US", {
+    timeZone,
+    hour12: false,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit"
+  }).formatToParts(instant);
+  const read = (type) => Number(parts.find((p) => p.type === type)?.value ?? "0");
+  const hour = read("hour") % 24;
+  return Date.UTC(read("year"), read("month") - 1, read("day"), hour, read("minute"), read("second"));
+}
+function accountMidnightIso(daysAgo, timeZone, now = /* @__PURE__ */ new Date()) {
+  const localNow = new Date(wallClockAsUtc(now, timeZone));
+  const target = Date.UTC(localNow.getUTCFullYear(), localNow.getUTCMonth(), localNow.getUTCDate() - daysAgo, 0, 0, 0);
+  let instant = target;
+  for (let i = 0; i < 2; i++) {
+    instant = target - (wallClockAsUtc(new Date(instant), timeZone) - instant);
+  }
+  return isoSeconds(new Date(instant));
+}
+
+// src/commands/ads/x/stats/sync.ts
+registerSchema({
+  command: "ads.x.statsSync",
+  description: "Synchronous analytics for an X Ads account (max 7 days). Use --preset for common queries or pass --entity, --entity-ids (CSV, max 20), --metric-groups (CSV), --start-time, --end-time, --granularity (DAY|HOUR|TOTAL), --placement (ALL_ON_TWITTER|PUBLISHER_NETWORK).",
+  args: {
+    "account-id": { type: "string", description: "X Ads account ID", required: false },
+    preset: { type: "string", description: "Use a stats preset (see --list-presets)", required: false },
+    "list-presets": { type: "boolean", description: "List available presets and exit", required: false },
+    days: { type: "string", description: "Override preset days (max 7)", required: false },
+    entity: { type: "string", description: "CAMPAIGN | LINE_ITEM | PROMOTED_TWEET | ...", required: false },
+    "entity-ids": { type: "string", description: "CSV of entity IDs (max 20)", required: false },
+    "start-time": { type: "string", description: "ISO 8601 hour-aligned start", required: false },
+    "end-time": { type: "string", description: "ISO 8601 hour-aligned end", required: false },
+    granularity: { type: "string", description: "TOTAL | DAY | HOUR", required: false },
+    "metric-groups": {
+      type: "string",
+      description: "CSV: ENGAGEMENT,BILLING,VIDEO,MEDIA,WEB_CONVERSION,MOBILE_CONVERSION,LIFE_TIME_VALUE_MOBILE_CONVERSION",
+      required: false
+    },
+    placement: { type: "string", description: "ALL_ON_TWITTER | PUBLISHER_NETWORK", required: false },
+    country: { type: "string", description: "Country filter (mobile_conversion only)", required: false },
+    platform: { type: "string", description: "Platform filter (mobile_conversion only)", required: false },
+    "no-cache": { type: "boolean", description: "Skip cache", required: false }
+  }
+});
+function parseCsv(v) {
+  if (typeof v !== "string" || v.length === 0) return void 0;
+  const parts = v.split(",").map((s) => s.trim()).filter(Boolean);
+  return parts.length > 0 ? parts : void 0;
+}
+var SYNC_MAX_DAYS = 7;
+function resolveQueryFromArgs(args, timeZone) {
+  let entity = args.entity;
+  let metricGroups = parseCsv(args["metric-groups"]);
+  let granularity = args.granularity ?? "DAY";
+  let placement = args.placement ?? "ALL_ON_TWITTER";
+  let startTime = args["start-time"];
+  let endTime = args["end-time"];
+  const hints = [];
+  if (args.preset) {
+    const preset = getPreset(args.preset);
+    if (!preset) {
+      return { error: `Unknown preset '${args.preset}'. Run with --list-presets to see options.` };
+    }
+    entity ??= preset.entity;
+    metricGroups ??= preset.metricGroups;
+    granularity = args.granularity ?? preset.granularity;
+    placement = args.placement ?? preset.placement;
+    const requested = args.days ? Number(args.days) : preset.defaultDays;
+    const days = Math.min(SYNC_MAX_DAYS, Math.max(1, requested));
+    if (requested > SYNC_MAX_DAYS) {
+      hints.push(
+        `Sync stats cover at most ${SYNC_MAX_DAYS} days, so '${preset.name}' was shortened to the last ${days}. For the full window run: baker ads x stats job --entity ${entity} --entity-ids <ids> --metric-groups ${metricGroups?.join(",")} --start-time <start> --end-time <end>`
+      );
+    }
+    const floor = granularity === "DAY" ? (d) => accountMidnightIso(d, timeZone) : isoHourFloor;
+    startTime ??= floor(days);
+    endTime ??= floor(0);
+  }
+  const entityIds = parseCsv(args["entity-ids"]);
+  if (!entity || !metricGroups || metricGroups.length === 0 || !startTime || !endTime || !entityIds) {
+    return {
+      error: "stats sync requires entity, entity-ids, metric-groups, start-time, end-time. Use --preset for defaults."
+    };
+  }
+  return { entity, metricGroups, granularity, placement, startTime, endTime, entityIds, hints };
+}
+async function runSync(args, accountId, q) {
+  const useCache = !args["no-cache"];
+  const body = {
+    accountId,
+    entity: q.entity,
+    entityIds: q.entityIds,
+    startTime: q.startTime,
+    endTime: q.endTime,
+    granularity: q.granularity,
+    metricGroups: q.metricGroups,
+    placement: q.placement,
+    country: args.country ?? void 0,
+    platform: args.platform ?? void 0,
+    skipCache: !useCache || void 0
+  };
+  const cacheKey = `stats-sync:${JSON.stringify(body)}`;
+  if (useCache) {
+    const cached = cacheGet("x-stats", cacheKey);
+    if (cached) {
+      writeAdsJson({ ok: true, data: cached.data, cached: true, ...q.hints.length ? { hints: q.hints } : {} });
+      return;
+    }
+  }
+  try {
+    const data = await apiPost("/api/ads/x/stats", body);
+    if (useCache) {
+      cacheSet("x-stats", cacheKey, data, 60 * 60 * 1e3);
+    }
+    writeAdsJson({ ok: true, data, ...q.hints.length ? { hints: q.hints } : {} });
+  } catch (err) {
+    if (err instanceof ApiError) {
+      writeAdsJson(parseXApiError(err.message, accountId));
+      process.exit(1);
+    }
+    writeAdsJson({ ok: false, error: { code: "NETWORK_ERROR", message: "Unexpected error" } });
+    process.exit(1);
+  }
+}
+var statsSyncCommand = defineCommand({
+  meta: {
+    name: "sync",
+    description: `Synchronous X Ads analytics (max 7-day window).
+
+Examples:
+  baker ads x stats sync --preset campaign-engagement-7d --account-id 18ce53xyz --entity-ids abc,def
+  baker ads x stats sync --account-id 18ce53xyz --entity LINE_ITEM --entity-ids abc \\
+    --start-time 2026-05-01T00:00:00Z --end-time 2026-05-07T00:00:00Z \\
+    --metric-groups ENGAGEMENT,BILLING --granularity DAY
+  baker ads x stats sync --list-presets`
+  },
+  args: {
+    "account-id": { type: "string", description: "X Ads account ID", required: false },
+    preset: { type: "string", description: "Stats preset name", required: false },
+    "list-presets": { type: "boolean", description: "List presets and exit", required: false },
+    days: { type: "string", description: "Override days (1\u20137)", required: false },
+    entity: { type: "string", description: "Entity type", required: false },
+    "entity-ids": { type: "string", description: "CSV of entity IDs", required: false },
+    "start-time": { type: "string", description: "ISO 8601 start", required: false },
+    "end-time": { type: "string", description: "ISO 8601 end", required: false },
+    granularity: { type: "string", description: "Granularity", required: false },
+    "metric-groups": { type: "string", description: "Metric groups CSV", required: false },
+    placement: { type: "string", description: "Placement", required: false },
+    country: { type: "string", description: "Country filter", required: false },
+    platform: { type: "string", description: "Platform filter", required: false },
+    "no-cache": { type: "boolean", description: "Skip cache", required: false }
+  },
+  run: async ({ args }) => {
+    if (args["list-presets"]) {
+      writeAdsJson({ ok: true, data: X_STATS_PRESETS });
+      return;
+    }
+    const accountId = await resolveXAccountId(args);
+    const timeZone = await resolveXAccountTimezone(accountId, args);
+    const resolved = resolveQueryFromArgs(args, timeZone);
+    if ("error" in resolved) {
+      writeAdsJson({ ok: false, error: { code: "INVALID_PARAMETER", message: resolved.error } });
+      process.exit(1);
+    }
+    await runSync(args, accountId, resolved);
+  }
+});
+export {
+  statsSyncCommand
+};
+//# sourceMappingURL=sync-W3XDDTRG.js.map

package/dist/sync-definition-K6UMLDZF.js

@@ -0,0 +1,52 @@
+import {
+  buildDefinitionSyncPayload,
+  readDefinitionSeriesPlace,
+  readDefinitionSourceFields,
+  readDefinitionStrategyFields,
+  readDefinitionTitle,
+  resolveCanvasPath,
+  syncCreativeDefinitionBestEffort,
+  syncDefinitionCommand
+} from "./chunk-2EINLGUZ.js";
+import "./chunk-32JOLCMG.js";
+import "./chunk-MSJKALUF.js";
+import "./chunk-WNTVBUVI.js";
+import "./chunk-377O74GF.js";
+import "./chunk-ZZMP35QD.js";
+import "./chunk-ME6PYW77.js";
+import "./chunk-FUHGPB4S.js";
+import "./chunk-SKZW5R2C.js";
+import "./chunk-XIWPSGSG.js";
+import "./chunk-UE2RCK6D.js";
+import "./chunk-3GGDOCKZ.js";
+import "./chunk-L5MTH7DH.js";
+import "./chunk-DGCUPJZD.js";
+import "./chunk-5SHXEZ3V.js";
+import "./chunk-CHSNHVYF.js";
+import "./chunk-PGI4HVLR.js";
+import "./chunk-5HYSKH77.js";
+import "./chunk-KIGGMKAE.js";
+import "./chunk-X5FJVZF4.js";
+import "./chunk-W6ZA67TV.js";
+import "./chunk-PP3IOXY3.js";
+import "./chunk-A7VSSDMJ.js";
+import "./chunk-WXC3I4CT.js";
+import "./chunk-GXDLWBOY.js";
+import "./chunk-GIWHHCD6.js";
+import "./chunk-XQIOCIDO.js";
+import "./chunk-ML7DLFFY.js";
+import "./chunk-7QDVAEB6.js";
+import "./chunk-NVBBZPJP.js";
+import "./chunk-KCA5CDCU.js";
+import "./chunk-YQSBHWOI.js";
+export {
+  buildDefinitionSyncPayload,
+  readDefinitionSeriesPlace,
+  readDefinitionSourceFields,
+  readDefinitionStrategyFields,
+  readDefinitionTitle,
+  resolveCanvasPath,
+  syncCreativeDefinitionBestEffort,
+  syncDefinitionCommand
+};
+//# sourceMappingURL=sync-definition-K6UMLDZF.js.map

package/dist/tag-manager-GGZQZQ4P.js

@@ -0,0 +1,43 @@
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/tag-manager/index.ts
+import { defineCommand } from "citty";
+var tagManagerCommand = defineCommand({
+  meta: {
+    name: "tag-manager",
+    description: `Read and change what lives inside the client's Google Tag Manager container \u2014 tags, triggers, variables, folders and built-in variables.
+
+Start here:
+  baker tag-manager read                       \u2014 see what the container holds today
+
+Then stage changes (nothing is sent to Tag Manager until publish):
+  baker tag-manager trigger create --json '{"name":"Quote Submit","type":"customEvent"}'
+  baker tag-manager tag create --json '{"name":"GA4 Quote","type":"gaawe","firingTriggerId":["gtm_temp_trigger_..."]}'
+  baker tag-manager draft list                 \u2014 review everything staged
+
+On publish, staged changes are written into the container and closed as a new Tag Manager
+version, and a clean run PUBLISHES that version \u2014 so the changes go live on the user's site.
+Say they go live when the user publishes the chat; never that they are live already, and never
+that someone still has to approve them inside Tag Manager. (If the publish call itself fails the
+version stands unpublished, and \`draft list\` says so and what is left to do.)
+
+This owns the CONTENTS of the container. Installing the container snippet on the site is a
+different job \u2014 that is \`baker tags\` with the googleTagManager tag.
+
+Full guide: __tooling__/docs/tools/baker/tag-manager.md`
+  },
+  subCommands: {
+    containers: () => import("./read-IFX7QZNP.js").then((m) => m.containersCommand),
+    read: () => import("./read-IFX7QZNP.js").then((m) => m.readCommand),
+    tag: () => import("./write-commands-HHOB5UCJ.js").then((m) => m.tagCommand),
+    trigger: () => import("./write-commands-HHOB5UCJ.js").then((m) => m.triggerCommand),
+    variable: () => import("./write-commands-HHOB5UCJ.js").then((m) => m.variableCommand),
+    folder: () => import("./write-commands-HHOB5UCJ.js").then((m) => m.folderCommand),
+    builtin: () => import("./write-commands-HHOB5UCJ.js").then((m) => m.builtinCommand),
+    draft: () => import("./draft-55QRG3MW.js").then((m) => m.draftCommand)
+  }
+});
+export {
+  tagManagerCommand
+};
+//# sourceMappingURL=tag-manager-GGZQZQ4P.js.map

package/dist/tags-AWO5FFGM.js

@@ -0,0 +1,224 @@
+import {
+  CHAT_READ_ARG
+} from "./chunk-PFBQERWX.js";
+import {
+  TAG_IDENTIFYING_FIELD
+} from "./chunk-WXC3I4CT.js";
+import "./chunk-GXDLWBOY.js";
+import "./chunk-GIWHHCD6.js";
+import "./chunk-XQIOCIDO.js";
+import "./chunk-ML7DLFFY.js";
+import {
+  ApiError,
+  apiPost
+} from "./chunk-CK5ZNZ3I.js";
+import "./chunk-7QDVAEB6.js";
+import {
+  requireChatId,
+  resolveChatId
+} from "./chunk-NVBBZPJP.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-KCA5CDCU.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/tags/index.ts
+import { defineCommand } from "citty";
+
+// src/commands/tags/shared.ts
+function failApi(err) {
+  if (err instanceof ApiError) {
+    writeJson({ ok: false, error: { code: err.code, message: err.message } });
+    process.exit(1);
+  }
+  if (err instanceof Error) {
+    writeJson({ ok: false, error: { code: "INTERNAL_ERROR", message: err.message } });
+    process.exit(1);
+  }
+  writeJson({ ok: false, error: { code: "INTERNAL_ERROR", message: "Unexpected error" } });
+  process.exit(1);
+}
+function failValidation(message) {
+  writeJson({ ok: false, error: { code: "VALIDATION_ERROR", message } });
+  process.exit(1);
+}
+function renderConfigValue(value) {
+  return value.includes("\n") ? value.replace(/\n/g, "\n      ") : value;
+}
+function renderEffectiveEntry(entry) {
+  const parts = [entry.ref, entry.type];
+  if (entry.identifier !== void 0) {
+    parts.push(entry.identifier);
+  }
+  if (entry.staged !== void 0) {
+    parts.push(`[staged: ${entry.staged}]`);
+  }
+  const secretBits = [
+    ...entry.secretsSet.map((field) => `${field} \u2713 set`),
+    ...entry.secretsPending.map((field) => `${field} \u23F3 pending`)
+  ];
+  if (secretBits.length > 0) {
+    parts.push(`[secrets: ${secretBits.join(", ")}]`);
+  }
+  const header = parts.join("  ");
+  const identifyingField = TAG_IDENTIFYING_FIELD[entry.type];
+  const configLines = Object.entries(entry.config).filter(([key]) => key !== identifyingField).map(([key, value]) => `    ${key}: ${renderConfigValue(value)}`);
+  return configLines.length > 0 ? `${header}
+${configLines.join("\n")}` : header;
+}
+function tagsListHints() {
+  return [
+    "To create, edit or delete a tag, call the `request_tag_input` approval form (tool `mcp__baker_ui__request_tag_input`, server `baker_ui`) \u2014 it is attached to every turn of this chat and collects any secret values itself.",
+    "Don't conclude the form is unavailable from your tool list: call it, and report what it returns. And never file a tag change as a Task \u2014 a Task hands the user work this chat can stage in one call."
+  ];
+}
+
+// src/commands/tags/index.ts
+registerSchema({
+  command: "tags.list",
+  description: "Effective marketing tags for this chat: production tags overlaid with the changes staged in this chat. Prints each tag's readable config in full (secrets are never included) \u2014 e.g. the Clarity projectId, GA4 measurementId, or the entire custom `code` snippet \u2014 so reuse a stored value to pre-fill a follow-up change instead of asking the user for something we already have. The printed refs (tag ids or tag_temp_*) are exactly what flow side-effect tagIds should reference. Read-only \u2014 every tag change (create, edit, delete) goes through the request_tag_input approval tool; `baker tags unstage` takes back one this chat staged.",
+  args: {
+    json: { type: "boolean", description: "Print the raw JSON envelope instead of the readable list", required: false }
+  }
+});
+async function listTags(json) {
+  try {
+    const chatId = requireChatId();
+    const response = await apiPost("/api/tags/list", { chatId });
+    const hints = tagsListHints();
+    if (json) {
+      writeJson({ ok: true, data: response, hints });
+      return;
+    }
+    if (response.tags.length === 0) {
+      process.stdout.write("No tags configured.\n");
+    } else {
+      process.stdout.write(`${response.tags.map(renderEffectiveEntry).join("\n")}
+`);
+    }
+    for (const hint of hints) {
+      process.stderr.write(`${hint}
+`);
+    }
+  } catch (err) {
+    failApi(err);
+  }
+}
+var listArgs = {
+  json: { type: "boolean", description: "Print the raw JSON envelope instead of the readable list" }
+};
+var listCommand = defineCommand({
+  meta: {
+    name: "list",
+    description: "Effective tags for this chat (production + staged), with each tag's full readable config (secrets excluded) \u2014 reuse a stored value to pre-fill a change rather than asking the user. Refs printed here are what flow side-effect tagIds should use. Example: baker tags list"
+  },
+  args: listArgs,
+  run: async ({ args }) => {
+    await listTags(args.json === true);
+  }
+});
+async function listDraft(chat) {
+  try {
+    const chatId = resolveChatId(chat);
+    const response = await apiPost("/api/tags/draft", { chatId });
+    writeJson({ ok: true, data: response, hints: tagsListHints() });
+  } catch (err) {
+    failApi(err);
+  }
+}
+var draftCommand = defineCommand({
+  meta: {
+    name: "draft",
+    description: "Review the tag changes staged in this chat (read-only). Staged changes were approved via request_tag_input and apply when the chat is published. To drop one, `baker tags unstage <ref>` with the ref printed here (or --all); to amend one, propose a follow-up change through the same tool. Takes --chat <id> to read an earlier chat's staged changes instead."
+  },
+  args: { chat: CHAT_READ_ARG },
+  run: async ({ args }) => {
+    await listDraft(args.chat);
+  }
+});
+registerSchema({
+  command: "tags.unstage",
+  description: "Take back a tag change this chat staged, before Publish \u2014 the same as discarding its row in the change review. Pass the ref `baker tags draft` prints (a tag id, or tag_temp_* for a staged create), or --all for every staged tag change. Taking back a staged create also drops the secrets the user entered for it. Never touches a live tag: to change or remove one, propose the change through request_tag_input.",
+  args: {
+    ref: { type: "string", description: "The staged change's ref, from `baker tags draft`", required: false },
+    all: { type: "boolean", description: "Take back every tag change staged in this chat", required: false }
+  }
+});
+function unstageBody(args, chatId) {
+  const ref = args.ref?.trim();
+  if (args.all === true && ref) {
+    failValidation("Pass one ref to take back that change, or --all for every staged tag change \u2014 not both.");
+  }
+  if (args.all === true) {
+    return { chatId, all: true };
+  }
+  if (!ref) {
+    failValidation("Pass the ref of the staged change (from `baker tags draft`), or --all.");
+  }
+  return { chatId, ref };
+}
+var unstageCommand = defineCommand({
+  meta: {
+    name: "unstage",
+    description: "Take back a tag change this chat staged, before Publish. Examples: baker tags unstage tag_temp_abc123 | baker tags unstage --all"
+  },
+  args: {
+    ref: { type: "positional", description: "The staged change's ref, from `baker tags draft`", required: false },
+    all: { type: "boolean", description: "Take back every tag change staged in this chat", required: false }
+  },
+  run: async ({ args }) => {
+    try {
+      const body = unstageBody(
+        {
+          ...typeof args.ref === "string" ? { ref: args.ref } : {},
+          ...args.all === true ? { all: true } : {}
+        },
+        requireChatId()
+      );
+      const response = await apiPost("/api/tags/draft-op/remove", body);
+      writeJson({
+        ...response,
+        hints: ["Taken back: it does not apply when the chat is published. Live tags are unchanged."]
+      });
+    } catch (err) {
+      failApi(err);
+    }
+  }
+});
+var tagsCommand = defineCommand({
+  meta: {
+    name: "tags",
+    description: `Read the client's marketing/analytics tags (Meta pixel, GA4, Google Ads, GTM, Clarity, Hotjar, \u2026) \u2014 production tags plus the changes staged in this chat.
+
+Every tag change \u2014 create, edit, or delete \u2014 goes through the request_tag_input tool (baker_ui MCP server): propose one or more changes (each becomes a tab in one approval form), pre-fill the non-secret fields you know, and the user reviews, fills secrets, and approves or skips each. Secret values (accessToken, apiSecret, authorizationToken, apiKey, conversionToken, OAuth connections) never pass through the CLI or the chat.
+
+Refs: \`baker tags list\` prints each tag's ref \u2014 a real tag id, or tag_temp_* for creates staged in this chat. Use these refs as flow side-effect tagIds; they keep resolving after publish.
+
+\`baker tags list\` prints each tag's readable config in full (secrets excluded) \u2014 the Clarity projectId, GA4 measurementId, the whole custom \`code\` snippet, etc. Reuse a stored value to pre-fill a follow-up change instead of asking the user for something already installed.
+
+To take back a change this chat staged (before Publish), \`baker tags unstage <ref>\` \u2014 the ref \`baker tags draft\` prints \u2014 or \`--all\`. It never touches a live tag.
+
+Examples:
+  baker tags list       # production + staged, full readable config + secret status
+  baker tags draft      # review the staged changes awaiting publish
+  baker tags unstage tag_temp_abc123   # take back one staged change
+Full guide: __tooling__/docs/tools/baker/tags.md`
+  },
+  subCommands: {
+    list: listCommand,
+    draft: draftCommand,
+    unstage: unstageCommand
+  },
+  // Bare `baker tags` lists the effective tags. `args` stays so citty knows this
+  // command's flags when it scans rawArgs for a subcommand name, and `default` (not
+  // `run`) dispatches the bare invocation — citty falls through to `run` after a
+  // subcommand, so a `run` here would also list on every `baker tags draft`.
+  args: listArgs,
+  default: "list"
+});
+export {
+  tagsCommand,
+  unstageBody
+};
+//# sourceMappingURL=tags-AWO5FFGM.js.map

package/dist/tags-DGLT344J.js

@@ -0,0 +1,20 @@
+import {
+  makeTagsCommand
+} from "./chunk-WWCQBHDC.js";
+import "./chunk-WXC3I4CT.js";
+import "./chunk-GXDLWBOY.js";
+import "./chunk-GIWHHCD6.js";
+import "./chunk-XQIOCIDO.js";
+import "./chunk-ML7DLFFY.js";
+import "./chunk-CK5ZNZ3I.js";
+import "./chunk-7QDVAEB6.js";
+import "./chunk-NVBBZPJP.js";
+import "./chunk-KCA5CDCU.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/images/tags.ts
+var tagsCommand = makeTagsCommand("images", "image", "/api/images/tags");
+export {
+  tagsCommand
+};
+//# sourceMappingURL=tags-DGLT344J.js.map

package/dist/tags-NBUNSN5L.js

@@ -0,0 +1,20 @@
+import {
+  makeTagsCommand
+} from "./chunk-WWCQBHDC.js";
+import "./chunk-WXC3I4CT.js";
+import "./chunk-GXDLWBOY.js";
+import "./chunk-GIWHHCD6.js";
+import "./chunk-XQIOCIDO.js";
+import "./chunk-ML7DLFFY.js";
+import "./chunk-CK5ZNZ3I.js";
+import "./chunk-7QDVAEB6.js";
+import "./chunk-NVBBZPJP.js";
+import "./chunk-KCA5CDCU.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/testimonials/tags.ts
+var tagsCommand = makeTagsCommand("testimonials", "testimonial", "/api/testimonials/tags");
+export {
+  tagsCommand
+};
+//# sourceMappingURL=tags-NBUNSN5L.js.map

package/dist/tags-NBVQWFS2.js

@@ -0,0 +1,26 @@
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/actions/tags/index.ts
+import { defineCommand } from "citty";
+var tagsCommand = defineCommand({
+  meta: {
+    name: "tags",
+    description: `Manage the action tag taxonomy (built-in defaults + company custom tags). Tags are strict \u2014 only listed names work with --tags on create/update.
+
+Examples:
+  baker actions tags list                                  # available tags (defaults + custom)
+  baker actions tags create --slug pmax --description "\u2026"   # mint a custom tag
+  baker actions tags update --slug pmax --description "\u2026"   # change what it means
+  baker actions tags delete --slug pmax                     # remove a custom tag`
+  },
+  subCommands: {
+    list: () => import("./list-JNRFSARX.js").then((m) => m.tagsListCommand),
+    create: () => import("./create-5NLAAJE4.js").then((m) => m.tagsCreateCommand),
+    update: () => import("./update-PMFYYMFX.js").then((m) => m.tagsUpdateCommand),
+    delete: () => import("./delete-7MNFMQ6X.js").then((m) => m.tagsDeleteCommand)
+  }
+});
+export {
+  tagsCommand
+};
+//# sourceMappingURL=tags-NBVQWFS2.js.map

package/dist/tags-ZOK7CY4V.js

@@ -0,0 +1,20 @@
+import {
+  makeTagsCommand
+} from "./chunk-WWCQBHDC.js";
+import "./chunk-WXC3I4CT.js";
+import "./chunk-GXDLWBOY.js";
+import "./chunk-GIWHHCD6.js";
+import "./chunk-XQIOCIDO.js";
+import "./chunk-ML7DLFFY.js";
+import "./chunk-CK5ZNZ3I.js";
+import "./chunk-7QDVAEB6.js";
+import "./chunk-NVBBZPJP.js";
+import "./chunk-KCA5CDCU.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/videos/tags.ts
+var tagsCommand = makeTagsCommand("videos", "video", "/api/videos/tags");
+export {
+  tagsCommand
+};
+//# sourceMappingURL=tags-ZOK7CY4V.js.map