@koda-sl/baker-cli 0.449.0 → 0.450.0-dev.b454c3dd2

package/dist/stale-W756ACKC.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/commands/canvas/stale.ts"],"sourcesContent":["import { defineCommand } from \"citty\";\nimport { findWorkspaceRoot } from \"./normalize-paths.ts\";\nimport { staleCreatives } from \"./render-state.ts\";\n\nexport const staleCommand = defineCommand({\n  meta: {\n    name: \"stale\",\n    description:\n      \"List the creatives edited since their last render in this workspace: what the models would be sent (the projected canvas, prompt.json without its `reference`/`source_context`/`notes` bookkeeping, scenes/*.json, the compositions it renders, the formats in _definition.md) no longer matches what the last completed `baker canvas run` drew, so the preview shows an older creative. Reformatting a file is not an edit. Read-only, offline and free. During a turn, re-render each one listed that the person should see with `baker canvas run <canvasPath>`. During a publish, never: Publish ships the last version the person was shown. Creatives never rendered here and half-built ones (unfilled [TODO] asset slots) are not listed.\",\n  },\n  args: {},\n  async run() {\n    const cwd = process.cwd();\n    const stale = await staleCreatives(findWorkspaceRoot(cwd) ?? cwd);\n    process.stdout.write(\n      `${JSON.stringify(\n        {\n          ok: true,\n          data: { stale },\n          ...(stale.length > 0\n            ? { hints: stale.map((c) => `Re-render ${c.slug} before showing it (never during a publish): baker canvas run ${c.canvasPath}`) }\n            : {}),\n        },\n        null,\n        2,\n      )}\\n`,\n    );\n  },\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,SAAS,qBAAqB;AAIvB,IAAM,eAAe,cAAc;AAAA,EACxC,MAAM;AAAA,IACJ,MAAM;AAAA,IACN,aACE;AAAA,EACJ;AAAA,EACA,MAAM,CAAC;AAAA,EACP,MAAM,MAAM;AACV,UAAM,MAAM,QAAQ,IAAI;AACxB,UAAM,QAAQ,MAAM,eAAe,kBAAkB,GAAG,KAAK,GAAG;AAChE,YAAQ,OAAO;AAAA,MACb,GAAG,KAAK;AAAA,QACN;AAAA,UACE,IAAI;AAAA,UACJ,MAAM,EAAE,MAAM;AAAA,UACd,GAAI,MAAM,SAAS,IACf,EAAE,OAAO,MAAM,IAAI,CAAC,MAAM,aAAa,EAAE,IAAI,iEAAiE,EAAE,UAAU,EAAE,EAAE,IAC9H,CAAC;AAAA,QACP;AAAA,QACA;AAAA,QACA;AAAA,MACF,CAAC;AAAA;AAAA,IACH;AAAA,EACF;AACF,CAAC;","names":[]}

package/dist/status-SE2VZJJB.js

@@ -0,0 +1,63 @@
+import {
+  failApi,
+  failValidation
+} from "./chunk-SJYEY5MV.js";
+import "./chunk-7EPXVICM.js";
+import "./chunk-GXDLWBOY.js";
+import "./chunk-TEINLN64.js";
+import "./chunk-ZJWUBJYQ.js";
+import "./chunk-HR6IWNKE.js";
+import "./chunk-NE4F3FHN.js";
+import {
+  apiPost
+} from "./chunk-XBOK23HI.js";
+import "./chunk-IFWP3ZDO.js";
+import {
+  getEnv
+} from "./chunk-NAWWC5I3.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-NU7JSWVA.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/actions/status.ts
+import { defineCommand } from "citty";
+registerSchema({
+  command: "actions.status",
+  description: "Resolve one or more Work Action refs by real action ID or temp_* ref in a single batch call. When BAKER_CHAT_ID is set, a temp_* ref still staged in THIS chat resolves to status 'draft' (not 'not_found') \u2014 staged ops only become published actions on chat publish.",
+  args: {
+    ref: {
+      type: "positional",
+      description: "One or more action refs: real action IDs or temp_* refs (space-separated)",
+      required: true
+    }
+  }
+});
+var statusCommand = defineCommand({
+  meta: {
+    name: "status",
+    description: "Resolve Work Action refs by real ID or temp_* ref. Example: baker actions status temp_hero jx123"
+  },
+  args: {
+    ref: { type: "positional", description: "Action ID or temp_* ref; accepts multiple refs", required: false }
+  },
+  run: async ({ args }) => {
+    try {
+      const refs = [args.ref, ...Array.isArray(args._) ? args._ : []].filter((ref) => typeof ref === "string").map((ref) => ref.trim()).filter(Boolean);
+      if (refs.length === 0) {
+        failValidation("At least one action ref is required.");
+      }
+      const { BAKER_CHAT_ID } = getEnv();
+      const body = BAKER_CHAT_ID ? { refs, chatId: BAKER_CHAT_ID } : { refs };
+      const response = await apiPost("/api/actions/status", body);
+      writeJson(response);
+    } catch (err) {
+      failApi(err);
+    }
+  }
+});
+export {
+  statusCommand
+};
+//# sourceMappingURL=status-SE2VZJJB.js.map

