@koda-sl/baker-cli 0.563.0-dev.25ca3cbc8 → 0.564.0

package/dist/tags-YTZ6ZPQQ.js

@@ -0,0 +1,227 @@
+import {
+  CHAT_READ_ARG
+} from "./chunk-X32MFGWW.js";
+import {
+  TAG_IDENTIFYING_FIELD
+} from "./chunk-7BV5QN2P.js";
+import "./chunk-QV6AST5T.js";
+import "./chunk-WCU362Z6.js";
+import "./chunk-GIWHHCD6.js";
+import "./chunk-SOPVIIUW.js";
+import "./chunk-G4FG5EQO.js";
+import "./chunk-R7XDGNZD.js";
+import "./chunk-MSMTG6OC.js";
+import {
+  ApiError,
+  apiPost
+} from "./chunk-QEREDRZO.js";
+import "./chunk-JXTNP3B5.js";
+import {
+  requireChatId,
+  resolveChatId
+} from "./chunk-45D6WRCJ.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-CCYZJMZ7.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/tags/index.ts
+import { defineCommand } from "citty";
+
+// src/commands/tags/shared.ts
+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);
+}
+function failValidation(message) {
+  writeJson({ ok: false, error: { code: "VALIDATION_ERROR", message } });
+  process.exit(1);
+}
+function renderConfigValue(value) {
+  return value.includes("\n") ? value.replace(/\n/g, "\n      ") : value;
+}
+function renderEffectiveEntry(entry) {
+  const parts = [entry.ref, entry.type];
+  if (entry.identifier !== void 0) {
+    parts.push(entry.identifier);
+  }
+  if (entry.staged !== void 0) {
+    parts.push(`[staged: ${entry.staged}]`);
+  }
+  const secretBits = [
+    ...entry.secretsSet.map((field) => `${field} \u2713 set`),
+    ...entry.secretsPending.map((field) => `${field} \u23F3 pending`)
+  ];
+  if (secretBits.length > 0) {
+    parts.push(`[secrets: ${secretBits.join(", ")}]`);
+  }
+  const header = parts.join("  ");
+  const identifyingField = TAG_IDENTIFYING_FIELD[entry.type];
+  const configLines = Object.entries(entry.config).filter(([key]) => key !== identifyingField).map(([key, value]) => `    ${key}: ${renderConfigValue(value)}`);
+  return configLines.length > 0 ? `${header}
+${configLines.join("\n")}` : header;
+}
+function tagsListHints() {
+  return [
+    "To create, edit or delete a tag, call the `request_tag_input` approval form (tool `mcp__baker_ui__request_tag_input`, server `baker_ui`) \u2014 it is attached to every turn of this chat and collects any secret values itself.",
+    "Don't conclude the form is unavailable from your tool list: call it, and report what it returns. And never file a tag change as a Task \u2014 a Task hands the user work this chat can stage in one call."
+  ];
+}
+
+// src/commands/tags/index.ts
+registerSchema({
+  command: "tags.list",
+  description: "Effective marketing tags for this chat: production tags overlaid with the changes staged in this chat. Prints each tag's readable config in full (secrets are never included) \u2014 e.g. the Clarity projectId, GA4 measurementId, or the entire custom `code` snippet \u2014 so reuse a stored value to pre-fill a follow-up change instead of asking the user for something we already have. The printed refs (tag ids or tag_temp_*) are exactly what flow side-effect tagIds should reference. Read-only \u2014 every tag change (create, edit, delete) goes through the request_tag_input approval tool; `baker tags unstage` takes back one this chat staged.",
+  args: {
+    json: { type: "boolean", description: "Print the raw JSON envelope instead of the readable list", required: false }
+  }
+});
+async function listTags(json) {
+  try {
+    const chatId = requireChatId();
+    const response = await apiPost("/api/tags/list", { chatId });
+    const hints = tagsListHints();
+    if (json) {
+      writeJson({ ok: true, data: response, hints });
+      return;
+    }
+    if (response.tags.length === 0) {
+      process.stdout.write("No tags configured.\n");
+    } else {
+      process.stdout.write(`${response.tags.map(renderEffectiveEntry).join("\n")}
+`);
+    }
+    for (const hint of hints) {
+      process.stderr.write(`${hint}
+`);
+    }
+  } catch (err) {
+    failApi(err);
+  }
+}
+var listArgs = {
+  json: { type: "boolean", description: "Print the raw JSON envelope instead of the readable list" }
+};
+var listCommand = defineCommand({
+  meta: {
+    name: "list",
+    description: "Effective tags for this chat (production + staged), with each tag's full readable config (secrets excluded) \u2014 reuse a stored value to pre-fill a change rather than asking the user. Refs printed here are what flow side-effect tagIds should use. Example: baker tags list"
+  },
+  args: listArgs,
+  run: async ({ args }) => {
+    await listTags(args.json === true);
+  }
+});
+async function listDraft(chat) {
+  try {
+    const chatId = resolveChatId(chat);
+    const response = await apiPost("/api/tags/draft", { chatId });
+    writeJson({ ok: true, data: response, hints: tagsListHints() });
+  } catch (err) {
+    failApi(err);
+  }
+}
+var draftCommand = defineCommand({
+  meta: {
+    name: "draft",
+    description: "Review the tag changes staged in this chat (read-only). Staged changes were approved via request_tag_input and apply when the chat is published. To drop one, `baker tags unstage <ref>` with the ref printed here (or --all); to amend one, propose a follow-up change through the same tool. Takes --chat <id> to read an earlier chat's staged changes instead."
+  },
+  args: { chat: CHAT_READ_ARG },
+  run: async ({ args }) => {
+    await listDraft(args.chat);
+  }
+});
+registerSchema({
+  command: "tags.unstage",
+  description: "Take back a tag change this chat staged, before Publish \u2014 the same as discarding its row in the change review. Pass the ref `baker tags draft` prints (a tag id, or tag_temp_* for a staged create), or --all for every staged tag change. Taking back a staged create also drops the secrets the user entered for it. Never touches a live tag: to change or remove one, propose the change through request_tag_input.",
+  args: {
+    ref: { type: "string", description: "The staged change's ref, from `baker tags draft`", required: false },
+    all: { type: "boolean", description: "Take back every tag change staged in this chat", required: false }
+  }
+});
+function unstageBody(args, chatId) {
+  const ref = args.ref?.trim();
+  if (args.all === true && ref) {
+    failValidation("Pass one ref to take back that change, or --all for every staged tag change \u2014 not both.");
+  }
+  if (args.all === true) {
+    return { chatId, all: true };
+  }
+  if (!ref) {
+    failValidation("Pass the ref of the staged change (from `baker tags draft`), or --all.");
+  }
+  return { chatId, ref };
+}
+var unstageCommand = defineCommand({
+  meta: {
+    name: "unstage",
+    description: "Take back a tag change this chat staged, before Publish. Examples: baker tags unstage tag_temp_abc123 | baker tags unstage --all"
+  },
+  args: {
+    ref: { type: "positional", description: "The staged change's ref, from `baker tags draft`", required: false },
+    all: { type: "boolean", description: "Take back every tag change staged in this chat", required: false }
+  },
+  run: async ({ args }) => {
+    try {
+      const body = unstageBody(
+        {
+          ...typeof args.ref === "string" ? { ref: args.ref } : {},
+          ...args.all === true ? { all: true } : {}
+        },
+        requireChatId()
+      );
+      const response = await apiPost("/api/tags/draft-op/remove", body);
+      writeJson({
+        ...response,
+        hints: ["Taken back: it does not apply when the chat is published. Live tags are unchanged."]
+      });
+    } catch (err) {
+      failApi(err);
+    }
+  }
+});
+var tagsCommand = defineCommand({
+  meta: {
+    name: "tags",
+    description: `Read the client's marketing/analytics tags (Meta pixel, GA4, Google Ads, GTM, Clarity, Hotjar, \u2026) \u2014 production tags plus the changes staged in this chat.
+
+Every tag change \u2014 create, edit, or delete \u2014 goes through the request_tag_input tool (baker_ui MCP server): propose one or more changes (each becomes a tab in one approval form), pre-fill the non-secret fields you know, and the user reviews, fills secrets, and approves or skips each. Secret values (accessToken, apiSecret, authorizationToken, apiKey, conversionToken, OAuth connections) never pass through the CLI or the chat.
+
+Refs: \`baker tags list\` prints each tag's ref \u2014 a real tag id, or tag_temp_* for creates staged in this chat. Use these refs as flow side-effect tagIds; they keep resolving after publish.
+
+\`baker tags list\` prints each tag's readable config in full (secrets excluded) \u2014 the Clarity projectId, GA4 measurementId, the whole custom \`code\` snippet, etc. Reuse a stored value to pre-fill a follow-up change instead of asking the user for something already installed.
+
+To take back a change this chat staged (before Publish), \`baker tags unstage <ref>\` \u2014 the ref \`baker tags draft\` prints \u2014 or \`--all\`. It never touches a live tag.
+
+Examples:
+  baker tags list       # production + staged, full readable config + secret status
+  baker tags draft      # review the staged changes awaiting publish
+  baker tags unstage tag_temp_abc123   # take back one staged change
+Full guide: __tooling__/docs/tools/baker/tags.md`
+  },
+  subCommands: {
+    list: listCommand,
+    draft: draftCommand,
+    unstage: unstageCommand
+  },
+  // Bare `baker tags` lists the effective tags. `args` stays so citty knows this
+  // command's flags when it scans rawArgs for a subcommand name, and `default` (not
+  // `run`) dispatches the bare invocation — citty falls through to `run` after a
+  // subcommand, so a `run` here would also list on every `baker tags draft`.
+  args: listArgs,
+  default: "list"
+});
+export {
+  tagsCommand,
+  unstageBody
+};
+//# sourceMappingURL=tags-YTZ6ZPQQ.js.map

