@koda-sl/baker-cli 0.465.0 → 0.467.0

package/dist/chunk-VAYFVC5B.js

@@ -0,0 +1,297 @@
+import {
+  REDDIT_LINK_REJECTED,
+  redditSearchHints,
+  redditSubredditsHints,
+  redditThreadHints
+} from "./chunk-YT74ZEVP.js";
+import {
+  handleResearchError,
+  writeResearchJson
+} from "./chunk-57UECM77.js";
+import {
+  repeatedValues
+} from "./chunk-ERSX3MKH.js";
+import {
+  RESEARCH_REDDIT_THREAD_DEFAULT_COMMENTS
+} from "./chunk-WXC3I4CT.js";
+import {
+  apiPost
+} from "./chunk-KB5XJHQX.js";
+import {
+  registerSchema
+} from "./chunk-4DM6OAQ6.js";
+
+// src/commands/research/reddit.ts
+import { defineCommand } from "citty";
+var TIMEOUT_MS = 18e4;
+var TEXT_PREVIEW_CHARS = 1500;
+var ITEM_FIELDS = {
+  kind: "post or comment",
+  subreddit: "Where it was said",
+  title: "The post's title (on a comment: the post it answers)",
+  text: "Verbatim \u2014 quote this, exactly",
+  text_truncated: "The text was cut; re-run with --full before quoting the end of it",
+  author: "Reddit username, or null once the account is deleted",
+  score: "Points",
+  comment_count: "Posts only",
+  created: "Date written (UTC)",
+  permalink: "Cite THIS link \u2014 it is built from where the words actually are",
+  depth: "Thread comments: 0 answers the post, 1 answers a comment",
+  source: "reddit_api / reddit_web = live Reddit; archive = the Arctic Shift archive of Reddit"
+};
+registerSchema({
+  command: "research.reddit.search",
+  description: "Search Reddit posts or comments for the audience's own words. Returns verbatim text with a real permalink for each hit. Start here for voice-of-customer work on Reddit.",
+  args: {
+    query: {
+      type: "string",
+      description: "Words to match \u2014 the audience's phrasing, not a description of it",
+      required: true
+    },
+    subreddit: {
+      type: "string",
+      description: "Subreddits to search (up to 10): comma-separated (couriersofreddit,AmazonFlexUK) or the flag repeated. Needed for --kind comments",
+      required: false
+    },
+    kind: {
+      type: "string",
+      description: "posts (default) or comments \u2014 the replies are where most of the voice is",
+      required: false,
+      enum: ["posts", "comments"]
+    },
+    since: { type: "string", description: "Only things written on or after this day, YYYY-MM-DD", required: false },
+    limit: { type: "number", description: "Results to return (1-50, default 25)", required: false },
+    full: {
+      type: "boolean",
+      description: "Return every text whole instead of a preview",
+      required: false,
+      default: false
+    }
+  }
+});
+registerSchema({
+  command: "research.reddit.thread",
+  description: "Read one Reddit thread verbatim: the post and its best comments, each with its own permalink. Use it on any Reddit link before quoting it \u2014 it also exposes links that point somewhere other than they claim.",
+  args: {
+    target: {
+      type: "string",
+      description: "The thread's link (any Reddit form, including share links) or post id",
+      required: true
+    },
+    comments: { type: "number", description: "Comments to return, best first (0-200, default 40)", required: false },
+    full: {
+      type: "boolean",
+      description: "Return every text whole instead of a preview",
+      required: false,
+      default: false
+    }
+  }
+});
+registerSchema({
+  command: "research.reddit.subreddits",
+  description: "Find the subreddits where an audience talks about a topic, with member counts and whether they can be read. Run it before searching, instead of guessing subreddit names.",
+  args: {
+    query: { type: "string", description: 'The audience or topic, e.g. "amazon flex uk", "deliveroo"', required: true },
+    limit: { type: "number", description: "Subreddits to return (1-25, default 10)", required: false }
+  }
+});
+function searchReddit(body) {
+  return apiPost("/api/research/reddit/search", body, { timeoutMs: TIMEOUT_MS });
+}
+function findSubreddits(body) {
+  return apiPost("/api/research/reddit/subreddits", body, { timeoutMs: TIMEOUT_MS });
+}
+function row(item, full) {
+  const cut = !full && item.text.length > TEXT_PREVIEW_CHARS;
+  return {
+    kind: item.kind,
+    subreddit: item.subreddit,
+    title: item.title,
+    text: cut ? `${item.text.slice(0, TEXT_PREVIEW_CHARS)}\u2026` : item.text,
+    ...cut ? { text_truncated: true } : {},
+    author: item.author,
+    score: item.score,
+    ...item.kind === "post" ? { comment_count: item.commentCount } : {},
+    created: item.createdAt.slice(0, 10),
+    permalink: item.permalink,
+    ...item.depth !== null ? { depth: item.depth } : {}
+  };
+}
+function redditFix(code) {
+  if (code === "NOT_FOUND") return REDDIT_LINK_REJECTED;
+  if (code === "BAD_REQUEST" || code === "VALIDATION_ERROR") {
+    return { action: "retry_with_changes", explanation: "Follow the message above and run the command again." };
+  }
+  return {
+    action: "continue_without",
+    explanation: "Don't loop on it. Finish the job with the other sources, say plainly that Reddit is a gap in this research, and never stand in a summary's paraphrase for a Reddit quote."
+  };
+}
+function failValidation(message) {
+  writeResearchJson({ ok: false, error: { code: "VALIDATION_ERROR", message, fix: redditFix("VALIDATION_ERROR") } });
+  process.exit(1);
+}
+function subredditsFromArgs(rawArgs, parsed) {
+  return repeatedValues(rawArgs, "subreddit", parsed).flatMap((value) => value.split(",")).map((name) => name.trim()).filter(Boolean);
+}
+var searchCommand = defineCommand({
+  meta: {
+    name: "search",
+    description: `Search Reddit for the audience's own words, verbatim, each with a permalink you can cite.
+
+Start here for Reddit voice-of-customer. Matches words, not meaning \u2014 search the way the audience writes, and quote a phrase to keep it together ('"right to work"').
+
+Examples:
+  baker research reddit search "agency never paid" --subreddit couriersofreddit,AmazonFlexUK
+  baker research reddit search '"right to work"' --subreddit UKJobs,AmazonFlexUK
+  baker research reddit search "visa" --subreddit UberEATS --kind comments --since 2025-01-01
+  baker research reddit search "side hustle student deliveries"`
+  },
+  args: {
+    query: { type: "positional", description: "Words to match", required: false },
+    subreddit: {
+      type: "string",
+      description: "Subreddits (up to 10): comma-separated, or repeat the flag",
+      required: false
+    },
+    kind: { type: "string", description: "posts (default) or comments", required: false },
+    since: { type: "string", description: "YYYY-MM-DD", required: false },
+    limit: { type: "string", description: "1-50, default 25", required: false },
+    full: { type: "boolean", description: "Whole texts, not previews", required: false }
+  },
+  run: async ({ args, rawArgs }) => {
+    const query = args.query?.trim();
+    if (!query) failValidation('Say what to search for: baker research reddit search "<words>"');
+    const kind = args.kind ?? "posts";
+    if (kind !== "posts" && kind !== "comments") failValidation("--kind must be posts or comments");
+    const body = {
+      query,
+      kind,
+      subreddits: subredditsFromArgs(rawArgs, args.subreddit)
+    };
+    if (args.since) body.since = args.since;
+    if (args.limit) body.limit = Number(args.limit);
+    try {
+      const data = await searchReddit(body);
+      writeResearchJson({
+        ok: true,
+        data: data.results.map((item) => row(item, Boolean(args.full))),
+        source: data.source,
+        fields: ITEM_FIELDS,
+        hints: redditSearchHints({ resultCount: data.results.length, kind, source: data.source })
+      });
+    } catch (err) {
+      handleResearchError(err, redditFix);
+    }
+  }
+});
+var threadCommand = defineCommand({
+  meta: {
+    name: "thread",
+    description: `Read one Reddit thread verbatim \u2014 the post and its best comments, each with its own permalink.
+
+Run it on every Reddit link before you quote from it, including links a research summary gave you: it refuses a link whose post is somewhere other than the link claims.
+
+Examples:
+  baker research reddit thread "https://www.reddit.com/r/AmazonFlexUK/comments/1abc2de/agency_still_hasnt_paid_me/"
+  baker research reddit thread "https://www.reddit.com/r/UberEATS/s/3TzXiyxaMD" --comments 100
+  baker research reddit thread 1abc2de --full`
+  },
+  args: {
+    target: { type: "positional", description: "Thread link or post id", required: false },
+    comments: { type: "string", description: "0-200, default 40", required: false },
+    full: { type: "boolean", description: "Whole texts, not previews", required: false }
+  },
+  run: async ({ args }) => {
+    const target = args.target?.trim();
+    if (!target) failValidation("Pass the thread's link or post id: baker research reddit thread <url>");
+    const commentsAsked = args.comments ? Number(args.comments) : RESEARCH_REDDIT_THREAD_DEFAULT_COMMENTS;
+    const body = { target, comments: commentsAsked };
+    try {
+      const data = await apiPost("/api/research/reddit/thread", body, {
+        timeoutMs: TIMEOUT_MS
+      });
+      const full = Boolean(args.full);
+      writeResearchJson({
+        ok: true,
+        data: { post: row(data.post, full), comments: data.comments.map((item) => row(item, full)) },
+        source: data.source,
+        fields: ITEM_FIELDS,
+        hints: redditThreadHints({
+          commentsShown: data.comments.length,
+          commentsAsked,
+          commentCount: data.post.commentCount,
+          source: data.source
+        })
+      });
+    } catch (err) {
+      handleResearchError(err, redditFix);
+    }
+  }
+});
+var subredditsCommand = defineCommand({
+  meta: {
+    name: "subreddits",
+    description: `Find the subreddits where an audience talks \u2014 name, members, and whether it can be read.
+
+Run it before \`reddit search\` instead of guessing names: a plausible-sounding subreddit can be dead (r/CouriersUK has one post), while the conversation sits in r/AmazonFlexUK or r/deliveroos.
+
+Examples:
+  baker research reddit subreddits "amazon flex uk"
+  baker research reddit subreddits "deliveroo" --limit 5`
+  },
+  args: {
+    query: { type: "positional", description: "Audience or topic", required: false },
+    limit: { type: "string", description: "1-25, default 10", required: false }
+  },
+  run: async ({ args }) => {
+    const query = args.query?.trim();
+    if (!query) failValidation('Say what to look for: baker research reddit subreddits "<audience or topic>"');
+    const body = { query };
+    if (args.limit) body.limit = Number(args.limit);
+    try {
+      const data = await findSubreddits(body);
+      writeResearchJson({
+        ok: true,
+        data: data.results,
+        source: data.source,
+        fields: {
+          name: "Pass this to --subreddit",
+          subscribers: "Members \u2014 size, not activity",
+          access: "public / restricted (readable, members post) / private (unreadable) / null when the source doesn't say",
+          description: "The subreddit's own summary",
+          url: "The subreddit"
+        },
+        hints: redditSubredditsHints({ resultCount: data.results.length })
+      });
+    } catch (err) {
+      handleResearchError(err, redditFix);
+    }
+  }
+});
+var redditCommand = defineCommand({
+  meta: {
+    name: "reddit",
+    description: `Read Reddit verbatim \u2014 the one site no page reader will open for us.
+
+Commands:
+  subreddits \u2014 Find where the audience talks (start here)
+  search     \u2014 Find posts or comments in the audience's own words
+  thread     \u2014 Read one thread: the post and its best comments
+
+Examples:
+  baker research reddit subreddits "amazon flex uk"
+  baker research reddit search "agency never paid" --subreddit couriersofreddit,AmazonFlexUK --kind comments
+  baker research reddit thread "https://www.reddit.com/r/AmazonFlexUK/comments/1abc2de/"
+Full guide: __tooling__/docs/tools/baker/research.md`
+  },
+  subCommands: { subreddits: subredditsCommand, search: searchCommand, thread: threadCommand }
+});
+
+export {
+  searchReddit,
+  findSubreddits,
+  subredditsFromArgs,
+  redditCommand
+};
+//# sourceMappingURL=chunk-VAYFVC5B.js.map