package/dist/status-SE2VZJJB.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/commands/actions/status.ts"],"sourcesContent":["import type { ActionsStatusResponse } from \"@baker/api\";\nimport { defineCommand } from \"citty\";\nimport { apiPost } from \"../../client.ts\";\nimport { getEnv } from \"../../env.ts\";\nimport { writeJson } from \"../../output.ts\";\nimport { registerSchema } from \"../../schemas.ts\";\nimport { failApi, failValidation } from \"./shared.ts\";\n\nregisterSchema({\n  command: \"actions.status\",\n  description:\n    \"Resolve one or more Work Action refs by real action ID or temp_* ref in a single batch call. When BAKER_CHAT_ID is set, a temp_* ref still staged in THIS chat resolves to status 'draft' (not 'not_found') — staged ops only become published actions on chat publish.\",\n  args: {\n    ref: {\n      type: \"positional\",\n      description: \"One or more action refs: real action IDs or temp_* refs (space-separated)\",\n      required: true,\n    },\n  },\n});\n\nexport const statusCommand = defineCommand({\n  meta: {\n    name: \"status\",\n    description: \"Resolve Work Action refs by real ID or temp_* ref. Example: baker actions status temp_hero jx123\",\n  },\n  args: {\n    ref: { type: \"positional\", description: \"Action ID or temp_* ref; accepts multiple refs\", required: false },\n  },\n  run: async ({ args }) => {\n    try {\n      const refs = [args.ref, ...(Array.isArray(args._) ? args._ : [])]\n        .filter((ref): ref is string => typeof ref === \"string\")\n        .map((ref) => ref.trim())\n        .filter(Boolean);\n      if (refs.length === 0) {\n        failValidation(\"At least one action ref is required.\");\n      }\n\n      // Pass the caller's own chat (if any) so temps still staged in THIS chat\n      // resolve to \"draft\". status stays usable without a chat — temps just\n      // resolve to not_found until published, as before.\n      const { BAKER_CHAT_ID } = getEnv();\n      const body = BAKER_CHAT_ID ? { refs, chatId: BAKER_CHAT_ID } : { refs };\n      const response = await apiPost<ActionsStatusResponse>(\"/api/actions/status\", body);\n      writeJson(response);\n    } catch (err) {\n      failApi(err);\n    }\n  },\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AACA,SAAS,qBAAqB;AAO9B,eAAe;AAAA,EACb,SAAS;AAAA,EACT,aACE;AAAA,EACF,MAAM;AAAA,IACJ,KAAK;AAAA,MACH,MAAM;AAAA,MACN,aAAa;AAAA,MACb,UAAU;AAAA,IACZ;AAAA,EACF;AACF,CAAC;AAEM,IAAM,gBAAgB,cAAc;AAAA,EACzC,MAAM;AAAA,IACJ,MAAM;AAAA,IACN,aAAa;AAAA,EACf;AAAA,EACA,MAAM;AAAA,IACJ,KAAK,EAAE,MAAM,cAAc,aAAa,kDAAkD,UAAU,MAAM;AAAA,EAC5G;AAAA,EACA,KAAK,OAAO,EAAE,KAAK,MAAM;AACvB,QAAI;AACF,YAAM,OAAO,CAAC,KAAK,KAAK,GAAI,MAAM,QAAQ,KAAK,CAAC,IAAI,KAAK,IAAI,CAAC,CAAE,EAC7D,OAAO,CAAC,QAAuB,OAAO,QAAQ,QAAQ,EACtD,IAAI,CAAC,QAAQ,IAAI,KAAK,CAAC,EACvB,OAAO,OAAO;AACjB,UAAI,KAAK,WAAW,GAAG;AACrB,uBAAe,sCAAsC;AAAA,MACvD;AAKA,YAAM,EAAE,cAAc,IAAI,OAAO;AACjC,YAAM,OAAO,gBAAgB,EAAE,MAAM,QAAQ,cAAc,IAAI,EAAE,KAAK;AACtE,YAAM,WAAW,MAAM,QAA+B,uBAAuB,IAAI;AACjF,gBAAU,QAAQ;AAAA,IACpB,SAAS,KAAK;AACZ,cAAQ,GAAG;AAAA,IACb;AAAA,EACF;AACF,CAAC;","names":[]}