package/dist/targeting-criteria-JTY4OUQV.js

@@ -0,0 +1,113 @@
+import {
+  parseXApiError
+} from "./chunk-FIN4ZXGJ.js";
+import {
+  resolveXAccountId
+} from "./chunk-YD6OZSSY.js";
+import {
+  cacheGet,
+  cacheSet,
+  writeAdsJson,
+  writeAdsOutput
+} from "./chunk-RBCO3C3Q.js";
+import {
+  ApiError,
+  apiGet
+} from "./chunk-QEREDRZO.js";
+import "./chunk-JXTNP3B5.js";
+import "./chunk-45D6WRCJ.js";
+import {
+  registerSchema
+} from "./chunk-CCYZJMZ7.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/ads/x/targeting-criteria.ts
+import { defineCommand } from "citty";
+registerSchema({
+  command: "ads.x.targetingCriteria",
+  description: "List targeting criteria attached to line items in an X Ads account. Returns targeting_type, targeting_value, name, operator_type per criterion. Filter by line-item-ids.",
+  args: {
+    "account-id": { type: "string", description: "X Ads account ID", required: false },
+    "line-item-ids": { type: "string", description: "CSV of line item IDs", required: false },
+    "no-cache": { type: "boolean", description: "Skip cache", required: false }
+  }
+});
+var targetingCriteriaListCommand = defineCommand({
+  meta: {
+    name: "targeting-criteria",
+    description: `List targeting criteria attached to line items.
+
+Examples:
+  baker ads x targeting-criteria --account-id 18ce53xyz --line-item-ids abc`
+  },
+  args: {
+    "account-id": { type: "string", description: "X Ads account ID", required: false },
+    "line-item-ids": { type: "string", description: "CSV of line item IDs", required: false },
+    "no-cache": { type: "boolean", description: "Skip cache", required: false },
+    output: { type: "string", description: "Format: json|csv|md", required: false, default: "json" }
+  },
+  run: async ({ args }) => {
+    const accountId = await resolveXAccountId(args);
+    const useCache = !args["no-cache"];
+    const cacheKey = `targeting-criteria:${accountId}:${args["line-item-ids"] ?? ""}`;
+    if (useCache) {
+      const cached = cacheGet("x-account-data", cacheKey);
+      if (cached) {
+        writeAdsJson({ ok: true, data: cached.data, cached: true });
+        return;
+      }
+    }
+    try {
+      const params = { "account-id": accountId };
+      if (args["line-item-ids"]) params["line-item-ids"] = args["line-item-ids"];
+      if (!useCache) params["skip-cache"] = "true";
+      const data = await apiGet("/api/ads/x/targeting-criteria", params);
+      if (useCache) {
+        cacheSet("x-account-data", cacheKey, data, 60 * 60 * 1e3);
+      }
+      const format = args.output || "json";
+      if (format !== "json") {
+        writeAdsOutput(data, format);
+        return;
+      }
+      writeAdsJson({ ok: true, data });
+    } catch (err) {
+      if (err instanceof ApiError) {
+        writeAdsJson(parseXApiError(err.message, accountId));
+        process.exit(1);
+      }
+      writeAdsJson({ ok: false, error: { code: "NETWORK_ERROR", message: "Unexpected error" } });
+      process.exit(1);
+    }
+  }
+});
+var targetingCriteriaCommand = defineCommand({
+  meta: {
+    name: "targeting-criteria",
+    description: `Targeting attached to ad groups \u2014 read it, or stage a change.
+
+X stores each criterion as its own entity, so one op targets one value. Look
+values up with \`baker ads x targeting-constants\` first.
+
+Examples:
+  baker ads x targeting-criteria --line-item-ids wiee9
+  baker ads x targeting-criteria create --line-item-id wiee9 --type LOCATION --value 96683cc9126741d1
+  baker ads x targeting-criteria remove 1dmtken`
+  },
+  subCommands: {
+    list: targetingCriteriaListCommand,
+    create: () => import("./promoted-tweet-writes-DB6U5OIJ.js").then((m) => m.targetingCriteriaCreateCommand),
+    remove: () => import("./promoted-tweet-writes-DB6U5OIJ.js").then((m) => m.targetingCriteriaRemoveCommand)
+  },
+  args: {
+    "account-id": { type: "string", description: "X Ads account ID" },
+    "line-item-ids": { type: "string", description: "CSV of line item IDs" },
+    "no-cache": { type: "boolean", description: "Skip cache" },
+    output: { type: "string", description: "Format: json|csv|md", default: "json" }
+  },
+  default: "list"
+});
+export {
+  targetingCriteriaCommand
+};
+//# sourceMappingURL=targeting-criteria-JTY4OUQV.js.map