package/dist/chunk-VFSLIDXA.js

@@ -0,0 +1,42 @@
+import {
+  ApiError
+} from "./chunk-KB5XJHQX.js";
+import {
+  writeJson
+} from "./chunk-4DM6OAQ6.js";
+
+// src/commands/studio/errors.ts
+var CREDIT_HINTS = ["credit", "top up", "billing", "quota"];
+function studioStartFix(message) {
+  const lower = message.toLowerCase();
+  if (CREDIT_HINTS.some((hint) => lower.includes(hint))) {
+    return {
+      action: "Stop generating and finish the task with assets that already exist",
+      explanation: "No generation will run until the plan is topped up, so retrying costs time and changes nothing. Source or reuse an image instead, complete the rest of the work, and tell the user the new artwork could not be produced."
+    };
+  }
+  return {
+    action: "Drop or correct the setting the message names, then run the command once more",
+    explanation: "The message says which model was chosen and what it accepts. If the setting is not essential to the brief, leave it out rather than switching model. Do not abort the wider job over one refused setting."
+  };
+}
+function failStudioCommand(error, opts = {}) {
+  if (error instanceof ApiError) {
+    writeJson({
+      ok: false,
+      error: {
+        code: error.code,
+        message: error.message,
+        ...opts.withFix ? { fix: studioStartFix(error.message) } : {}
+      }
+    });
+    process.exit(1);
+  }
+  writeJson({ ok: false, error: { code: "INTERNAL_ERROR", message: "Unexpected error" } });
+  process.exit(1);
+}
+
+export {
+  failStudioCommand
+};
+//# sourceMappingURL=chunk-VFSLIDXA.js.map