package/dist/stock-KXJ26BY4.js

@@ -0,0 +1,179 @@
+import {
+  AUTO_INGEST_MAX,
+  parseAutoIngest
+} from "./chunk-KKJ4KJCW.js";
+import {
+  activeFilterFlags,
+  emptyResultHints
+} from "./chunk-Q6ULQMWG.js";
+import {
+  ApiError,
+  apiPost
+} from "./chunk-XBOK23HI.js";
+import "./chunk-IFWP3ZDO.js";
+import "./chunk-NAWWC5I3.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-NU7JSWVA.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/images/stock.ts
+import { defineCommand } from "citty";
+var STOCK_ERROR_FIX = {
+  action: "use_different_resource",
+  explanation: "Switch provider instead of retrying stock search. Stock search is one of several image sources. Run `baker images find <query> --sources library,pinterest,google` (`--sources` is required \u2014 `find` alone searches the library only) or `baker studio generate` to make the asset. Never sleep-and-retry this command \u2014 the CLI already backs off on rate limits. If no image can be sourced, continue the rest of the task with a placeholder rather than aborting it."
+};
+registerSchema({
+  command: "images.stock",
+  description: "Stock search across the free libraries \u2014 Pexels photos plus Pixabay photos, illustrations and vectors. The previous provider's --license, --ai, --people and --order do not exist here: everything both libraries hold is free for commercial use with no attribution, neither indexes AI-generated content separately, neither has a people filter (name the person in the query instead), and both sort by relevance only.",
+  args: {
+    query: { type: "string", description: "Search query", required: true },
+    type: {
+      type: "string",
+      description: "Content type: photo (default, both libraries) | illustration | vector (Pixabay only)",
+      required: false,
+      enum: ["photo", "illustration", "vector"]
+    },
+    orientation: {
+      type: "string",
+      description: "landscape | portrait | square (square searches Pexels only \u2014 Pixabay has no square)",
+      required: false,
+      enum: ["landscape", "portrait", "square"]
+    },
+    size: {
+      type: "string",
+      description: "Minimum resolution: large (24MP) | medium (12MP) | small (4MP)",
+      required: false,
+      enum: ["large", "medium", "small"]
+    },
+    color: {
+      type: "string",
+      description: "Colour filter \u2014 a name (red, turquoise, black, \u2026) searches both libraries; a hex code such as '#0a0a0a' searches Pexels only",
+      required: false
+    },
+    locale: {
+      type: "string",
+      description: "Locale of the search terms, e.g. 'es-ES' or 'de-DE' \u2014 Pexels matches translated tags",
+      required: false
+    },
+    limit: { type: "number", description: "Max results (1-80, default 10)", required: false, default: 10 },
+    page: { type: "number", description: "Page number for pagination", required: false },
+    "auto-ingest": {
+      type: "number",
+      description: `Auto-ingest top N hits (0-${AUTO_INGEST_MAX.stock}, default 0) and return Baker-owned URLs on ingested hits`,
+      required: false,
+      default: 0
+    },
+    context: {
+      type: "string",
+      description: "Free-text hint applied to every auto-ingested hit (overrides the library's own alt text or tags)",
+      required: false
+    }
+  }
+});
+function buildStockRequest(query, args) {
+  const body = { query };
+  if (args.type) body.contentType = args.type;
+  if (args.orientation) body.orientation = args.orientation;
+  if (args.size) body.size = args.size;
+  if (args.color) body.color = args.color;
+  if (args.locale) body.locale = args.locale;
+  if (args.limit) body.limit = Number(args.limit);
+  if (args.page) body.page = Number(args.page);
+  if (args["auto-ingest"]) body.autoIngest = Number(args["auto-ingest"]);
+  if (args.context) body.descriptionContext = args.context;
+  return body;
+}
+function partialLibraryHints(errors, hitCount) {
+  if (!errors || errors.length === 0) return [];
+  const sources = errors.map((e) => e.source);
+  const names = sources.join(", ");
+  if (hitCount === 0) {
+    const failed = sources.length === 1 ? `${sources[0]} did not answer` : `none of ${names} answered`;
+    return [
+      `Stock search did not run \u2014 ${failed}. This is an outage, not an empty result: do not re-run it with a different query or flags, and report that stock search is unavailable. Source the asset another way (\`baker images find <query> --sources library,pinterest,google\`) or \`baker studio generate\`.`
+    ];
+  }
+  return [
+    `These results are partial: ${names} did not answer, so they come from the remaining library alone. Treat a thin result as unproven rather than as "stock does not have this", and report the outage rather than re-running the search.`
+  ];
+}
+var stockCommand = defineCommand({
+  meta: {
+    name: "stock",
+    description: "Stock search across the free libraries \u2014 Pexels photographs plus Pixabay photographs, illustrations and vectors. No per-request cost. With --auto-ingest, ingested hits return Baker-owned URLs.\n\nExamples:\n  baker images stock 'minimalist office'\n  baker images stock 'hero photo of a kitchen' --orientation landscape --size large\n  baker images stock 'flat office workers' --type illustration\n  baker images stock 'leaf outline mark' --type vector\n  baker images stock 'smiling carpenter portrait' --orientation portrait"
+  },
+  args: {
+    query: { type: "positional", description: "Search query", required: false },
+    type: { type: "string", description: "photo|illustration|vector", required: false },
+    orientation: { type: "string", description: "landscape|portrait|square", required: false },
+    size: { type: "string", description: "Minimum resolution: large|medium|small", required: false },
+    color: { type: "string", description: "Colour name or hex code", required: false },
+    locale: { type: "string", description: "Locale of the search terms, e.g. es-ES", required: false },
+    limit: { type: "string", description: "Max results (1-80)", required: false },
+    page: { type: "string", description: "Page number", required: false },
+    "auto-ingest": {
+      type: "string",
+      description: `Auto-ingest top N (0-${AUTO_INGEST_MAX.stock}) and return Baker-owned URLs on ingested hits`,
+      required: false
+    },
+    context: { type: "string", description: "Description context hint applied to auto-ingested hits", required: false }
+  },
+  run: async ({ args }) => {
+    try {
+      const query = args.query;
+      if (!query) {
+        writeJson({ ok: false, error: { code: "VALIDATION_ERROR", message: "Query is required" } });
+        process.exit(1);
+      }
+      if (args["auto-ingest"] !== void 0) {
+        const parsed = parseAutoIngest(args["auto-ingest"], AUTO_INGEST_MAX.stock);
+        if (!parsed.ok) {
+          writeJson({
+            ok: false,
+            error: {
+              code: "VALIDATION_ERROR",
+              message: parsed.message,
+              fix: {
+                action: "retry_with_changes",
+                explanation: `Re-run with --auto-ingest in 0-${AUTO_INGEST_MAX.stock}.`
+              }
+            }
+          });
+          process.exit(1);
+        }
+      }
+      const data = await apiPost("/api/images/stock", buildStockRequest(query, args));
+      const outage = (data.errors?.length ?? 0) > 0 && data.hits.length === 0;
+      const hints = [
+        ...partialLibraryHints(data.errors, data.hits.length),
+        ...outage ? [] : emptyResultHints({
+          provider: "stock",
+          hitCount: data.hits.length,
+          activeFilters: activeFilterFlags(args, ["type", "orientation", "size", "color", "locale"])
+        })
+      ];
+      writeJson({ ok: true, data, ...hints.length ? { hints } : {} });
+    } catch (err) {
+      if (err instanceof ApiError) {
+        writeJson({
+          ok: false,
+          error: {
+            code: err.code,
+            message: err.message,
+            fix: STOCK_ERROR_FIX
+          }
+        });
+        process.exit(1);
+      }
+      writeJson({ ok: false, error: { code: "INTERNAL_ERROR", message: "Unexpected error" } });
+      process.exit(1);
+    }
+  }
+});
+export {
+  partialLibraryHints,
+  stockCommand
+};
+//# sourceMappingURL=stock-KXJ26BY4.js.map