package/dist/targets-RG3NONXL.js

@@ -0,0 +1,106 @@
+import {
+  chatBody,
+  failApi,
+  failValidation
+} from "./chunk-RM6ZIQHH.js";
+import "./chunk-WR5Y64OE.js";
+import {
+  TRIGGER_KIND_IDS,
+  TRIGGER_TARGET_FIELD_IDS
+} from "./chunk-7BV5QN2P.js";
+import "./chunk-QV6AST5T.js";
+import "./chunk-WCU362Z6.js";
+import "./chunk-GIWHHCD6.js";
+import "./chunk-SOPVIIUW.js";
+import "./chunk-G4FG5EQO.js";
+import "./chunk-R7XDGNZD.js";
+import "./chunk-MSMTG6OC.js";
+import {
+  apiPost
+} from "./chunk-QEREDRZO.js";
+import "./chunk-JXTNP3B5.js";
+import "./chunk-45D6WRCJ.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-CCYZJMZ7.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/scheduled-agents/targets.ts
+import { defineCommand } from "citty";
+var ARGS = {
+  trigger: {
+    type: "string",
+    description: "The trigger kind to point, e.g. task.claimed. `baker scheduled-agents triggers --trigger <kind>` lists its `pointAt` fields.",
+    required: true
+  },
+  field: {
+    type: "string",
+    description: `Which of its narrowings to list: ${TRIGGER_TARGET_FIELD_IDS.join(", ")}. Defaults to the kind's first.`,
+    required: false
+  },
+  search: { type: "string", description: "Only options whose name contains this.", required: false },
+  form: {
+    type: "string",
+    description: "With --field stepId: the Form (slug) whose steps to list.",
+    required: false
+  },
+  app: {
+    type: "string",
+    description: "With --trigger app.event and --field appEvent or account: the connected tool (slug) to list for.",
+    required: false
+  },
+  event: {
+    type: "string",
+    description: "With --field appEvent --app <tool>: describe ONE event whole \u2014 every setting (description, default, examples) and every field it sends. Read it before narrowing.",
+    required: false
+  }
+};
+registerSchema({
+  command: "scheduled-agents.targets",
+  description: "What a trigger can be pointed at: the open Tasks, the company's scheduled agents, its review sources, followed competitors, pages, Forms and their steps, Knowledge collections, tools. Returns each option's value (pass it to the matching flag on create/update) with its name.",
+  args: ARGS
+});
+var targetsCommand = defineCommand({
+  meta: {
+    name: "targets",
+    description: `What a trigger can be pointed at \u2014 so "when a Task is picked up" becomes "when THIS Task is picked up".
+
+Each trigger's narrowings (\`pointAt\` in \`triggers\`) are chosen from a list, the same list the user's picker shows. Pass an option's \`value\` to the flag the response names; leave the flag off to run on any.
+
+Examples:
+  baker scheduled-agents targets --trigger task.claimed --field taskId --search hero
+  baker scheduled-agents targets --trigger session.published --field agentId
+  baker scheduled-agents targets --trigger flow.step.submitted --field stepId --form quote
+  baker scheduled-agents targets --trigger advertiser.new_ads
+  baker scheduled-agents targets --trigger app.event --field toolkit
+  baker scheduled-agents targets --trigger app.event --field appEvent --app gmail
+  baker scheduled-agents targets --trigger app.event --field appEvent --app gmail --event GMAIL_NEW_GMAIL_MESSAGE
+Full guide: __tooling__/docs/tools/baker/scheduled-agents.md`
+  },
+  args: ARGS,
+  run: async ({ args }) => {
+    const trigger = args.trigger;
+    if (!TRIGGER_KIND_IDS.some((kind) => kind === trigger)) {
+      failValidation(`--trigger must be one of: ${TRIGGER_KIND_IDS.join(", ")}.`);
+    }
+    try {
+      const response = await apiPost("/api/scheduled-agents/targets", {
+        trigger,
+        ...args.field ? { field: args.field } : {},
+        ...args.search ? { search: args.search } : {},
+        ...args.form ? { flowId: args.form } : {},
+        ...args.app ? { toolkit: args.app } : {},
+        ...args.event ? { event: args.event } : {},
+        ...chatBody()
+      });
+      writeJson(response);
+    } catch (err) {
+      failApi(err);
+    }
+  }
+});
+export {
+  targetsCommand
+};
+//# sourceMappingURL=targets-RG3NONXL.js.map