package/dist/chunk-VHMNSO2B.js

@@ -0,0 +1,84 @@
+import {
+  findWorkspaceRoot
+} from "./chunk-65BQAJMH.js";
+
+// src/commands/canvas/unbilled-spend.ts
+import { randomUUID } from "crypto";
+import { mkdir, readdir, readFile, rename, unlink, writeFile } from "fs/promises";
+import path from "path";
+import { z } from "zod";
+var DIR = "unbilled-spend";
+var Held = z.array(
+  z.object({ model: z.string(), inputTokens: z.number(), outputTokens: z.number(), costUsd: z.number() })
+);
+async function holdUnbilledSpend(cacheDir, usage) {
+  if (usage.length === 0) return;
+  const dir = path.join(cacheDir, DIR);
+  await mkdir(dir, { recursive: true });
+  await writeFile(path.join(dir, `${Date.now()}-${randomUUID()}.json`), JSON.stringify(usage), "utf8");
+}
+async function holdWorkspaceSpend(usage) {
+  const root = findWorkspaceRoot(process.cwd()) ?? process.cwd();
+  await holdUnbilledSpend(path.join(root, "canvas", ".cache"), usage).catch(() => {
+  });
+}
+async function takeUnbilledSpend(cacheDir) {
+  const dir = path.join(cacheDir, DIR);
+  const files = await readdir(dir).catch(() => []);
+  const byModel = /* @__PURE__ */ new Map();
+  for (const file of files.filter((f) => f.endsWith(".json"))) {
+    const claimed = path.join(dir, `${file}.${randomUUID()}.taken`);
+    try {
+      await rename(path.join(dir, file), claimed);
+    } catch {
+      continue;
+    }
+    const parsed = Held.safeParse(await readFile(claimed, "utf8").then(JSON.parse, () => null).catch(() => null));
+    await unlink(claimed).catch(() => {
+    });
+    for (const call of parsed.success ? parsed.data : []) {
+      const sum = byModel.get(call.model);
+      byModel.set(
+        call.model,
+        sum ? {
+          model: call.model,
+          inputTokens: sum.inputTokens + call.inputTokens,
+          outputTokens: sum.outputTokens + call.outputTokens,
+          costUsd: sum.costUsd + call.costUsd
+        } : { ...call }
+      );
+    }
+  }
+  return [...byModel.values()];
+}
+async function sendBillingSpend(cacheDir, usage, send) {
+  try {
+    await send();
+    return null;
+  } catch (e) {
+    await holdUnbilledSpend(cacheDir, usage).catch(() => {
+    });
+    return e instanceof Error ? e.message : String(e);
+  }
+}
+function holdWhenSettled(cacheDir, spendOf) {
+  const pending = [];
+  return {
+    settled: (run, outputs) => {
+      pending.push(holdUnbilledSpend(cacheDir, spendOf(run, outputs)).catch(() => {
+      }));
+    },
+    drained: async () => {
+      await Promise.all(pending);
+    }
+  };
+}
+
+export {
+  holdUnbilledSpend,
+  holdWorkspaceSpend,
+  takeUnbilledSpend,
+  sendBillingSpend,
+  holdWhenSettled
+};
+//# sourceMappingURL=chunk-VHMNSO2B.js.map

