@koda-sl/baker-cli 0.491.0 → 0.493.0

package/dist/chunk-RDEAVCMF.js

@@ -0,0 +1,399 @@
+import {
+  agentProfile
+} from "./chunk-3B5LPK6D.js";
+import {
+  AUTO_PUBLISH_REFUSAL,
+  TRIGGER_KINDS,
+  TRIGGER_KIND_IDS,
+  TRIGGER_TARGETS,
+  TRIGGER_TARGET_FIELDS,
+  TRIGGER_TARGET_FIELD_IDS,
+  firstTimes,
+  isTriggerKind,
+  parseConditionsExpression
+} from "./chunk-DAO63OOP.js";
+import {
+  ApiError,
+  validateConvexId
+} from "./chunk-6YLNY6CK.js";
+import {
+  getEnv
+} from "./chunk-57KKVDDR.js";
+import {
+  writeJson
+} from "./chunk-QANGHND7.js";
+
+// src/commands/scheduled-agents/shared.ts
+var TEMP_SCHEDULED_AGENT_PREFIX = "temp_agent_";
+var TEMP_ID_PREFIX = "temp_";
+function writeOk(data, hints) {
+  writeJson({ ok: true, data: data ?? null, ...hints && hints.length > 0 ? { hints } : {} });
+}
+function failValidation(message) {
+  writeJson({ ok: false, error: { code: "VALIDATION_ERROR", message } });
+  process.exit(1);
+}
+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);
+}
+var AUTO_PUBLISH_ARG = {
+  "auto-publish": {
+    type: "string",
+    description: "Not available to the agent: publishing every run unreviewed is switched on by the user, on the item, after this chat is published. Passing it is refused and tells you what to ask them.",
+    required: false
+  }
+};
+function refuseAutoPublish(args) {
+  if (args["auto-publish"] === void 0) {
+    return;
+  }
+  writeJson({
+    ok: false,
+    error: {
+      code: "FORBIDDEN",
+      message: AUTO_PUBLISH_REFUSAL,
+      fix: {
+        action: "ask_user",
+        explanation: 'Run the command again without --auto-publish. After this chat is published, ask the user to open the item in Scheduled agents and switch on "Publish its work on its own" under "When a run finishes" \u2014 until then each run waits for their review.'
+      }
+    }
+  });
+  process.exit(1);
+}
+function isTempScheduledAgentId(id) {
+  return id.startsWith(TEMP_SCHEDULED_AGENT_PREFIX);
+}
+function isOtherTempId(id) {
+  return id.startsWith(TEMP_ID_PREFIX) && !isTempScheduledAgentId(id);
+}
+function validateScheduledAgentRef(ref) {
+  if (isOtherTempId(ref)) {
+    failValidation(`Scheduled agent temp IDs must start with ${TEMP_SCHEDULED_AGENT_PREFIX}.`);
+  }
+  if (!isTempScheduledAgentId(ref)) {
+    validateConvexId(ref);
+  }
+}
+var TRIGGER_ARG_DESCRIPTION = `What makes this run. ${TRIGGER_KIND_IDS.map(
+  (id) => `${id}: ${TRIGGER_KINDS[id].description}`
+).join(" ")} For the two time ones, pass --cron or --run-at instead and the kind is implied.`;
+var TRIGGER_KIND_LIST = [...TRIGGER_KIND_IDS];
+var NARROWING_DESCRIPTIONS = {
+  eventName: "With --trigger event.received: only this event name (a source's name, or one your site sends). Omit it to run on any event.",
+  toolkit: "With --trigger app.event (required): the connected tool, by its slug \u2014 gmail, slack, googlesheets.",
+  account: "With --trigger app.event (required): which connected account of that tool, by id (a tool can be connected more than once).",
+  appEvent: "With --trigger app.event (required): what happens in the tool, by the tool's own id \u2014 GMAIL_NEW_GMAIL_MESSAGE. `targets --field appEvent --app <tool>` lists them with the settings each needs.",
+  provider: "With --trigger connection.created, connection.removed or connection.needs_reconnect: only this tool (google-ads, hubspot, meta, or a connected tool's slug such as slack). Omit it for any tool.",
+  flowId: "With --trigger form.submitted or flow.step.submitted: which Form, by slug. Omit it on form.submitted for any Form.",
+  stepId: "With --trigger flow.step.submitted: which step of that Form, by id \u2014 `targets --field stepId --form <slug>` lists them by name.",
+  page: "With --trigger landing.created or landing.published: only this page, by slug. Omit it for any page.",
+  tag: "With --trigger task.created, task.claimed, task.completed, landing.created or landing.published: only ones carrying this tag. Omit it for any.",
+  experimentId: 'With --trigger experiment.decided, experiment.ended or experiment.concluded: only this test. Omit it for any test. Not for experiment.started \u2014 narrow that with --when "page = <page>".',
+  taskId: "With --trigger task.claimed or task.completed: only this Task, by id (a temp_ id of a Task staged in this chat works too). Omit it for any Task.",
+  agentId: "With --trigger session.published, session.publish_failed or session.publish_incomplete: only the runs of this scheduled agent, by id (a temp_agent_ id staged in this chat works too). Omit it for any agent's work.",
+  platform: "With --trigger session.publish_incomplete: only when this platform's changes did not all land \u2014 google-ads, meta-ads, linkedin-ads, x-ads, tag-manager or ga4. Omit it for any.",
+  collection: "With --trigger knowledge.updated: only this Knowledge collection. Omit it for any of them.",
+  sourceId: "With --trigger review.received: only reviews from this review source, by id. Omit it for any source.",
+  advertiserId: "With --trigger advertiser.new_ads: only this followed advertiser, by id. Omit it for any of them."
+};
+var NARROWING_ARGS = {
+  ...Object.fromEntries(
+    TRIGGER_TARGET_FIELD_IDS.map((field) => [
+      TRIGGER_TARGET_FIELDS[field].flag,
+      {
+        type: "string",
+        description: `${NARROWING_DESCRIPTIONS[field]} \`baker scheduled-agents targets --trigger <kind> --field ${field}\` lists the values.`,
+        required: false
+      }
+    ])
+  ),
+  config: {
+    type: "string",
+    description: `With --trigger app.event: the event's own settings as a JSON object \u2014 they filter inside the tool, before anything is sent. A Gmail search ('{"query":"from:ana@acme.com"}'), a label, a Slack channel, a GitHub repository ('{"owner":"acme","repo":"site"}'). \`targets --field appEvent --app <tool> --event <id>\` lists each setting with its examples.`,
+    required: false
+  }
+};
+function validateRunAt(runAt) {
+  if (!runAt.endsWith("Z")) {
+    failValidation("--run-at must be an ISO UTC timestamp ending in Z.");
+  }
+  const parsed = Date.parse(runAt);
+  if (!Number.isFinite(parsed)) {
+    failValidation("--run-at must be a valid ISO timestamp.");
+  }
+  if (parsed <= Date.now()) {
+    failValidation(
+      `--run-at ${runAt} has already passed. A one-off item only runs at a time still to come \u2014 pass a later ISO UTC timestamp, and check which timezone you converted from if you worked it out from a local time.`
+    );
+  }
+}
+function buildTriggerBody(args, options) {
+  const cron = args.cron;
+  const runAt = args["run-at"];
+  const timezone = args.timezone;
+  const kind = args.trigger;
+  const given = [cron, runAt, kind].filter(Boolean).length;
+  if (given > 1) {
+    failValidation("--cron, --run-at and --trigger are mutually exclusive.");
+  }
+  refuseNarrowingWithoutKind(args, kind, given);
+  if (runAt) {
+    validateRunAt(runAt);
+    return { runAt, ...timezone ? { timezone } : {} };
+  }
+  if (cron) {
+    return { cron, ...timezone ? { timezone } : {} };
+  }
+  if (kind) {
+    return { trigger: triggerFromFlags(kind, args), ...timezone ? { timezone } : {} };
+  }
+  if (timezone && !options.required) {
+    return { timezone };
+  }
+  if (options.required) {
+    failValidation(
+      `A trigger is required. Pass --cron or --run-at for a time-based one, or --trigger with one of: ${TRIGGER_KIND_IDS.join(", ")}.`
+    );
+  }
+  return void 0;
+}
+function flagText(args, key) {
+  const value = args[key];
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
+}
+function refuseMisusedKinds(kind, args) {
+  if (kind === "time.once") {
+    failValidation("Use --run-at for a one-off, rather than --trigger time.once.");
+  }
+  if (kind === "time.cron") {
+    failValidation("Use --cron for a repeating schedule, rather than --trigger time.cron.");
+  }
+  if (kind === "experiment.started" && flagText(args, "experiment")) {
+    failValidation(
+      'A test that exists has already started, so --experiment never fires on experiment.started. Leave it off and add --when "page = <page>" to watch one page.'
+    );
+  }
+}
+function refuseStrayFlags(kind, args) {
+  const allowed = new Set(TRIGGER_TARGETS[kind].map((target) => TRIGGER_TARGET_FIELDS[target.field].flag));
+  const stray = TRIGGER_TARGET_FIELD_IDS.map((field) => TRIGGER_TARGET_FIELDS[field].flag).filter(
+    (flag) => !allowed.has(flag) && flagText(args, flag) !== void 0 && !(kind === "experiment.started" && flag === "experiment")
+  );
+  if (stray.length === 0) {
+    return;
+  }
+  failValidation(
+    `${stray.map((flag) => `--${flag}`).join(", ")} does not narrow ${kind}. ${allowed.size > 0 ? `It can be pointed with ${[...allowed].map((flag) => `--${flag}`).join(", ")}.` : "It runs every time it happens \u2014 narrow it with --when rules over its payload instead."}`
+  );
+}
+var NARROWING_FLAGS = [...TRIGGER_TARGET_FIELD_IDS.map((field) => TRIGGER_TARGET_FIELDS[field].flag), "config"];
+function refuseNarrowingWithoutKind(args, kind, given) {
+  if (kind) {
+    return;
+  }
+  const stray = NARROWING_FLAGS.filter((flag) => flagText(args, flag) !== void 0);
+  if (stray.length === 0) {
+    return;
+  }
+  const flags = stray.map((flag) => `--${flag}`).join(", ");
+  failValidation(
+    given > 0 ? `${flags} does not narrow --cron or --run-at: a time trigger runs every time it comes round. Use --trigger <kind> with ${flags} instead, or leave ${flags} off.` : `${flags} narrows a trigger, and no trigger was given. Pass --trigger <kind> too \u2014 the item's whole trigger, with ${flags} \u2014 or leave ${flags} off.`
+  );
+}
+function configFromFlag(kind, args) {
+  const config = flagText(args, "config");
+  if (!config) {
+    return {};
+  }
+  if (kind !== "app.event") {
+    failValidation("--config is only for --trigger app.event: the settings of what happens in the tool.");
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(config);
+  } catch {
+    parsed = null;
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    failValidation(`--config must be a JSON object, e.g. '{"labelIds":"INBOX"}'.`);
+  }
+  return { configJson: config };
+}
+function triggerFromFlags(kind, args) {
+  if (!isTriggerKind(kind)) {
+    failValidation(`--trigger must be one of: ${TRIGGER_KIND_IDS.join(", ")}.`);
+  }
+  refuseMisusedKinds(kind, args);
+  refuseStrayFlags(kind, args);
+  const narrowings = {};
+  for (const { field, required } of TRIGGER_TARGETS[kind]) {
+    const value = flagText(args, TRIGGER_TARGET_FIELDS[field].flag);
+    if (value) {
+      narrowings[field] = value;
+    } else if (required) {
+      failValidation(
+        `--trigger ${kind} needs --${TRIGGER_TARGET_FIELDS[field].flag}. \`baker scheduled-agents targets --trigger ${kind} --field ${field}\` lists what it can be.`
+      );
+    }
+  }
+  return { kind, ...narrowings, ...configFromFlag(kind, args) };
+}
+function parseOccurrences(raw) {
+  if (raw === void 0) {
+    return void 0;
+  }
+  if (typeof raw !== "string") {
+    failValidation("--occurrences must be a comma-separated list of whole numbers, e.g. 1 or 1,3.");
+  }
+  const parts = raw.split(",").map((part) => part.trim()).filter((part) => part.length > 0);
+  const numbers = parts.map((part) => Number(part));
+  if (numbers.length === 0 || numbers.some((n) => !Number.isInteger(n) || n <= 0)) {
+    failValidation("--occurrences must be a comma-separated list of whole numbers above zero, e.g. 1 or 1,3.");
+  }
+  return numbers;
+}
+function parseBooleanFlag(raw, flagName) {
+  if (raw === void 0) {
+    return void 0;
+  }
+  if (raw === true || raw === "true") {
+    return true;
+  }
+  if (raw === false || raw === "false") {
+    return false;
+  }
+  failValidation(`${flagName} must be true or false.`);
+}
+var REACTION_ARGS = {
+  when: {
+    type: "string",
+    description: "Only run when what arrived passes these rules: `<field> <operator> <value>` joined by AND or by OR (either case). Fields are the trigger's payload fields (`baker scheduled-agents triggers --trigger <kind>` lists them; a webhook's are whatever was posted; an app.event's are what `targets --field appEvent --app <tool> --event <id>` says it sends). Operators: =, !=, contains, does not contain, starts with, ends with, >, <, >=, <=, in (comma list), exists, missing. Example: --when \"deal.stage = won AND amount > 10000\". A payload that fails is not counted and starts nothing. `none` clears the rules.",
+    required: false
+  },
+  times: {
+    type: "string",
+    description: "Only the first N times it fires (and its --when rules pass), then never again. `--times 1` is only the first time. Shorthand for --occurrences 1,2,\u2026,N.",
+    required: false
+  },
+  payload: {
+    type: "string",
+    description: "include (default) or omit. Whether the run's first message carries what arrived \u2014 the posted body, the event's properties, the Form's answers (emails and phones masked). Place single values in --prompt with {{payload.<field>}} instead; those are filled either way.",
+    required: false
+  },
+  cooldown: {
+    type: "string",
+    description: "At most one run per this many minutes, however often it fires. 0 removes it.",
+    required: false
+  }
+};
+var SLACK_ARG = {
+  slack: {
+    type: "string",
+    description: "Tell each run in Slack: `here` (the Slack conversation this chat came from), `me` (a direct message to the person in this chat), `#channel` (a channel linked to this company), or `off`. Each run opens its own thread there and Baker reports on it: what it found, what it needs, whether to publish.",
+    required: false
+  }
+};
+function companiesArg(profile = agentProfile()) {
+  return profile === "organization" ? {
+    companies: {
+      type: "string",
+      description: "The companies whose events it hears, by id, comma-separated (`baker organization companies` lists them), or `all`. Left out, it hears every company, including ones added later. Only on a trigger that happens in a company; one company's Form, page or tag is a --when rule instead.",
+      required: false
+    }
+  } : {};
+}
+function companiesBody(args) {
+  return typeof args.companies === "string" && args.companies.trim().length > 0 ? { companies: args.companies.trim() } : {};
+}
+function slackBody(args) {
+  return typeof args.slack === "string" && args.slack.trim().length > 0 ? { slack: args.slack.trim() } : {};
+}
+function wholeNumber(raw, flag, { min }) {
+  if (raw === void 0) {
+    return void 0;
+  }
+  const value = Number(raw);
+  if (!Number.isInteger(value) || value < min) {
+    failValidation(`${flag} must be a whole number of at least ${min}.`);
+  }
+  return value;
+}
+function reactionBody(args) {
+  const occurrences = occurrencesFromFlags(args);
+  const when = whenFromFlag(args.when);
+  const includePayload = payloadFromFlag(args.payload);
+  const cooldownMinutes = wholeNumber(args.cooldown, "--cooldown", { min: 0 });
+  return {
+    ...occurrences !== void 0 ? { occurrences } : {},
+    ...when !== void 0 ? { when } : {},
+    ...includePayload !== void 0 ? { includePayload } : {},
+    ...cooldownMinutes !== void 0 ? { cooldownMinutes } : {}
+  };
+}
+function occurrencesFromFlags(args) {
+  const times = wholeNumber(args.times, "--times", { min: 1 });
+  const occurrences = parseOccurrences(args.occurrences);
+  if (times !== void 0 && occurrences !== void 0) {
+    failValidation("Pass --times or --occurrences, not both \u2014 --times 3 is --occurrences 1,2,3.");
+  }
+  return times !== void 0 ? firstTimes(times) : occurrences;
+}
+function whenFromFlag(raw) {
+  if (typeof raw !== "string") {
+    return void 0;
+  }
+  const text = raw.trim();
+  if (text.length === 0 || text.toLowerCase() === "none") {
+    return "none";
+  }
+  const parsed = parseConditionsExpression(text);
+  if (!parsed.ok) {
+    failValidation(parsed.error);
+  }
+  return text;
+}
+function payloadFromFlag(raw) {
+  if (raw === void 0) {
+    return void 0;
+  }
+  if (raw !== "include" && raw !== "omit") {
+    failValidation("--payload must be include or omit.");
+  }
+  return raw === "include";
+}
+function chatBody() {
+  const id = getEnv().BAKER_CHAT_ID;
+  return id ? { chatId: id } : {};
+}
+
+export {
+  writeOk,
+  failValidation,
+  failApi,
+  AUTO_PUBLISH_ARG,
+  refuseAutoPublish,
+  isTempScheduledAgentId,
+  validateScheduledAgentRef,
+  TRIGGER_ARG_DESCRIPTION,
+  TRIGGER_KIND_LIST,
+  NARROWING_ARGS,
+  buildTriggerBody,
+  parseBooleanFlag,
+  REACTION_ARGS,
+  SLACK_ARG,
+  companiesArg,
+  companiesBody,
+  slackBody,
+  reactionBody,
+  chatBody
+};
+//# sourceMappingURL=chunk-RDEAVCMF.js.map

