@koda-sl/baker-cli 0.449.0 → 0.450.0-dev.b454c3dd2

package/dist/chunk-I3ZR655O.js

@@ -0,0 +1,382 @@
+import {
+  AUTO_PUBLISH_REFUSAL,
+  TRIGGER_KINDS,
+  TRIGGER_KIND_IDS,
+  TRIGGER_TARGETS,
+  TRIGGER_TARGET_FIELDS,
+  TRIGGER_TARGET_FIELD_IDS,
+  firstTimes,
+  isTriggerKind,
+  parseConditionsExpression
+} from "./chunk-7EPXVICM.js";
+import {
+  ApiError,
+  validateConvexId
+} from "./chunk-XBOK23HI.js";
+import {
+  getEnv
+} from "./chunk-NAWWC5I3.js";
+import {
+  writeJson
+} from "./chunk-NU7JSWVA.js";
+
+// src/commands/scheduled-agents/shared.ts
+var TEMP_SCHEDULED_AGENT_PREFIX = "temp_agent_";
+var TEMP_ID_PREFIX = "temp_";
+function writeOk(data, hints) {
+  writeJson({ ok: true, data: data ?? null, ...hints && hints.length > 0 ? { hints } : {} });
+}
+function failValidation(message) {
+  writeJson({ ok: false, error: { code: "VALIDATION_ERROR", message } });
+  process.exit(1);
+}
+function failApi(err) {
+  if (err instanceof ApiError) {
+    writeJson({ ok: false, error: { code: err.code, message: err.message } });
+    process.exit(1);
+  }
+  if (err instanceof Error) {
+    writeJson({ ok: false, error: { code: "INTERNAL_ERROR", message: err.message } });
+    process.exit(1);
+  }
+  writeJson({ ok: false, error: { code: "INTERNAL_ERROR", message: "Unexpected error" } });
+  process.exit(1);
+}
+var AUTO_PUBLISH_ARG = {
+  "auto-publish": {
+    type: "string",
+    description: "Not available to the agent: publishing every run unreviewed is switched on by the user, on the item, after this chat is published. Passing it is refused and tells you what to ask them.",
+    required: false
+  }
+};
+function refuseAutoPublish(args) {
+  if (args["auto-publish"] === void 0) {
+    return;
+  }
+  writeJson({
+    ok: false,
+    error: {
+      code: "FORBIDDEN",
+      message: AUTO_PUBLISH_REFUSAL,
+      fix: {
+        action: "ask_user",
+        explanation: 'Run the command again without --auto-publish. After this chat is published, ask the user to open the item in Scheduled agents and switch on "Publish its work on its own" under "When a run finishes" \u2014 until then each run waits for their review.'
+      }
+    }
+  });
+  process.exit(1);
+}
+function isTempScheduledAgentId(id) {
+  return id.startsWith(TEMP_SCHEDULED_AGENT_PREFIX);
+}
+function isOtherTempId(id) {
+  return id.startsWith(TEMP_ID_PREFIX) && !isTempScheduledAgentId(id);
+}
+function validateScheduledAgentRef(ref) {
+  if (isOtherTempId(ref)) {
+    failValidation(`Scheduled agent temp IDs must start with ${TEMP_SCHEDULED_AGENT_PREFIX}.`);
+  }
+  if (!isTempScheduledAgentId(ref)) {
+    validateConvexId(ref);
+  }
+}
+var TRIGGER_ARG_DESCRIPTION = `What makes this run. ${TRIGGER_KIND_IDS.map(
+  (id) => `${id}: ${TRIGGER_KINDS[id].description}`
+).join(" ")} For the two time ones, pass --cron or --run-at instead and the kind is implied.`;
+var TRIGGER_KIND_LIST = [...TRIGGER_KIND_IDS];
+var NARROWING_DESCRIPTIONS = {
+  eventName: "With --trigger event.received: only this event name (a source's name, or one your site sends). Omit it to run on any event.",
+  toolkit: "With --trigger app.event (required): the connected tool, by its slug \u2014 gmail, slack, googlesheets.",
+  account: "With --trigger app.event (required): which connected account of that tool, by id (a tool can be connected more than once).",
+  appEvent: "With --trigger app.event (required): what happens in the tool, by the tool's own id \u2014 GMAIL_NEW_GMAIL_MESSAGE. `targets --field appEvent --app <tool>` lists them with the settings each needs.",
+  provider: "With --trigger connection.created, connection.removed or connection.needs_reconnect: only this tool (google-ads, hubspot, meta, or a connected tool's slug such as slack). Omit it for any tool.",
+  flowId: "With --trigger form.submitted or flow.step.submitted: which Form, by slug. Omit it on form.submitted for any Form.",
+  stepId: "With --trigger flow.step.submitted: which step of that Form, by id \u2014 `targets --field stepId --form <slug>` lists them by name.",
+  page: "With --trigger landing.created or landing.published: only this page, by slug. Omit it for any page.",
+  tag: "With --trigger task.created, task.claimed, task.completed, landing.created or landing.published: only ones carrying this tag. Omit it for any.",
+  experimentId: 'With --trigger experiment.decided, experiment.ended or experiment.concluded: only this test. Omit it for any test. Not for experiment.started \u2014 narrow that with --when "page = <page>".',
+  taskId: "With --trigger task.claimed or task.completed: only this Task, by id (a temp_ id of a Task staged in this chat works too). Omit it for any Task.",
+  agentId: "With --trigger session.published, session.publish_failed or session.publish_incomplete: only the runs of this scheduled agent, by id (a temp_agent_ id staged in this chat works too). Omit it for any agent's work.",
+  platform: "With --trigger session.publish_incomplete: only when this platform's changes did not all land \u2014 google-ads, meta-ads, linkedin-ads, x-ads, tag-manager or ga4. Omit it for any.",
+  collection: "With --trigger knowledge.updated: only this Knowledge collection. Omit it for any of them.",
+  sourceId: "With --trigger review.received: only reviews from this review source, by id. Omit it for any source.",
+  advertiserId: "With --trigger advertiser.new_ads: only this followed advertiser, by id. Omit it for any of them."
+};
+var NARROWING_ARGS = {
+  ...Object.fromEntries(
+    TRIGGER_TARGET_FIELD_IDS.map((field) => [
+      TRIGGER_TARGET_FIELDS[field].flag,
+      {
+        type: "string",
+        description: `${NARROWING_DESCRIPTIONS[field]} \`baker scheduled-agents targets --trigger <kind> --field ${field}\` lists the values.`,
+        required: false
+      }
+    ])
+  ),
+  config: {
+    type: "string",
+    description: `With --trigger app.event: the event's own settings as a JSON object \u2014 they filter inside the tool, before anything is sent. A Gmail search ('{"query":"from:ana@acme.com"}'), a label, a Slack channel, a GitHub repository ('{"owner":"acme","repo":"site"}'). \`targets --field appEvent --app <tool> --event <id>\` lists each setting with its examples.`,
+    required: false
+  }
+};
+function validateRunAt(runAt) {
+  if (!runAt.endsWith("Z")) {
+    failValidation("--run-at must be an ISO UTC timestamp ending in Z.");
+  }
+  const parsed = Date.parse(runAt);
+  if (!Number.isFinite(parsed)) {
+    failValidation("--run-at must be a valid ISO timestamp.");
+  }
+  if (parsed <= Date.now()) {
+    failValidation(
+      `--run-at ${runAt} has already passed. A one-off item only runs at a time still to come \u2014 pass a later ISO UTC timestamp, and check which timezone you converted from if you worked it out from a local time.`
+    );
+  }
+}
+function buildTriggerBody(args, options) {
+  const cron = args.cron;
+  const runAt = args["run-at"];
+  const timezone = args.timezone;
+  const kind = args.trigger;
+  const given = [cron, runAt, kind].filter(Boolean).length;
+  if (given > 1) {
+    failValidation("--cron, --run-at and --trigger are mutually exclusive.");
+  }
+  refuseNarrowingWithoutKind(args, kind, given);
+  if (runAt) {
+    validateRunAt(runAt);
+    return { runAt, ...timezone ? { timezone } : {} };
+  }
+  if (cron) {
+    return { cron, ...timezone ? { timezone } : {} };
+  }
+  if (kind) {
+    return { trigger: triggerFromFlags(kind, args), ...timezone ? { timezone } : {} };
+  }
+  if (timezone && !options.required) {
+    return { timezone };
+  }
+  if (options.required) {
+    failValidation(
+      `A trigger is required. Pass --cron or --run-at for a time-based one, or --trigger with one of: ${TRIGGER_KIND_IDS.join(", ")}.`
+    );
+  }
+  return void 0;
+}
+function flagText(args, key) {
+  const value = args[key];
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
+}
+function refuseMisusedKinds(kind, args) {
+  if (kind === "time.once") {
+    failValidation("Use --run-at for a one-off, rather than --trigger time.once.");
+  }
+  if (kind === "time.cron") {
+    failValidation("Use --cron for a repeating schedule, rather than --trigger time.cron.");
+  }
+  if (kind === "experiment.started" && flagText(args, "experiment")) {
+    failValidation(
+      'A test that exists has already started, so --experiment never fires on experiment.started. Leave it off and add --when "page = <page>" to watch one page.'
+    );
+  }
+}
+function refuseStrayFlags(kind, args) {
+  const allowed = new Set(TRIGGER_TARGETS[kind].map((target) => TRIGGER_TARGET_FIELDS[target.field].flag));
+  const stray = TRIGGER_TARGET_FIELD_IDS.map((field) => TRIGGER_TARGET_FIELDS[field].flag).filter(
+    (flag) => !allowed.has(flag) && flagText(args, flag) !== void 0 && !(kind === "experiment.started" && flag === "experiment")
+  );
+  if (stray.length === 0) {
+    return;
+  }
+  failValidation(
+    `${stray.map((flag) => `--${flag}`).join(", ")} does not narrow ${kind}. ${allowed.size > 0 ? `It can be pointed with ${[...allowed].map((flag) => `--${flag}`).join(", ")}.` : "It runs every time it happens \u2014 narrow it with --when rules over its payload instead."}`
+  );
+}
+var NARROWING_FLAGS = [...TRIGGER_TARGET_FIELD_IDS.map((field) => TRIGGER_TARGET_FIELDS[field].flag), "config"];
+function refuseNarrowingWithoutKind(args, kind, given) {
+  if (kind) {
+    return;
+  }
+  const stray = NARROWING_FLAGS.filter((flag) => flagText(args, flag) !== void 0);
+  if (stray.length === 0) {
+    return;
+  }
+  const flags = stray.map((flag) => `--${flag}`).join(", ");
+  failValidation(
+    given > 0 ? `${flags} does not narrow --cron or --run-at: a time trigger runs every time it comes round. Use --trigger <kind> with ${flags} instead, or leave ${flags} off.` : `${flags} narrows a trigger, and no trigger was given. Pass --trigger <kind> too \u2014 the item's whole trigger, with ${flags} \u2014 or leave ${flags} off.`
+  );
+}
+function configFromFlag(kind, args) {
+  const config = flagText(args, "config");
+  if (!config) {
+    return {};
+  }
+  if (kind !== "app.event") {
+    failValidation("--config is only for --trigger app.event: the settings of what happens in the tool.");
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(config);
+  } catch {
+    parsed = null;
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    failValidation(`--config must be a JSON object, e.g. '{"labelIds":"INBOX"}'.`);
+  }
+  return { configJson: config };
+}
+function triggerFromFlags(kind, args) {
+  if (!isTriggerKind(kind)) {
+    failValidation(`--trigger must be one of: ${TRIGGER_KIND_IDS.join(", ")}.`);
+  }
+  refuseMisusedKinds(kind, args);
+  refuseStrayFlags(kind, args);
+  const narrowings = {};
+  for (const { field, required } of TRIGGER_TARGETS[kind]) {
+    const value = flagText(args, TRIGGER_TARGET_FIELDS[field].flag);
+    if (value) {
+      narrowings[field] = value;
+    } else if (required) {
+      failValidation(
+        `--trigger ${kind} needs --${TRIGGER_TARGET_FIELDS[field].flag}. \`baker scheduled-agents targets --trigger ${kind} --field ${field}\` lists what it can be.`
+      );
+    }
+  }
+  return { kind, ...narrowings, ...configFromFlag(kind, args) };
+}
+function parseOccurrences(raw) {
+  if (raw === void 0) {
+    return void 0;
+  }
+  if (typeof raw !== "string") {
+    failValidation("--occurrences must be a comma-separated list of whole numbers, e.g. 1 or 1,3.");
+  }
+  const parts = raw.split(",").map((part) => part.trim()).filter((part) => part.length > 0);
+  const numbers = parts.map((part) => Number(part));
+  if (numbers.length === 0 || numbers.some((n) => !Number.isInteger(n) || n <= 0)) {
+    failValidation("--occurrences must be a comma-separated list of whole numbers above zero, e.g. 1 or 1,3.");
+  }
+  return numbers;
+}
+function parseBooleanFlag(raw, flagName) {
+  if (raw === void 0) {
+    return void 0;
+  }
+  if (raw === true || raw === "true") {
+    return true;
+  }
+  if (raw === false || raw === "false") {
+    return false;
+  }
+  failValidation(`${flagName} must be true or false.`);
+}
+var REACTION_ARGS = {
+  when: {
+    type: "string",
+    description: "Only run when what arrived passes these rules: `<field> <operator> <value>` joined by AND or by OR (either case). Fields are the trigger's payload fields (`baker scheduled-agents triggers --trigger <kind>` lists them; a webhook's are whatever was posted; an app.event's are what `targets --field appEvent --app <tool> --event <id>` says it sends). Operators: =, !=, contains, does not contain, starts with, ends with, >, <, >=, <=, in (comma list), exists, missing. Example: --when \"deal.stage = won AND amount > 10000\". A payload that fails is not counted and starts nothing. `none` clears the rules.",
+    required: false
+  },
+  times: {
+    type: "string",
+    description: "Only the first N times it fires (and its --when rules pass), then never again. `--times 1` is only the first time. Shorthand for --occurrences 1,2,\u2026,N.",
+    required: false
+  },
+  payload: {
+    type: "string",
+    description: "include (default) or omit. Whether the run's first message carries what arrived \u2014 the posted body, the event's properties, the Form's answers (emails and phones masked). Place single values in --prompt with {{payload.<field>}} instead; those are filled either way.",
+    required: false
+  },
+  cooldown: {
+    type: "string",
+    description: "At most one run per this many minutes, however often it fires. 0 removes it.",
+    required: false
+  }
+};
+var SLACK_ARG = {
+  slack: {
+    type: "string",
+    description: "Tell each run in Slack: `here` (the Slack conversation this chat came from), `me` (a direct message to the person in this chat), `#channel` (a channel linked to this company), or `off`. Each run opens its own thread there and Baker reports on it: what it found, what it needs, whether to publish.",
+    required: false
+  }
+};
+function slackBody(args) {
+  return typeof args.slack === "string" && args.slack.trim().length > 0 ? { slack: args.slack.trim() } : {};
+}
+function wholeNumber(raw, flag, { min }) {
+  if (raw === void 0) {
+    return void 0;
+  }
+  const value = Number(raw);
+  if (!Number.isInteger(value) || value < min) {
+    failValidation(`${flag} must be a whole number of at least ${min}.`);
+  }
+  return value;
+}
+function reactionBody(args) {
+  const occurrences = occurrencesFromFlags(args);
+  const when = whenFromFlag(args.when);
+  const includePayload = payloadFromFlag(args.payload);
+  const cooldownMinutes = wholeNumber(args.cooldown, "--cooldown", { min: 0 });
+  return {
+    ...occurrences !== void 0 ? { occurrences } : {},
+    ...when !== void 0 ? { when } : {},
+    ...includePayload !== void 0 ? { includePayload } : {},
+    ...cooldownMinutes !== void 0 ? { cooldownMinutes } : {}
+  };
+}
+function occurrencesFromFlags(args) {
+  const times = wholeNumber(args.times, "--times", { min: 1 });
+  const occurrences = parseOccurrences(args.occurrences);
+  if (times !== void 0 && occurrences !== void 0) {
+    failValidation("Pass --times or --occurrences, not both \u2014 --times 3 is --occurrences 1,2,3.");
+  }
+  return times !== void 0 ? firstTimes(times) : occurrences;
+}
+function whenFromFlag(raw) {
+  if (typeof raw !== "string") {
+    return void 0;
+  }
+  const text = raw.trim();
+  if (text.length === 0 || text.toLowerCase() === "none") {
+    return "none";
+  }
+  const parsed = parseConditionsExpression(text);
+  if (!parsed.ok) {
+    failValidation(parsed.error);
+  }
+  return text;
+}
+function payloadFromFlag(raw) {
+  if (raw === void 0) {
+    return void 0;
+  }
+  if (raw !== "include" && raw !== "omit") {
+    failValidation("--payload must be include or omit.");
+  }
+  return raw === "include";
+}
+function chatBody() {
+  const id = getEnv().BAKER_CHAT_ID;
+  return id ? { chatId: id } : {};
+}
+
+export {
+  writeOk,
+  failValidation,
+  failApi,
+  AUTO_PUBLISH_ARG,
+  refuseAutoPublish,
+  isTempScheduledAgentId,
+  validateScheduledAgentRef,
+  TRIGGER_ARG_DESCRIPTION,
+  TRIGGER_KIND_LIST,
+  NARROWING_ARGS,
+  buildTriggerBody,
+  parseBooleanFlag,
+  REACTION_ARGS,
+  SLACK_ARG,
+  slackBody,
+  reactionBody,
+  chatBody
+};
+//# sourceMappingURL=chunk-I3ZR655O.js.map