package/dist/studio-SYKOSNDB.js

@@ -0,0 +1,49 @@
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/studio/index.ts
+import { defineCommand } from "citty";
+var studioCommand = defineCommand({
+  meta: {
+    name: "studio",
+    description: `Make new imagery and clips. Every batch is recorded and shows up in the dashboard Studio for the client to review, labelled with this conversation.
+
+Make something:
+  baker studio generate <prompt> [--reference ids,paths,urls] [--model \u2026] [--aspect-ratio \u2026] [--count N]
+                                        Render 1-8 takes of one still; each is ingested into the media library as it lands
+  baker studio animate <prompt> --image <id|path|url,\u2026>
+                                        Turn a still into a clip \u2014 the prompt describes MOVEMENT, not the look
+  baker studio skills                   Craft directions you can pass to --skill
+  baker studio improve <prompt>         Sharpen a rough brief (use it for the CLIENT's words, not your own)
+
+Know what you can ask for:
+  baker studio models [--kind video] [--model <id>]
+                                        Per model: shapes, resolutions, clip lengths, prompt cap, reference limit, every knob
+
+Review and pick:
+  baker studio get <generationId>       One batch: every take, its url, whether it is in the library, why one failed
+  baker studio list [--kind image|video] [--all]
+                                        Recent batches for this conversation (--all = the whole company)
+  baker studio keep <generationId> --slot N
+                                        Mark the keeper. Stars an image; INGESTS a clip into the video library
+
+Three rules worth remembering:
+  - --reference is the biggest quality lever there is. Ground a render in a real logo, product shot or mood image.
+  - A clip is not usable anywhere until it is kept. Unkept takes are never ingested.
+  - The models disagree about what they accept, and a setting the chosen model does not have is REFUSED rather than ignored. Run baker studio models to answer "can this one do that".
+Full guide: __tooling__/docs/tools/baker/studio.md`
+  },
+  subCommands: {
+    generate: () => import("./generate-3XYYITU6.js").then((m) => m.generateCommand),
+    animate: () => import("./animate-AIZ3GS4J.js").then((m) => m.animateCommand),
+    get: () => import("./get-3L6W3E3T.js").then((m) => m.getCommand),
+    list: () => import("./list-A5UCIR2J.js").then((m) => m.listCommand),
+    keep: () => import("./keep-55CPC7DG.js").then((m) => m.keepCommand),
+    models: () => import("./models-3Z6MDHQW.js").then((m) => m.modelsCommand),
+    skills: () => import("./skills-6TQZLIMP.js").then((m) => m.skillsCommand),
+    improve: () => import("./improve-BCCU5AS6.js").then((m) => m.improveCommand)
+  }
+});
+export {
+  studioCommand
+};
+//# sourceMappingURL=studio-SYKOSNDB.js.map