package/dist/testimonials-UOVGKW23.js

@@ -0,0 +1,32 @@
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/testimonials/index.ts
+import { defineCommand } from "citty";
+var testimonialsCommand = defineCommand({
+  meta: {
+    name: "testimonials",
+    description: `Find and browse testimonials in Baker, and manage the review pages they come from. Subcommands: search, get, list, delete, tags, sources.
+
+Examples:
+  baker testimonials search "great customer service" --limit 5
+  baker testimonials search "value for money" --rating-min 4
+  baker testimonials get <testimonial-id>
+  baker testimonials list --source google --sentiment positive
+  baker testimonials delete <testimonial-id> --dry-run
+  baker testimonials tags
+  baker testimonials sources add https://www.yelp.com/biz/acme-bakery-madrid
+Full guide: __tooling__/docs/tools/baker/testimonials.md`
+  },
+  subCommands: {
+    get: () => import("./get-TBMTBGHJ.js").then((m) => m.getCommand),
+    search: () => import("./search-563LZ4JQ.js").then((m) => m.searchCommand),
+    list: () => import("./list-LLLEF6YM.js").then((m) => m.listCommand),
+    delete: () => import("./delete-ZHGITRWJ.js").then((m) => m.deleteCommand),
+    tags: () => import("./tags-HN67SXIG.js").then((m) => m.tagsCommand),
+    sources: () => import("./sources-QSKRDIT5.js").then((m) => m.sourcesCommand)
+  }
+});
+export {
+  testimonialsCommand
+};
+//# sourceMappingURL=testimonials-UOVGKW23.js.map

