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

package/dist/chunk-V7EN5LFS.js

@@ -0,0 +1,115 @@
+import {
+  writeJsonEnvelope
+} from "./chunk-MPTNN35I.js";
+import {
+  ApiError,
+  apiPost
+} from "./chunk-LJEJCIHR.js";
+import {
+  requireChatId
+} from "./chunk-B64KJW5C.js";
+
+// src/commands/draft-refs.ts
+function draftRefs(positionals) {
+  const values = Array.isArray(positionals) ? positionals.filter((v) => typeof v === "string") : [];
+  return [
+    ...new Set(
+      values.flatMap((v) => v.split(",")).map((v) => v.trim()).filter(Boolean)
+    )
+  ];
+}
+function failureOf(ref, err) {
+  if (err instanceof ApiError) return { ref, code: err.code, message: err.message };
+  return { ref, code: "INTERNAL_ERROR", message: err instanceof Error ? err.message : String(err) };
+}
+function dataOf(response) {
+  if (typeof response !== "object" || response === null) return {};
+  const record = response;
+  const data = "ok" in record && typeof record.data === "object" && record.data !== null ? record.data : record;
+  return data;
+}
+function removedOf(data) {
+  const { removed } = data;
+  return Array.isArray(removed) ? removed.filter((r) => typeof r === "string") : [];
+}
+function updatedOf(data) {
+  const { updated } = data;
+  return Array.isArray(updated) ? updated.filter((u) => typeof u === "object" && u !== null && typeof u.ref === "string") : [];
+}
+function writeSummary(data, failed, verb) {
+  if (failed.length === 0) {
+    writeJsonEnvelope({ ok: true, data });
+    return;
+  }
+  writeJsonEnvelope({
+    ok: false,
+    data: { ...data, failed },
+    error: {
+      code: failed[0]?.code ?? "INTERNAL_ERROR",
+      message: `${failed.length} ref(s) could not be ${verb}: ${failed.map((f) => `${f.ref} (${f.message})`).join("; ")}`,
+      fix: `Everything else listed in data was ${verb}. Fix or drop only the refs under data.failed (a failure with its own \`fix\` says what to do for that ref), then run the command again for those.`
+    }
+  });
+  process.exit(1);
+}
+function removeSummary(removed, updated, notFound) {
+  const kept = [...updated.values()].filter((op) => !removed.includes(op.ref));
+  return {
+    removed,
+    count: removed.length,
+    ...kept.length > 0 ? { updated: kept } : {},
+    ...notFound.length > 0 ? { notFound } : {}
+  };
+}
+async function removeDraftRefs(path, refs) {
+  const chatId = requireChatId();
+  const removed = [];
+  const updated = /* @__PURE__ */ new Map();
+  const notFound = [];
+  const failed = [];
+  for (const ref of refs) {
+    if (removed.includes(ref)) continue;
+    try {
+      const data = dataOf(await apiPost(path, { chatId, ref }));
+      const gone = removedOf(data);
+      if (gone.length === 0) notFound.push(ref);
+      removed.push(...gone.filter((r) => !removed.includes(r)));
+      for (const op of updatedOf(data)) updated.set(op.ref, op);
+    } catch (err) {
+      if (err instanceof ApiError && err.code === "NOT_FOUND") notFound.push(ref);
+      else failed.push(failureOf(ref, err));
+    }
+  }
+  writeSummary(removeSummary(removed, updated, notFound), failed, "removed");
+}
+async function amendDraftRefs(path, refs, patch, refusalOf) {
+  const chatId = requireChatId();
+  const amended = [];
+  const failed = [];
+  for (const ref of refs) {
+    try {
+      const data = dataOf(await apiPost(path, { chatId, ref, patch }));
+      const refusal = refusalOf?.(data);
+      if (refusal) {
+        failed.push({ ref, ...refusal });
+        continue;
+      }
+      const { summary, warnings } = data;
+      amended.push({
+        ref,
+        ...summary !== void 0 ? { summary } : {},
+        ...Array.isArray(warnings) && warnings.length > 0 ? { warnings } : {}
+      });
+    } catch (err) {
+      failed.push(failureOf(ref, err));
+    }
+  }
+  writeSummary({ amended, count: amended.length }, failed, "amended");
+}
+
+export {
+  draftRefs,
+  removeDraftRefs,
+  amendDraftRefs
+};
+//# sourceMappingURL=chunk-V7EN5LFS.js.map

