@koda-sl/baker-cli 0.471.0 → 0.472.0

package/dist/fetch-ZMRIW4LN.js

@@ -0,0 +1,139 @@
+import {
+  MAX_VIDEO_INGEST_SECONDS,
+  downloadTimeoutMs,
+  refuseByDuration
+} from "./chunk-FKOECEVC.js";
+import {
+  YtDlpError,
+  durationSeconds,
+  isAudioOnly,
+  probeYtDlp,
+  runYtDlp
+} from "./chunk-64XIDXCN.js";
+import {
+  captureVimeoCookie
+} from "./chunk-5TTHWWON.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-KCA5CDCU.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/videos/fetch.ts
+import { constants } from "fs";
+import { copyFile, mkdir, mkdtemp, rm } from "fs/promises";
+import { tmpdir } from "os";
+import path from "path";
+import { defineCommand } from "citty";
+registerSchema({
+  command: "videos.fetch",
+  description: "Download a video page (YouTube, TikTok, Vimeo, \u2026) to a local .mp4 without adding it to the library. For editing a clip locally; use `videos ingest` to add one to the library.",
+  args: {
+    url: { type: "string", description: "Video page URL", required: true },
+    out: { type: "string", description: "Directory to write the file into (created if missing)", required: true },
+    "max-seconds": {
+      type: "string",
+      description: `Refuse videos longer than this many seconds (default ${MAX_VIDEO_INGEST_SECONDS})`,
+      required: false
+    },
+    "timeout-ms": { type: "string", description: "Download time limit in milliseconds", required: false },
+    "max-height": {
+      type: "string",
+      description: "Keep a version whose shorter side is at most this many pixels (e.g. 1080 \u2014 a vertical Short keeps 1080\xD71920) when the site offers one",
+      required: false
+    }
+  }
+});
+function positiveInt(value) {
+  const parsed = typeof value === "string" ? Number.parseInt(value, 10) : Number.NaN;
+  return Number.isInteger(parsed) && parsed > 0 ? parsed : void 0;
+}
+var fetchCommand = defineCommand({
+  meta: {
+    name: "fetch",
+    description: "Download a video page to a local .mp4 without adding it to the library. Same downloader as `ingest` (proxy fallback, duration check).\n\nExample: baker videos fetch https://www.youtube.com/watch?v=abc123 --out ./clips"
+  },
+  args: {
+    url: { type: "positional", description: "Video page URL", required: true },
+    out: { type: "string", description: "Directory to write the file into", required: true },
+    "max-seconds": { type: "string", description: "Refuse videos longer than this", required: false },
+    "timeout-ms": { type: "string", description: "Download time limit in milliseconds", required: false },
+    "max-height": {
+      type: "string",
+      description: "Cap the shorter side at this many pixels (e.g. 1080)",
+      required: false
+    }
+  },
+  run: async ({ args }) => {
+    const result = await fetchVideo({
+      url: String(args.url ?? ""),
+      out: String(args.out ?? ""),
+      maxSeconds: positiveInt(args["max-seconds"]),
+      timeoutMs: positiveInt(args["timeout-ms"]),
+      maxHeight: positiveInt(args["max-height"])
+    });
+    writeJson(result);
+    if (!result.ok) process.exit(1);
+  }
+});
+async function fetchVideo(args) {
+  const outDir = path.resolve(args.out);
+  const workDir = await mkdtemp(path.join(tmpdir(), "videos-fetch-"));
+  try {
+    await mkdir(outDir, { recursive: true });
+    const vimeoCookie = captureVimeoCookie();
+    const probe = await probeYtDlp({ url: args.url, vimeoCookie, cookieDir: workDir });
+    if (isAudioOnly(probe.info)) {
+      return { ok: false, error: { code: "VALIDATION_ERROR", message: "That link is audio, not video." } };
+    }
+    const seconds = durationSeconds(probe.info);
+    const tooLong = refuseByDuration(seconds, args.maxSeconds ?? MAX_VIDEO_INGEST_SECONDS);
+    if (tooLong) {
+      return { ok: false, error: { code: "VALIDATION_ERROR", message: tooLong } };
+    }
+    const { filePath, tier, reducedQuality } = await runYtDlp({
+      url: args.url,
+      audioOnly: false,
+      workDir,
+      vimeoCookie,
+      timeoutMs: args.timeoutMs ?? downloadTimeoutMs(seconds),
+      maxHeight: args.maxHeight
+    });
+    return {
+      ok: true,
+      data: {
+        file: await placeInto(outDir, filePath, fileStem(probe.info)),
+        durationSeconds: seconds,
+        egress: tier,
+        ...reducedQuality ? { reducedQuality: true } : {}
+      }
+    };
+  } catch (err) {
+    const message = err instanceof YtDlpError ? `${err.message}: ${err.stderrTail}`.trim() : err instanceof Error ? err.message : String(err);
+    return { ok: false, error: { code: "DOWNLOAD_FAILED", message } };
+  } finally {
+    await rm(workDir, { recursive: true, force: true }).catch(() => {
+    });
+  }
+}
+function fileStem(info) {
+  const parts = [info.extractor_key, info.id].filter((part) => typeof part === "string" && part !== "");
+  const stem = parts.join("-").toLowerCase().replace(/[^a-z0-9._-]+/g, "_").replace(/^[._-]+/, "");
+  return stem === "" ? "video" : stem;
+}
+async function placeInto(outDir, source, stem) {
+  for (let n = 1; ; n++) {
+    const target = path.join(outDir, `${stem}${n === 1 ? "" : `-${n}`}${path.extname(source)}`);
+    try {
+      await copyFile(source, target, constants.COPYFILE_EXCL);
+      return target;
+    } catch (err) {
+      if (!(err instanceof Error && "code" in err && err.code === "EEXIST")) throw err;
+    }
+  }
+}
+export {
+  fetchCommand,
+  fetchVideo
+};
+//# sourceMappingURL=fetch-ZMRIW4LN.js.map

