@koda-sl/baker-cli 0.121.0-dev.87e882ae1 → 0.121.0-dev.a2cdb40bc

package/README.md

@@ -2504,22 +2504,26 @@ Rules:
 
 ### Marketing Tags (`baker tags`)
 
-Read the client's marketing/analytics tags (Meta pixel, GA4, Google Ads, GTM, Clarity, Hotjar, PostHog, …) — production tags overlaid with the changes staged in this chat.
-
-**The CLI is read-only.** Every tag change (create, edit, delete) goes through the `request_tag_input` tool (`baker_ui` MCP server): the agent proposes one or more changes — each becomes a tab in one blocking approval form — pre-filling the non-secret fields it knows; the user reviews, edits, fills secret fields, and approves or skips each tab. Approved changes stage on the chat and apply when the chat is published; discarding the chat drops them.
+Manage the client's marketing/analytics tags (Meta pixel, GA4, Google Ads, GTM, Clarity, Hotjar, PostHog, …) as per-chat **staged** changes. Nothing touches production tags until the chat is published; discarding the chat drops the draft.
 
 `BAKER_CHAT_ID` must be set.
 
 ```bash
-baker tags list       # effective view: production + staged, with secret status
-baker tags draft      # review the staged changes awaiting publish
+baker tags list                                              # effective view: production + staged, with secret status
+baker tags add clarity --set projectId=abcde12345            # client-only tag, no secrets needed
+baker tags add meta --set pixelId=123 --request-secret accessToken
+baker tags update <ref> --set pixelId=999 --clear testEventCode
+baker tags remove <ref>                                      # stage deletion (tag_temp_* ref drops the staged create)
+baker tags draft                                             # review staged ops
+baker tags draft remove <ref>                                # drop one staged op
+baker tags draft clear                                       # drop everything staged
 ```
 
 Notes:
 
-- **Secrets never travel through this CLI or the chat.** Secret fields (`accessToken`, `apiSecret`, `authorizationToken`, `apiKey`, `conversionToken`, `oauthProviderId`) are entered only in the dashboard's secure tag form and flow straight into the staged draft; tool responses only ever name which secret fields are set/pending.
-- Staged creates get a server-generated `tag_temp_*` ref (returned in the tool result and printed by `list`). Use it (or a real tag id) as flow side-effect `tagIds` — the published tag keeps resolving under the temp ref.
-- Proposing a delete on a `tag_temp_*` ref drops the staged create instead.
+- **Secrets never travel through this CLI.** Secret fields (`accessToken`, `apiSecret`, `authorizationToken`, `apiKey`, `conversionToken`, `oauthProviderId`) are rejected in `--set`. Stage with `--request-secret <field>`; the user provides values via the secure tag form in the chat (`request_tag_input`), which writes them straight into the staged draft. Responses only ever name which secret fields are set/pending.
+- Staged creates get a server-generated `tag_temp_*` ref. Use it (or a real tag id) as flow side-effect `tagIds` — the published tag keeps resolving under the temp ref.
+- `update`/`remove` with a `tag_temp_*` ref amend/drop the staged create in place.
 - Single-instance types (`code`, `posthog`, `datafast`) reject a second instance against the chat's effective view.
 - Conflicts at publish (tag deleted in the dashboard, config invalid) skip the op with a recorded reason — they never block the publish.
 

package/dist/cli.js

@@ -1939,6 +1939,46 @@ var TAG_TYPES = [
   "twitterAds"
 ];
 var tagTypeSchema = z5.enum(TAG_TYPES);