package/dist/sync-LJGSODK3.js

@@ -0,0 +1,55 @@
+import {
+  reportError,
+  reportInvalid
+} from "./chunk-6G5K6ZC6.js";
+import {
+  testimonialSourcesSyncRequestSchema
+} from "./chunk-7EPXVICM.js";
+import "./chunk-GXDLWBOY.js";
+import "./chunk-TEINLN64.js";
+import "./chunk-ZJWUBJYQ.js";
+import "./chunk-HR6IWNKE.js";
+import "./chunk-NE4F3FHN.js";
+import {
+  apiPost
+} from "./chunk-XBOK23HI.js";
+import "./chunk-IFWP3ZDO.js";
+import "./chunk-NAWWC5I3.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-NU7JSWVA.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/testimonials/sources/sync.ts
+import { defineCommand } from "citty";
+registerSchema({
+  command: "testimonials.sources.sync",
+  description: "Import a review source's new reviews now. Only reviews newer than the last import are read where the site allows it.",
+  args: { id: { type: "string", description: "Source id from `testimonials sources list`", required: true } }
+});
+var syncCommand = defineCommand({
+  meta: {
+    name: "sync",
+    description: "Import a review source's new reviews now.\n\nExample: baker testimonials sources sync <source-id>"
+  },
+  args: { id: { type: "positional", description: "Source id from `testimonials sources list`", required: true } },
+  run: async ({ args }) => {
+    const parsed = testimonialSourcesSyncRequestSchema.safeParse({ id: String(args.id ?? "") });
+    if (!parsed.success) reportInvalid(parsed.error.issues[0]);
+    try {
+      const data = await apiPost("/api/testimonials/sources/sync", parsed.data);
+      writeJson({
+        ok: true,
+        data,
+        hints: data.started ? void 0 : ["An import was already running for this source; nothing new was started."]
+      });
+    } catch (err) {
+      reportError(err);
+    }
+  }
+});
+export {
+  syncCommand
+};
+//# sourceMappingURL=sync-LJGSODK3.js.map

