@koda-sl/baker-cli 0.531.0 → 0.534.0-dev.911a80433

package/dist/lead-routes-IXUCGINI.js

@@ -0,0 +1,733 @@
+import {
+  repeatedValues
+} from "./chunk-ERSX3MKH.js";
+import {
+  ApiError,
+  apiGet,
+  apiPost
+} from "./chunk-CIW3Q7B2.js";
+import "./chunk-O7AMKMII.js";
+import {
+  optionalChatId,
+  requireChatId
+} from "./chunk-VPF5A7CM.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-HZPTQRX6.js";
+import "./chunk-YQSBHWOI.js";
+
+// ../api/src/lead-routes.ts
+import { z } from "zod";
+var LEAD_ROUTE_PLATFORMS = ["meta", "linkedin", "google"];
+var leadRoutePlatformSchema = z.enum(LEAD_ROUTE_PLATFORMS);
+var LEAD_ROUTE_DESTINATION_TYPES = [
+  "googleSpreadsheet",
+  "hubspotForm",
+  "httpWebhook",
+  "zapier",
+  "email",
+  "pipedrive",
+  "goHighlevelContact",
+  "activeCampaignContact"
+];
+var leadRouteDestinationTypeSchema = z.enum(LEAD_ROUTE_DESTINATION_TYPES);
+var LEAD_CONTACT_FIELDS = [
+  "email",
+  "phone",
+  "first_name",
+  "last_name",
+  "full_name",
+  "company",
+  "job_title",
+  "city",
+  "state",
+  "zip",
+  "country",
+  "street_address",
+  "work_email",
+  "work_phone"
+];
+var LEAD_CONTEXT_FIELDS = [
+  "platform",
+  "lead_id",
+  "submitted_at",
+  "form_id",
+  "form_name",
+  "campaign_id",
+  "campaign_name",
+  "ad_set_id",
+  "ad_set_name",
+  "ad_id",
+  "ad_name",
+  "is_test",
+  "gclid"
+];
+var LEAD_SUMMARY_FIELDS = ["answers", "consents"];
+var LEAD_ANSWER_PREFIX = "answer:";
+var LEAD_TEXT_PREFIX = "text:";
+function isLeadPath(from) {
+  if (from.startsWith(LEAD_ANSWER_PREFIX)) return from.length > LEAD_ANSWER_PREFIX.length;
+  if (from.startsWith(LEAD_TEXT_PREFIX)) return true;
+  return LEAD_CONTACT_FIELDS.includes(from) || LEAD_CONTEXT_FIELDS.includes(from) || LEAD_SUMMARY_FIELDS.includes(from);
+}
+var leadRouteFieldSchema = z.object({
+  key: z.string().trim().min(1),
+  from: z.string().trim().min(1).refine(isLeadPath, { message: "not something a lead carries \u2014 see `baker lead-routes fields`" })
+});
+var leadRouteDestinationInputSchema = z.discriminatedUnion("type", [
+  z.object({
+    type: z.literal("googleSpreadsheet"),
+    account: z.string().optional(),
+    /** An existing spreadsheet id (from `baker flows options googleSpreadsheet`). */
+    resourceId: z.string().optional(),
+    tab: z.string().optional(),
+    /** Create a spreadsheet for these leads instead, headed with the route's columns. */
+    newSheet: z.object({ title: z.string().trim().min(1) }).optional()
+  }),
+  /** A HubSpot form by id (`baker hubspot forms list`): the lead is submitted to it as a contact. */
+  z.object({ type: z.literal("hubspotForm"), formId: z.string().trim().min(1) }),
+  /** A webhook with no credential in its headers. */
+  z.object({ type: z.literal("httpWebhook"), url: z.string().trim().url() }),
+  /** A Zapier "Catch Hook" address. */
+  z.object({ type: z.literal("zapier"), url: z.string().trim().url() }),
+  /** A notification email to the team: one or more addresses, comma-separated. */
+  z.object({ type: z.literal("email"), email: z.string().trim().min(1), subject: z.string().trim().min(1).optional() }),
+  z.object({ type: z.literal("pipedrive"), account: z.string().optional() }),
+  z.object({ type: z.literal("goHighlevelContact"), account: z.string().optional() }),
+  z.object({ type: z.literal("activeCampaignContact"), account: z.string().optional() })
+]);
+var MAX_LEAD_ROUTES = 50;
+var leadRouteSetSchema = z.object({
+  /** Change this live or staged route instead of adding one. */
+  id: z.string().trim().min(1).optional(),
+  name: z.string().trim().min(1).max(120).optional(),
+  platform: leadRoutePlatformSchema,
+  /** LinkedIn: the ad account. Google: the customer id. Meta: not needed — a form id is the Page's. */
+  account: z.string().trim().min(1).optional(),
+  formId: z.string().trim().min(1),
+  destination: leadRouteDestinationInputSchema,
+  /** Omitted: the destination's own defaults (see `baker lead-routes fields`). */
+  fields: z.array(leadRouteFieldSchema).max(100).optional(),
+  /** Also send the leads submitted since this day (YYYY-MM-DD), at most 30 days back. Default: only new leads. */
+  since: z.string().regex(/^\d{4}-\d{2}-\d{2}$/, "a date like 2026-10-01").optional()
+});
+var leadRouteAmendSchema = z.object({
+  id: z.string().trim().min(1),
+  name: z.string().trim().min(1).max(120).optional(),
+  /** Replaces the whole mapping. */
+  fields: z.array(leadRouteFieldSchema).max(100).optional(),
+  /** Laid over the existing mapping by key: a new key is added, a known one replaced. */
+  addFields: z.array(leadRouteFieldSchema).max(100).optional(),
+  since: z.string().regex(/^\d{4}-\d{2}-\d{2}$/, "a date like 2026-10-01").optional()
+});
+var leadRouteStageRequestSchema = z.object({
+  chatId: z.string().min(1),
+  set: leadRouteSetSchema.optional(),
+  amend: leadRouteAmendSchema.optional(),
+  /** Stop these live routes at Publish. */
+  remove: z.array(z.string().trim().min(1)).max(MAX_LEAD_ROUTES).optional()
+});
+var leadRouteDestinationViewSchema = z.object({
+  type: leadRouteDestinationTypeSchema,
+  label: z.string(),
+  url: z.string().optional()
+});
+var LEAD_ROUTE_STATUSES = ["active", "paused"];
+var leadRouteViewSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  platform: leadRoutePlatformSchema,
+  account: z.string().optional(),
+  formId: z.string(),
+  formName: z.string().optional(),
+  /** The Form its leads are counted under, as submissions: `baker analytics flow|submissions --flow <formSlug>`. */
+  formSlug: z.string(),
+  destination: leadRouteDestinationViewSchema,
+  fields: z.array(z.object({ key: z.string(), from: z.string() })),
+  /** What the lead form asks, as read when the route was staged. */
+  questions: z.array(z.object({ from: z.string(), label: z.string() })).optional(),
+  status: z.enum(LEAD_ROUTE_STATUSES),
+  /** Leads submitted from this moment on are delivered. 0 on a staged route: from the moment it is published. */
+  startAt: z.number(),
+  /** Only on a live route. */
+  delivered: z.number().optional(),
+  lastLeadAt: z.number().optional(),
+  lastCheckedAt: z.number().optional(),
+  /** Why the last check could not read or deliver, in words. Cleared by the next one that could. */
+  lastError: z.string().optional()
+});
+var leadRouteStagedOpSchema = z.object({
+  kind: z.enum(["set", "remove"]),
+  routeId: z.string(),
+  summary: z.string(),
+  stagedAt: z.number(),
+  route: leadRouteViewSchema.optional(),
+  /** The live route as it was when this was staged: absent for a route this chat adds. */
+  before: leadRouteViewSchema.optional(),
+  result: z.object({ status: z.enum(["applied", "skipped"]), reason: z.string().optional() }).optional()
+});
+var leadRouteStageResponseSchema = z.object({
+  ok: z.literal(true),
+  data: z.object({ staged: z.array(leadRouteStagedOpSchema) }),
+  hints: z.array(z.string()).optional()
+});
+var leadRouteListResponseSchema = z.object({
+  ok: z.literal(true),
+  data: z.object({ routes: z.array(leadRouteViewSchema), staged: z.array(leadRouteStagedOpSchema) }),
+  hints: z.array(z.string()).optional()
+});
+var leadRouteUnstageRequestSchema = z.object({
+  chatId: z.string().min(1),
+  /** Omitted: every staged route change on this chat. */
+  routeId: z.string().optional()
+});
+var leadRouteUnstageResponseSchema = z.object({
+  ok: z.literal(true),
+  data: z.object({ removed: z.number() })
+});
+var leadRouteFieldsRequestSchema = z.object({
+  platform: leadRoutePlatformSchema,
+  account: z.string().optional(),
+  formId: z.string().trim().min(1)
+});
+var leadFormQuestionSchema = z.object({
+  /** What `--field <key>=<from>` takes: a contact field, or `answer:<key>`. */
+  from: z.string(),
+  label: z.string()
+});
+var leadRouteFieldsResponseSchema = z.object({
+  ok: z.literal(true),
+  data: z.object({
+    platform: leadRoutePlatformSchema,
+    formId: z.string(),
+    formName: z.string().optional(),
+    questions: z.array(leadFormQuestionSchema),
+    /** Always available, whatever the form asks. */
+    context: z.array(z.string())
+  }),
+  hints: z.array(z.string()).optional()
+});
+var leadRoutePreviewRequestSchema = z.object({
+  /** A route staged on `chatId` or live: preview it exactly as it will send. */
+  id: z.string().trim().min(1).optional(),
+  chatId: z.string().optional(),
+  platform: leadRoutePlatformSchema.optional(),
+  account: z.string().optional(),
+  formId: z.string().trim().min(1).optional(),
+  destinationType: leadRouteDestinationTypeSchema.optional(),
+  fields: z.array(leadRouteFieldSchema).max(100).optional(),
+  /** How many of the latest leads to show. */
+  limit: z.number().int().min(1).max(5).optional(),
+  /** Show contact details unmasked. */
+  full: z.boolean().optional()
+}).refine((request) => request.id !== void 0 || request.platform && request.formId && request.destinationType, {
+  message: "Name a route (--id) or a form and a destination (--platform, --form, --to)"
+});
+var leadRoutePreviewResponseSchema = z.object({
+  ok: z.literal(true),
+  data: z.object({
+    fields: z.array(z.object({ key: z.string(), from: z.string() })),
+    /** What the destination would have received for each of the latest leads, newest first. */
+    samples: z.array(z.object({ leadId: z.string(), submittedAt: z.string(), sent: z.record(z.string(), z.string()) })),
+    masked: z.boolean()
+  }),
+  hints: z.array(z.string()).optional()
+});
+
+// src/commands/lead-routes/index.ts
+import { defineCommand } from "citty";
+
+// src/commands/lead-routes/args.ts
+var LeadRouteArgsError = class extends Error {
+};
+function parseFields(values) {
+  return values.map((value) => {
+    const at = value.indexOf("=");
+    if (at <= 0 || at === value.length - 1) {
+      throw new LeadRouteArgsError(
+        `--field "${value}" needs the form <destination key>=<lead field>, e.g. --field C=email or --field firstname=first_name.`
+      );
+    }
+    return { key: value.slice(0, at).trim(), from: value.slice(at + 1).trim() };
+  });
+}
+var DESTINATION_FLAGS = {
+  googleSpreadsheet: ["sheet", "new-sheet", "tab", "destination-account"],
+  hubspotForm: ["hubspot-form"],
+  httpWebhook: ["url"],
+  zapier: ["url"],
+  email: ["email", "subject"],
+  pipedrive: ["destination-account"],
+  goHighlevelContact: ["destination-account"],
+  activeCampaignContact: ["destination-account"]
+};
+var ALL_DESTINATION_FLAGS = new Set(Object.values(DESTINATION_FLAGS).flat());
+function need(value, message) {
+  if (!value) throw new LeadRouteArgsError(message);
+  return value;
+}
+function sheetDestination(flags) {
+  if (!flags.sheet === !flags["new-sheet"]) {
+    throw new LeadRouteArgsError(
+      "Name the spreadsheet with --sheet <id> (`baker flows options googleSpreadsheet`) or make one with --new-sheet <title>."
+    );
+  }
+  return {
+    type: "googleSpreadsheet",
+    ...flags["destination-account"] ? { account: flags["destination-account"] } : {},
+    ...flags.sheet ? { resourceId: flags.sheet } : {},
+    ...flags["new-sheet"] ? { newSheet: { title: flags["new-sheet"] } } : {},
+    ...flags.tab ? { tab: flags.tab } : {}
+  };
+}
+function accountDestination(type) {
+  return (flags) => ({
+    type,
+    ...flags["destination-account"] ? { account: flags["destination-account"] } : {}
+  });
+}
+var DESTINATIONS = {
+  googleSpreadsheet: sheetDestination,
+  hubspotForm: (flags) => ({
+    type: "hubspotForm",
+    formId: need(flags["hubspot-form"], "--to hubspotForm needs --hubspot-form <id> (`baker hubspot forms list`).")
+  }),
+  httpWebhook: (flags) => ({ type: "httpWebhook", url: need(flags.url, "--to httpWebhook needs --url <address>.") }),
+  zapier: (flags) => ({ type: "zapier", url: need(flags.url, "--to zapier needs --url <address>.") }),
+  email: (flags) => ({
+    type: "email",
+    email: need(flags.email, "--to email needs --email <address>[,<address>\u2026]."),
+    ...flags.subject ? { subject: flags.subject } : {}
+  }),
+  pipedrive: accountDestination("pipedrive"),
+  goHighlevelContact: accountDestination("goHighlevelContact"),
+  activeCampaignContact: accountDestination("activeCampaignContact")
+};
+function destinationOf(flags) {
+  const to = flags.to;
+  if (!to || !LEAD_ROUTE_DESTINATION_TYPES.includes(to)) {
+    throw new LeadRouteArgsError(`--to must be one of ${LEAD_ROUTE_DESTINATION_TYPES.join(", ")}.`);
+  }
+  const type = to;
+  const allowed = new Set(DESTINATION_FLAGS[type]);
+  const stray = [...ALL_DESTINATION_FLAGS].filter((flag) => !allowed.has(flag) && flags[flag]);
+  if (stray.length > 0) {
+    throw new LeadRouteArgsError(`--to ${type} does not take ${stray.map((flag) => `--${flag}`).join(", ")}.`);
+  }
+  return DESTINATIONS[type](flags);
+}
+function parseSetArgs(flags, fieldValues) {
+  if (!flags.platform || !LEAD_ROUTE_PLATFORMS.includes(flags.platform)) {
+    throw new LeadRouteArgsError(`--platform must be one of ${LEAD_ROUTE_PLATFORMS.join(", ")}.`);
+  }
+  if (!flags.form) throw new LeadRouteArgsError("--form <lead form id> is required.");
+  const fields = parseFields(fieldValues);
+  const parsed = leadRouteSetSchema.safeParse({
+    ...flags.id ? { id: flags.id } : {},
+    ...flags.name ? { name: flags.name } : {},
+    platform: flags.platform,
+    ...flags.account ? { account: flags.account } : {},
+    formId: flags.form,
+    destination: destinationOf(flags),
+    ...fields.length > 0 ? { fields } : {},
+    ...flags.since ? { since: flags.since } : {}
+  });
+  if (!parsed.success) {
+    const issue = parsed.error.issues[0];
+    throw new LeadRouteArgsError(`${issue?.path.join(".") || "route"}: ${issue?.message ?? "invalid"}`);
+  }
+  return parsed.data;
+}
+var ROUTE_FLAGS = ["platform", "account", "form", ...ALL_DESTINATION_FLAGS];
+function amendArgs(flags, fieldValues, addFieldValues) {
+  const named = ROUTE_FLAGS.filter((flag) => flags[flag]);
+  if (named.length > 0) {
+    throw new LeadRouteArgsError(
+      `set --id without --to keeps the route's form and destination, so it takes no ${named.map((flag) => `--${flag}`).join(", ")}. Change the mapping with --add-field or --field; to move the route, pass --to with its destination flags too.`
+    );
+  }
+  const fields = parseFields(fieldValues);
+  const addFields = parseFields(addFieldValues);
+  const parsed = leadRouteAmendSchema.safeParse({
+    id: flags.id,
+    ...flags.name ? { name: flags.name } : {},
+    ...fields.length > 0 ? { fields } : {},
+    ...addFields.length > 0 ? { addFields } : {},
+    ...flags.since ? { since: flags.since } : {}
+  });
+  if (!parsed.success) {
+    const issue = parsed.error.issues[0];
+    throw new LeadRouteArgsError(`${issue?.path.join(".") || "route"}: ${issue?.message ?? "invalid"}`);
+  }
+  return parsed.data;
+}
+function parseStageArgs(flags, values) {
+  if (flags.id && !flags.to) return { amend: amendArgs(flags, values.fields, values.addFields) };
+  if (values.addFields.length > 0) {
+    throw new LeadRouteArgsError(
+      "--add-field changes an existing route: use it with --id <route> and without --to. A new route names its fields with --field."
+    );
+  }
+  return { set: parseSetArgs(flags, values.fields) };
+}
+function previewDestinationRefusal(flags, hasFields) {
+  if (hasFields || !(flags.sheet || flags["hubspot-form"])) return void 0;
+  return "An existing sheet's or HubSpot form's columns are read from it when the route is staged. Stage it with `baker lead-routes set`, then `baker lead-routes preview --id <route>` shows exactly what it sends \u2014 or pass --field to preview a mapping of your own.";
+}
+
+// src/commands/lead-routes/index.ts
+function fail(err) {
+  if (err instanceof LeadRouteArgsError) {
+    writeJson({ ok: false, error: { code: "VALIDATION_ERROR", message: err.message } });
+  } else if (err instanceof ApiError) {
+    writeJson({ ok: false, error: { code: err.code, message: err.message } });
+  } else {
+    writeJson({
+      ok: false,
+      error: { code: "INTERNAL_ERROR", message: err instanceof Error ? err.message : "Unexpected error" }
+    });
+  }
+  process.exit(1);
+}
+var PLATFORM_ARG = { type: "string", description: "meta | linkedin | google", required: true };
+var ACCOUNT_ARG = {
+  type: "string",
+  description: "LinkedIn ad account id, or Google Ads customer id. Not needed for Meta",
+  required: false
+};
+var FORM_ARG = {
+  type: "string",
+  description: "The lead form's id (`ads meta lead-forms`, `ads linkedin lead-forms`, a Google LEAD_FORM asset id)",
+  required: true
+};
+var FIELD_ARG = {
+  type: "string",
+  description: "Repeatable. <destination key>=<lead field>: C=email, firstname=first_name, notes=answer:budget, source=text:Meta lead ad",
+  required: false
+};
+registerSchema({
+  command: "lead-routes.list",
+  description: "Start here: every lead form whose leads Baker sends somewhere \u2014 the form, where they go, the fields sent, whether it is active or paused, how many were delivered, the last lead and the last problem \u2014 plus `staged`: what this chat changed. Read-only.",
+  args: {}
+});
+registerSchema({
+  command: "lead-routes.fields",
+  description: "What a lead form asks, by the names `--field` uses: a contact field (email, phone, first_name, company\u2026) for the platform's own questions, answer:<key> for the client's own, plus the context every lead carries (campaign_name, ad_name, submitted_at, form_name, answers, consents\u2026). Read-only.",
+  args: { platform: PLATFORM_ARG, account: ACCOUNT_ARG, form: FORM_ARG }
+});
+var OPTIONAL_PLATFORM_ARG = {
+  ...PLATFORM_ARG,
+  description: "meta | linkedin | google (not with --id)",
+  required: false
+};
+var OPTIONAL_FORM_ARG = { ...FORM_ARG, description: "The lead form's id (not with --id)", required: false };
+var OPTIONAL_TO_ARG = {
+  type: "string",
+  description: `${LEAD_ROUTE_DESTINATION_TYPES.join(" | ")} (not with --id)`,
+  required: false
+};
+var PREVIEW_ID_ARG = {
+  type: "string",
+  description: "A route staged on this chat or live (r1): preview it exactly as it will send \u2014 its destination and fields",
+  required: false
+};
+var PREVIEW_DESTINATION_ARGS = {
+  sheet: {
+    type: "string",
+    description: "Existing spreadsheet id (needs --field; else stage, then --id)",
+    required: false
+  },
+  "new-sheet": { type: "string", description: "A sheet `set` would create: its default columns", required: false },
+  tab: { type: "string", description: "Ignored by a preview", required: false },
+  "destination-account": { type: "string", description: "Ignored by a preview", required: false },
+  "hubspot-form": {
+    type: "string",
+    description: "HubSpot form id (needs --field; else stage, then --id)",
+    required: false
+  },
+  url: { type: "string", description: "Ignored by a preview", required: false },
+  email: { type: "string", description: "Ignored by a preview", required: false },
+  subject: { type: "string", description: "Ignored by a preview", required: false }
+};
+registerSchema({
+  command: "lead-routes.preview",
+  description: "What a destination would receive for the form's latest leads, contact details masked unless --full. Reads the platform only; nothing is sent. After `set`, `--id <route>` shows exactly what the staged route will send (an existing sheet's or a HubSpot form's own defaults included); before it, --platform/--form/--to [--field] try a mapping.",
+  args: {
+    id: PREVIEW_ID_ARG,
+    platform: OPTIONAL_PLATFORM_ARG,
+    account: ACCOUNT_ARG,
+    form: OPTIONAL_FORM_ARG,
+    to: OPTIONAL_TO_ARG,
+    field: FIELD_ARG,
+    ...PREVIEW_DESTINATION_ARGS,
+    limit: { type: "string", description: "How many of the latest leads, 1-5 (default 1)", required: false },
+    full: { type: "boolean", description: "Show contact details unmasked", required: false }
+  }
+});
+var SET_PLATFORM_ARG = { ...PLATFORM_ARG, description: "meta | linkedin | google", required: false };
+var SET_FORM_ARG = { ...FORM_ARG, required: false };
+var SET_TO_ARG = {
+  type: "string",
+  description: `${LEAD_ROUTE_DESTINATION_TYPES.join(" | ")}. Leave out with --id to keep the route's destination`,
+  required: false
+};
+var ADD_FIELD_ARG = {
+  type: "string",
+  description: "Repeatable, with --id and no --to: add or replace one column of the route's mapping, M=answer:budget",
+  required: false
+};
+registerSchema({
+  command: "lead-routes.set",
+  description: "Stage a lead route: every new lead of one lead form goes to one destination, from when this chat is published. --to googleSpreadsheet (--sheet <id> | --new-sheet <title>, [--tab]), hubspotForm (--hubspot-form <id>), httpWebhook (--url, no credential), zapier (--url, a Catch Hook), email (--email, [--subject]), pipedrive | goHighlevelContact | activeCampaignContact (the connected account). Without --field the destination's defaults apply: a new sheet gets standard columns, an existing sheet its recognised headers, HubSpot the contact fields its form has, a webhook/Zapier/email the whole lead. --since YYYY-MM-DD also sends the leads since that day (at most 30 days back). --id changes an existing route: with --to and its destination flags, the whole route; without --to, only its mapping (--add-field M=answer:budget adds or replaces one column, --field replaces them all), --since or --name \u2014 its form and destination are kept.",
+  args: {
+    platform: SET_PLATFORM_ARG,
+    account: ACCOUNT_ARG,
+    form: SET_FORM_ARG,
+    to: SET_TO_ARG,
+    sheet: {
+      type: "string",
+      description: "Existing spreadsheet id (`baker flows options googleSpreadsheet`)",
+      required: false
+    },
+    "new-sheet": { type: "string", description: "Create a spreadsheet with this title for the leads", required: false },
+    tab: { type: "string", description: "The sheet's tab to append to (default: the first)", required: false },
+    "destination-account": {
+      type: "string",
+      description: "Which connected Google Drive / Pipedrive / GoHighLevel / ActiveCampaign account, when there are several",
+      required: false
+    },
+    "hubspot-form": { type: "string", description: "HubSpot form id (`baker hubspot forms list`)", required: false },
+    url: { type: "string", description: "Webhook or Zapier hook address", required: false },
+    email: { type: "string", description: "Who is emailed each lead, comma-separated", required: false },
+    subject: { type: "string", description: "Email subject (default: New lead: <form>)", required: false },
+    field: FIELD_ARG,
+    "add-field": ADD_FIELD_ARG,
+    since: {
+      type: "string",
+      description: "Also send leads since this day, YYYY-MM-DD, at most 30 days back",
+      required: false
+    },
+    id: { type: "string", description: "Change this route instead of adding one", required: false },
+    name: { type: "string", description: "A name for the route", required: false }
+  }
+});
+registerSchema({
+  command: "lead-routes.remove",
+  description: "Stage stopping live lead routes, by id; they stop when this chat is published. A route staged in this same chat is simply taken back.",
+  args: { id: { type: "string", description: "Route ids, comma-separated (r1,r2)", required: true } }
+});
+registerSchema({
+  command: "lead-routes.unstage",
+  description: "Take back a lead route change this chat staged, before publish. --all takes back every one.",
+  args: {
+    id: { type: "string", description: "A routeId from `baker lead-routes list` \u2192 staged", required: false },
+    all: { type: "boolean", description: "Take back every staged lead route change", required: false }
+  }
+});
+function asPlatform(value) {
+  return value;
+}
+var listCommand = defineCommand({
+  meta: {
+    name: "list",
+    description: "Every lead route, live and staged in this chat.\n\nExample: baker lead-routes list"
+  },
+  run: async () => {
+    try {
+      const chatId = optionalChatId();
+      writeJson(await apiGet("/api/lead-routes", chatId ? { chatId } : void 0));
+    } catch (err) {
+      fail(err);
+    }
+  }
+});
+var fieldsCommand = defineCommand({
+  meta: {
+    name: "fields",
+    description: "What a lead form asks, by the names --field uses.\n\nExamples:\n  baker lead-routes fields --platform meta --form 1234567890\n  baker lead-routes fields --platform linkedin --account 513852526 --form 987654"
+  },
+  args: { platform: PLATFORM_ARG, account: ACCOUNT_ARG, form: FORM_ARG },
+  run: async ({ args }) => {
+    try {
+      const body = {
+        platform: asPlatform(args.platform),
+        formId: String(args.form),
+        ...args.account ? { account: String(args.account) } : {}
+      };
+      writeJson(await apiPost("/api/lead-routes/fields", body));
+    } catch (err) {
+      fail(err);
+    }
+  }
+});
+var previewCommand = defineCommand({
+  meta: {
+    name: "preview",
+    description: "What a destination would receive for the latest leads. Sends nothing.\n\nExamples:\n  baker lead-routes preview --id r1\n  baker lead-routes preview --platform meta --form 1234567890 --to httpWebhook\n  baker lead-routes preview --platform meta --form 1234567890 --to hubspotForm --field email=email --field firstname=first_name"
+  },
+  args: {
+    id: PREVIEW_ID_ARG,
+    platform: OPTIONAL_PLATFORM_ARG,
+    account: ACCOUNT_ARG,
+    form: OPTIONAL_FORM_ARG,
+    to: OPTIONAL_TO_ARG,
+    field: FIELD_ARG,
+    ...PREVIEW_DESTINATION_ARGS,
+    limit: { type: "string", description: "1-5", required: false },
+    full: { type: "boolean", description: "Unmasked", required: false }
+  },
+  run: async ({ args, rawArgs }) => {
+    try {
+      const fields = parseFields(repeatedValues(rawArgs, "field", args.field));
+      const refusal = previewDestinationRefusal(
+        { sheet: args.sheet, "hubspot-form": args["hubspot-form"] },
+        fields.length > 0
+      );
+      if (refusal) throw new LeadRouteArgsError(refusal);
+      if (!args.id && !(args.platform && args.form && args.to)) {
+        throw new LeadRouteArgsError(
+          "Name a route with --id r1, or a form and a destination: --platform, --form, --to"
+        );
+      }
+      const chatId = optionalChatId();
+      const body = {
+        ...args.id ? { id: String(args.id) } : {},
+        ...chatId ? { chatId } : {},
+        ...args.platform ? { platform: asPlatform(args.platform) } : {},
+        ...args.form ? { formId: String(args.form) } : {},
+        ...args.to ? { destinationType: args.to } : {},
+        ...args.account ? { account: String(args.account) } : {},
+        ...fields.length > 0 ? { fields } : {},
+        ...args.limit ? { limit: Number(args.limit) } : {},
+        ...args.full === true ? { full: true } : {}
+      };
+      writeJson(await apiPost("/api/lead-routes/preview", body));
+    } catch (err) {
+      fail(err);
+    }
+  }
+});
+var setCommand = defineCommand({
+  meta: {
+    name: "set",
+    description: 'Stage a lead route; it starts delivering when this chat is published.\n\nExamples:\n  baker lead-routes set --platform meta --form 1234567890 --to googleSpreadsheet --new-sheet "Meta leads"\n  baker lead-routes set --platform linkedin --account 513852526 --form 987654 --to hubspotForm --hubspot-form 3f2a\u2026\n  baker lead-routes set --platform meta --form 1234567890 --to httpWebhook --url https://hooks.example.com/leads\n  baker lead-routes set --platform google --account 3865083115 --form 555 --to email --email sales@acme.com\n  baker lead-routes set --id r1 --add-field M=answer:budget --add-field "N=text:Facebook lead ad"'
+  },
+  args: {
+    platform: SET_PLATFORM_ARG,
+    account: ACCOUNT_ARG,
+    form: SET_FORM_ARG,
+    to: SET_TO_ARG,
+    sheet: { type: "string", description: "Existing spreadsheet id", required: false },
+    "new-sheet": { type: "string", description: "Create a spreadsheet with this title", required: false },
+    tab: { type: "string", description: "Tab to append to", required: false },
+    "destination-account": { type: "string", description: "Which connected account", required: false },
+    "hubspot-form": { type: "string", description: "HubSpot form id", required: false },
+    url: { type: "string", description: "Webhook or Zapier hook address", required: false },
+    email: { type: "string", description: "Recipients, comma-separated", required: false },
+    subject: { type: "string", description: "Email subject", required: false },
+    field: FIELD_ARG,
+    "add-field": ADD_FIELD_ARG,
+    since: { type: "string", description: "YYYY-MM-DD, at most 30 days back", required: false },
+    id: { type: "string", description: "Change this route", required: false },
+    name: { type: "string", description: "Route name", required: false }
+  },
+  run: async ({ args, rawArgs }) => {
+    try {
+      const text = (key) => {
+        const value = args[key];
+        return typeof value === "string" && value.length > 0 ? value : void 0;
+      };
+      const staged = parseStageArgs(
+        {
+          id: text("id"),
+          name: text("name"),
+          platform: text("platform"),
+          account: text("account"),
+          form: text("form"),
+          to: text("to"),
+          sheet: text("sheet"),
+          "new-sheet": text("new-sheet"),
+          tab: text("tab"),
+          "destination-account": text("destination-account"),
+          "hubspot-form": text("hubspot-form"),
+          url: text("url"),
+          email: text("email"),
+          subject: text("subject"),
+          since: text("since")
+        },
+        {
+          fields: repeatedValues(rawArgs, "field", args.field),
+          addFields: repeatedValues(rawArgs, "add-field", args["add-field"])
+        }
+      );
+      const body = { chatId: requireChatId(), ...staged };
+      writeJson(await apiPost("/api/lead-routes/stage", body));
+    } catch (err) {
+      fail(err);
+    }
+  }
+});
+var removeCommand = defineCommand({
+  meta: {
+    name: "remove",
+    description: "Stage stopping live lead routes.\n\nExample: baker lead-routes remove r1"
+  },
+  args: { id: { type: "positional", description: "Route ids, comma-separated", required: true } },
+  run: async ({ args }) => {
+    try {
+      const remove = String(args.id).split(",").map((id) => id.trim()).filter(Boolean);
+      const body = { chatId: requireChatId(), remove };
+      writeJson(await apiPost("/api/lead-routes/stage", body));
+    } catch (err) {
+      fail(err);
+    }
+  }
+});
+var unstageCommand = defineCommand({
+  meta: {
+    name: "unstage",
+    description: "Take back a staged lead route change.\n\nExamples:\n  baker lead-routes unstage r2\n  baker lead-routes unstage --all"
+  },
+  args: {
+    id: { type: "positional", description: "A staged routeId", required: false },
+    all: { type: "boolean", description: "Every staged change", required: false }
+  },
+  run: async ({ args }) => {
+    try {
+      const id = typeof args.id === "string" && args.id.length > 0 ? args.id : void 0;
+      if (id === void 0 === (args.all !== true)) {
+        throw new LeadRouteArgsError("Pass one route id (see `baker lead-routes list` \u2192 staged) or --all.");
+      }
+      const body = { chatId: requireChatId(), ...id ? { routeId: id } : {} };
+      writeJson(await apiPost("/api/lead-routes/unstage", body));
+    } catch (err) {
+      fail(err);
+    }
+  }
+});
+var leadRoutesCommand = defineCommand({
+  meta: {
+    name: "lead-routes",
+    description: `Send the leads an ad platform's lead form collects \u2014 a Meta Instant Form, a LinkedIn Lead Gen Form, a Google lead form \u2014 to a Google Sheet, HubSpot, a webhook, Zapier, an email, Pipedrive, GoHighLevel or ActiveCampaign. Staged on this chat; delivering from when it is published. Subcommands: list, fields, preview, set, remove, unstage.
+
+Examples:
+  baker lead-routes list
+  baker lead-routes fields --platform meta --form 1234567890
+  baker lead-routes set --platform meta --form 1234567890 --to googleSpreadsheet --new-sheet "Meta leads"
+  baker lead-routes remove r1
+Full guide: __tooling__/docs/tools/baker/lead-routes.md`
+  },
+  subCommands: {
+    list: listCommand,
+    fields: fieldsCommand,
+    preview: previewCommand,
+    set: setCommand,
+    remove: removeCommand,
+    unstage: unstageCommand
+  }
+});
+export {
+  leadRoutesCommand
+};
+//# sourceMappingURL=lead-routes-IXUCGINI.js.map