+var TAG_SECRET_FIELDS = {
+  meta: ["accessToken"],
+  amplitude: [],
+  googleAds: ["oauthProviderId", "customerAccountId", "customerId", "loginCustomerId"],
+  tiktok: ["accessToken"],
+  vwo: [],
+  hotjar: [],
+  clarity: [],
+  pinterest: ["conversionToken"],
+  code: [],
+  googleAnalytics: ["apiSecret"],
+  googleTagManager: ["authorizationToken"],
+  hubspot: [],
+  linkedinInsightTag: ["oauthProviderId"],
+  onetrust: [],
+  posthog: [],
+  datafast: ["apiKey"],
+  recaptcha: [],
+  twitterAds: ["oauthProviderId"]
+};
+var TAG_REQUESTABLE_SECRET_FIELDS = {
+  meta: ["accessToken"],
+  amplitude: [],
+  googleAds: ["oauthProviderId", "customerAccountId"],
+  tiktok: ["accessToken"],
+  vwo: [],
+  hotjar: [],
+  clarity: [],
+  pinterest: ["conversionToken"],
+  code: [],
+  googleAnalytics: ["apiSecret"],
+  googleTagManager: ["authorizationToken"],
+  hubspot: [],
+  linkedinInsightTag: ["oauthProviderId"],
+  onetrust: [],
+  posthog: [],
+  datafast: ["apiKey"],
+  recaptcha: [],
+  twitterAds: ["oauthProviderId"]
+};
 var tagDraftOpKindSchema = z5.enum(["create", "update", "delete"]);
 var tagDraftOpViewSchema = z5.object({
   /** `tag_temp_*` for staged creates; the real tag id for update/delete ops. */
@@ -1974,17 +2014,49 @@ var tagsEffectiveEntrySchema = z5.object({
 });
 var tagsListRequestSchema = z5.object({ chatId: z5.string() });
 var tagsListResponseSchema = z5.object({ tags: z5.array(tagsEffectiveEntrySchema) });
+var tagsDraftStageRequestSchema = z5.discriminatedUnion("kind", [
+  z5.object({
+    kind: z5.literal("create"),
+    chatId: z5.string(),
+    type: tagTypeSchema,
+    config: z5.record(z5.string(), z5.string()),
+    requestSecrets: z5.array(z5.string()).optional(),
+    summary: z5.string().optional()
+  }),
+  z5.object({
+    kind: z5.literal("update"),
+    chatId: z5.string(),
+    ref: z5.string(),
+    config: z5.record(z5.string(), z5.string()).optional(),
+    clearFields: z5.array(z5.string()).optional(),
+    requestSecrets: z5.array(z5.string()).optional(),
+    summary: z5.string().optional()
+  }),
+  z5.object({
+    kind: z5.literal("delete"),
+    chatId: z5.string(),
+    ref: z5.string()
+  })
+]);
+var tagsDraftStageResponseSchema = z5.object({
+  /** Null when the request dissolved a staged create (delete/clearing an unpublished temp ref). */
+  op: tagDraftOpViewSchema.nullable(),
+  /** True when a `delete <tag_temp_*>` dropped the staged create instead of staging a delete. */
+  removedStagedCreate: z5.boolean().optional()
+});
 var tagsDraftListRequestSchema = z5.object({ chatId: z5.string() });
 var tagsDraftListResponseSchema = z5.object({
   status: z5.enum(["active", "publishing", "applied", "discarded", "none"]),
   ops: z5.array(tagDraftOpViewSchema)
 });
+var tagsDraftRemoveRequestSchema = z5.object({ chatId: z5.string(), ref: z5.string() });
+var tagsDraftRemoveResponseSchema = z5.object({ removed: z5.boolean() });
+var tagsDraftClearRequestSchema = z5.object({ chatId: z5.string() });
+var tagsDraftClearResponseSchema = z5.object({ cleared: z5.number() });
 var tagInputRequestSchema = z5.object({
-  // Every tag change is a tab in the approval form: create/edit show the full
-  // body; delete shows a confirm. No tag change bypasses this approval.
-  mode: z5.enum(["create", "edit", "delete"]),
+  mode: z5.enum(["create", "edit"]),
   tagType: tagTypeSchema,
-  /** Edit/delete mode — the real tag id or `tag_temp_*` ref being changed. */
+  /** Edit mode — the real tag id or `tag_temp_*` ref being edited. */
   ref: z5.string().optional(),
   /** Non-secret values the agent proposes to prefill. Secret keys are stripped at every boundary. */
   prefilledConfig: z5.record(z5.string(), z5.string()).optional(),
@@ -1993,9 +2065,6 @@ var tagInputRequestSchema = z5.object({
   /** Short message shown above the form explaining why the input is needed. */
   message: z5.string().optional()
 });
-var tagChangeToolInputSchema = z5.object({
-  changes: z5.array(tagInputRequestSchema).min(1).max(8)
-});
 var tagInputResultSchema = z5.discriminatedUnion("status", [
   z5.object({
     status: z5.literal("submitted"),
@@ -2011,9 +2080,6 @@ var tagInputResultSchema = z5.discriminatedUnion("status", [
     reason: z5.string().optional()
   })
 ]);
-var tagChangeToolResultSchema = z5.object({
-  results: z5.array(tagInputResultSchema)
-});
 
 // ../api/src/testimonials.ts
 import { z as z6 } from "zod";
@@ -23916,6 +23982,10 @@ var schemaCommand = defineCommand147({
 import { defineCommand as defineCommand148 } from "citty";
 
 // src/commands/tags/shared.ts
+function failValidation3(message) {
+  writeJson({ ok: false, error: { code: "VALIDATION_ERROR", message } });
+  process.exit(1);
+}
 function failApi3(err) {
   if (err instanceof ApiError) {
     writeJson({ ok: false, error: { code: err.code, message: err.message } });
@@ -23928,6 +23998,53 @@ function failApi3(err) {
   writeJson({ ok: false, error: { code: "INTERNAL_ERROR", message: "Unexpected error" } });
   process.exit(1);
 }
+function parseTagType(value) {
+  const parsed = tagTypeSchema.safeParse(value);
+  if (!parsed.success) {
+    failValidation3(`Unknown tag type "${value}". Valid types: ${TAG_TYPES.join(", ")}.`);
+  }
+  return parsed.data;
+}
+function toArray(value) {
+  if (value === void 0 || typeof value === "boolean") {
+    return [];
+  }
+  return Array.isArray(value) ? value : [value];
+}
+function parseSetArgs(value) {
+  const config = {};
+  for (const entry of toArray(value)) {
+    const eq = entry.indexOf("=");
+    if (eq <= 0) {
+      failValidation3(`--set expects key=value, got "${entry}".`);
+    }
+    config[entry.slice(0, eq)] = entry.slice(eq + 1);
+  }
+  return config;
+}
+function parseListArg(value) {
+  return toArray(value).flatMap(
+    (entry) => entry.split(",").map((item) => item.trim()).filter((item) => item !== "")
+  );
+}
+function rejectSecretSets(type, config) {
+  const secretFields = TAG_SECRET_FIELDS[type];
+  const offending = Object.keys(config).filter((key) => secretFields.includes(key));
+  if (offending.length > 0) {
+    failValidation3(
+      `${offending.join(", ")} ${offending.length === 1 ? "is a secret field" : "are secret fields"} \u2014 never pass secret values on the command line. Re-run with --request-secret ${offending[0]} and the user will provide it via the secure tag form in the chat.`
+    );
+  }
+}
+function validateRequestSecrets(type, fields) {
+  const requestable = TAG_REQUESTABLE_SECRET_FIELDS[type];
+  const invalid = fields.filter((field) => !requestable.includes(field));
+  if (invalid.length > 0) {
+    failValidation3(
+      `Cannot request ${invalid.join(", ")} for a ${type} tag. Requestable secret fields: ${requestable.length > 0 ? requestable.join(", ") : "(none \u2014 this type has no secret fields)"}.`
+    );
+  }
+}
 function renderEffectiveEntry(entry) {
   const parts = [entry.ref, entry.type];
   if (entry.identifier !== void 0) {
@@ -23949,11 +24066,47 @@ function renderEffectiveEntry(entry) {
 // 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. 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.",
+  description: "Effective marketing tags for this chat: production tags overlaid with the ops staged in this chat's draft. The printed refs (tag ids or tag_temp_*) are exactly what flow side-effect tagIds should reference.",
   args: {
     json: { type: "boolean", description: "Print the raw JSON envelope instead of the readable list", required: false }
   }
 });
+registerSchema({
+  command: "tags.add",
+  description: "Stage creation of a marketing tag (applies when the chat publishes). Set every non-secret field with --set; request secret fields (API keys, tokens, OAuth connections) with --request-secret \u2014 the user provides them via the secure tag form in the chat, never through the CLI.",
+  args: {
+    type: {
+      type: "positional",
+      description: "Tag type (see `baker tags list` output / meta, googleAnalytics, clarity, \u2026)",
+      required: true
+    },
+    set: { type: "string", description: "Repeatable key=value for non-secret config fields", required: false },
+    "request-secret": {
+      type: "string",
+      description: "Repeatable secret field name to request from the user",
+      required: false
+    }
+  }
+});
+registerSchema({
+  command: "tags.update",
+  description: "Stage an update to a tag by ref (real tag id, or tag_temp_* to amend a create staged in this chat). --set patches fields, --clear removes them, --request-secret asks the user for secret values.",
+  args: {
+    ref: { type: "positional", description: "Tag ref from `baker tags list`", required: true },
+    set: { type: "string", description: "Repeatable key=value for non-secret config fields", required: false },
+    clear: { type: "string", description: "Repeatable field name to clear", required: false },
+    "request-secret": {
+      type: "string",
+      description: "Repeatable secret field name to request from the user",
+      required: false
+    }
+  }
+});
+registerSchema({
+  command: "tags.remove",
+  description: "Stage deletion of a tag by ref (applies on publish). Removing a tag_temp_* ref drops the staged create instead.",
+  args: { ref: { type: "positional", description: "Tag ref from `baker tags list`", required: true } }
+});
 async function listTags(json) {
   try {
     const chatId = requireChatId();
@@ -23963,7 +24116,7 @@ async function listTags(json) {
       return;
     }
     if (response.tags.length === 0) {
-      process.stdout.write("No tags configured. Propose one with the request_tag_input tool (baker_ui).\n");
+      process.stdout.write("No tags configured. Stage one with `baker tags add <type> --set key=value`.\n");
       return;
     }
     process.stdout.write(`${response.tags.map(renderEffectiveEntry).join("\n")}
@@ -23982,6 +24135,84 @@ var listCommand7 = defineCommand148({
     await listTags(args.json === true);
   }
 });
+async function stage(body) {
+  try {
+    const response = await apiPost("/api/tags/draft/stage", body);
+    writeJson({ ok: true, data: response });
+  } catch (err) {
+    failApi3(err);
+  }
+}
+var addCommand2 = defineCommand148({
+  meta: {
+    name: "add",
+    description: "Stage a new tag (applies on publish). Secret fields are never passed here \u2014 use --request-secret and the user fills them in the chat's secure tag form. Example: baker tags add meta --set pixelId=123456 --request-secret accessToken"
+  },
+  args: {
+    type: {
+      type: "positional",
+      description: "Tag type (meta, googleAnalytics, googleAds, clarity, \u2026)",
+      required: true
+    },
+    set: { type: "string", description: "key=value for a non-secret config field (repeatable)" },
+    "request-secret": { type: "string", description: "Secret field name the user should provide (repeatable)" }
+  },
+  run: async ({ args }) => {
+    const type = parseTagType(args.type);
+    const config = parseSetArgs(args.set);
+    const requestSecrets = parseListArg(args["request-secret"]);
+    rejectSecretSets(type, config);
+    validateRequestSecrets(type, requestSecrets);
+    const chatId = requireChatId();
+    await stage({
+      kind: "create",
+      chatId,
+      type,
+      config,
+      ...requestSecrets.length > 0 ? { requestSecrets } : {}
+    });
+  }
+});
+var updateCommand3 = defineCommand148({
+  meta: {
+    name: "update",
+    description: "Stage an update to a tag. A tag_temp_* ref amends the create staged in this chat. Example: baker tags update <ref> --set pixelId=999 --clear testEventCode"
+  },
+  args: {
+    ref: { type: "positional", description: "Tag ref from `baker tags list`", required: true },
+    set: { type: "string", description: "key=value patch for a non-secret config field (repeatable)" },
+    clear: { type: "string", description: "Field name to clear (repeatable)" },
+    "request-secret": { type: "string", description: "Secret field name the user should provide (repeatable)" }
+  },
+  run: async ({ args }) => {
+    const config = parseSetArgs(args.set);
+    const clearFields = parseListArg(args.clear);
+    const requestSecrets = parseListArg(args["request-secret"]);
+    if (Object.keys(config).length === 0 && clearFields.length === 0 && requestSecrets.length === 0) {
+      failValidation3("Nothing to update \u2014 pass --set, --clear, or --request-secret.");
+    }
+    const chatId = requireChatId();
+    await stage({
+      kind: "update",
+      chatId,
+      ref: args.ref,
+      ...Object.keys(config).length > 0 ? { config } : {},
+      ...clearFields.length > 0 ? { clearFields } : {},
+      ...requestSecrets.length > 0 ? { requestSecrets } : {}
+    });
+  }
+});
+var removeCommand5 = defineCommand148({
+  meta: {
+    name: "remove",
+    description: "Stage deletion of a tag (applies on publish). Removing a tag_temp_* ref drops the staged create instead. Example: baker tags remove <ref>"
+  },
+  args: { ref: { type: "positional", description: "Tag ref from `baker tags list`", required: true } },
+  run: async ({ args }) => {
+    const chatId = requireChatId();
+    await stage({ kind: "delete", chatId, ref: args.ref });
+  }
+});
 async function listDraft3() {
   try {
     const chatId = requireChatId();
@@ -23991,10 +24222,55 @@ async function listDraft3() {
     failApi3(err);
   }
 }
+var draftListCommand = defineCommand148({
+  meta: { name: "list", description: "Review the tag ops staged in this chat. Example: baker tags draft" },
+  run: async () => {
+    await listDraft3();
+  }
+});
+var draftRemoveCommand = defineCommand148({
+  meta: {
+    name: "remove",
+    description: "Drop one staged tag op by ref. Example: baker tags draft remove tag_temp_abc123"
+  },
+  args: { ref: { type: "positional", description: "Staged op ref", required: true } },
+  run: async ({ args }) => {
+    try {
+      const chatId = requireChatId();
+      const response = await apiPost("/api/tags/draft/remove", {
+        chatId,
+        ref: args.ref
+      });
+      writeJson({ ok: true, data: response });
+    } catch (err) {
+      failApi3(err);
+    }
+  }
+});
+var draftClearCommand = defineCommand148({
+  meta: {
+    name: "clear",
+    description: "Drop ALL tag ops staged in this chat \u2014 nothing will apply on publish. Example: baker tags draft clear"
+  },
+  run: async () => {
+    try {
+      const chatId = requireChatId();
+      const response = await apiPost("/api/tags/draft/clear", { chatId });
+      writeJson({ ok: true, data: response });
+    } catch (err) {
+      failApi3(err);
+    }
+  }
+});
 var draftCommand3 = defineCommand148({
   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 amend or drop one, propose a follow-up change through the same tool (a delete on a tag_temp_* ref drops the staged create)."
+    description: "Review and edit the tag ops staged in this chat BEFORE publish. Subcommands: list (default), remove, clear. Ops never touch production tags until the chat is published."
+  },
+  subCommands: {
+    list: draftListCommand,
+    remove: draftRemoveCommand,
+    clear: draftClearCommand
   },
   run: async () => {
     await listDraft3();
@@ -24003,18 +24279,25 @@ var draftCommand3 = defineCommand148({
 var tagsCommand3 = defineCommand148({
   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.
+    description: `Manage the client's marketing/analytics tags (Meta pixel, GA4, Google Ads, GTM, Clarity, Hotjar, \u2026) as per-chat STAGED changes \u2014 nothing touches production until the chat is published.
 
-This command is READ-ONLY. 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.
+Secrets: secret fields (accessToken, apiSecret, authorizationToken, apiKey, conversionToken, oauthProviderId) are NEVER typed into chat or passed to this CLI. Stage with --request-secret <field>, then invoke the request_tag_input tool (baker_ui) so the user fills them in the dashboard's secure tag form.
 
 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.
 
 Examples:
-  baker tags list       # production + staged, with secret status
-  baker tags draft      # review the staged changes awaiting publish`
+  baker tags list                                              # production + staged, with secret status
+  baker tags add clarity --set projectId=abcde12345            # client-only tag, no secrets needed
+  baker tags add meta --set pixelId=123 --request-secret accessToken
+  baker tags update <ref> --set pixelId=999 --clear testEventCode
+  baker tags remove <ref>                                      # stage deletion (temp ref = drop the create)
+  baker tags draft                                             # review staged ops before finishing`
   },
   subCommands: {
     list: listCommand7,
+    add: addCommand2,
+    update: updateCommand3,
+    remove: removeCommand5,
     draft: draftCommand3
   },
   run: async () => {