package/dist/sync-LJGSODK3.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/commands/testimonials/sources/sync.ts"],"sourcesContent":["import { type TestimonialSourcesSyncResponse, testimonialSourcesSyncRequestSchema } from \"@baker/api\";\nimport { defineCommand } from \"citty\";\nimport { apiPost } from \"../../../client.ts\";\nimport { writeJson } from \"../../../output.ts\";\nimport { registerSchema } from \"../../../schemas.ts\";\nimport { reportError, reportInvalid } from \"./shared.ts\";\n\nregisterSchema({\n  command: \"testimonials.sources.sync\",\n  description:\n    \"Import a review source's new reviews now. Only reviews newer than the last import are read where the site allows it.\",\n  args: { id: { type: \"string\", description: \"Source id from `testimonials sources list`\", required: true } },\n});\n\nexport const syncCommand = defineCommand({\n  meta: {\n    name: \"sync\",\n    description: \"Import a review source's new reviews now.\\n\\nExample: baker testimonials sources sync <source-id>\",\n  },\n  args: { id: { type: \"positional\", description: \"Source id from `testimonials sources list`\", required: true } },\n  run: async ({ args }) => {\n    const parsed = testimonialSourcesSyncRequestSchema.safeParse({ id: String(args.id ?? \"\") });\n    if (!parsed.success) reportInvalid(parsed.error.issues[0]);\n    try {\n      const data = await apiPost<TestimonialSourcesSyncResponse>(\"/api/testimonials/sources/sync\", parsed.data);\n      writeJson({\n        ok: true,\n        data,\n        hints: data.started ? undefined : [\"An import was already running for this source; nothing new was started.\"],\n      });\n    } catch (err) {\n      reportError(err);\n    }\n  },\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AACA,SAAS,qBAAqB;AAM9B,eAAe;AAAA,EACb,SAAS;AAAA,EACT,aACE;AAAA,EACF,MAAM,EAAE,IAAI,EAAE,MAAM,UAAU,aAAa,8CAA8C,UAAU,KAAK,EAAE;AAC5G,CAAC;AAEM,IAAM,cAAc,cAAc;AAAA,EACvC,MAAM;AAAA,IACJ,MAAM;AAAA,IACN,aAAa;AAAA,EACf;AAAA,EACA,MAAM,EAAE,IAAI,EAAE,MAAM,cAAc,aAAa,8CAA8C,UAAU,KAAK,EAAE;AAAA,EAC9G,KAAK,OAAO,EAAE,KAAK,MAAM;AACvB,UAAM,SAAS,oCAAoC,UAAU,EAAE,IAAI,OAAO,KAAK,MAAM,EAAE,EAAE,CAAC;AAC1F,QAAI,CAAC,OAAO,QAAS,eAAc,OAAO,MAAM,OAAO,CAAC,CAAC;AACzD,QAAI;AACF,YAAM,OAAO,MAAM,QAAwC,kCAAkC,OAAO,IAAI;AACxG,gBAAU;AAAA,QACR,IAAI;AAAA,QACJ;AAAA,QACA,OAAO,KAAK,UAAU,SAAY,CAAC,yEAAyE;AAAA,MAC9G,CAAC;AAAA,IACH,SAAS,KAAK;AACZ,kBAAY,GAAG;AAAA,IACjB;AAAA,EACF;AACF,CAAC;","names":[]}