package/dist/chunk-KMKEYI37.js

@@ -0,0 +1,96 @@
+import {
+  loadCompositionMeta
+} from "./chunk-LYQJ4PZW.js";
+import {
+  parseRefExpr
+} from "./chunk-FPOGPFAG.js";
+import {
+  resolveAdaptFormats
+} from "./chunk-CAMX6OHF.js";
+
+// src/commands/canvas/output-ratio.ts
+import { readFile } from "fs/promises";
+import path from "path";
+function definitionFormats(markdown) {
+  const front = markdown.match(/^---\n([\s\S]*?)\n---/)?.[1];
+  if (!front) return [];
+  const clean = (s) => s.trim().replace(/^["']|["']$/g, "");
+  const flow = front.match(/^formats:\s*\[([^\]]*)\]/m);
+  if (flow) return (flow[1] ?? "").split(",").map(clean).filter(Boolean);
+  const block = front.match(/^formats:\s*\n((?:\s+-\s+.*\n?)+)/m);
+  if (!block) return [];
+  return (block[1] ?? "").split("\n").map((l) => l.replace(/^\s+-\s+/, "")).map(clean).filter(Boolean);
+}
+function reduce(width, height) {
+  const gcd = (a, b) => b === 0 ? a : gcd(b, a % b);
+  const d = gcd(width, height);
+  return `${width / d}:${height / d}`;
+}
+async function ratiosOf(nodes, id, seen) {
+  const node = nodes.get(id);
+  if (!node || seen.has(id)) return null;
+  seen.add(id);
+  const p = node.params ?? {};
+  switch (node.type) {
+    case "image_generate":
+      return typeof p.aspect_ratio === "string" ? [p.aspect_ratio] : null;
+    case "image_aspect_adapt":
+      return [...resolveAdaptFormats(p)];
+    case "hyperframe_snapshot": {
+      if (typeof p.composition !== "string") return null;
+      const meta = await loadCompositionMeta(p.composition).catch(() => null);
+      return meta ? [reduce(meta.width, meta.height)] : null;
+    }
+    case "collect": {
+      const images = node.inputs?.images;
+      if (!Array.isArray(images)) return null;
+      const out = [];
+      for (const entry of images) {
+        const ref = typeof entry === "string" ? parseRefExpr(entry) : null;
+        if (!ref || ref.kind !== "ref") return null;
+        const upstream = await ratiosOf(nodes, ref.nodeId, seen);
+        if (!upstream) return null;
+        out.push(ref.index !== void 0 && upstream.length > 1 ? upstream[ref.index] ?? "" : upstream[0] ?? "");
+      }
+      return out.filter(Boolean);
+    }
+    default:
+      return null;
+  }
+}
+async function producedRatios(canvas) {
+  const c = canvas;
+  if (!Array.isArray(c?.nodes) || typeof c?.output?.node !== "string") return null;
+  const nodes = new Map(c.nodes.flatMap((n) => typeof n.id === "string" ? [[n.id, n]] : []));
+  return ratiosOf(nodes, c.output.node, /* @__PURE__ */ new Set());
+}
+function value(ratio) {
+  const [w, h] = ratio.split(":").map(Number);
+  return w && h ? w / h : null;
+}
+function outputRatioWarnings(declared, produced) {
+  if (!produced || produced.length === 0) return [];
+  const shapes = produced.flatMap((r) => value(r) ?? []);
+  return declared.flatMap((format) => {
+    const want = value(format);
+    if (want === null || shapes.some((s) => Math.abs(s / want - 1) <= 0.02)) return [];
+    return [
+      {
+        path: "output",
+        code: "OUTPUT_RATIO_MISMATCH",
+        severity: "warning",
+        message: `_definition.md declares ${format}, but this canvas delivers ${produced.join(", ")}. A ${format} placement would get the wrong shape: re-scaffold with that format, or fix the formats the creative declares.`
+      }
+    ];
+  });
+}
+async function outputRatioWarningsFor(canvas, canvasPath) {
+  const definition = await readFile(path.join(path.dirname(canvasPath), "_definition.md"), "utf8").catch(() => null);
+  if (!definition) return [];
+  return outputRatioWarnings(definitionFormats(definition), await producedRatios(canvas));
+}
+
+export {
+  outputRatioWarningsFor
+};
+//# sourceMappingURL=chunk-KMKEYI37.js.map

package/dist/chunk-KS2QY6MK.js

@@ -0,0 +1,139 @@
+import {
+  brandVerificationHints
+} from "./chunk-IVIJJXXT.js";
+import {
+  OUTPUT_ARGS,
+  writeProviderHits
+} from "./chunk-WS2GMOSG.js";
+import {
+  AUTO_INGEST_MAX,
+  parseAutoIngest
+} from "./chunk-KKJ4KJCW.js";
+import {
+  emptyResultHints
+} from "./chunk-Q6ULQMWG.js";
+import {
+  ApiError,
+  apiPost
+} from "./chunk-XBOK23HI.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-NU7JSWVA.js";
+
+// src/commands/images/logo.ts
+import { defineCommand } from "citty";
+registerSchema({
+  command: "images.logo",
+  description: "Brand logo lookup via Brandfetch. Auto-ingests by default. Returns `brandMatch` \u2014 Brandfetch's own verdict on whose brand the domain is (confirmed | mismatch | unverified). Branch on it: `mismatch` means the mark is another company's, so do not place it. `confirmed` verifies the record, not the artwork \u2014 read the ingested row back to check the mark itself.",
+  args: {
+    domain: { type: "string", description: "Brand domain (e.g. stripe.com)", required: true },
+    variant: { type: "string", description: "icon | logo | symbol", required: false },
+    "auto-ingest": {
+      type: "number",
+      description: `Ingest top N hits (0-${AUTO_INGEST_MAX.logo}). Defaults to 1 (the first variant). Brandfetch resolves at most ${AUTO_INGEST_MAX.logo} variants, so ${AUTO_INGEST_MAX.logo} ingests every one. Keep it at 1+ \u2014 the ingested row is the only way to check the mark is the brand you asked for.`,
+      required: false
+    },
+    "no-auto-ingest": {
+      type: "boolean",
+      description: "Skip auto-ingest (equivalent to --auto-ingest 0). Leaves the returned mark unverifiable.",
+      required: false,
+      default: false
+    },
+    context: {
+      type: "string",
+      description: "Free-text hint applied to ingested logo variants (e.g. 'Stripe \u2014 payments integration partner', 'Acme competitor brand mark')",
+      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 logoCommand = defineCommand({
+  meta: {
+    name: "logo",
+    description: "Brand logo via Brandfetch. Returns up to 5 variants (icon, light/dark logo, light/dark symbol) plus `brandMatch`. Auto-ingests the first variant.\n\nStart here: check `brandMatch.verdict`.\n  mismatch   \u2192 the mark belongs to `brandMatch.name`, a different company. Do not place it.\n  unverified \u2192 nothing confirmed whose logo this is. Treat as unchecked.\n  confirmed  \u2192 Brandfetch has this brand's record. That verifies the record, NOT the artwork \u2014 a confirmed domain has served another company's logo before.\n\n\u26A0 Whatever the verdict, read the ingested row back with `baker images get <imageId>` and check `textInImage`/`subject` before placing it. That is the only check that looks at the mark.\n\nExample: baker images logo stripe.com --variant logo"
+  },
+  args: {
+    domain: { type: "positional", description: "Brand domain", required: false },
+    variant: { type: "string", description: "icon|logo|symbol", required: false },
+    "auto-ingest": {
+      type: "string",
+      description: `Ingest top N (0-${AUTO_INGEST_MAX.logo}, default 1)`,
+      required: false
+    },
+    "no-auto-ingest": { type: "boolean", description: "Skip auto-ingest", required: false },
+    context: { type: "string", description: "Description context hint applied to ingested logos", required: false },
+    ...OUTPUT_ARGS
+  },
+  run: async ({ args }) => {
+    try {
+      const domain = args.domain;
+      if (!domain) {
+        writeJson({ ok: false, error: { code: "VALIDATION_ERROR", message: "Domain is required" } });
+        process.exit(1);
+      }
+      const body = { domain };
+      if (args.variant) body.variant = args.variant;
+      if (args["auto-ingest"] !== void 0) {
+        const parsed = parseAutoIngest(args["auto-ingest"], AUTO_INGEST_MAX.logo);
+        if (!parsed.ok) {
+          writeJson({
+            ok: false,
+            error: {
+              code: "VALIDATION_ERROR",
+              message: parsed.message,
+              fix: {
+                action: "retry_with_changes",
+                explanation: `Brandfetch resolves at most ${AUTO_INGEST_MAX.logo} variants for a domain, so --auto-ingest ${AUTO_INGEST_MAX.logo} already ingests every one. Re-run with a value in 0-${AUTO_INGEST_MAX.logo}.`
+              }
+            }
+          });
+          process.exit(1);
+        }
+        body.autoIngest = parsed.value;
+      } else if (args["no-auto-ingest"]) {
+        body.autoIngest = 0;
+      }
+      if (args.context) body.descriptionContext = args.context;
+      const data = await apiPost("/api/images/logo", body);
+      const hints = [
+        // `brandMatch` is Brandfetch's own answer to whose brand this domain is,
+        // so the warning can now be graded instead of fired blind: loud on a
+        // mismatch, honest about what a confirmation does and does not cover.
+        ...brandVerificationHints({
+          domain,
+          ingested: data.ingested,
+          hitCount: data.hits.length,
+          brandMatch: data.brandMatch
+        }),
+        ...emptyResultHints({ provider: "logo", hitCount: data.hits.length, activeFilters: [], subject: domain })
+      ];
+      writeProviderHits(data, 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);
+    }
+  }
+});
+async function fetchBrandLogo(domain) {
+  try {
+    const body = { domain, variant: "logo" };
+    const data = await apiPost("/api/images/logo", body);
+    if (data?.brandMatch?.verdict === "mismatch") return null;
+    return data?.ingested?.[0]?.imageUrl ?? data?.hits?.find((h) => h.imageUrl)?.imageUrl ?? null;
+  } catch {
+    return null;
+  }
+}
+
+export {
+  logoCommand,
+  fetchBrandLogo
+};
+//# sourceMappingURL=chunk-KS2QY6MK.js.map