package/dist/chunk-VOH2QWVG.js

@@ -0,0 +1,275 @@
+import {
+  FLOW_ACCOUNT_ONLY_KINDS,
+  FLOW_AGENT_DESTINATION_KINDS,
+  FLOW_DELIVERY_SIDE_EFFECT_TYPES,
+  FLOW_RESOURCE_NODE_TYPES,
+  FLOW_SECRET_FIELDS,
+  flowCatalogEntry,
+  isFlowOauthSideEffect
+} from "./chunk-WXC3I4CT.js";
+import {
+  apiPost
+} from "./chunk-KB5XJHQX.js";
+import {
+  writeJson
+} from "./chunk-4DM6OAQ6.js";
+
+// src/commands/flows/shared.ts
+import { existsSync, readdirSync, readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+var FLOWS_DIR = "src/lib/flow-engine/flows";
+function flowsDir() {
+  let dir = process.cwd();
+  for (let i = 0; i < 6; i++) {
+    const candidate = join(dir, FLOWS_DIR);
+    if (existsSync(candidate)) {
+      return candidate;
+    }
+    const parent = join(dir, "..");
+    if (parent === dir) {
+      break;
+    }
+    dir = parent;
+  }
+  return join(process.cwd(), FLOWS_DIR);
+}
+function failLocal(message) {
+  writeJson({ ok: false, error: { code: "NOT_FOUND", message } });
+  process.exit(1);
+}
+function listFlowSlugs() {
+  const dir = flowsDir();
+  if (!existsSync(dir)) {
+    return [];
+  }
+  return readdirSync(dir, { withFileTypes: true }).filter((entry) => entry.isDirectory() && !entry.name.startsWith("_") && entry.name !== ".gitkeep").map((entry) => entry.name).sort();
+}
+function flowDataPath(slug) {
+  return join(flowsDir(), slug, "_data.json");
+}
+function writeFlowTree(slug, tree) {
+  writeFileSync(flowDataPath(slug), `${JSON.stringify(tree, null, 2)}
+`, "utf-8");
+}
+function walkNodes(node, acc = []) {
+  if (!node || typeof node !== "object") return acc;
+  acc.push(node);
+  if (Array.isArray(node.children)) {
+    for (const child of node.children) walkNodes(child, acc);
+  }
+  return acc;
+}
+function collectSideEffects(tree) {
+  return walkNodes(tree).flatMap(
+    (node) => Array.isArray(node.sideEffects) ? node.sideEffects.filter((sideEffect) => Boolean(sideEffect) && typeof sideEffect === "object").map((sideEffect) => ({ node, sideEffect })) : []
+  );
+}
+function sealedSideEffects(tree) {
+  return collectSideEffects(tree).flatMap(({ sideEffect }) => {
+    const { id, type, encryptedConfig } = sideEffect;
+    const sealed = typeof id === "string" && typeof type === "string" && FLOW_DELIVERY_SIDE_EFFECT_TYPES.includes(type) && typeof encryptedConfig === "string" && encryptedConfig.length > 0;
+    return sealed ? [{ sideEffectId: id, type, encryptedConfig }] : [];
+  });
+}
+function describeSettings(settings) {
+  if (typeof settings.email === "string") {
+    return `to ${settings.email}${typeof settings.subject === "string" ? ` \xB7 subject "${settings.subject}"` : ""}`;
+  }
+  return Object.entries(settings).filter(([, value]) => typeof value === "string" || typeof value === "number").map(([key, value]) => `${key}: ${String(value)}`).join(" \xB7 ");
+}
+function withSettings(rows, settingsById) {
+  return rows.map((row) => {
+    const settings = row.sideEffectId ? settingsById[row.sideEffectId] : void 0;
+    const described = settings ? describeSettings(settings) : "";
+    return described ? { ...row, status: `${row.status} \u2192 ${described}` } : row;
+  });
+}
+function flowExists(slug) {
+  return existsSync(join(flowsDir(), slug, "_data.json"));
+}
+function readFlowTree(slug) {
+  const path = join(flowsDir(), slug, "_data.json");
+  if (!existsSync(path)) {
+    failLocal(`No form "${slug}". Run "baker flows list" to see the forms in this workspace.`);
+  }
+  try {
+    return JSON.parse(readFileSync(path, "utf-8"));
+  } catch (error) {
+    failLocal(`Could not read form "${slug}": ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+function isConfigured(value) {
+  return typeof value === "string" && value.length > 0;
+}
+function nodeMeta(record) {
+  const nodeId = typeof record.id === "string" ? record.id : "";
+  const nodeName = typeof record.name === "string" ? record.name : void 0;
+  return { nodeId, ...nodeName ? { nodeName } : {} };
+}
+function widgetNodeStatus(record, meta) {
+  const nodeData = record.nodeData;
+  const nodeType = nodeData?.type;
+  if (typeof nodeType !== "string" || !FLOW_RESOURCE_NODE_TYPES.includes(nodeType)) {
+    return null;
+  }
+  const external = nodeData?.form?.external;
+  const selected = external != null && typeof external === "object";
+  const name = selected ? external.name : void 0;
+  return {
+    ...meta,
+    target: "node",
+    kind: nodeType,
+    status: selected ? `${nodeType} \u2014 selected${typeof name === "string" ? ` "${name}"` : ""}` : `${nodeType} \u2014 not selected`,
+    needsInput: !selected
+  };
+}
+function sideEffectNeedsInput(raw) {
+  const effect = raw;
+  const type = effect?.type;
+  if (typeof type !== "string" || !FLOW_DELIVERY_SIDE_EFFECT_TYPES.includes(type)) {
+    return false;
+  }
+  const configured = isConfigured(effect?.encryptedConfig);
+  if (!isFlowOauthSideEffect(type)) return !configured;
+  return !isConfigured(effect?.oauthProviderId) || !configured;
+}
+function trackingStatus(effect, type, meta) {
+  if (flowCatalogEntry("side-effect", type)?.owners?.tagIds !== "tags") return null;
+  const tags = Array.isArray(effect.tagIds) ? effect.tagIds.length : 0;
+  const event = typeof effect.eventName === "string" ? ` "${effect.eventName}"` : "";
+  return {
+    ...meta,
+    target: "sideEffect",
+    ...typeof effect.id === "string" ? { sideEffectId: effect.id } : {},
+    kind: type,
+    status: `${type}${event} \u2014 ${tags > 0 ? `[${tags} tag${tags === 1 ? "" : "s"}]` : "[no tag]"}`,
+    needsInput: false
+  };
+}
+function sideEffectStatus(raw, meta) {
+  const effect = raw;
+  const type = effect?.type;
+  if (typeof type !== "string") return null;
+  if (!FLOW_DELIVERY_SIDE_EFFECT_TYPES.includes(type)) {
+    return effect ? trackingStatus(effect, type, meta) : null;
+  }
+  const configured = isConfigured(effect?.encryptedConfig);
+  const oauth = isFlowOauthSideEffect(type);
+  const connected = isConfigured(effect?.oauthProviderId);
+  const needs = FLOW_SECRET_FIELDS[type];
+  const status = oauth ? `${type} \u2014 connection ${connected ? "[connected]" : "[needs connection]"}, config ${configured ? "[set]" : "[missing]"}` : configured ? `${type} \u2014 [configured]` : `${type} \u2014 [missing]${needs.length > 0 ? ` (needs: ${needs.join(", ")})` : ""}`;
+  return {
+    ...meta,
+    target: "sideEffect",
+    ...typeof effect?.id === "string" ? { sideEffectId: effect.id } : {},
+    kind: type,
+    status,
+    needsInput: sideEffectNeedsInput(effect)
+  };
+}
+function requestFlowInputCall(slug, status) {
+  const args = status.target === "node" ? `{ target: "node", flowSlug: "${slug}", nodeId: "${status.nodeId}", nodeType: "${status.kind}" }` : `{ target: "sideEffect", flowSlug: "${slug}", nodeId: "${status.nodeId}", sideEffectId: "${status.sideEffectId}", sideEffectType: "${status.kind}" }`;
+  const card = `request_flow_input with ${args}`;
+  const target = status.target === "node" ? `--node ${status.nodeId}` : `--side-effect ${status.sideEffectId}`;
+  const fallback = "only if nothing is connected or several could be meant";
+  if (status.kind === "email") {
+    return `baker flows connect ${slug} ${target} --email "<who receives each lead, comma-separated>" --subject "<New lead \u2014 the Form's name>"`;
+  }
+  if (status.kind === "httpWebhook") {
+    return `baker flows connect ${slug} ${target} --url <https address> \u2014 only a webhook that needs a token or password goes to the user: ${card}`;
+  }
+  if (status.kind === "hubspotForm") {
+    return `baker flows connect ${slug} ${target} --hubspot-form <formId from baker hubspot forms list> \u2014 ${fallback}: ${card}`;
+  }
+  if (status.kind === "hubspot" || status.kind === "hubspotMeeting") {
+    const list = status.kind === "hubspot" ? "forms view <id>" : "meetings view <slug>";
+    return `write \`baker hubspot ${list} --as-node\` into the step's form.external \u2014 ${fallback}: ${card}`;
+  }
+  if (FLOW_ACCOUNT_ONLY_KINDS.includes(status.kind)) {
+    return `baker flows connect ${slug} ${target} \u2014 ${fallback}: ${card}`;
+  }
+  if (FLOW_AGENT_DESTINATION_KINDS.includes(status.kind)) {
+    const sheet = status.kind === "googleSpreadsheet" ? ' (or --new-sheet "<title>" --columns "\u2026")' : "";
+    return `baker flows connect ${slug} ${target} --resource <id from baker flows options ${status.kind}>${sheet} \u2014 ${fallback}: ${card}`;
+  }
+  return card;
+}
+function collectConfigStatus(node, acc) {
+  if (!node || typeof node !== "object") {
+    return;
+  }
+  const record = node;
+  const meta = nodeMeta(record);
+  const widget = widgetNodeStatus(record, meta);
+  if (widget) {
+    acc.push(widget);
+  }
+  if (Array.isArray(record.sideEffects)) {
+    for (const raw of record.sideEffects) {
+      const status = sideEffectStatus(raw, meta);
+      if (status) {
+        acc.push(status);
+      }
+    }
+  }
+  if (Array.isArray(record.children)) {
+    for (const child of record.children) {
+      collectConfigStatus(child, acc);
+    }
+  }
+}
+function redactTree(node) {
+  if (Array.isArray(node)) {
+    return node.map(redactTree);
+  }
+  if (!node || typeof node !== "object") {
+    return node;
+  }
+  const out = {};
+  for (const [key, value] of Object.entries(node)) {
+    if (key === "encryptedConfig") {
+      out[key] = isConfigured(value) ? "[configured]" : value;
+    } else {
+      out[key] = redactTree(value);
+    }
+  }
+  return out;
+}
+function stepNameKey(name) {
+  return name.replace(/([a-z])([A-Z])/g, "$1_$2").replace(/[-\s]+/g, "_").toUpperCase();
+}
+function isUsableStepNameKey(key) {
+  return /^[\p{ID_Start}$_][\p{ID_Continue}$‌‍]*$/u.test(key);
+}
+async function readSettings(tree) {
+  const sealed = sealedSideEffects(tree);
+  if (sealed.length === 0) return {};
+  try {
+    const { data } = await apiPost("/api/flows/destinations/reveal", {
+      items: sealed.map(({ type, encryptedConfig }) => ({ type, encryptedConfig }))
+    });
+    return Object.fromEntries(sealed.map((item, index) => [item.sideEffectId, data.items[index] ?? null]));
+  } catch {
+    return null;
+  }
+}
+
+export {
+  flowsDir,
+  listFlowSlugs,
+  flowDataPath,
+  writeFlowTree,
+  walkNodes,
+  collectSideEffects,
+  withSettings,
+  flowExists,
+  readFlowTree,
+  sideEffectNeedsInput,
+  requestFlowInputCall,
+  collectConfigStatus,
+  redactTree,
+  stepNameKey,
+  isUsableStepNameKey,
+  readSettings
+};
+//# sourceMappingURL=chunk-VOH2QWVG.js.map