@koda-sl/baker-cli 0.569.0 → 0.571.0-dev.6a3439a0a

package/dist/activecampaign-EYRHDSXY.js

@@ -0,0 +1,938 @@
+import {
+  CHAT_READ_ARG
+} from "./chunk-X32MFGWW.js";
+import {
+  failApi
+} from "./chunk-YAINUFSC.js";
+import "./chunk-6DSPB6YA.js";
+import "./chunk-QV6AST5T.js";
+import "./chunk-WCU362Z6.js";
+import "./chunk-GIWHHCD6.js";
+import "./chunk-SOPVIIUW.js";
+import "./chunk-G4FG5EQO.js";
+import "./chunk-R7XDGNZD.js";
+import "./chunk-IMS53EQU.js";
+import {
+  ApiError,
+  apiPost
+} from "./chunk-LJEJCIHR.js";
+import "./chunk-SIRRBWQ2.js";
+import {
+  requireChatId,
+  resolveChatId
+} from "./chunk-B64KJW5C.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-NXNOXZGB.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/activecampaign/index.ts
+import { defineCommand as defineCommand5 } from "citty";
+
+// src/commands/activecampaign/drafts.ts
+import { defineCommand } from "citty";
+
+// src/commands/activecampaign/refusal.ts
+var CONTINUE = "Keep going with the wider task: say which part you could not read, skip it, and finish everything else.";
+function activeCampaignRefusal(code, message) {
+  if (code === "NOT_FOUND" && (message.includes("No ActiveCampaign account is connected") || message.includes("ActiveCampaign connection no longer exists"))) {
+    return {
+      code: "NO_ACTIVECAMPAIGN_CONNECTION",
+      fix: {
+        action: "request_connection",
+        explanation: 'AGENT INSTRUCTION: ActiveCampaign is not connected, and only the user can connect it. Call the `request_connection` tool with { platform: "activecampaign", reason } \u2014 reason in their words \u2014 and they paste the API URL and key inside the chat; then run this command again. ' + CONTINUE
+      }
+    };
+  }
+  if (code === "CONFLICT" && message.includes("connect ActiveCampaign again")) {
+    return {
+      code: "ACTIVECAMPAIGN_RECONNECT_REQUIRED",
+      fix: {
+        action: "request_connection",
+        explanation: 'AGENT INSTRUCTION: ActiveCampaign is connected, but its saved key no longer works \u2014 do not retry. Call the `request_connection` tool with { platform: "activecampaign", reason } so the user pastes a current key, then run this command again. ' + CONTINUE
+      }
+    };
+  }
+  return null;
+}
+function failActiveCampaign(err) {
+  const refusal = err instanceof ApiError ? activeCampaignRefusal(err.code, err.message) : null;
+  if (err instanceof ApiError && refusal !== null) {
+    writeJson({ ok: false, error: { code: refusal.code, message: err.message, fix: refusal.fix } });
+    process.exit(1);
+  }
+  failApi(err);
+}
+
+// src/commands/activecampaign/drafts.ts
+var DESCRIPTION = "The ActiveCampaign changes staged on this chat \u2014 fields, lists, tags, pipelines \u2014 and, once published, what happened to each (created, reused because it already existed, or failed and why). Take --chat <id> to read an earlier chat's.";
+registerSchema({
+  command: "activecampaign.drafts",
+  description: DESCRIPTION,
+  args: { chat: { type: "string", description: CHAT_READ_ARG.description, required: false } }
+});
+function outcomeOf(op) {
+  if (!op.result) return void 0;
+  if (op.result.status === "applied") return op.result.reused ? "already there, reused" : "created";
+  return op.result.status === "failed" ? `failed: ${op.result.error ?? "no reason given"}` : "not sent";
+}
+var draftsCommand = defineCommand({
+  meta: { name: "drafts", description: DESCRIPTION },
+  args: { chat: CHAT_READ_ARG },
+  run: async ({ args }) => {
+    const chatId = resolveChatId(args.chat);
+    try {
+      const data = await apiPost("/api/activecampaign/draft", { chatId });
+      const ops = data.ops.map((op) => {
+        const outcome = outcomeOf(op);
+        return { ref: op.ref, kind: op.kind, summary: op.summary, ...outcome ? { outcome } : {} };
+      });
+      const hints = data.status === "active" && data.count > 0 ? ["Staged only \u2014 these are created in ActiveCampaign when the user publishes this chat."] : [];
+      writeJson({
+        ok: true,
+        data: {
+          status: data.status,
+          count: data.count,
+          ops,
+          ...data.publishError ? { publishError: data.publishError } : {}
+        },
+        ...hints.length > 0 ? { hints } : {}
+      });
+    } catch (err) {
+      failActiveCampaign(err);
+    }
+  }
+});
+
+// ../api/src/activecampaign-reads.ts
+import { z } from "zod";
+var raw = z.record(z.string(), z.unknown()).optional();
+var limit = z.number().int().min(1).max(100).optional();
+var baseRequest = z.object({
+  /** Connection id; optional when the company has exactly one ActiveCampaign account. */
+  account: z.string().optional(),
+  full: z.boolean().optional()
+});
+function envelope(shape) {
+  return z.object({ ok: z.literal(true), data: z.object({ account: z.string(), ...shape }) });
+}
+var activeCampaignAccountSummarySchema = z.object({
+  label: z.string(),
+  apiUrl: z.string(),
+  contactCount: z.number().nullable(),
+  siteTracking: z.object({
+    enabled: z.boolean().nullable(),
+    /** The id `vgo('setAccount', …)` takes — what the ActiveCampaign tag on a landing needs. */
+    trackingAccountId: z.string().nullable(),
+    /** Domains ActiveCampaign accepts visits from; empty means it records visits from none. */
+    domains: z.array(z.string())
+  }),
+  eventTracking: z.object({ enabled: z.boolean().nullable() })
+});
+var activeCampaignAccountResponseSchema = envelope({ summary: activeCampaignAccountSummarySchema });
+var activeCampaignListRowSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  activeContacts: z.number().nullable(),
+  createdAt: z.string().nullable(),
+  raw
+});
+var activeCampaignListsResponseSchema = envelope({ lists: z.array(activeCampaignListRowSchema) });
+var activeCampaignAutomationsRequestSchema = baseRequest.extend({ activeOnly: z.boolean().optional() });
+var ACTIVECAMPAIGN_AUTOMATION_STATUSES = ["active", "inactive", "unknown"];
+var activeCampaignAutomationRowSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  status: z.enum(ACTIVECAMPAIGN_AUTOMATION_STATUSES),
+  /** Contacts that have ever entered / finished it. */
+  entered: z.number().nullable(),
+  exited: z.number().nullable(),
+  /** What starts it (`subscribe`, `tagadd`, …), as ActiveCampaign names its triggers. */
+  triggers: z.array(z.string()),
+  createdAt: z.string().nullable(),
+  modifiedAt: z.string().nullable(),
+  raw
+});
+var activeCampaignAutomationsResponseSchema = envelope({
+  automations: z.array(activeCampaignAutomationRowSchema)
+});
+var activeCampaignStageSchema = z.object({ id: z.string(), title: z.string(), order: z.number().nullable() });
+var activeCampaignPipelineRowSchema = z.object({
+  id: z.string(),
+  title: z.string(),
+  currency: z.string().nullable(),
+  /** In board order: the first is where a new deal lands. */
+  stages: z.array(activeCampaignStageSchema),
+  raw
+});
+var activeCampaignPipelinesResponseSchema = envelope({
+  pipelines: z.array(activeCampaignPipelineRowSchema)
+});
+var activeCampaignTagsRequestSchema = baseRequest.extend({ search: z.string().optional() });
+var activeCampaignTagRowSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  /** `contact` or `template`; only contact tags can be put on a lead. */
+  type: z.string().nullable(),
+  contactCount: z.number().nullable(),
+  raw
+});
+var activeCampaignTagsResponseSchema = envelope({ tags: z.array(activeCampaignTagRowSchema) });
+var activeCampaignCustomFieldRowSchema = z.object({
+  id: z.string(),
+  title: z.string(),
+  /** ActiveCampaign's type: `text`, `textarea`, `date`, `dropdown`, `multiselect`, `radio`, `checkbox`, … */
+  type: z.string().nullable(),
+  perstag: z.string().nullable(),
+  required: z.boolean(),
+  /** For a choice field, what may be stored (`value`) and what people see (`label`). */
+  options: z.array(z.object({ value: z.string(), label: z.string() })),
+  /** True when the field shows on every list (ActiveCampaign's relid 0). */
+  allLists: z.boolean(),
+  listIds: z.array(z.string()),
+  raw
+});
+var activeCampaignCustomFieldsResponseSchema = envelope({
+  fields: z.array(activeCampaignCustomFieldRowSchema)
+});
+var activeCampaignUserRowSchema = z.object({
+  id: z.string(),
+  username: z.string().nullable(),
+  name: z.string().nullable(),
+  email: z.string().nullable(),
+  raw
+});
+var activeCampaignUsersResponseSchema = envelope({ users: z.array(activeCampaignUserRowSchema) });
+var ACTIVECAMPAIGN_CAMPAIGN_STATUSES = [
+  "draft",
+  "scheduled",
+  "sending",
+  "paused",
+  "stopped",
+  "completed"
+];
+var isoDay = z.string().regex(/^\d{4}-\d{2}-\d{2}$/, "Use a date like 2026-01-31");
+var activeCampaignCampaignsRequestSchema = baseRequest.extend({
+  status: z.enum(ACTIVECAMPAIGN_CAMPAIGN_STATUSES).optional(),
+  /** Only campaigns first sent on or after this day. */
+  since: isoDay.optional(),
+  limit
+});
+var activeCampaignCampaignRatesSchema = z.object({
+  open: z.number().nullable(),
+  click: z.number().nullable(),
+  clickToOpen: z.number().nullable(),
+  unsubscribe: z.number().nullable(),
+  bounce: z.number().nullable()
+});
+var activeCampaignCampaignRowSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  /** `single`, `recurring`, `split`, `responder`, `reminder`, `special`, `activerss`, `text`, … */
+  type: z.string().nullable(),
+  status: z.enum([...ACTIVECAMPAIGN_CAMPAIGN_STATUSES, "unknown"]),
+  /** When it (first) went out, and when its last send ran — ActiveCampaign's `sdate` / `ldate`. */
+  sentAt: z.string().nullable(),
+  lastSentAt: z.string().nullable(),
+  /** Set when an automation sends it. */
+  automationId: z.string().nullable(),
+  sends: z.number(),
+  opens: z.number(),
+  uniqueOpens: z.number(),
+  clicks: z.number(),
+  uniqueClicks: z.number(),
+  unsubscribes: z.number(),
+  hardBounces: z.number(),
+  softBounces: z.number(),
+  rates: activeCampaignCampaignRatesSchema,
+  raw
+});
+var activeCampaignCampaignsResponseSchema = envelope({
+  campaigns: z.array(activeCampaignCampaignRowSchema),
+  /** True when more campaigns matched than `limit` returned. */
+  truncated: z.boolean()
+});
+var activeCampaignContactsRequestSchema = baseRequest.extend({
+  /** The contact's ActiveCampaign id — what an ActiveCampaign event's `contact.id` carries. */
+  id: z.string().optional(),
+  email: z.string().optional(),
+  /** A tag's id or exact name. */
+  tag: z.string().optional(),
+  /** A list's id or exact name. */
+  list: z.string().optional(),
+  /** ActiveCampaign's own search over name, email, phone and organisation. */
+  search: z.string().optional(),
+  limit
+});
+var activeCampaignContactRowSchema = z.object({
+  id: z.string(),
+  email: z.string().nullable(),
+  firstName: z.string().nullable(),
+  lastName: z.string().nullable(),
+  createdAt: z.string().nullable(),
+  updatedAt: z.string().nullable(),
+  /** The contact's tags by name; only on a lookup by `id` or `email`. */
+  tags: z.array(z.string()).optional(),
+  /** What the contact did and what ActiveCampaign did with them; only on a lookup by `id` or `email`. */
+  activity: z.object({
+    /** Custom events (`event.name` on a Form, or any event tracking), newest first. */
+    events: z.array(z.object({ name: z.string(), data: z.string().nullable(), at: z.string().nullable() })),
+    /** Site-tracking page visits, newest first. */
+    pageVisits: z.array(z.object({ url: z.string(), at: z.string().nullable() })),
+    /** Campaign emails: each one sent, opened, and each tracked link clicked (with its address), newest first. */
+    emails: z.array(
+      z.object({
+        campaignId: z.string(),
+        event: z.enum(["sent", "opened", "clicked"]),
+        url: z.string().nullable(),
+        at: z.string().nullable()
+      })
+    ),
+    automations: z.array(
+      z.object({
+        id: z.string(),
+        name: z.string().nullable(),
+        status: z.enum(["running", "completed", "unknown"]),
+        startedAt: z.string().nullable(),
+        endedAt: z.string().nullable()
+      })
+    ),
+    lists: z.array(
+      z.object({
+        id: z.string(),
+        name: z.string().nullable(),
+        status: z.enum(["subscribed", "unsubscribed", "unconfirmed", "bounced", "unknown"]),
+        since: z.string().nullable()
+      })
+    )
+  }).optional(),
+  raw
+});
+var activeCampaignContactsResponseSchema = envelope({
+  /** Every contact the filters match, of which `contacts` is the newest `limit`. */
+  total: z.number().nullable(),
+  contacts: z.array(activeCampaignContactRowSchema)
+});
+var ACTIVECAMPAIGN_DEAL_STATUSES = ["open", "won", "lost"];
+var activeCampaignDealsRequestSchema = baseRequest.extend({
+  /** A pipeline's id or exact title. */
+  pipeline: z.string().optional(),
+  /** A stage's id or exact title (within `pipeline` when both are given). */
+  stage: z.string().optional(),
+  status: z.enum(ACTIVECAMPAIGN_DEAL_STATUSES).optional(),
+  /** A user's id, username or email. */
+  owner: z.string().optional(),
+  limit
+});
+var named = z.object({ id: z.string(), title: z.string() }).nullable();
+var activeCampaignDealRowSchema = z.object({
+  id: z.string(),
+  title: z.string(),
+  /** In the currency's major units (ActiveCampaign stores cents). */
+  value: z.number().nullable(),
+  currency: z.string().nullable(),
+  status: z.enum([...ACTIVECAMPAIGN_DEAL_STATUSES, "unknown"]),
+  pipeline: named,
+  stage: named,
+  ownerId: z.string().nullable(),
+  contactId: z.string().nullable(),
+  createdAt: z.string().nullable(),
+  modifiedAt: z.string().nullable(),
+  raw
+});
+var activeCampaignDealTotalSchema = z.object({
+  currency: z.string(),
+  count: z.number(),
+  /** Major units, every matching deal — not only the rows returned. */
+  value: z.number()
+});
+var activeCampaignDealsResponseSchema = envelope({
+  total: z.number().nullable(),
+  totals: z.array(activeCampaignDealTotalSchema),
+  deals: z.array(activeCampaignDealRowSchema)
+});
+function activeCampaignReadPath(read) {
+  return `/api/activecampaign/reads/${read}`;
+}
+
+// src/commands/activecampaign/reads.ts
+import { defineCommand as defineCommand2 } from "citty";
+var COMMON_ARGS = {
+  account: {
+    type: "string",
+    description: "Which connection to read when the company has more than one (the id the error lists)",
+    required: false
+  },
+  full: {
+    type: "boolean",
+    description: "Add each row's untouched ActiveCampaign payload as `raw`",
+    required: false,
+    default: false
+  }
+};
+var LIMIT_ARG = { type: "string", description: "How many rows, 1-100 (default 20)", required: false };
+function parseLimit(value) {
+  if (value === void 0 || value === "") return void 0;
+  const limit2 = Number(value);
+  if (!Number.isInteger(limit2) || limit2 < 1 || limit2 > 100) {
+    throw new ApiError("VALIDATION_ERROR", "--limit must be a whole number from 1 to 100");
+  }
+  return limit2;
+}
+function optionalString(value) {
+  return typeof value === "string" && value.trim() !== "" ? value.trim() : void 0;
+}
+function readCommand(spec) {
+  const args = { ...spec.args ?? {}, ...COMMON_ARGS };
+  registerSchema({ command: `activecampaign.${spec.read}`, description: spec.description, args });
+  return defineCommand2({
+    meta: { name: spec.read, description: spec.description },
+    args,
+    run: async ({ args: values }) => {
+      try {
+        const body = {
+          ...spec.body ? spec.body(values) : {},
+          ...optionalString(values.account) ? { account: optionalString(values.account) } : {},
+          ...values.full === true ? { full: true } : {}
+        };
+        const response = await apiPost(activeCampaignReadPath(spec.read), body);
+        const hints = spec.hints ? spec.hints(response.data, values) : [];
+        writeJson({
+          ok: true,
+          data: response.data,
+          meta: { count: spec.rows(response.data).length },
+          ...hints.length > 0 ? { hints } : {}
+        });
+      } catch (err) {
+        failActiveCampaign(err);
+      }
+    }
+  });
+}
+var accountCommand = readCommand({
+  read: "account",
+  description: "Start here for ActiveCampaign: the connected account at a glance \u2014 its label, how many contacts it holds, whether site tracking is on (and its tracking account id, the one id the ActiveCampaign tag on a landing needs), which domains it accepts visits from, and whether event tracking is on. Example: baker activecampaign account",
+  rows: (data) => [data.summary],
+  hints: ({ summary }) => {
+    const hints = [];
+    if (summary.siteTracking.enabled === false) {
+      hints.push(
+        "Site tracking is off in ActiveCampaign, so it records no page visits for these contacts even with the tag on a page."
+      );
+    }
+    if (summary.siteTracking.enabled && summary.siteTracking.domains.length === 0) {
+      hints.push("Site tracking is on but no domain is allowed, so ActiveCampaign ignores visits from every site.");
+    }
+    return hints;
+  }
+});
+var listsCommand = readCommand({
+  read: "lists",
+  description: "Every list on the connected ActiveCampaign account with its id and how many active contacts it holds. Use the id or the name with `baker activecampaign contacts --list`. Example: baker activecampaign lists",
+  rows: (data) => data.lists
+});
+var automationsCommand = readCommand({
+  read: "automations",
+  description: "Every automation on the connected ActiveCampaign account: on or off, how many contacts entered and finished it, and what starts it (subscribe, tag added, \u2026). Read it when auditing what happens to a lead after it arrives \u2014 an automation that is off looks connected and does nothing. Example: baker activecampaign automations --active-only",
+  args: {
+    "active-only": { type: "boolean", description: "Only automations that are on", required: false, default: false }
+  },
+  body: (args) => args["active-only"] === true ? { activeOnly: true } : {},
+  rows: (data) => data.automations,
+  hints: (data) => data.automations.length === 0 ? ["This account has no automations, so nothing runs after a lead arrives unless someone acts on it by hand."] : []
+});
+var pipelinesCommand = readCommand({
+  read: "pipelines",
+  description: "Deal pipelines on the connected ActiveCampaign account with their stages in board order \u2014 the first stage is where a new deal lands. Ids and titles feed `baker activecampaign deals --pipeline/--stage`. Example: baker activecampaign pipelines",
+  rows: (data) => data.pipelines,
+  hints: (data) => data.pipelines.length === 0 ? ["This account has no deal pipelines, so there are no deals to read."] : []
+});
+var tagsCommand = readCommand({
+  read: "tags",
+  description: "Tags on the connected ActiveCampaign account with how many contacts carry each. Use a name with `baker activecampaign contacts --tag`. Example: baker activecampaign tags --search withbaker-",
+  args: { search: { type: "string", description: "Only tags whose name contains this text", required: false } },
+  body: (args) => optionalString(args.search) ? { search: optionalString(args.search) } : {},
+  rows: (data) => data.tags
+});
+var fieldsCommand = readCommand({
+  read: "fields",
+  description: "The account's own custom contact fields: id, title, type, personalization tag, whether it is required, the choices a dropdown/radio/checkbox accepts (store the `value`), and which lists it shows on. Map a Form answer onto one with `baker flows map` (`custom.<id>` or the tag). Example: baker activecampaign fields",
+  rows: (data) => data.fields
+});
+var usersCommand = readCommand({
+  read: "users",
+  description: "The people with a login on the connected ActiveCampaign account \u2014 who can own a deal. Example: baker activecampaign users",
+  rows: (data) => data.users
+});
+var campaignsCommand = readCommand({
+  read: "campaigns",
+  description: "Email campaign reports from the connected ActiveCampaign account, most recently sent first: status, send date, sends, opens and unique opens, clicks and unique clicks, unsubscribes, hard and soft bounces, and the rates (open, click and unsubscribe rates are shares of sends; click-to-open is unique clicks over unique opens; 0-1, null before anything is sent). Start here for 'how are my emails doing'. Example: baker activecampaign campaigns --since 2026-09-01 --status completed",
+  args: {
+    status: {
+      type: "string",
+      description: `Only campaigns in this state: ${ACTIVECAMPAIGN_CAMPAIGN_STATUSES.join("|")}`,
+      required: false,
+      enum: [...ACTIVECAMPAIGN_CAMPAIGN_STATUSES]
+    },
+    since: { type: "string", description: "Only campaigns sent on or after this day (YYYY-MM-DD)", required: false },
+    limit: LIMIT_ARG
+  },
+  body: (args) => ({
+    ...optionalString(args.status) ? { status: optionalString(args.status) } : {},
+    ...optionalString(args.since) ? { since: optionalString(args.since) } : {},
+    ...parseLimit(args.limit) ? { limit: parseLimit(args.limit) } : {}
+  }),
+  rows: (data) => data.campaigns,
+  hints: (data) => {
+    const hints = [];
+    if (data.truncated) hints.push("More campaigns matched than were returned; raise --limit or narrow with --since.");
+    if (data.campaigns.length === 0) hints.push("No campaign matched \u2014 this account may not have sent any yet.");
+    if (data.campaigns.some((campaign) => campaign.automationId !== null)) {
+      hints.push("Rows with an automationId are emails an automation sends; their counts grow as contacts enter it.");
+    }
+    return hints;
+  }
+});
+var contactsCommand = readCommand({
+  read: "contacts",
+  description: "Contacts on the connected ActiveCampaign account, newest first: one by --email (was this lead received?) or by --id (the `contact.id` an ActiveCampaign event carries \u2014 a scheduled agent's payload never holds the email), each with its `tags` by name and its `activity` (events, page visits, campaign emails sent/opened/clicked, automation runs, list subscriptions \u2014 did the Form's event land? did it enter the automation?); everyone with a --tag or on a --list (id or exact name), or a --search; with no filter, the most recent. `total` counts every match, so `--limit 1` answers 'how many'. Rows are personal data: quote counts in a report, never names or emails. Example: baker activecampaign contacts --tag withbaker-/pricing --limit 5",
+  args: {
+    id: { type: "string", description: "The contact's ActiveCampaign id, e.g. an event's contact.id", required: false },
+    email: { type: "string", description: "The contact's exact email", required: false },
+    tag: { type: "string", description: "A tag id or exact name", required: false },
+    list: { type: "string", description: "A list id or exact name", required: false },
+    search: { type: "string", description: "Free text over name, email, phone and organisation", required: false },
+    limit: LIMIT_ARG
+  },
+  body: (args) => ({
+    ...Object.fromEntries(
+      ["id", "email", "tag", "list", "search"].flatMap(
+        (key) => optionalString(args[key]) ? [[key, optionalString(args[key])]] : []
+      )
+    ),
+    ...parseLimit(args.limit) ? { limit: parseLimit(args.limit) } : {}
+  }),
+  rows: (data) => data.contacts,
+  hints: (data, args) => optionalString(args.email) && data.contacts.length === 0 ? ["No contact has that email: the lead never reached ActiveCampaign. That is a finding, not an error."] : optionalString(args.id) && data.contacts.length === 0 ? ["No contact has that id: it was deleted or merged in ActiveCampaign since the event."] : []
+});
+var dealsCommand = readCommand({
+  read: "deals",
+  description: "Deals on the connected ActiveCampaign account, newest first, narrowed by --pipeline / --stage (id or exact title, from `baker activecampaign pipelines`), --status open|won|lost and --owner (user id, username or email). Values are in the currency's major units; `totals` sums every matching deal per currency, not only the rows returned. Example: baker activecampaign deals --status won",
+  args: {
+    pipeline: { type: "string", description: "A pipeline id or exact title", required: false },
+    stage: { type: "string", description: "A stage id or exact title", required: false },
+    status: {
+      type: "string",
+      description: `Only deals that are ${ACTIVECAMPAIGN_DEAL_STATUSES.join("|")}`,
+      required: false,
+      enum: [...ACTIVECAMPAIGN_DEAL_STATUSES]
+    },
+    owner: { type: "string", description: "A user id, username or email", required: false },
+    limit: LIMIT_ARG
+  },
+  body: (args) => ({
+    ...Object.fromEntries(
+      ["pipeline", "stage", "status", "owner"].flatMap(
+        (key) => optionalString(args[key]) ? [[key, optionalString(args[key])]] : []
+      )
+    ),
+    ...parseLimit(args.limit) ? { limit: parseLimit(args.limit) } : {}
+  }),
+  rows: (data) => data.deals
+});
+var READ_COMMANDS = {
+  account: accountCommand,
+  lists: listsCommand,
+  automations: automationsCommand,
+  pipelines: pipelinesCommand,
+  tags: tagsCommand,
+  fields: fieldsCommand,
+  users: usersCommand,
+  campaigns: campaignsCommand,
+  contacts: contactsCommand,
+  deals: dealsCommand
+};
+
+// ../api/src/activecampaign-writes.ts
+import { z as z2 } from "zod";
+var ACTIVECAMPAIGN_WRITE_KINDS = ["field", "list", "tag", "pipeline"];
+var ACTIVECAMPAIGN_STAGEABLE_FIELD_TYPES = [
+  "text",
+  "textarea",
+  "date",
+  "datetime",
+  "dropdown",
+  "listbox",
+  "radio",
+  "checkbox",
+  "hidden"
+];
+var OPTION_FIELD_TYPES = /* @__PURE__ */ new Set([
+  "dropdown",
+  "listbox",
+  "radio",
+  "checkbox"
+]);
+function activeCampaignFieldTakesOptions(type) {
+  return OPTION_FIELD_TYPES.has(type);
+}
+function activeCampaignPerstag(title) {
+  return title.trim().toUpperCase().replace(/\s+/g, "_").replace(/[^A-Z0-9_]/g, "");
+}
+var name = z2.string().trim().min(1).max(255);
+var description = z2.string().trim().max(1e3).optional();
+var PERSTAG = /^[A-Z0-9_]+$/;
+var activeCampaignFieldOpSchema = z2.object({
+  kind: z2.literal("field"),
+  title: name,
+  type: z2.enum(ACTIVECAMPAIGN_STAGEABLE_FIELD_TYPES).default("text"),
+  /** `UTM_SOURCE` — what Forms map onto (`custom.UTM_SOURCE`). Derived from the title when absent. */
+  perstag: z2.string().trim().transform((value) => value.replace(/^%|%$/g, "").toUpperCase()).pipe(z2.string().min(1).max(100).regex(PERSTAG, "perstag may only use letters, digits and _ (like UTM_SOURCE)")).optional(),
+  options: z2.array(name).max(200).optional(),
+  description
+}).superRefine((op, ctx) => {
+  const takesOptions = activeCampaignFieldTakesOptions(op.type);
+  if (takesOptions && (op.options ?? []).length === 0) {
+    ctx.addIssue({ code: "custom", path: ["options"], message: `a ${op.type} field needs at least one option` });
+  }
+  if (!takesOptions && op.options !== void 0) {
+    ctx.addIssue({ code: "custom", path: ["options"], message: `a ${op.type} field takes no options` });
+  }
+  if (op.perstag === void 0 && activeCampaignPerstag(op.title) === "") {
+    ctx.addIssue({
+      code: "custom",
+      path: ["perstag"],
+      message: "pass --perstag: the title has no letters or digits"
+    });
+  }
+  const values = (op.options ?? []).map((option) => option.toLowerCase());
+  if (new Set(values).size !== values.length) {
+    ctx.addIssue({ code: "custom", path: ["options"], message: "options must not repeat" });
+  }
+});
+var activeCampaignListOpSchema = z2.object({ kind: z2.literal("list"), name, description });
+var activeCampaignTagOpSchema = z2.object({ kind: z2.literal("tag"), name, description });
+var activeCampaignPipelineOpSchema = z2.object({
+  kind: z2.literal("pipeline"),
+  title: name,
+  currency: z2.string().trim().toLowerCase().regex(/^[a-z]{3}$/, "currency is a three-letter code like usd").default("usd"),
+  /** In order. A new pipeline gets exactly these; an existing one gains the ones it lacks. */
+  stages: z2.array(name).max(30).optional()
+}).superRefine((op, ctx) => {
+  const titles = (op.stages ?? []).map((stage2) => stage2.toLowerCase());
+  if (new Set(titles).size !== titles.length) {
+    ctx.addIssue({ code: "custom", path: ["stages"], message: "stages must not repeat" });
+  }
+});
+var activeCampaignWriteOpSchema = z2.discriminatedUnion("kind", [
+  activeCampaignFieldOpSchema,
+  activeCampaignListOpSchema,
+  activeCampaignTagOpSchema,
+  activeCampaignPipelineOpSchema
+]);
+var activeCampaignDraftOpResultSchema = z2.object({
+  status: z2.enum(["applied", "failed", "skipped"]),
+  /** The id ActiveCampaign gave, or the one it already had. */
+  id: z2.string().optional(),
+  /** True when the account already had it and nothing new was made. */
+  reused: z2.boolean().optional(),
+  note: z2.string().optional(),
+  error: z2.string().optional(),
+  executedAt: z2.number().optional()
+});
+var activeCampaignDraftStageRequestSchema = z2.object({
+  chatId: z2.string().min(1),
+  /** Connection id; optional when the company has exactly one ActiveCampaign account. */
+  account: z2.string().optional(),
+  op: activeCampaignWriteOpSchema
+});
+var activeCampaignDraftStageResponseSchema = z2.object({
+  ref: z2.string(),
+  kind: z2.enum(ACTIVECAMPAIGN_WRITE_KINDS),
+  summary: z2.string(),
+  account: z2.string(),
+  /** True when this replaced an earlier staged op for the same thing. */
+  replaced: z2.boolean(),
+  /** The account already has it: publishing reuses it (a field gains missing options). */
+  alreadyInAccount: z2.boolean(),
+  /** A Form maps a staged field as `custom.<perstag>`. */
+  mapAs: z2.string().optional(),
+  hints: z2.array(z2.string()).optional()
+});
+var activeCampaignDraftListRequestSchema = z2.object({ chatId: z2.string().min(1) });
+var activeCampaignDraftOpViewSchema = z2.object({
+  ref: z2.string(),
+  kind: z2.enum(ACTIVECAMPAIGN_WRITE_KINDS),
+  name: z2.string(),
+  summary: z2.string(),
+  account: z2.string(),
+  stagedAt: z2.number(),
+  result: activeCampaignDraftOpResultSchema.optional()
+});
+var activeCampaignDraftListResponseSchema = z2.object({
+  status: z2.enum(["none", "active", "publishing", "applied", "discarded"]),
+  count: z2.number(),
+  ops: z2.array(activeCampaignDraftOpViewSchema),
+  publishError: z2.string().optional()
+});
+var activeCampaignDraftRemoveRequestSchema = z2.object({
+  chatId: z2.string().min(1),
+  /** A staged ref (`ac_field_1`) or the thing's name / perstag. */
+  ref: z2.string().min(1)
+});
+var activeCampaignDraftRemoveResponseSchema = z2.object({ removed: z2.array(z2.string()) });
+var activeCampaignDraftClearRequestSchema = z2.object({ chatId: z2.string().min(1) });
+var activeCampaignDraftClearResponseSchema = z2.object({ cleared: z2.number() });
+
+// src/commands/activecampaign/stage.ts
+import { defineCommand as defineCommand3 } from "citty";
+var UTM_FIELDS = [
+  ["UTM_SOURCE", "UTM source"],
+  ["UTM_MEDIUM", "UTM medium"],
+  ["UTM_CAMPAIGN", "UTM campaign"],
+  ["UTM_CONTENT", "UTM content"],
+  ["UTM_TERM", "UTM term"]
+];
+function text(value) {
+  return typeof value === "string" && value.trim() !== "" ? value.trim() : void 0;
+}
+function commaList(value) {
+  const raw2 = text(value);
+  return raw2 === void 0 ? void 0 : raw2.split(",").map((part) => part.trim()).filter((part) => part !== "");
+}
+function defined(entries) {
+  return Object.fromEntries(Object.entries(entries).filter(([, value]) => value !== void 0));
+}
+function stageOpsFromArgs(kind, args) {
+  switch (kind) {
+    case "field":
+      if (args.utm === true) {
+        return UTM_FIELDS.map(([perstag, title]) => ({ kind, title, type: "text", perstag }));
+      }
+      return [
+        {
+          kind,
+          ...defined({
+            title: text(args.title),
+            type: text(args.type),
+            perstag: text(args.perstag),
+            options: commaList(args.options),
+            description: text(args.description)
+          })
+        }
+      ];
+    case "list":
+    case "tag":
+      return [{ kind, ...defined({ name: text(args.name), description: text(args.description) }) }];
+    default:
+      return [
+        {
+          kind,
+          ...defined({ title: text(args.title), currency: text(args.currency), stages: commaList(args.stages) })
+        }
+      ];
+  }
+}
+var STAGED_HINT = "Staged only \u2014 nothing has changed in ActiveCampaign yet. It is created when the user publishes this chat (an existing one with the same name is reused, never duplicated). Say it is ready and gets created on Publish \u2014 not that it exists already.";
+async function stage(kind, args) {
+  const chatId = requireChatId();
+  const account = text(args.account);
+  try {
+    const staged = [];
+    for (const op of stageOpsFromArgs(kind, args)) {
+      staged.push(
+        await apiPost("/api/activecampaign/draft/stage", {
+          chatId,
+          ...account ? { account } : {},
+          op
+        })
+      );
+    }
+    const hints = [...new Set(staged.flatMap((entry) => entry.hints ?? []))];
+    const mapAs = staged.flatMap((entry) => entry.mapAs ? [entry.mapAs] : []);
+    if (mapAs.length > 0) {
+      hints.push(
+        `Map a Form answer onto it with \`baker flows map\` as ${mapAs.map((key) => `\`${key}\``).join(", ")} \u2014 the field is found by its perstag when a lead arrives, so the mapping works before and after Publish creates it.`
+      );
+    }
+    if (staged.some((entry) => entry.alreadyInAccount)) {
+      hints.push("The account already has at least one of these: Publish reuses it rather than creating a copy.");
+    }
+    const data = staged.map(({ hints: _hints, ...entry }) => entry);
+    writeJson({ ok: true, data: data.length === 1 ? data[0] : data, hints: [STAGED_HINT, ...hints] });
+  } catch (err) {
+    failActiveCampaign(err);
+  }
+}
+var ACCOUNT_ARG = {
+  type: "string",
+  description: "Which ActiveCampaign connection, when the company has more than one (the id the error lists)",
+  required: false
+};
+var FIELD_ARGS = {
+  title: { type: "string", description: 'Field name as people see it, e.g. "UTM source"', required: false },
+  type: {
+    type: "string",
+    description: `${ACTIVECAMPAIGN_STAGEABLE_FIELD_TYPES.join("|")} (default text)`,
+    required: false
+  },
+  perstag: {
+    type: "string",
+    description: "Personalization tag, e.g. UTM_SOURCE \u2014 what Forms map onto (custom.UTM_SOURCE). Default: from the title",
+    required: false
+  },
+  options: {
+    type: "string",
+    description: 'Comma-separated choices for dropdown|listbox|radio|checkbox, e.g. "Basic,Pro"',
+    required: false
+  },
+  description: { type: "string", description: "Help text shown with the field", required: false },
+  utm: {
+    type: "boolean",
+    description: "Stage the five UTM text fields at once: UTM_SOURCE, UTM_MEDIUM, UTM_CAMPAIGN, UTM_CONTENT, UTM_TERM",
+    required: false
+  },
+  account: ACCOUNT_ARG
+};
+var NAMED_ARGS = {
+  name: { type: "string", description: "Its name in ActiveCampaign", required: false },
+  description: { type: "string", description: "Optional description", required: false },
+  account: ACCOUNT_ARG
+};
+var PIPELINE_ARGS = {
+  title: { type: "string", description: 'Pipeline name, e.g. "Inbound leads"', required: false },
+  stages: {
+    type: "string",
+    description: 'Comma-separated stages in order, e.g. "New lead,Qualified,Proposal,Won". A new pipeline gets exactly these; an existing one only gains the missing ones',
+    required: false
+  },
+  currency: { type: "string", description: "Deal currency, three letters (default usd)", required: false },
+  account: ACCOUNT_ARG
+};
+var DESCRIPTIONS = {
+  field: 'Stage a custom contact field (applied at Publish, on every list). Start here for UTMs: `stage field --utm`, then map `custom.UTM_SOURCE=tracking:utm_source` etc. with `baker flows map`. One field: `stage field --title "Plan" --type dropdown --options "Basic,Pro"`.',
+  list: 'Stage a contact list, e.g. `stage list --name "Webinar sign-ups"` (applied at Publish; an existing list of that name is reused).',
+  tag: 'Stage a contact tag, e.g. `stage tag --name "hot-lead"` (applied at Publish; reused when it exists). A Form can also create tags on its own when it tags a lead.',
+  pipeline: 'Stage a deal pipeline with its stages, e.g. `stage pipeline --title "Inbound" --stages "New lead,Qualified,Won"` (applied at Publish; an existing pipeline only gains missing stages).'
+};
+function schemaArgs(args) {
+  return Object.fromEntries(
+    Object.entries(args).map(([name2, arg]) => [
+      name2,
+      { type: arg.type ?? "string", description: arg.description ?? "", required: arg.required === true }
+    ])
+  );
+}
+function stageCommand(kind, args) {
+  registerSchema({ command: `activecampaign.stage.${kind}`, description: DESCRIPTIONS[kind], args: schemaArgs(args) });
+  return defineCommand3({
+    meta: { name: kind, description: DESCRIPTIONS[kind] },
+    args,
+    run: async ({ args: values }) => {
+      await stage(kind, values);
+    }
+  });
+}
+var stageCommandGroup = defineCommand3({
+  meta: {
+    name: "stage",
+    description: "Stage an ActiveCampaign change on this chat \u2014 a custom field, list, tag or deal pipeline. Nothing changes in ActiveCampaign until the chat is published; restaging the same name replaces the staged one. Review with `baker activecampaign drafts`, drop with `baker activecampaign unstage`."
+  },
+  subCommands: {
+    field: stageCommand("field", FIELD_ARGS),
+    list: stageCommand("list", NAMED_ARGS),
+    tag: stageCommand("tag", NAMED_ARGS),
+    pipeline: stageCommand("pipeline", PIPELINE_ARGS)
+  }
+});
+
+// src/commands/activecampaign/unstage.ts
+import { defineCommand as defineCommand4 } from "citty";
+var DESCRIPTION2 = 'Drop a staged ActiveCampaign change from this chat before it is published: `unstage ac_field_1`, `unstage UTM_SOURCE` (a field\'s perstag) or `unstage "Webinar sign-ups"` (a name). `--all` drops every staged ActiveCampaign change. Nothing in ActiveCampaign is touched.';
+registerSchema({
+  command: "activecampaign.unstage",
+  description: DESCRIPTION2,
+  args: {
+    ref: { type: "positional", description: "Staged ref, name, or a field's perstag", required: false },
+    all: { type: "boolean", description: "Drop every staged ActiveCampaign change on this chat", required: false }
+  }
+});
+var unstageCommand = defineCommand4({
+  meta: { name: "unstage", description: DESCRIPTION2 },
+  args: {
+    ref: { type: "positional", description: "Staged ref, name, or a field's perstag", required: false },
+    all: { type: "boolean", description: "Drop every staged ActiveCampaign change on this chat", required: false }
+  },
+  run: async ({ args }) => {
+    const chatId = requireChatId();
+    try {
+      if (args.all === true) {
+        const data2 = await apiPost("/api/activecampaign/draft/clear", { chatId });
+        writeJson({ ok: true, data: data2 });
+        return;
+      }
+      const ref = typeof args.ref === "string" ? args.ref.trim() : "";
+      if (!ref) {
+        writeJson({
+          ok: false,
+          error: { code: "VALIDATION_ERROR", message: "pass the staged ref, name or perstag to drop, or --all" }
+        });
+        process.exit(1);
+      }
+      const data = await apiPost("/api/activecampaign/draft/remove", {
+        chatId,
+        ref
+      });
+      writeJson({
+        ok: true,
+        data,
+        ...data.removed.length === 0 ? { hints: [`Nothing staged matches "${ref}". Run \`baker activecampaign drafts\` to see the refs.`] } : {}
+      });
+    } catch (err) {
+      failActiveCampaign(err);
+    }
+  }
+});
+
+// src/commands/activecampaign/index.ts
+var activecampaignCommand = defineCommand5({
+  meta: {
+    name: "activecampaign",
+    description: `Read the connected ActiveCampaign account \u2014 its tracking set-up, lists, automations, pipelines,
+tags, custom fields, users, email campaign reports, contacts and deals. These reads are live and change nothing.
+
+Examples:
+  baker activecampaign account                         # contacts, site tracking + tracking account id, domains
+  baker activecampaign campaigns --since 2026-09-01    # email reports: sends, opens, clicks, unsubscribes, bounces, rates
+  baker activecampaign automations --active-only       # what runs after a lead arrives, and how many went through
+  baker activecampaign contacts --email a@b.com        # did this lead arrive?
+  baker activecampaign contacts --tag webinar --limit 1     # how many carry a tag (total)
+  baker activecampaign deals --status won              # won deals and their value per currency
+  baker activecampaign pipelines | lists | tags | fields | users
+
+Changes are staged on this chat and made in ActiveCampaign only when the user publishes it:
+  baker activecampaign stage field --utm               # UTM_SOURCE \u2026 UTM_TERM, for Forms to map onto
+  baker activecampaign stage field --title "Plan" --type dropdown --options "Basic,Pro"
+  baker activecampaign stage list --name "Webinar sign-ups"
+  baker activecampaign stage tag --name "hot-lead"
+  baker activecampaign stage pipeline --title "Inbound" --stages "New lead,Qualified,Won"
+  baker activecampaign drafts                          # what is staged, and after Publish what happened
+  baker activecampaign unstage <ref|name|perstag>      # drop one; unstage --all drops every staged change
+
+Every command takes --account <id> when the company has more than one ActiveCampaign connection, and --full
+for the untouched ActiveCampaign payload. NO_ACTIVECAMPAIGN_CONNECTION / ACTIVECAMPAIGN_RECONNECT_REQUIRED
+carry a request_connection fix \u2014 only the user can clear them.
+Full guide: __tooling__/docs/tools/baker/activecampaign.md`
+  },
+  subCommands: {
+    ...READ_COMMANDS,
+    stage: stageCommandGroup,
+    unstage: unstageCommand,
+    drafts: draftsCommand
+  }
+});
+export {
+  activecampaignCommand
+};
+//# sourceMappingURL=activecampaign-EYRHDSXY.js.map