package/dist/find-D4LQ32H6.js

@@ -0,0 +1,134 @@
+import {
+  OUTPUT_ARGS,
+  writeProviderHits
+} from "./chunk-2645YOF3.js";
+import {
+  emptyResultHints
+} from "./chunk-Q6ULQMWG.js";
+import {
+  AUTO_INGEST_MAX,
+  parseAutoIngest
+} from "./chunk-KKJ4KJCW.js";
+import {
+  ApiError,
+  apiPost
+} from "./chunk-QG2WPVKE.js";
+import "./chunk-TSOJM4EO.js";
+import "./chunk-5TTHWWON.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-KCA5CDCU.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/images/find.ts
+import { defineCommand } from "citty";
+registerSchema({
+  command: "images.find",
+  description: "Fanout image search: library first, then opted-in external providers.",
+  args: {
+    query: { type: "string", description: "Search query", required: true },
+    sources: {
+      type: "string",
+      description: "Comma-separated providers: library,pexels,pixabay,google,iconify,giphy,pinterest (brandfetch lives at `baker images logo`)",
+      required: false
+    },
+    limit: { type: "number", description: "Max results per group", required: false, default: 20 },
+    fallback: {
+      type: "boolean",
+      description: "Only cascade to externals when top library score < threshold",
+      required: false,
+      default: false
+    },
+    threshold: { type: "number", description: "Fallback threshold (0-1)", required: false, default: 0.4 },
+    "auto-ingest": {
+      type: "number",
+      description: `Auto-ingest top N external hits (0-${AUTO_INGEST_MAX.find}, default 0) and return Baker-owned URLs on ingested hits`,
+      required: false,
+      default: 0
+    },
+    context: {
+      type: "string",
+      description: "Free-text hint applied to every auto-ingested hit (overrides provider-derived context)",
+      required: false
+    },
+    output: { type: "string", description: "Output format: json|files|md", required: false, default: "json" },
+    fields: { type: "string", description: "Comma-separated field names to include", required: false },
+    full: { type: "boolean", description: "Include full metadata", required: false, default: false }
+  }
+});
+var findCommand = defineCommand({
+  meta: {
+    name: "find",
+    description: "Library-first fanout image search. Opt in to providers with --sources. `--fallback` short-circuits to externals only when library is thin. With --auto-ingest, ingested external hits return Baker-owned URLs.\n\nExample: baker images find 'office' --sources library,pexels --limit 20"
+  },
+  args: {
+    query: { type: "positional", description: "Search query", required: false },
+    sources: { type: "string", description: "Comma-separated providers", required: false },
+    limit: { type: "string", description: "Max results per group (default 20)", required: false },
+    fallback: { type: "boolean", description: "Cascade to externals only when library thin", required: false },
+    threshold: { type: "string", description: "Fallback threshold (default 0.4)", required: false },
+    "auto-ingest": {
+      type: "string",
+      description: `Auto-ingest top N external hits (0-${AUTO_INGEST_MAX.find}) and return Baker-owned URLs on ingested hits`,
+      required: false
+    },
+    context: { type: "string", description: "Description context hint applied to auto-ingested hits", required: false },
+    ...OUTPUT_ARGS
+  },
+  run: async ({ args }) => {
+    try {
+      const query = args.query;
+      if (!query) {
+        writeJson({ ok: false, error: { code: "VALIDATION_ERROR", message: "Query is required" } });
+        process.exit(1);
+      }
+      const body = { query };
+      if (args.sources) {
+        body.sources = args.sources.split(",").filter(Boolean);
+      }
+      if (args.limit) body.limit = Number(args.limit);
+      if (args.fallback) body.fallback = true;
+      if (args.threshold) body.threshold = Number(args.threshold);
+      if (args["auto-ingest"] !== void 0) {
+        const parsed = parseAutoIngest(args["auto-ingest"], AUTO_INGEST_MAX.find);
+        if (!parsed.ok) {
+          writeJson({
+            ok: false,
+            error: {
+              code: "VALIDATION_ERROR",
+              message: parsed.message,
+              fix: {
+                action: "retry_with_changes",
+                explanation: `Re-run with --auto-ingest in 0-${AUTO_INGEST_MAX.find}.`
+              }
+            }
+          });
+          process.exit(1);
+        }
+        body.autoIngest = parsed.value;
+      }
+      if (args.context) body.descriptionContext = args.context;
+      const data = await apiPost("/api/images/find", body);
+      const hits = [...data.groups.library, ...data.groups.external];
+      const hints = emptyResultHints({
+        provider: "find",
+        hitCount: hits.length,
+        activeFilters: args.fallback ? ["--fallback"] : [],
+        subject: query
+      });
+      writeProviderHits(data, hits, args, hints);
+    } catch (err) {
+      if (err instanceof ApiError) {
+        writeJson({ ok: false, error: { code: err.code, message: err.message } });
+        process.exit(1);
+      }
+      writeJson({ ok: false, error: { code: "INTERNAL_ERROR", message: "Unexpected error" } });
+      process.exit(1);
+    }
+  }
+});
+export {
+  findCommand
+};
+//# sourceMappingURL=find-D4LQ32H6.js.map