package/dist/themes-WMZJWXFT.js

@@ -0,0 +1,95 @@
+import {
+  exitWithServiceReadError
+} from "./chunk-2LBQNTTH.js";
+import {
+  failWriteValidation,
+  listFlag,
+  requireCustomerId
+} from "./chunk-DFDV42NY.js";
+import "./chunk-ERSX3MKH.js";
+import "./chunk-CDTAKCJR.js";
+import "./chunk-4NZ47VXO.js";
+import "./chunk-D5FY4FAK.js";
+import "./chunk-4H6XLX7E.js";
+import "./chunk-QALAJNBG.js";
+import "./chunk-Q2JDS6WL.js";
+import {
+  getManagerIdForCustomer,
+  writeJsonEnvelope
+} from "./chunk-RBCO3C3Q.js";
+import "./chunk-Y5PNLB24.js";
+import "./chunk-N3PASNUA.js";
+import "./chunk-E56V3RFO.js";
+import "./chunk-EL3TDR5S.js";
+import "./chunk-G6U45QD3.js";
+import "./chunk-X6U3B6YK.js";
+import "./chunk-R7XDGNZD.js";
+import "./chunk-MSMTG6OC.js";
+import {
+  apiPost
+} from "./chunk-QEREDRZO.js";
+import "./chunk-JXTNP3B5.js";
+import "./chunk-45D6WRCJ.js";
+import {
+  registerSchema
+} from "./chunk-CCYZJMZ7.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/ads/google/keywords/themes.ts
+import { defineCommand } from "citty";
+var ARGS = {
+  "customer-id": { type: "string", description: "Google Ads customer ID (10 digits, no dashes)" },
+  keywords: { type: "string", description: "Comma-separated keywords to place" },
+  "ad-groups": {
+    type: "string",
+    description: "Comma-separated existing ad group ids (or resource names) to sort them into \u2014 read them with `ad-groups list`"
+  }
+};
+registerSchema({
+  command: "ads.google.keywords.themes",
+  description: "Which existing ad group each keyword belongs in, by Google's reading of the ad groups' themes (Keyword Planner GenerateAdGroupThemes). Start here: `baker ads google keywords themes --customer-id 1234567890 --keywords \"solar panels,heat pumps\" --ad-groups 111,222`. Returns suggestions (keyword \u2192 suggested keyword, match type, ad group) and unusable_ad_groups (ones Google could not read a theme from).",
+  args: Object.fromEntries(
+    Object.entries(ARGS).map(([name, arg]) => [
+      name,
+      { type: arg.type, description: arg.description, required: false }
+    ])
+  )
+});
+var themesCommand = defineCommand({
+  meta: {
+    name: "themes",
+    description: `Sort keywords into the existing ad groups whose theme fits them (Keyword Planner).
+
+Example:
+  baker ads google keywords themes --customer-id 1234567890 --keywords "solar panels,heat pumps" --ad-groups 111,222`
+  },
+  args: ARGS,
+  run: async ({ args }) => {
+    const customerId = requireCustomerId(args);
+    const keywords = listFlag(args.keywords);
+    const adGroups = listFlag(args["ad-groups"]);
+    if (!keywords?.length || !adGroups?.length) failWriteValidation("pass --keywords and --ad-groups");
+    const managerId = getManagerIdForCustomer(customerId);
+    try {
+      const { data } = await apiPost(
+        "/api/ads/google/keywords/themes",
+        {
+          customerId,
+          ...managerId ? { managerId } : {},
+          keywords,
+          adGroups
+        }
+      );
+      const hints = data.unusable_ad_groups.length > 0 ? [
+        `${data.unusable_ad_groups.length} ad group(s) gave Google no theme to match against (removed, empty or under a removed campaign) \u2014 they received no keywords.`
+      ] : [];
+      writeJsonEnvelope(hints.length > 0 ? { ok: true, data, hints } : { ok: true, data });
+    } catch (err) {
+      exitWithServiceReadError(err);
+    }
+  }
+});
+export {
+  themesCommand
+};
+//# sourceMappingURL=themes-WMZJWXFT.js.map