package/dist/chunk-RGMKXNQP.js

@@ -0,0 +1,23 @@
+import {
+  creativesRunResponseSchema
+} from "./chunk-DAO63OOP.js";
+import {
+  ApiError,
+  apiPost
+} from "./chunk-6YLNY6CK.js";
+
+// src/commands/canvas/run-history.ts
+async function fetchRunRecord(runId, post = apiPost) {
+  try {
+    const response = await post("/api/creatives/run", { runId });
+    return creativesRunResponseSchema.parse(response).data;
+  } catch (e) {
+    if (e instanceof ApiError && e.code === "NOT_FOUND") return null;
+    throw e;
+  }
+}
+
+export {
+  fetchRunRecord
+};
+//# sourceMappingURL=chunk-RGMKXNQP.js.map

package/dist/chunk-RJZS4XDJ.js

@@ -0,0 +1,64 @@
+import {
+  REF_PREFIX
+} from "./chunk-OL7JS4NG.js";
+
+// src/commands/canvas/node-preview.ts
+var MAX_PARAMS_PREVIEW_LENGTH = 4e3;
+var SPEC_KEYS = [
+  "model",
+  "format",
+  "mode",
+  "aspect_ratio",
+  "image_size",
+  "resolution",
+  "duration",
+  "subject_type",
+  "font_size",
+  "expect",
+  "source",
+  "path",
+  "url"
+];
+var BODY_KEYS = ["prompt", "text", "subject_description"];
+function scalarField(params, key) {
+  const value = params[key];
+  if (typeof value === "number") return String(value);
+  if (typeof value !== "string") return void 0;
+  const trimmed = value.trim();
+  return trimmed && !trimmed.startsWith(REF_PREFIX) ? trimmed : void 0;
+}
+function compactJson(params) {
+  try {
+    const json = JSON.stringify(params);
+    return json && json !== "{}" ? json : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function cap(text) {
+  return text.length > MAX_PARAMS_PREVIEW_LENGTH ? `${text.slice(0, MAX_PARAMS_PREVIEW_LENGTH - 1)}\u2026` : text;
+}
+function nodeParamsPreview(params, deps) {
+  const refsLine = deps && deps.length > 0 ? `refs: ${deps.join(", ")}` : void 0;
+  if (!params || typeof params !== "object") return refsLine;
+  const own = params;
+  const nested = (key) => own[key] && typeof own[key] === "object" && !Array.isArray(own[key]) ? own[key] : {};
+  const record = { ...nested("paint"), ...nested("words"), ...own };
+  const spec = [];
+  for (const key of SPEC_KEYS) {
+    const value = scalarField(record, key);
+    if (value !== void 0) spec.push(`${key}: ${value}`);
+  }
+  if (refsLine) spec.push(refsLine);
+  const body = BODY_KEYS.map((key) => scalarField(record, key)).find(Boolean);
+  const header = spec.join("\n");
+  const composed = header && body ? `${header}
+
+${body}` : header || body || compactJson(record);
+  return composed ? cap(composed) : void 0;
+}
+
+export {
+  nodeParamsPreview
+};
+//# sourceMappingURL=chunk-RJZS4XDJ.js.map

package/dist/chunk-RMMSBI5C.js

@@ -0,0 +1,149 @@
+import {
+  hintLines,
+  splitHints
+} from "./chunk-D5FY4FAK.js";
+import {
+  isNotConnectedError,
+  writeJsonEnvelope
+} from "./chunk-2VIZ4UUZ.js";
+import {
+  ApiError,
+  apiPost
+} from "./chunk-6YLNY6CK.js";
+import {
+  requireChatId,
+  resolveChatId
+} from "./chunk-57KKVDDR.js";
+
+// src/commands/tag-manager/shared.ts
+import { readFileSync } from "fs";
+function failValidation(message) {
+  writeJsonEnvelope({ ok: false, error: { code: "VALIDATION_ERROR", message } });
+  process.exit(1);
+}
+function requireTarget(args, entity) {
+  const positional = Array.isArray(args._) ? args._[0] : void 0;
+  const target = args.id ?? args.target ?? positional;
+  if (typeof target !== "string" || target.length === 0) {
+    failValidation(`pass the ${entity} id or path as the positional argument`);
+  }
+  return target;
+}
+function loadJsonArg(args, flag = "json") {
+  const inline = args[flag];
+  const file = args.file;
+  const raw = typeof file === "string" && file.length > 0 ? readFileSync(file, "utf8") : typeof inline === "string" && inline.length > 0 ? inline : void 0;
+  if (raw === void 0) {
+    failValidation(`pass --${flag} with inline JSON or --file with a path to a JSON file`);
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      failValidation(`--${flag} must be a JSON object`);
+    }
+    return parsed;
+  } catch {
+    return failValidation(`--${flag} is not valid JSON`);
+  }
+}
+var RETRYABLE_CODES = /* @__PURE__ */ new Set(["RATE_LIMITED", "UNAVAILABLE", "INTERNAL_ERROR", "NETWORK_ERROR", "TIMEOUT"]);
+function handleError(err) {
+  if (err instanceof ApiError) {
+    writeJsonEnvelope({
+      ok: false,
+      error: {
+        code: err.code,
+        message: err.message,
+        ...err.code === "UNAUTHORIZED" || err.code === "FORBIDDEN" && isNotConnectedError(err.code, err.message) ? {
+          fix: {
+            action: "request_connection",
+            explanation: 'Tag Manager is not connected for this company yet, or no container has been picked. Don\'t send the user to Settings \u2014 call the `request_connection` tool with { platform: "google-tag-manager", reason } and they connect and pick their containers (they can pick more than one) from inside the chat. `request_tag_input` is not the route: that form manages the container snippet on the site, not what runs inside the container, and it cannot pick a container. If the `request_connection` call fails, say so plainly and give the exact route: dashboard \u2192 Brain \u2192 Integrations \u2192 Platforms \u2192 Google Tag Manager, where they also pick the container. Then carry on with the rest of the task.'
+          }
+        } : {},
+        retryable: RETRYABLE_CODES.has(err.code)
+      }
+    });
+    process.exit(1);
+  }
+  writeJsonEnvelope({ ok: false, error: { code: "NETWORK_ERROR", message: "Unexpected error", retryable: true } });
+  process.exit(1);
+}
+var TAG_MANAGER_TIMEOUT_MS = 18e4;
+var STAGE_HINTS = [
+  "Staged only \u2014 nothing has changed in Tag Manager yet. These apply when the chat completes, in dependency order, and close as a Tag Manager version that is then published, so they do go live on the user's site. Say the changes are ready and go live when they publish \u2014 not that they are live already."
+];
+async function stageOp(op) {
+  const chatId = requireChatId();
+  try {
+    const { data, hints } = splitHints(
+      await apiPost(
+        "/api/tag-manager/draft/stage",
+        { chatId, op },
+        { timeoutMs: TAG_MANAGER_TIMEOUT_MS }
+      )
+    );
+    writeJsonEnvelope({ ok: true, data, hints: [...hints, ...STAGE_HINTS] });
+  } catch (err) {
+    handleError(err);
+  }
+}
+async function draftAction(path, body, chat) {
+  const chatId = resolveChatId(chat);
+  try {
+    const { data, hints } = splitHints(
+      await apiPost(path, { chatId, ...body }, { timeoutMs: TAG_MANAGER_TIMEOUT_MS })
+    );
+    writeJsonEnvelope({ ok: true, data, ...hints.length > 0 ? { hints } : {} });
+    return data;
+  } catch (err) {
+    handleError(err);
+  }
+}
+function renderDraft(response) {
+  if (response.count === 0) {
+    return "No Tag Manager changes staged on this chat.";
+  }
+  const lines = [
+    `${response.count} staged Tag Manager change(s)`,
+    ...response.ops.flatMap((op) => {
+      const status = op.result ? ` [${op.result.status}]` : "";
+      return [`  ${op.ref}  ${op.summary}${status}`, ...(op.warnings ?? []).map((warning) => `    \u26A0 ${warning}`)];
+    })
+  ];
+  if (response.versionId) {
+    lines.push(
+      "",
+      response.published ? `Applied and published as Tag Manager version ${response.versionId}. These changes are live on the site.` : `Applied into Tag Manager version ${response.versionId}. It is NOT published \u2014 publish it in Tag Manager to go live.`
+    );
+  }
+  if (response.compilerError) {
+    lines.push("", `Tag Manager reported a problem building the version: ${response.compilerError}`);
+  }
+  return lines.join("\n");
+}
+async function draftList(json, chat) {
+  const chatId = resolveChatId(chat);
+  try {
+    const response = await apiPost("/api/tag-manager/draft", { chatId });
+    const { data, hints } = splitHints(response);
+    if (json) {
+      writeJsonEnvelope({ ok: true, data, ...hints.length > 0 ? { hints } : {} });
+      return;
+    }
+    process.stdout.write(`${renderDraft(data)}${hintLines(response)}
+`);
+  } catch (err) {
+    handleError(err);
+  }
+}
+
+export {
+  requireTarget,
+  loadJsonArg,
+  handleError,
+  TAG_MANAGER_TIMEOUT_MS,
+  stageOp,
+  draftAction,
+  draftList
+};
+//# sourceMappingURL=chunk-RMMSBI5C.js.map