package/dist/fit-EL3PY56R.js

@@ -0,0 +1,45 @@
+import {
+  FitAnswerSchema,
+  NO_FIT_HINT,
+  buildFitPrompt,
+  conceptFromFit,
+  fitCachePath,
+  fitCommand,
+  fitHints,
+  fitOnce,
+  fitReference,
+  readCachedFit,
+  readKnowledge,
+  reviewsForFit
+} from "./chunk-EM773PVV.js";
+import "./chunk-CNABBWT5.js";
+import "./chunk-SGPQ2NDZ.js";
+import "./chunk-XI7ILRIX.js";
+import "./chunk-DGCUPJZD.js";
+import "./chunk-M5K24DZK.js";
+import "./chunk-CHSNHVYF.js";
+import "./chunk-H4WZ3OZX.js";
+import "./chunk-UJSPFZH3.js";
+import "./chunk-73U6LGCH.js";
+import "./chunk-64XIDXCN.js";
+import "./chunk-KGSDVTY6.js";
+import "./chunk-QG2WPVKE.js";
+import "./chunk-TSOJM4EO.js";
+import "./chunk-5TTHWWON.js";
+import "./chunk-KCA5CDCU.js";
+import "./chunk-YQSBHWOI.js";
+export {
+  FitAnswerSchema,
+  NO_FIT_HINT,
+  buildFitPrompt,
+  conceptFromFit,
+  fitCachePath,
+  fitCommand,
+  fitHints,
+  fitOnce,
+  fitReference,
+  readCachedFit,
+  readKnowledge,
+  reviewsForFit
+};
+//# sourceMappingURL=fit-EL3PY56R.js.map