package/dist/chunk-WTOBG3YL.js

@@ -0,0 +1,392 @@
+import {
+  mappingRowProblem,
+  mentionOf
+} from "./chunk-NKQWDEB7.js";
+import {
+  CONDITION_LOGICS,
+  HUBSPOT_DEAL_CONTACTS,
+  HUBSPOT_OBJECTS,
+  HUBSPOT_PROPERTY_KINDS,
+  REJECTION_MESSAGES,
+  TRIGGER_CONDITIONS_MAX,
+  onlyCondition,
+  triggerProblem,
+  validateEventName
+} from "./chunk-6DSPB6YA.js";
+
+// ../api/src/event-sources/hubspot.ts
+var HUBSPOT_CONTACT_ID_VARIABLE = "id";
+var HUBSPOT_CONTACT_PREFIX = "contact.";
+function contactPath(property) {
+  return `${HUBSPOT_CONTACT_PREFIX}${property}`;
+}
+var HUBSPOT_DEFAULT_PROPERTIES = {
+  email: "email",
+  phone: "phone",
+  external_id: HUBSPOT_CONTACT_ID_VARIABLE,
+  first_name: "firstname",
+  last_name: "lastname",
+  city: "city",
+  postal_code: "zip",
+  country: "country",
+  gclid: "hs_google_click_id",
+  fbclid: "hs_facebook_click_id"
+};
+var throughContact = Object.fromEntries(
+  Object.entries(HUBSPOT_DEFAULT_PROPERTIES).map(([field, property]) => [field, contactPath(property)])
+);
+var HUBSPOT_DEAL_DEFAULT_PROPERTIES = {
+  ...throughContact,
+  value: "amount",
+  currency: "deal_currency_code"
+};
+var HUBSPOT_LEAD_DEFAULT_PROPERTIES = throughContact;
+var DEFAULTS = {
+  contact: HUBSPOT_DEFAULT_PROPERTIES,
+  deal: HUBSPOT_DEAL_DEFAULT_PROPERTIES,
+  lead: HUBSPOT_LEAD_DEFAULT_PROPERTIES
+};
+function hubspotDefaultMapping(sourceName, object = "contact") {
+  const mapping = { event_name: sourceName };
+  for (const [field, property] of Object.entries(DEFAULTS[object])) {
+    mapping[field] = mentionOf(property);
+  }
+  return mapping;
+}
+
+// ../api/src/event-sources/wire.ts
+import { z as z2 } from "zod";
+
+// ../api/src/event-sources/activecampaign.ts
+import { z } from "zod";
+var ACTIVECAMPAIGN_WEBHOOK_EVENTS = {
+  subscribe: "A contact subscribes to a list",
+  unsubscribe: "A contact unsubscribes",
+  update: "A contact's details change",
+  contact_tag_added: "A tag is added to a contact",
+  contact_tag_removed: "A tag is removed from a contact",
+  subscriber_note: "A note is added to a contact",
+  contact_task_add: "A task is added to a contact",
+  sent: "A campaign starts sending",
+  open: "A contact opens a campaign",
+  click: "A contact clicks a link in a campaign",
+  reply: "A contact replies to a campaign",
+  forward: "A contact forwards a campaign",
+  share: "A contact shares a campaign",
+  bounce: "A campaign email bounces",
+  list_add: "A list is created",
+  deal_add: "A deal is created",
+  deal_update: "A deal changes",
+  deal_note_add: "A note is added to a deal",
+  deal_task_add: "A task is added to a deal",
+  deal_task_complete: "A deal task is completed",
+  deal_pipeline_add: "A pipeline is created",
+  deal_stage_add: "A deal stage is created",
+  deal_tasktype_add: "A deal task type is created",
+  account_add: "An account is created",
+  account_update: "An account changes",
+  account_contact_add: "A contact is added to an account",
+  account_contact_update: "A contact on an account changes"
+};
+var ACTIVECAMPAIGN_WEBHOOK_EVENT_TYPES = Object.keys(
+  ACTIVECAMPAIGN_WEBHOOK_EVENTS
+);
+var EVENT_PREFIX = "activecampaign.";
+function activeCampaignEventOf(eventName) {
+  if (!eventName.startsWith(EVENT_PREFIX)) return null;
+  const type = eventName.slice(EVENT_PREFIX.length);
+  return type in ACTIVECAMPAIGN_WEBHOOK_EVENTS ? type : null;
+}
+var activeCampaignEventsSchema = z.array(z.string().trim().min(1)).min(1, "Pick at least one ActiveCampaign event to listen to.").max(ACTIVECAMPAIGN_WEBHOOK_EVENT_TYPES.length).transform((raw, ctx) => {
+  const picked = /* @__PURE__ */ new Set();
+  for (const item of raw) {
+    const type = activeCampaignEventOf(item) ?? (item in ACTIVECAMPAIGN_WEBHOOK_EVENTS ? item : null);
+    if (type === null) {
+      ctx.addIssue({
+        code: "custom",
+        message: `"${item}" is not an ActiveCampaign event. Pick from: ${ACTIVECAMPAIGN_WEBHOOK_EVENT_TYPES.join(", ")}.`
+      });
+      return z.NEVER;
+    }
+    picked.add(type);
+  }
+  return ACTIVECAMPAIGN_WEBHOOK_EVENT_TYPES.filter((type) => picked.has(type));
+});
+var ACTIVECAMPAIGN_WEBHOOK_STATES = ["listening", "not_configured", "failed"];
+
+// ../api/src/event-sources/wire.ts
+var SOURCE_KINDS = ["webhook", "hubspot", "activecampaign"];
+var SOURCE_STATUSES = ["learning", "counting", "paused"];
+var SOURCE_NAME_MAX = 80;
+var sourceNameSchema = z2.string().trim().min(1).max(SOURCE_NAME_MAX).refine((name) => validateEventName(name) === null, REJECTION_MESSAGES.invalid_name);
+var sourceIdSchema = z2.string().min(1);
+var sourceMappingSchema = z2.record(z2.string(), z2.string().min(1)).superRefine((mapping, ctx) => {
+  for (const row of Object.keys(mapping)) {
+    const problem = mappingRowProblem(row);
+    if (problem !== null) ctx.addIssue({ code: "custom", message: problem, path: [row] });
+  }
+});
+var currencyCodeSchema = z2.string().trim().toUpperCase().regex(/^[A-Z]{3}$/, "A currency is a three-letter code, like EUR or USD.");
+var hubspotObjectSchema = z2.enum(HUBSPOT_OBJECTS);
+var hubspotDealContactsSchema = z2.enum(HUBSPOT_DEAL_CONTACTS);
+var hubspotConditionInputSchema = z2.strictObject({
+  property: z2.string().trim().min(1),
+  /** One of the property's kind's operators (`baker hubspot contacts properties` lists them); `is` when unsaid. */
+  operator: z2.string().trim().min(1).default("is"),
+  /** As HubSpot spells them: an option's internal value, a number, a `YYYY-MM-DD`, `true`/`false`. None for an empty check, two for a between, several for a list. */
+  values: z2.array(z2.string().trim().min(1)).max(50).default([])
+});
+var conditionLogicSchema = z2.enum(CONDITION_LOGICS);
+var conditionGroupInputSchema = z2.strictObject({
+  logic: conditionLogicSchema,
+  conditions: z2.array(hubspotConditionInputSchema).min(1).max(TRIGGER_CONDITIONS_MAX)
+});
+var combinedInputSchema = z2.strictObject({
+  /** How the rows combine: `And` (every one) or `Or` (any one) — a Form's filter's "Match AND / OR". */
+  logic: conditionLogicSchema.default("And"),
+  /** Conditions, and groups of conditions with their own logic, one level deep. */
+  conditions: z2.array(z2.union([hubspotConditionInputSchema, conditionGroupInputSchema])).min(1).max(TRIGGER_CONDITIONS_MAX)
+}).superRefine((trigger, context) => {
+  const problem = triggerProblem(trigger);
+  if (problem !== null) context.addIssue({ code: "custom", message: problem });
+});
+var hubspotTriggerInputSchema = z2.union([combinedInputSchema, hubspotConditionInputSchema]).transform((input) => "conditions" in input ? input : onlyCondition(input));
+var hubspotConditionSchema = hubspotConditionInputSchema.extend({
+  propertyLabel: z2.string(),
+  kind: z2.enum(HUBSPOT_PROPERTY_KINDS),
+  /** A select that holds several values at once (`a;b`); decides what HubSpot may filter on. */
+  multiple: z2.boolean().optional(),
+  valueLabels: z2.array(z2.string())
+});
+var hubspotTriggerFields = {
+  logic: conditionLogicSchema,
+  conditions: z2.array(
+    z2.union([
+      hubspotConditionSchema,
+      z2.strictObject({ logic: conditionLogicSchema, conditions: z2.array(hubspotConditionSchema) })
+    ])
+  )
+};
+var hubspotWatchSchema = z2.strictObject({
+  ...hubspotTriggerFields,
+  object: hubspotObjectSchema,
+  contacts: hubspotDealContactsSchema.optional()
+});
+var sampleRecordSchema = z2.strictObject({ id: z2.string(), properties: z2.record(z2.string(), z2.string()) });
+var hubspotPreviewRequestSchema = z2.strictObject({
+  object: hubspotObjectSchema.default("contact"),
+  trigger: hubspotTriggerInputSchema,
+  /** Property names to read off the sample; `id` is always there. On a deal or a lead, `contact.<name>` reads its first contact. */
+  properties: z2.array(z2.string().trim().min(1)).max(60).optional(),
+  /** The record to draw the preview from — an id, or text to search (an email or a name for a contact, a deal's or a lead's name). The one most recently at the trigger when unsaid. */
+  contact: z2.string().trim().min(1).max(200).optional()
+});
+var hubspotPreviewSchema = z2.strictObject({
+  /** Records satisfying the trigger today — the ones that will NOT be counted. */
+  total: z2.number(),
+  /** False when the trigger has more combinations than HubSpot's search takes, so `total` is only near. */
+  exact: z2.boolean().optional(),
+  /**
+   * The sample record the trigger is on, with the properties asked for and
+   * the contacts behind it, first first; none when nothing fits.
+   *
+   * One field rather than one per object: a contact source's record *is* the
+   * person and its `contacts` is empty, while a deal's and a lead's carry the
+   * people the event is about. Three parallel nullable fields, exactly one of
+   * them ever set, would say the same thing and let a caller read the wrong one.
+   */
+  record: sampleRecordSchema.extend({ contacts: z2.array(sampleRecordSchema) }).nullable()
+});
+var sourcesRequestSchema = z2.strictObject({
+  /** The company's own server door: made once, `counting` from the start, the same address for ever after. */
+  server: z2.strictObject({}).optional(),
+  create: z2.strictObject({ name: sourceNameSchema }).optional(),
+  /** A HubSpot event: read every five minutes, counting from now. The labels are looked up server-side. */
+  createHubspot: z2.strictObject({
+    name: sourceNameSchema.optional(),
+    /** A contact, a deal or a lead. A deal's and a lead's event is about its contact, read through `contact.<property>` rows. */
+    object: hubspotObjectSchema.default("contact"),
+    trigger: hubspotTriggerInputSchema,
+    /** On a deal: the deal's first contact (the default), or every contact on it, each its own event. */
+    contacts: hubspotDealContactsSchema.optional(),
+    /** Rows to read off the record, over the defaults; the same table `map` writes. */
+    mapping: sourceMappingSchema.optional(),
+    /** A number property on the record to read as the amount; needs `currency` beside it. Sugar over the mapping's `value` and `currency` rows. */
+    amountProperty: z2.string().trim().min(1).optional(),
+    currency: currencyCodeSchema.optional()
+  }).optional(),
+  /**
+   * An ActiveCampaign source: ActiveCampaign's own webhook, made on the
+   * account when this is applied, sending the events picked here. Each raises
+   * `activecampaign.<type>` and counts from then on.
+   */
+  createActiveCampaign: z2.strictObject({
+    name: sourceNameSchema.optional(),
+    /** ActiveCampaign's event names (`subscribe`, `deal_update`, …); the lead and deal moments when unsaid. */
+    events: activeCampaignEventsSchema.optional(),
+    /** Which connection, when the company has more than one. */
+    account: z2.string().trim().min(1).optional()
+  }).optional(),
+  /** Change what a HubSpot event watches. It counts from now on under the new trigger; the rows stay. The object cannot change: the rows read it. */
+  setTrigger: z2.strictObject({
+    sourceId: sourceIdSchema,
+    trigger: hubspotTriggerInputSchema,
+    contacts: hubspotDealContactsSchema.optional()
+  }).optional(),
+  /** Ask HubSpot what a trigger would count today, and read one real record, without making anything. */
+  preview: hubspotPreviewRequestSchema.optional(),
+  /** Change where a HubSpot-read source takes its amount from; no `amountProperty` clears it. Sugar over `map`. */
+  setAmount: z2.strictObject({
+    sourceId: sourceIdSchema,
+    amountProperty: z2.string().trim().min(1).optional(),
+    currency: currencyCodeSchema.optional()
+  }).optional(),
+  /**
+   * Count a HubSpot event's history: every moment its trigger came to hold
+   * since `since`, read out of HubSpot's own property history.
+   *
+   * Not the thing a source deliberately refuses to do. A source never
+   * backfills the **present state** — somebody who already satisfies a
+   * condition is not an event today — and this reports only moments HubSpot
+   * has a timestamp for, so nothing is invented. Dry unless `write`.
+   */
+  backfill: z2.strictObject({
+    sourceId: sourceIdSchema,
+    /** ISO instant, or Unix milliseconds. Bounded by the 400 days the store keeps. */
+    since: z2.union([z2.string().trim().min(1), z2.number()]),
+    /**
+     * Where a capped run carries on from: only records last changed at or
+     * before this instant are read.
+     *
+     * The **read** is what it bounds, never the history. Records are chosen
+     * most-recently-changed first, so a run that reaches its cap has covered
+     * the newest of them and the rest are the ones nearest `since` — which
+     * no shorter window can reach, because shortening one only drops
+     * candidates from the old end and hands back the same newest records
+     * again. `reachedBack` is the value to pass here, and the moments each
+     * record is then judged on are still the whole of `since` to now.
+     */
+    before: z2.union([z2.string().trim().min(1), z2.number()]).optional(),
+    /** Without it, nothing is counted and the answer says what would be. */
+    write: z2.boolean().optional()
+  }).optional(),
+  map: z2.strictObject({ sourceId: sourceIdSchema, mapping: sourceMappingSchema }).optional(),
+  pause: z2.strictObject({ sourceId: sourceIdSchema }).optional(),
+  resume: z2.strictObject({ sourceId: sourceIdSchema }).optional(),
+  remove: z2.strictObject({ sourceId: sourceIdSchema }).optional()
+});
+var sourceRefusalSchema = z2.strictObject({
+  at: z2.number(),
+  count: z2.number(),
+  code: z2.string(),
+  reason: z2.string()
+});
+var detectedFieldSchema = z2.strictObject({
+  path: z2.string(),
+  confidence: z2.enum(["key", "value"])
+});
+var HUBSPOT_LISTENING_STATES = ["listening", "not_configured", "failed"];
+var sourceViewSchema = z2.strictObject({
+  id: z2.string(),
+  kind: z2.enum(SOURCE_KINDS),
+  name: z2.string(),
+  status: z2.enum(SOURCE_STATUSES),
+  /** The address a tool posts to. A HubSpot source has none: Baker calls HubSpot. */
+  url: z2.string().optional(),
+  /** What a HubSpot source watches, and on which object. */
+  hubspot: hubspotWatchSchema.optional(),
+  /**
+   * What an ActiveCampaign source listens to, and whether ActiveCampaign has
+   * the webhook that sends it: `listening` once it is made, `not_configured`
+   * until then, `failed` when ActiveCampaign refused it — `detail` says why.
+   */
+  activecampaign: z2.strictObject({
+    events: z2.array(z2.string()),
+    webhook: z2.strictObject({ state: z2.enum(ACTIVECAMPAIGN_WEBHOOK_STATES), detail: z2.string().optional() })
+  }).optional(),
+  /** A HubSpot source counts changes from here on; one HubSpot reports from before it is dropped. Moves when the trigger changes. */
+  countingSince: z2.number().optional(),
+  /**
+   * Whether HubSpot is keeping this source's changes for Baker, as last
+   * checked: `listening` when the app's journal subscription on the account
+   * names the property; `not_configured` when the app has not been told yet
+   * (or cannot be, with no credentials); `failed` when HubSpot refused the
+   * subscription. `detail` says what to do.
+   */
+  listening: z2.strictObject({ state: z2.enum(HUBSPOT_LISTENING_STATES), detail: z2.string().optional() }).optional(),
+  /** Why the last delivery could not be counted, in product words; absent when the last one was. */
+  lastError: z2.string().optional(),
+  lastArrivalAt: z2.number().optional(),
+  /**
+   * What its last delivery **refused, event by event** — which `lastError` is
+   * not and `lastArrivalAt` cannot be. A source refusing everything it
+   * receives has no arrival and no read failure, so without this it reads as
+   * one nobody has sent anything to. `refusalWords` turns it into the
+   * sentence a person is shown. Cleared by the next delivery that counts.
+   */
+  lastRefusal: sourceRefusalSchema.optional(),
+  /** The first send, masked, while learning. Kept once confirmed. */
+  sample: z2.strictObject({ receivedAt: z2.number(), body: z2.string() }).optional(),
+  /** Field → template; empty means the guess (an address) or the defaults (a HubSpot read). */
+  mapping: z2.record(z2.string(), z2.string()),
+  /** The guess over the sample, for the sheet to prefill and the CLI to suggest. */
+  detected: z2.record(z2.string(), detectedFieldSchema).optional(),
+  /** Every path the sample's first item holds, with its masked value — what the picker offers. */
+  paths: z2.array(z2.strictObject({ path: z2.string(), value: z2.string() })).optional(),
+  /** `baker` when the sample already parses as the `POST /v1/events` contract and needs no mapping. */
+  format: z2.enum(["baker", "foreign"]).optional()
+});
+var stagedSourceOpSchema = z2.strictObject({
+  kind: z2.enum(["create", "setTrigger", "map", "status", "remove"]),
+  ref: z2.string(),
+  name: z2.string(),
+  summary: z2.string(),
+  /** On a create: what the source will watch and read. */
+  hubspot: hubspotWatchSchema.optional(),
+  /** On an ActiveCampaign create: the events its webhook will send. */
+  activecampaign: z2.strictObject({ events: z2.array(z2.string()) }).optional(),
+  mapping: z2.record(z2.string(), z2.string()).optional(),
+  status: z2.enum(["paused", "counting"]).optional()
+});
+var backfillResultSchema = z2.strictObject({
+  sourceId: z2.string(),
+  name: z2.string(),
+  since: z2.number(),
+  /** Records whose history was read. */
+  examined: z2.number(),
+  /** Moments the trigger came to hold, across them. */
+  entries: z2.number(),
+  /** Of those, already counted — the journal got there first, or a previous run did. */
+  alreadyCounted: z2.number(),
+  /** What a `write` run would hand over, or did. */
+  pending: z2.number(),
+  /** Whether the read stopped at its cap; {@link BackfillResult.reachedBack} is where to carry on from. */
+  capped: z2.boolean(),
+  /**
+   * How far back the read got: the instant the oldest record it examined was
+   * last changed. Only on a capped run, and it is the next run's `before`.
+   */
+  reachedBack: z2.number().optional(),
+  counted: z2.number().optional(),
+  refused: z2.number().optional(),
+  refusedReason: z2.string().optional()
+});
+var sourcesResponseSchema = z2.strictObject({
+  ok: z2.literal(true),
+  data: z2.strictObject({
+    sources: z2.array(sourceViewSchema),
+    /** Only when the request carried `preview`. */
+    preview: hubspotPreviewSchema.optional(),
+    /** Only when the request carried `backfill`. */
+    backfill: backfillResultSchema.optional(),
+    /** What this chat has staged, when one is attached: applied at Publish, dropped with a discard. */
+    staged: z2.array(stagedSourceOpSchema).optional()
+  }),
+  hints: z2.array(z2.string()).optional()
+});
+
+export {
+  hubspotDefaultMapping,
+  hubspotTriggerInputSchema
+};
+//# sourceMappingURL=chunk-WTOBG3YL.js.map

package/dist/chunk-WTPID22G.js

@@ -0,0 +1,152 @@
+import {
+  hintLines,
+  splitHints
+} from "./chunk-D5FY4FAK.js";
+import {
+  isNotConnectedError,
+  writeJsonEnvelope
+} from "./chunk-MPTNN35I.js";
+import {
+  ApiError,
+  apiPost
+} from "./chunk-LJEJCIHR.js";
+import {
+  requireChatId,
+  resolveChatId
+} from "./chunk-B64KJW5C.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.status === "discarded" ? `${response.count} Tag Manager change(s) discarded with their chat \u2014 none will apply` : `${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, full = false) {
+  const chatId = resolveChatId(chat);
+  try {
+    const response = await apiPost("/api/tag-manager/draft", {
+      chatId,
+      ...full ? { full: true } : {}
+    });
+    const { data, hints } = splitHints(response);
+    if (json || full) {
+      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-WTPID22G.js.map