@koda-sl/baker-cli 0.533.0 → 0.534.0-dev.4da06ee4d

package/dist/chunk-Z3UJKRF7.js

@@ -0,0 +1,547 @@
+import {
+  hubspotRefusal
+} from "./chunk-N2MYKKHX.js";
+import {
+  collectSideEffects,
+  readFlowTree,
+  readSettings,
+  walkNodes,
+  writeFlowTree
+} from "./chunk-WR7T2ZLW.js";
+import {
+  failApi
+} from "./chunk-6SK56BHM.js";
+import {
+  FLOW_AGENT_DESTINATION_KINDS,
+  FLOW_PROVIDER_TYPE
+} from "./chunk-WNIDYKWO.js";
+import {
+  ApiError,
+  apiPost
+} from "./chunk-IKZHHMG4.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-ERCYMMBF.js";
+
+// src/commands/flows/connect.ts
+import { defineCommand } from "citty";
+var STEP_KINDS = /* @__PURE__ */ new Set(["calendly", "savvycal", "highlevel", "highlevelForm", "hubspot", "hubspotMeeting"]);
+var OAUTH_SIDE_EFFECTS = /* @__PURE__ */ new Set([
+  "hubspotForm",
+  "googleSpreadsheet",
+  "pipedrive",
+  "goHighlevelContact",
+  "activeCampaignContact"
+]);
+function attachDestination(tree, named, sealed, type = "hubspotForm") {
+  const ofType = collectSideEffects(tree).filter((entry) => entry.sideEffect.type === type);
+  const inventory = ofType.map((entry) => String(entry.sideEffect.id)).join(", ") || "none";
+  const chosen = named ? collectSideEffects(tree).find((entry) => entry.sideEffect.id === named) : ofType.length === 1 ? ofType[0] : void 0;
+  if (!chosen) {
+    return {
+      ok: false,
+      message: named ? `No side effect with id "${named}" in this form.` : `This form has ${ofType.length} ${type} side effects \u2014 name one with --side-effect <id>.`,
+      fix: ofType.length === 0 ? `Add one first: baker flows add-side-effect <slug> --node <stepId> --type ${type}` : `${type} side effects in this form: ${inventory}`
+    };
+  }
+  if (chosen.sideEffect.type !== type) {
+    return {
+      ok: false,
+      message: `Side effect "${named}" is a ${String(chosen.sideEffect.type)}, not a ${type}.`,
+      fix: `${type} side effects in this form: ${inventory}`
+    };
+  }
+  chosen.sideEffect.oauthProviderId = sealed.oauthProviderId;
+  chosen.sideEffect.encryptedConfig = sealed.encryptedConfig;
+  return { ok: true, nodeId: String(chosen.node.id), sideEffectId: String(chosen.sideEffect.id) };
+}
+function isSet(value) {
+  return typeof value === "string" && value.length > 0;
+}
+function unwiredSideEffects(tree, type) {
+  return collectSideEffects(tree).filter(({ sideEffect }) => sideEffect.type === type).filter(
+    ({ sideEffect }) => OAUTH_SIDE_EFFECTS.has(type) && !isSet(sideEffect.oauthProviderId) || !isSet(sideEffect.encryptedConfig)
+  ).map(({ sideEffect }) => String(sideEffect.id));
+}
+function unwiredHubspotForms(tree) {
+  return unwiredSideEffects(tree, "hubspotForm");
+}
+var STATED_KINDS = /* @__PURE__ */ new Set(["email", "httpWebhook"]);
+function statedKind(args) {
+  if (typeof args.email === "string" || typeof args.subject === "string") return "email";
+  if (typeof args.url === "string") return "httpWebhook";
+  return void 0;
+}
+function sealRequestFor(kind, args) {
+  const text = (key) => typeof args[key] === "string" && args[key].trim() ? args[key].trim() : void 0;
+  if (kind === "email") {
+    const email = text("email");
+    const subject = text("subject");
+    if (!email || !subject) {
+      return {
+        ok: false,
+        message: "An email destination needs both who receives it and its subject.",
+        fix: 'Pass --email "a@x.com, b@x.com" --subject "New lead \u2014 <Form name>". Write the subject yourself from the Form; ask the user only for an address you were not given.'
+      };
+    }
+    return { ok: true, request: { type: "email", email, subject } };
+  }
+  if (kind === "httpWebhook") {
+    const apiUrl = text("url");
+    if (!apiUrl) {
+      return { ok: false, message: "A webhook destination needs its address.", fix: "Pass --url https://\u2026" };
+    }
+    return { ok: true, request: { type: "httpWebhook", apiUrl } };
+  }
+  return {
+    ok: false,
+    message: `A ${kind} destination holds a credential, so it is not one you can state.`,
+    fix: "Its token or URL is the user's to enter: request_flow_input."
+  };
+}
+var UNREADABLE = "holds settings this chat cannot read";
+function keepsWhatTheAgentCannotState(kind, settings) {
+  if (settings === null) return UNREADABLE;
+  if (kind === "httpWebhook" && typeof settings?.auth === "string" && settings.auth !== "noAuth") {
+    return "sends a credential the user entered";
+  }
+  if (kind === "email" && settings !== void 0 && "email" in settings && typeof settings.email !== "string") {
+    return "replies to the visitor's own email answer";
+  }
+  return void 0;
+}
+function restatableTargets(target, settingsById, all, replaceUnreadableEmail = false) {
+  const kept = target.ids.flatMap((id) => {
+    if (target.kind === "email" && settingsById[id] === null && replaceUnreadableEmail && !all && target.ids.length === 1) {
+      return [];
+    }
+    const why = keepsWhatTheAgentCannotState(target.kind, settingsById[id]);
+    return why ? [{ id, why }] : [];
+  });
+  const ids = target.ids.filter((id) => !kept.some((entry) => entry.id === id));
+  if (kept.length > 0 && (!all || ids.length === 0)) {
+    const [first] = kept;
+    return {
+      ok: false,
+      message: `"${first?.id}" ${first?.why}; restating it would replace that.`,
+      fix: first?.why === UNREADABLE ? target.kind === "email" ? `Baker cannot read the old recipients or tell whether this replies to a visitor. If the user wants to replace this destination, pass --side-effect ${first?.id} --replace-unreadable --email <complete recipient list> --subject <subject>. This replaces its entire previous setup; never use it to add a recipient to an unknown list. Otherwise leave it as it is and add a separate team email destination.` : "Have the user restate the webhook address and any credential once with request_flow_input; after that this command can change a webhook with no credential." : target.kind === "httpWebhook" ? "A new address for a webhook with a credential is the user's to enter with it: request_flow_input." : "Leave it as it is. Add a separate email destination for the team: baker flows add-side-effect."
+    };
+  }
+  return { ok: true, ids, skipped: kept.map((entry) => entry.id) };
+}
+function attachSettings(tree, id, encryptedConfig, type) {
+  const chosen = collectSideEffects(tree).find((entry) => entry.sideEffect.id === id);
+  if (!chosen || chosen.sideEffect.type !== type) {
+    const ofType = collectSideEffects(tree).filter((entry) => entry.sideEffect.type === type);
+    return {
+      ok: false,
+      message: chosen ? `Side effect "${id}" is a ${String(chosen.sideEffect.type)}, not a ${type}.` : `No side effect with id "${id}" in this form.`,
+      fix: `${type} side effects in this form: ${ofType.map((entry) => String(entry.sideEffect.id)).join(", ") || "none"}`
+    };
+  }
+  chosen.sideEffect.encryptedConfig = encryptedConfig;
+  return { ok: true, nodeId: String(chosen.node.id), sideEffectId: id };
+}
+function stepType(node) {
+  const type = node?.nodeData?.type;
+  return typeof type === "string" ? type : void 0;
+}
+function findStep(tree, nodeId) {
+  return walkNodes(tree).find((node) => node.id === nodeId);
+}
+function attachStep(tree, nodeId, external) {
+  const node = findStep(tree, nodeId);
+  const type = stepType(node);
+  if (!node || !type) {
+    return {
+      ok: false,
+      message: `No step with id "${nodeId}" in this form.`,
+      fix: "Step ids: baker flows show <slug>"
+    };
+  }
+  if (!STEP_KINDS.has(type)) {
+    return {
+      ok: false,
+      message: `Step "${nodeId}" is a ${type}, which embeds nothing from another platform.`,
+      fix: "Only calendly, savvycal, highlevel, highlevelForm, hubspot and hubspotMeeting steps take a resource."
+    };
+  }
+  const nodeData = node.nodeData;
+  const form = nodeData.form ?? {};
+  nodeData.form = { autofilledFields: {}, ...form, external };
+  return { ok: true, nodeId, type };
+}
+function unpickedSteps(tree, type) {
+  return walkNodes(tree).filter((node) => stepType(node) === type).filter((node) => node.nodeData.form?.external == null).map((node) => String(node.id));
+}
+function copyDestination(source, sourceId, target, targetId) {
+  const from = collectSideEffects(source).find((entry) => entry.sideEffect.id === sourceId);
+  if (from) {
+    const type = String(from.sideEffect.type);
+    if (!isSet(from.sideEffect.oauthProviderId) || !isSet(from.sideEffect.encryptedConfig)) {
+      return {
+        ok: false,
+        message: `"${sourceId}" is not wired itself \u2014 nothing to copy.`,
+        fix: "Copy from one that is."
+      };
+    }
+    const attached = attachDestination(
+      target,
+      targetId,
+      {
+        oauthProviderId: String(from.sideEffect.oauthProviderId),
+        encryptedConfig: String(from.sideEffect.encryptedConfig)
+      },
+      type
+    );
+    return attached.ok ? { ok: true, nodeId: attached.nodeId, type } : attached;
+  }
+  const step = findStep(source, sourceId);
+  const external = step?.nodeData?.form?.external;
+  if (!step || external == null || typeof external !== "object") {
+    return {
+      ok: false,
+      message: `No wired side effect or picked step "${sourceId}" in the source form.`,
+      fix: "Ids: baker flows show <slug>"
+    };
+  }
+  const targetType = stepType(findStep(target, targetId));
+  if (targetType !== stepType(step)) {
+    return {
+      ok: false,
+      message: `"${sourceId}" is a ${String(stepType(step))} and "${targetId}" a ${String(targetType)} \u2014 copy only between the same type.`,
+      fix: "Pick a source of the same type."
+    };
+  }
+  return attachStep(target, targetId, structuredClone(external));
+}
+function refuse(message, fix, code = "VALIDATION_ERROR") {
+  writeJson({ ok: false, error: { code, message, fix } });
+  process.exit(1);
+}
+function allTargets(tree, kind) {
+  if (!kind) refuse("--all needs --type <kind> to know what to wire.", "e.g. --all --type googleSpreadsheet");
+  const on = STEP_KINDS.has(kind) ? "node" : "sideEffect";
+  const ids = STATED_KINDS.has(kind) ? collectSideEffects(tree).filter(({ sideEffect }) => sideEffect.type === kind).map(({ sideEffect }) => String(sideEffect.id)) : on === "node" ? unpickedSteps(tree, kind) : unwiredSideEffects(tree, kind);
+  if (ids.length === 0 && STATED_KINDS.has(kind)) {
+    refuse(
+      `This Form has no ${kind} destination.`,
+      `Add one: baker flows add-side-effect <slug> --node <stepId> --type ${kind}`
+    );
+  }
+  if (ids.length === 0) {
+    refuse(
+      `Every ${kind} in this Form is already wired.`,
+      "Repoint one by naming it with --node / --side-effect instead of --all."
+    );
+  }
+  return { kind, on, ids };
+}
+function onlyOfType(tree, type) {
+  const probe = attachDestination(tree, void 0, { oauthProviderId: "", encryptedConfig: "" }, type);
+  if (!probe.ok) refuse(probe.message, probe.fix);
+  return probe.sideEffectId;
+}
+function stepTarget(tree, node) {
+  const type = stepType(findStep(tree, node));
+  if (!type) refuse(`No step with id "${node}" in this form.`, "Step ids: baker flows show <slug>");
+  return { kind: type, on: "node", ids: [node] };
+}
+function sideEffectTarget(tree, named) {
+  const found = collectSideEffects(tree).find((entry) => entry.sideEffect.id === named);
+  if (!found) refuse(`No side effect with id "${named}" in this form.`, "Side-effect ids: baker flows show <slug>");
+  return { kind: String(found.sideEffect.type), on: "sideEffect", ids: [named] };
+}
+function targetsFor(tree, args) {
+  const node = typeof args.node === "string" ? args.node : void 0;
+  const named = typeof args["side-effect"] === "string" ? args["side-effect"] : void 0;
+  if ([node, named, args.all === true ? "all" : void 0].filter(Boolean).length > 1) {
+    refuse("Pass one of --node, --side-effect or --all.", "One target per call; --all for every unwired one.");
+  }
+  if (args.all === true) {
+    const kind = typeof args.type === "string" ? args.type : args["hubspot-form"] ? "hubspotForm" : statedKind(args);
+    return allTargets(tree, kind);
+  }
+  if (node) return stepTarget(tree, node);
+  if (named) return sideEffectTarget(tree, named);
+  if (args["hubspot-form"]) return { kind: "hubspotForm", on: "sideEffect", ids: [onlyOfType(tree, "hubspotForm")] };
+  const stated = statedKind(args);
+  if (stated) return { kind: stated, on: "sideEffect", ids: [onlyOfType(tree, stated)] };
+  return refuse(
+    "Name what to fill: --node <stepId>, --side-effect <id>, or --all --type <kind>.",
+    "Ids: baker flows show <slug>"
+  );
+}
+async function sealHubspotForm(formId) {
+  try {
+    return (await apiPost("/api/hubspot/forms/destination", { formId })).data;
+  } catch (err) {
+    const refusal = err instanceof ApiError ? hubspotRefusal(err.code, err.message) : null;
+    if (err instanceof ApiError && refusal !== null) refuse(err.message, refusal.fix, refusal.code);
+    failApi(err);
+  }
+}
+function isAgentKind(kind) {
+  return FLOW_AGENT_DESTINATION_KINDS.includes(kind);
+}
+function destinationRefusal(kind, err) {
+  if (err.code === "NOT_FOUND" && err.message.includes("is connected to this company")) {
+    return {
+      code: "NOT_CONNECTED",
+      fix: `AGENT INSTRUCTION: only the user can connect it. Call request_connection with { platform: "${FLOW_PROVIDER_TYPE[kind]}", reason } \u2014 reason in their words \u2014 then run this again. Keep going with the rest of the task meanwhile.`
+    };
+  }
+  if (err.code === "CONFLICT" && err.message.includes("--account")) {
+    return {
+      code: "SEVERAL_ACCOUNTS",
+      fix: "Pass --account <id> when the user or the brief makes clear which one; otherwise ask them which (AskUserQuestion), naming the accounts above."
+    };
+  }
+  return null;
+}
+function resolveBody(kind, args) {
+  const columns = typeof args.columns === "string" ? args.columns.split(",").map((column) => column.trim()).filter(Boolean) : void 0;
+  return {
+    kind,
+    ...typeof args.account === "string" ? { account: args.account } : {},
+    ...typeof args.resource === "string" ? { resourceId: args.resource } : {},
+    ...typeof args.tab === "string" ? { tab: args.tab } : {},
+    ...typeof args["new-sheet"] === "string" ? { newSheet: { title: args["new-sheet"], columns } } : {}
+  };
+}
+async function resolveDestination(kind, args) {
+  try {
+    return (await apiPost("/api/flows/destinations/resolve", resolveBody(kind, args))).data;
+  } catch (err) {
+    const refusal = err instanceof ApiError ? destinationRefusal(kind, err) : null;
+    if (err instanceof ApiError && refusal !== null) refuse(err.message, refusal.fix, refusal.code);
+    failApi(err);
+  }
+}
+function applyAll(target, apply) {
+  return target.ids.map((id) => {
+    const done = apply(id);
+    if (!done.ok) refuse(done.message, done.fix);
+    return "sideEffectId" in done ? { nodeId: done.nodeId, sideEffectId: done.sideEffectId } : { nodeId: done.nodeId };
+  });
+}
+function sameAs(tree, target, ref) {
+  const [slug, id] = ref.split(":");
+  if (!slug || !id) refuse(`--same-as takes <slug>:<id>, got "${ref}".`, "e.g. --same-as madrid:se-gsheet-1");
+  const source = readFlowTree(slug);
+  const wired = applyAll(target, (targetId) => copyDestination(source, id, tree, targetId));
+  return { wired, destination: { sameAs: ref }, hints: [] };
+}
+async function fromHubspot(tree, target, formId, slug) {
+  if (target.kind !== "hubspotForm") {
+    refuse(
+      `--hubspot-form wires a hubspotForm side effect, not a ${target.kind}.`,
+      "A HubSpot step takes `baker hubspot forms view <id> --as-node` (or `meetings view <slug> --as-node`)."
+    );
+  }
+  const sealed = await sealHubspotForm(formId);
+  const wired = applyAll(target, (id) => attachDestination(tree, id, sealed));
+  return {
+    wired,
+    destination: { formGuid: sealed.formGuid, formName: sealed.formName, portalId: sealed.portalId },
+    hints: [
+      `Now map each step's answers onto it: baker flows map ${slug} --side-effect <id> --hubspot-form ${sealed.formGuid} --map email=<value> \u2026 --write. Field names come from \`baker hubspot forms view ${sealed.formGuid}\`.`
+    ]
+  };
+}
+function sheetHints(slug, data) {
+  const sheet = data.destination;
+  if (!sheet)
+    return [`Now map the fields: baker flows map ${slug} --side-effect <id> --map <fieldKey>=<value> \u2026 --write.`];
+  const columns = sheet.columns.map((column) => `${column.letter}=${column.header}`).join(", ");
+  return [
+    ...sheet.created ? [
+      `Created "${sheet.name}" in the connected Google account${sheet.url ? ` (${sheet.url})` : ""} \u2014 tell the user where their leads will land.`
+    ] : [],
+    columns ? `Columns: ${columns}. Map by letter: baker flows map ${slug} --side-effect <id> --map A=<value> \u2026 --write.` : `The "${sheet.tab}" tab has no header row. Map by letter anyway, and say which column holds what.`
+  ];
+}
+async function fromStated(tree, target, args) {
+  const plan = sealRequestFor(target.kind, args);
+  if (!plan.ok) refuse(plan.message, plan.fix);
+  const current = await readSettings(tree);
+  if (current === null) {
+    refuse(
+      "Could not read what this Form's destinations hold now, so nothing was overwritten.",
+      "Try again in a moment; if it keeps failing, carry on with the rest and tell the user this one is not set.",
+      "NETWORK_ERROR"
+    );
+  }
+  const restatable = restatableTargets(target, current, args.all === true, args["replace-unreadable"] === true);
+  if (!restatable.ok) refuse(restatable.message, restatable.fix);
+  const kept = restatable.skipped.length ? [`Left as it was: ${restatable.skipped.join(", ")} (it holds what only the user can set).`] : [];
+  let sealed;
+  try {
+    sealed = (await apiPost("/api/flows/destinations/seal", plan.request)).data;
+  } catch (err) {
+    failApi(err);
+  }
+  const wired = applyAll(
+    { ...target, ids: restatable.ids },
+    (id) => attachSettings(tree, id, sealed.encryptedConfig, target.kind)
+  );
+  return {
+    wired,
+    destination: sealed.settings,
+    hints: [
+      ...kept,
+      target.kind === "email" ? `Leads from these steps now go to ${String(sealed.settings.email)} with the subject "${String(sealed.settings.subject)}". Tell the user in those words.` : `Submissions now go to ${String(sealed.settings.apiUrl)}.`
+    ]
+  };
+}
+async function fromPlatform(tree, target, args, slug) {
+  const kind = target.kind;
+  if (!isAgentKind(kind)) {
+    const hubspotStep = kind === "hubspot" || kind === "hubspotMeeting";
+    refuse(
+      `A ${kind} ${target.on === "node" ? "step" : "side effect"} is not something this command can fill from a platform.`,
+      hubspotStep ? "Write the blob from `baker hubspot forms view <id> --as-node` (or `meetings view <slug> --as-node`) into the step's form.external." : OAUTH_SIDE_EFFECTS.has(kind) ? "Pass --hubspot-form <formId>." : "It takes typed credentials only the user has: request_flow_input."
+    );
+  }
+  const data = await resolveDestination(kind, args);
+  if (data.target === "node") {
+    const wired2 = applyAll(target, (id) => attachStep(tree, id, data.external));
+    return {
+      wired: wired2,
+      destination: { name: data.name, account: data.account },
+      hints: [`Picked "${data.name}". Autofill its fields from earlier answers in the step's form.autofilledFields.`]
+    };
+  }
+  const sealed = { oauthProviderId: data.oauthProviderId, encryptedConfig: data.encryptedConfig };
+  const wired = applyAll(target, (id) => attachDestination(tree, id, sealed, kind));
+  return {
+    wired,
+    destination: data.destination ? { ...data.destination, account: data.account } : { account: data.account },
+    hints: sheetHints(slug, data)
+  };
+}
+registerSchema({
+  command: "flows.connect",
+  description: 'Fill a Form\'s step or destination yourself \u2014 no card for the user. Steps: Calendly, SavvyCal, GoHighLevel calendar/form (`--node <id> --resource <id>`). Destinations: HubSpot form (`--hubspot-form <id>`), Google Sheets (`--resource <spreadsheetId>` or `--new-sheet <title> --columns \u2026`), Pipedrive, GoHighLevel contact and ActiveCampaign contact (no resource: the connected account is the destination), email (`--email "a@x.com, b@x.com" --subject "New lead \u2014 <Form>"`, never a card), webhook without a credential (`--url`). `--same-as <slug>:<id>` copies what another Form already has. `--all --type <kind>` fills every unwired one of that kind at once. Ids come from `baker flows options <kind>`. Fall back to request_flow_input only when nothing is connected, the sheet was never chosen, or several resources plausibly match.',
+  args: {
+    slug: { type: "positional", description: "Form slug", required: true },
+    node: {
+      type: "string",
+      description: "Step id to fill (calendly, savvycal, highlevel, highlevelForm)",
+      required: false
+    },
+    "side-effect": { type: "string", description: "Side-effect id to wire", required: false },
+    all: { type: "boolean", description: "Every unwired one of --type in this Form", required: false, default: false },
+    type: { type: "string", description: "The kind --all wires (e.g. googleSpreadsheet, calendly)", required: false },
+    resource: { type: "string", description: "Option id from `baker flows options <kind>`", required: false },
+    "hubspot-form": {
+      type: "string",
+      description: "HubSpot form id (from `baker hubspot forms list`)",
+      required: false
+    },
+    "new-sheet": {
+      type: "string",
+      description: "Create a Google spreadsheet with this title and wire it",
+      required: false
+    },
+    columns: {
+      type: "string",
+      description: "With --new-sheet: header row, comma-separated, from column A",
+      required: false
+    },
+    tab: { type: "string", description: "Google Sheets tab to append to (default: the first)", required: false },
+    "same-as": {
+      type: "string",
+      description: "<slug>:<id> \u2014 copy another Form's wired destination or picked step",
+      required: false
+    },
+    account: {
+      type: "string",
+      description: "Connection id, when more than one account of the platform is connected",
+      required: false
+    },
+    email: {
+      type: "string",
+      description: 'Email destination: who receives each lead, comma-separated for several (--email "ana@x.com, luis@x.com"). Never a card: you state it.',
+      required: false
+    },
+    subject: {
+      type: "string",
+      description: 'Email destination: the subject line. Write it yourself from the Form ("New lead \u2014 Private events").',
+      required: false
+    },
+    "replace-unreadable": {
+      type: "boolean",
+      description: "Email only, one destination: replace unreadable old settings with the complete --email and --subject. Use only when the user intends replacement, never to add to an unknown recipient list. Does not apply with --all.",
+      required: false,
+      default: false
+    },
+    url: {
+      type: "string",
+      description: "Webhook destination with no credential: its https address. One that needs a token goes to request_flow_input.",
+      required: false
+    }
+  }
+});
+var connectCommand = defineCommand({
+  meta: {
+    name: "connect",
+    description: 'Fill a step or destination yourself. Start here: baker flows options calendly, then baker flows connect contact --node book --resource <id>. Email: --side-effect se-email-1 --email "ana@x.com, luis@x.com" --subject "New lead \u2014 Contact". Sheets: --side-effect se-gsheet-1 --new-sheet "Leads" --columns "Name,Email". Same as another Form: --same-as madrid:se-gsheet-1'
+  },
+  args: {
+    slug: { type: "positional", description: "Form slug", required: true },
+    node: { type: "string", description: "Step id to fill" },
+    "side-effect": { type: "string", description: "Side-effect id to wire" },
+    all: { type: "boolean", description: "Every unwired one of --type" },
+    type: { type: "string", description: "The kind --all wires" },
+    resource: { type: "string", description: "Option id from baker flows options <kind>" },
+    "hubspot-form": { type: "string", description: "HubSpot form id (from baker hubspot forms list)" },
+    "new-sheet": { type: "string", description: "Create a spreadsheet with this title" },
+    columns: { type: "string", description: "Header row for --new-sheet, comma-separated" },
+    tab: { type: "string", description: "Sheet tab (default: the first)" },
+    "same-as": { type: "string", description: "<slug>:<id> to copy" },
+    account: { type: "string", description: "Connection id when several are connected" },
+    email: { type: "string", description: "Email destination: recipients, comma-separated" },
+    subject: { type: "string", description: "Email destination: subject line" },
+    "replace-unreadable": {
+      type: "boolean",
+      description: "Replace one unreadable email's entire setup with --email and --subject"
+    },
+    url: { type: "string", description: "Webhook destination with no credential: its address" }
+  },
+  run: async ({ args }) => {
+    const slug = String(args.slug);
+    const target = targetsFor(readFlowTree(slug), args);
+    const tree = readFlowTree(slug);
+    const result = typeof args["same-as"] === "string" ? sameAs(tree, target, args["same-as"]) : typeof args["hubspot-form"] === "string" ? await fromHubspot(tree, target, args["hubspot-form"], slug) : STATED_KINDS.has(target.kind) ? await fromStated(tree, target, args) : await fromPlatform(tree, target, args, slug);
+    writeFlowTree(slug, tree);
+    writeJson({
+      ok: true,
+      data: {
+        slug,
+        kind: target.kind,
+        [target.on === "node" ? "steps" : "sideEffects"]: result.wired,
+        destination: result.destination,
+        connected: true
+      },
+      hints: [...result.hints, "Staged like any other edit in this chat: it goes live when the chat is published."]
+    });
+  }
+});
+
+export {
+  attachDestination,
+  unwiredSideEffects,
+  unwiredHubspotForms,
+  sealRequestFor,
+  restatableTargets,
+  attachSettings,
+  attachStep,
+  unpickedSteps,
+  copyDestination,
+  targetsFor,
+  destinationRefusal,
+  connectCommand
+};
+//# sourceMappingURL=chunk-Z3UJKRF7.js.map