package/dist/top-companies-VNFPTJBI.js

@@ -0,0 +1,111 @@
+import {
+  csvOrJson,
+  daysAgoIso,
+  handleLinkedinError,
+  todayIso
+} from "./chunk-QML3FCJC.js";
+import {
+  TABLE_OUTPUT_FORMATS,
+  outputFormatRefusal,
+  writeAdsJson,
+  writeAdsOutput,
+  writeJsonEnvelope
+} from "./chunk-RBCO3C3Q.js";
+import {
+  NO_CACHE_ARG
+} from "./chunk-GO6ISZUZ.js";
+import "./chunk-7BV5QN2P.js";
+import "./chunk-QV6AST5T.js";
+import "./chunk-WCU362Z6.js";
+import "./chunk-GIWHHCD6.js";
+import "./chunk-SOPVIIUW.js";
+import "./chunk-G4FG5EQO.js";
+import "./chunk-R7XDGNZD.js";
+import "./chunk-MSMTG6OC.js";
+import {
+  apiPost
+} from "./chunk-QEREDRZO.js";
+import "./chunk-JXTNP3B5.js";
+import "./chunk-45D6WRCJ.js";
+import "./chunk-CCYZJMZ7.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/ads/linkedin/top-companies.ts
+import { defineCommand } from "citty";
+var COMPANIES_HINT = "For whole-account reach over months (one row per company, --by month|campaign, --with-domains), use `baker ads linkedin companies`.";
+var topCompaniesCommand = defineCommand({
+  meta: {
+    name: "top-companies",
+    description: `Top companies whose employees saw / clicked / converted on a campaign.
+
+Wrapper for: analytics --pivot company. Returns rows sorted by impressions desc.
+Each row's pivot[] contains { urn, id, name } \u2014 org names are resolved automatically.
+Cross-reference names against your target account list to spot audience leakage.
+
+Demographic data is delayed 12-24h with a \u22653-event privacy floor.
+
+Examples:
+  baker ads linkedin top-companies --campaign-id 1234 --last-days 30
+  baker ads linkedin top-companies --campaign-id 1,2,3 --intent revenue --last-days 90 --top-n 50
+  baker ads linkedin top-companies --campaign-id 1234 --output csv`
+  },
+  args: {
+    "campaign-id": { type: "string", description: "Comma-separated campaign IDs (required)" },
+    intent: { type: "string", description: "baseline | revenue | funnel | engagement | lead-gen (default: baseline)" },
+    "top-n": { type: "string", description: "Top rows by impressions (default: 25)" },
+    start: { type: "string", description: "Start date YYYY-MM-DD" },
+    end: { type: "string", description: "End date YYYY-MM-DD" },
+    "last-days": { type: "string", description: "Window relative to today (default: 30)" },
+    "no-cache": NO_CACHE_ARG,
+    output: { type: "string", description: "json|csv|jsonl|md", default: "json" }
+  },
+  run: async ({ args }) => {
+    const campaignIdsRaw = args["campaign-id"];
+    const invalid = !campaignIdsRaw ? "--campaign-id is required: one campaign id, or several comma-separated. For every company the whole ad account reached, use `baker ads linkedin companies`." : outputFormatRefusal(csvOrJson(args), TABLE_OUTPUT_FORMATS);
+    if (invalid !== null || !campaignIdsRaw) {
+      writeAdsJson({ ok: false, error: { code: "INVALID_ARGS", message: invalid ?? "" } });
+      process.exit(1);
+    }
+    const ids = campaignIdsRaw.split(",").map((s) => s.trim()).filter(Boolean);
+    const intent = args.intent ?? "baseline";
+    const topN = args["top-n"] ? Number(args["top-n"]) : 25;
+    const start = args.start ?? daysAgoIso(args["last-days"] ? Number(args["last-days"]) : 30);
+    const end = args.end ?? todayIso();
+    try {
+      const data = await apiPost("/api/ads/linkedin/analytics", {
+        request: {
+          level: "campaign",
+          ids,
+          intent,
+          pivot: "company",
+          start,
+          end,
+          granularity: "ALL",
+          limit: 500
+        },
+        skipCache: Boolean(args["no-cache"])
+      });
+      const top = [...data.rows].sort((a, b) => Number(b.impressions ?? 0) - Number(a.impressions ?? 0)).slice(0, topN);
+      const fmt = csvOrJson(args);
+      if (fmt !== "json") {
+        writeAdsOutput(top, fmt, data.fields, [COMPANIES_HINT]);
+        return;
+      }
+      writeJsonEnvelope({
+        ok: true,
+        data: {
+          query: { campaigns: ids, start, end, intent, topN },
+          rows: top,
+          warnings: data.warnings
+        },
+        hints: [COMPANIES_HINT]
+      });
+    } catch (err) {
+      handleLinkedinError(err);
+    }
+  }
+});
+export {
+  topCompaniesCommand
+};
+//# sourceMappingURL=top-companies-VNFPTJBI.js.map