package/dist/sync-definition-QR2N233R.js

@@ -0,0 +1,54 @@
+import {
+  buildDefinitionSyncPayload,
+  readDefinitionSeriesPlace,
+  readDefinitionSourceFields,
+  readDefinitionStrategyFields,
+  readDefinitionTitle,
+  resolveCanvasPath,
+  syncCreativeDefinitionBestEffort,
+  syncDefinitionCommand
+} from "./chunk-6Y7ZBENQ.js";
+import "./chunk-CWYAELVG.js";
+import "./chunk-6NY2GPR4.js";
+import "./chunk-ASI4P6X2.js";
+import "./chunk-4QEY2L6U.js";
+import "./chunk-VL43TNIP.js";
+import "./chunk-ZDMTXQ2Q.js";
+import "./chunk-F2S5BLPE.js";
+import "./chunk-WTOYCUKH.js";
+import "./chunk-DZSIUEGH.js";
+import "./chunk-LYQJ4PZW.js";
+import "./chunk-FPOGPFAG.js";
+import "./chunk-NCWCZY5P.js";
+import "./chunk-DGCUPJZD.js";
+import "./chunk-W3B4BHQU.js";
+import "./chunk-PZXCWSKV.js";
+import "./chunk-CAMX6OHF.js";
+import "./chunk-RX6F3GEA.js";
+import "./chunk-5HYSKH77.js";
+import "./chunk-KIGGMKAE.js";
+import "./chunk-VAJBWA2U.js";
+import "./chunk-HRYOZUSK.js";
+import "./chunk-VVZBBKRC.js";
+import "./chunk-YBMVHGY3.js";
+import "./chunk-7EPXVICM.js";
+import "./chunk-GXDLWBOY.js";
+import "./chunk-TEINLN64.js";
+import "./chunk-ZJWUBJYQ.js";
+import "./chunk-HR6IWNKE.js";
+import "./chunk-NE4F3FHN.js";
+import "./chunk-IFWP3ZDO.js";
+import "./chunk-NAWWC5I3.js";
+import "./chunk-NU7JSWVA.js";
+import "./chunk-YQSBHWOI.js";
+export {
+  buildDefinitionSyncPayload,
+  readDefinitionSeriesPlace,
+  readDefinitionSourceFields,
+  readDefinitionStrategyFields,
+  readDefinitionTitle,
+  resolveCanvasPath,
+  syncCreativeDefinitionBestEffort,
+  syncDefinitionCommand
+};
+//# sourceMappingURL=sync-definition-QR2N233R.js.map

package/dist/tags-4BAVFH4S.js

@@ -0,0 +1,225 @@
+import {
+  CHAT_READ_ARG
+} from "./chunk-PFBQERWX.js";
+import {
+  TAG_IDENTIFYING_FIELD
+} from "./chunk-7EPXVICM.js";
+import "./chunk-GXDLWBOY.js";
+import "./chunk-TEINLN64.js";
+import "./chunk-ZJWUBJYQ.js";
+import "./chunk-HR6IWNKE.js";
+import "./chunk-NE4F3FHN.js";
+import {
+  ApiError,
+  apiPost
+} from "./chunk-XBOK23HI.js";
+import "./chunk-IFWP3ZDO.js";
+import {
+  requireChatId,
+  resolveChatId
+} from "./chunk-NAWWC5I3.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-NU7JSWVA.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-4BAVFH4S.js.map