package/dist/chunk-Z5RBTOP5.js

@@ -0,0 +1,46 @@
+import {
+  RENDER_REVIEW_MODEL,
+  askAboutImages,
+  buildRulesReviewPrompt,
+  classifyRuleFindings,
+  reviewedRules,
+  rulesSystem
+} from "./chunk-7RAONNZM.js";
+
+// src/engine/nodes/local/lib/confirm-blocking.ts
+var cutByFrame = (f) => f.kind?.defect === "cut";
+async function confirmBlocking(findings, stills, formats, ask) {
+  const claims = findings.filter((f) => f.severity === "blocking" && !cutByFrame(f));
+  if (claims.length === 0 || stills.length === 0) return [...findings];
+  const prompt = [
+    `These are the finished sizes of one ad, in order: ${formats.map((f, i) => `Image ${i + 1} is the ${f}`).join("; ")}.`,
+    "A reviewer reported each claim below. Look again at the size each one names (and, for a claim comparing sizes, at the others) and answer true only when the defect is plainly there for someone looking at it on a phone.",
+    "Answer false when the thing is not there, when it is an ordinary part of the scene (a second house, a neighbour's roof, a reflection), or when the sizes it compares show the same thing.",
+    ...claims.map((c, i) => `${i + 1}. ${c.what}`),
+    `Reply with only this JSON: {"answers":[true|false, ...]}, one answer per claim, in order.`
+  ].join("\n");
+  const answer = await ask([...stills], prompt).catch(() => null);
+  const answers = answer?.answers;
+  if (!Array.isArray(answers) || answers.length !== claims.length) return [...findings];
+  const unconfirmed = new Set(claims.filter((_, i) => answers[i] === false));
+  return findings.map((f) => unconfirmed.has(f) ? { ...f, severity: "warning" } : f);
+}
+
+// src/engine/nodes/local/lib/rules-review.ts
+var RULES_REVIEW_TIMEOUT_MS = 12e4;
+async function reviewAgainstRules(opts) {
+  const rules = reviewedRules(opts.rules);
+  if (rules.length === 0 || opts.stills.length === 0) return [];
+  const system = rulesSystem(rules);
+  const ask = (images, prompt) => askAboutImages(RENDER_REVIEW_MODEL, images, prompt, opts.onSpend, RULES_REVIEW_TIMEOUT_MS, void 0, system);
+  const answer = await ask([...opts.stills], buildRulesReviewPrompt({ formats: opts.formats, rules }));
+  if (answer === null) return null;
+  return await confirmBlocking(classifyRuleFindings(answer, rules), opts.stills, opts.formats, ask);
+}
+
+export {
+  cutByFrame,
+  confirmBlocking,
+  reviewAgainstRules
+};
+//# sourceMappingURL=chunk-Z5RBTOP5.js.map