package/dist/flows-FP6FUVR2.js

@@ -0,0 +1,247 @@
+import {
+  collectConfigStatus,
+  collectSideEffects,
+  listFlowSlugs,
+  readFlowTree,
+  readSettings,
+  redactTree,
+  requestFlowInputCall,
+  withSettings
+} from "./chunk-BTOP5VWL.js";
+import {
+  FLOW_AGENT_DESTINATION_KINDS,
+  driftRepairHint,
+  flowNodeTriggers
+} from "./chunk-XABVEMC3.js";
+import "./chunk-GXDLWBOY.js";
+import "./chunk-GIWHHCD6.js";
+import "./chunk-XQIOCIDO.js";
+import "./chunk-ML7DLFFY.js";
+import {
+  apiPost
+} from "./chunk-QG2WPVKE.js";
+import "./chunk-TSOJM4EO.js";
+import "./chunk-5TTHWWON.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-KCA5CDCU.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/flows/index.ts
+import { defineCommand } from "citty";
+registerSchema({
+  command: "flows.list",
+  description: "List the Forms (flows) in this workspace and how many confidential fields each still needs configured. Read-only.",
+  args: {}
+});
+registerSchema({
+  command: "flows.show",
+  description: "Show a Form's confidential fields and whether each is configured (secrets/connections/third-party resources), AND whether its destination has changed under it \u2014 never reveals secret values. Destination drift is the one problem a Form cannot show you itself: when a HubSpot field a Form maps is deleted, HubSpot refuses the WHOLE submission and the visitor still sees the thank-you screen, so every lead is lost silently. Run this before changing any Form. Each sealed destination says where it sends (recipients, subject, sheet) \u2014 never a credential. Author structure by editing the flow's _data.json; set destinations yourself with `baker flows connect` (email: --email/--subject); only a typed secret goes to the request_flow_input tool.",
+  args: {
+    slug: { type: "positional", description: "Form slug (folder under flows/)", required: true },
+    full: { type: "boolean", description: "Include the full flow tree (secret values redacted)", required: false }
+  }
+});
+function statusFor(slug) {
+  const tree = readFlowTree(slug);
+  const config = [];
+  collectConfigStatus(tree, config);
+  return config;
+}
+function pendingInputHints(slug, config) {
+  const pending = config.filter((row) => row.needsInput);
+  if (pending.length === 0) return [];
+  const calls = pending.slice(0, MAX_PENDING_HINTS).map((row) => `${row.kind}: ${requestFlowInputCall(slug, row)}`);
+  const rest = pending.length - calls.length;
+  return [
+    ...repeatedKindHints(slug, pending),
+    `${pending.length} item${pending.length === 1 ? "" : "s"} still unwired. Wire each yourself with the command below when you know which resource is meant; the card is the fallback, and its result carries the destination \u2014 read the names from there rather than looking them up again.`,
+    ...calls,
+    ...rest > 0 ? [`\u2026and ${rest} more \u2014 see \`config\` above.`] : []
+  ];
+}
+function repeatedKindHints(slug, pending) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const row of pending) counts.set(row.kind, (counts.get(row.kind) ?? 0) + 1);
+  return [...counts].flatMap(([kind, count]) => {
+    if (count < 2) return [];
+    if (kind === "hubspotForm") {
+      return [
+        `${count} hubspotForm side effects are unwired. When they all send to the same HubSpot form: baker flows connect ${slug} --all --hubspot-form <formId>.`
+      ];
+    }
+    if (!FLOW_AGENT_DESTINATION_KINDS.includes(kind)) return [];
+    return [
+      `${count} ${kind} items are unwired. When they share one destination: baker flows connect ${slug} --all --type ${kind} [--resource <id>].`
+    ];
+  });
+}
+var MAX_PENDING_HINTS = 6;
+function inertSideEffectHints(tree) {
+  const dead = collectSideEffects(tree).flatMap(({ node, sideEffect }) => {
+    const triggers = flowNodeTriggers(node.nodeData);
+    if (!triggers.known) return [];
+    const triggerId = String(sideEffect.triggerId ?? "");
+    if (triggers.available.includes(triggerId)) return [];
+    const where = `${String(sideEffect.id ?? sideEffect.type)} on "${String(node.name ?? node.id)}"`;
+    const raises = triggers.available.length > 0 ? `It raises: ${triggers.available.join(", ")}.` : triggers.why ?? "That step raises nothing.";
+    return [`${where} fires on \`${triggerId || "(none)"}\`, which that step never raises. ${raises}`];
+  });
+  if (dead.length === 0) return [];
+  return [
+    `${dead.length} side effect${dead.length === 1 ? " has" : "s have"} a triggerId their step never raises, so ${dead.length === 1 ? "it never runs" : "they never run"} \u2014 no error, nothing half-written, just nothing. A triggerId belongs to the STEP, not to the side-effect type.`,
+    ...dead.slice(0, MAX_PENDING_HINTS),
+    ...dead.length > MAX_PENDING_HINTS ? [`\u2026and ${dead.length - MAX_PENDING_HINTS} more.`] : [],
+    "Fix each by setting the id its own step raises: `baker flows schema node <nodeType>` lists them."
+  ];
+}
+function funnelPlacementHint(slug) {
+  return `Whether this Form moves anyone along the company funnel is not in _data.json either: \`baker funnel\` names every Form no step counts. If it names this one, place its ending on the step it moves people to \u2014 \`submit:${slug}\`, or its booking trigger, both listed by \`baker funnel --moments\` \u2014 with \`baker funnel --step\`, which replaces the step it names, so keep that step's other ways in.`;
+}
+async function readDrift(slug) {
+  try {
+    const response = await apiPost("/api/flows/drift", { slug });
+    return response.data;
+  } catch {
+    return null;
+  }
+}
+function driftHints(slug, drift) {
+  if (drift === null) {
+    return [
+      "Could not check whether this Form's destination has changed under it. Treat that as UNKNOWN, not as healthy \u2014 a deleted HubSpot field refuses every submission while the visitor still sees the thank-you screen."
+    ];
+  }
+  const forms = drift.forms.filter((form) => form.slug === slug);
+  if (forms.length === 0) {
+    return drift.checkedAt === null ? [
+      "This Form's destination has never been checked, so nothing here says it is healthy \u2014 only that nothing was compared."
+    ] : [];
+  }
+  return forms.flatMap((form) => {
+    const repair = driftRepairHint(slug, form.formGuid, form.deadFields, form.sideEffectId);
+    return [`DESTINATION DRIFT (${form.severity}): ${form.summary}`, ...repair === null ? [] : [repair]];
+  });
+}
+function displayName(slug) {
+  const tree = readFlowTree(slug);
+  const name = tree.displayName;
+  return typeof name === "string" && name.trim() ? name.trim() : slug;
+}
+var listCommand = defineCommand({
+  meta: {
+    name: "list",
+    description: "List Forms in this workspace with the count of confidential fields still needing setup. Example: baker flows list"
+  },
+  run: () => {
+    const flows = listFlowSlugs().map((slug) => ({
+      slug,
+      name: displayName(slug),
+      needsConfig: statusFor(slug).filter((c) => c.needsInput).length
+    }));
+    const pending = flows.filter((flow) => flow.needsConfig > 0);
+    writeJson({
+      ok: true,
+      data: { flows },
+      hints: [
+        ...pending.length > 0 ? [
+          `Still unwired: ${pending.map((flow) => `${flow.slug} (${flow.needsConfig})`).join(", ")}. \`baker flows show <slug>\` returns the command that wires each \u2014 most you run yourself.`
+        ] : [],
+        // "Set the conversions on the Forms" lands here first, and nothing in
+        // this family can do it — the conversion side effects it does offer
+        // fire a pixel and are not what any Baker report counts.
+        "Setting what a Form COUNTS is not in this family: a conversion is a named event held in Baker. `baker analytics conversions` lists what this company counts; `--flow <slug>` spells one Form's endings as keys you can count, traffic or no traffic."
+      ]
+    });
+  }
+});
+var showCommand = defineCommand({
+  meta: {
+    name: "show",
+    description: "Show a Form's confidential fields and their configuration status (never secret values). Example: baker flows show contact"
+  },
+  args: {
+    slug: { type: "positional", description: "Form slug", required: true },
+    full: { type: "boolean", description: "Include the full flow tree (secret values redacted)" }
+  },
+  run: async ({ args }) => {
+    const slug = String(args.slug);
+    const tree = readFlowTree(slug);
+    const [drift, settings] = await Promise.all([readDrift(slug), readSettings(tree)]);
+    const config = withSettings(statusFor(slug), settings ?? {});
+    const response = {
+      slug,
+      name: displayName(slug),
+      config,
+      drift: drift === null ? null : drift.forms.filter((form) => form.slug === slug),
+      ...drift === null ? {} : { driftCheckedAt: drift.checkedAt },
+      ...args.full === true ? { tree: redactTree(tree) } : {}
+    };
+    writeJson({
+      ok: true,
+      data: response,
+      // Drift first, above everything. The other hints are about work still to
+      // do; this one is about leads already being lost, and it is the only
+      // thing here that is true of a Form that looks completely finished.
+      hints: [
+        ...driftHints(slug, drift),
+        ...inertSideEffectHints(tree),
+        ...pendingInputHints(slug, config),
+        // The question this command is asked — "is this Form wired up?" — has
+        // an answer that is not in this file at all. What a Form counts is a
+        // named event in Baker, and a Form can be perfectly configured, fire
+        // every pixel it has, and still report converting nobody.
+        `What this Form counts as a conversion is NOT in _data.json and not in any side effect here: it is a named event held in Baker. Read it, and this Form's own endings spelled as event keys, with \`baker analytics conversions --flow ${slug}\`.`,
+        funnelPlacementHint(slug)
+      ]
+    });
+  }
+});
+var flowsCommand = defineCommand({
+  meta: {
+    name: "flows",
+    description: `Read and shape this workspace's Forms (flows).
+
+Reads never reveal a secret value. Writes touch only the form's own _data.json \u2014 they stage structure, never a live system.
+
+Wire every destination yourself \u2014 no card for the user: an email (\`connect --email "a@x.com, b@x.com" --subject "New lead \u2014 Contact"\`; write the subject yourself), a webhook without a token (\`--url\`), and any connected platform once you know which resource is meant (\`baker flows options <kind>\` lists it; Calendly, SavvyCal, GoHighLevel steps; Google Sheets, Pipedrive, GoHighLevel, ActiveCampaign and HubSpot destinations; \`--same-as\` copies another Form's). A HubSpot step takes \`baker hubspot forms view <id> --as-node\`. \`show\` reads back where each destination sends; a credential is never shown.
+
+The request_flow_input tool (baker_ui MCP server) is only for what the user alone holds: a typed secret (a webhook token, Zapier, Crmble), a platform nobody connected, or several resources that could equally be meant.
+
+Examples:
+  baker flows list                                  # every Form + how many fields still need setup
+  baker flows show contact                          # one Form's confidential fields and their status
+  baker flows schema node customForm                # the shape of a step, before you author one
+  baker flows add-node contact --type text --name "Thanks"
+  baker flows add-side-effect contact --node <id> --type googleSpreadsheet
+  baker flows options calendly                      # what the connected account holds
+  baker flows connect contact --node book --resource <id>
+  baker flows connect contact --side-effect se-email-1 --email "ana@x.com, luis@x.com" --subject "New lead \u2014 Contact"
+  baker flows connect contact --side-effect se-hubspotForm-1 --hubspot-form <formId>   # --all: every unwired one
+  baker flows map contact --map A=name --map B=email --write
+Full guide: __tooling__/docs/tools/baker/flows.md`
+  },
+  subCommands: {
+    list: listCommand,
+    show: showCommand,
+    schema: () => import("./schema-3KGON5WS.js").then((m) => m.schemaCommand),
+    "add-node": () => import("./add-6D3W4Z7L.js").then((m) => m.addNodeCommand),
+    "add-side-effect": () => import("./add-6D3W4Z7L.js").then((m) => m.addSideEffectCommand),
+    options: () => import("./options-2TH4E4AK.js").then((m) => m.optionsCommand),
+    connect: () => import("./connect-QTYLBMZO.js").then((m) => m.connectCommand),
+    map: () => import("./map-3ETIGHF3.js").then((m) => m.mapCommand),
+    normalize: () => import("./normalize-AIKTTV67.js").then((m) => m.normalizeCommand)
+  },
+  // Bare `baker flows` lists the Forms. This must be `default`, not `run`: citty falls
+  // through to `run` after dispatching a subcommand, so a `run` here would also print
+  // the list on every `baker flows show <slug>`.
+  default: "list"
+});
+export {
+  driftHints,
+  flowsCommand,
+  funnelPlacementHint,
+  inertSideEffectHints
+};
+//# sourceMappingURL=flows-FP6FUVR2.js.map

package/dist/follow-RVOKLPZV.js

@@ -0,0 +1,94 @@
+import {
+  PLATFORM_NAMES,
+  reportError
+} from "./chunk-4AQJJHOM.js";
+import {
+  apiPost
+} from "./chunk-QG2WPVKE.js";
+import "./chunk-TSOJM4EO.js";
+import "./chunk-5TTHWWON.js";
+import {
+  brandAccountInput,
+  registerSchema,
+  writeJson
+} from "./chunk-KCA5CDCU.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/winning-ads/follow.ts
+import { defineCommand } from "citty";
+registerSchema({
+  command: "winning-ads.follow",
+  description: "Follow a brand so ALL its ads join your library \u2014 every platform (Meta, LinkedIn, TikTok, Google Ads), every account it runs there (one Facebook page per market, each Google entity) and every country. Paste whatever you have: a website (best \u2014 finds every account it links), a brand name, or any profile / ad-library link. Already-in-corpus brands are subscribed instantly; new brands are queued for ingestion. Accounts only named like the brand come back as `suggestions` with a ready `add-accounts` command.",
+  args: {
+    input: {
+      type: "string",
+      description: "Website (best), brand name, or any profile/ad-library link",
+      required: true
+    },
+    label: { type: "string", description: "Optional display label (defaults to the resolved name)", required: false }
+  }
+});
+function followHints(data) {
+  const hints = [];
+  if (data.status === "added") {
+    hints.push(
+      "This brand is new \u2014 we're adding every ad we can find across all platforms and countries. They appear as ingestion completes; check `baker winning-ads following`."
+    );
+  } else if (data.status === "ambiguous") {
+    hints.push(
+      "Multiple brands matched. Pick one from `candidates` and re-run `follow` with its exact website or link."
+    );
+  }
+  const suggestions = data.suggestions ?? [];
+  const names = suggestions.map((s) => `${s.name} (${PLATFORM_NAMES[s.platform]})`).join(", ");
+  if (data.status === "unconfirmed") {
+    const [first] = suggestions;
+    hints.push(
+      `Nothing followed yet: we found no account we're sure is this brand's, only accounts named like it: ${names}. Follow the brand's own with its link, e.g. baker winning-ads follow "${first ? brandAccountInput(first) : ""}", then add its other markets' accounts with \`add-accounts\`. Or retry with the brand's website.`
+    );
+    return hints;
+  }
+  if (data.advertiser && suggestions.length > 0) {
+    const inputs = suggestions.map(brandAccountInput).join(",");
+    hints.push(
+      `Also found accounts named like this brand, not tracked yet: ${names}. If they are the same brand (another country or language), track them with: baker winning-ads add-accounts ${data.advertiser.advertiser_id} "${inputs}" \u2014 drop any that belong to someone else.`
+    );
+  }
+  return hints.length > 0 ? hints : void 0;
+}
+var followCommand = defineCommand({
+  meta: {
+    name: "follow",
+    description: 'Follow a brand to track ALL its ads \u2014 every platform, every account and country. Paste a website (best), a brand name, or any profile/ad-library link. Example: baker winning-ads follow "barkibu.com"'
+  },
+  args: {
+    input: {
+      type: "positional",
+      description: "Website (best), brand name, or any profile/ad-library link",
+      required: true
+    },
+    label: { type: "string", description: "Optional display label", required: false },
+    platform: {
+      type: "string",
+      description: "Ignored \u2014 every platform is searched. Kept so older commands still run.",
+      required: false
+    }
+  },
+  run: async ({ args }) => {
+    try {
+      const body = { input: String(args.input) };
+      if (args.label) {
+        body.label = String(args.label);
+      }
+      const data = await apiPost("/api/ad-library/follow", body);
+      writeJson({ ok: true, data, hints: followHints(data) });
+    } catch (err) {
+      reportError(err);
+    }
+  }
+});
+export {
+  followCommand,
+  followHints
+};
+//# sourceMappingURL=follow-RVOKLPZV.js.map