@koda-sl/baker-cli 0.452.0-dev.b7636f278 → 0.453.0-dev.914a088e4

package/dist/normalize-L2YLADVY.js

@@ -0,0 +1,141 @@
+import {
+  flowDataPath,
+  listFlowSlugs,
+  readFlowTree,
+  walkNodes,
+  writeFlowTree
+} from "./chunk-ILBL7RHT.js";
+import {
+  looksLikeUnresolvedVariable,
+  parseEmailRecipients
+} from "./chunk-IDYAVGCS.js";
+import "./chunk-GXDLWBOY.js";
+import "./chunk-TEINLN64.js";
+import "./chunk-ZJWUBJYQ.js";
+import "./chunk-NE4F3FHN.js";
+import "./chunk-PCKVSSVT.js";
+import "./chunk-MCM3HMNZ.js";
+import "./chunk-UW36KPPH.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-NU7JSWVA.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/flows/normalize.ts
+import { defineCommand } from "citty";
+var OPTIONAL_STRINGS = ["oauthProviderId"];
+var ARRAY_FIELDS = [
+  "fieldMapping",
+  "columnMapping",
+  "payloadKeys",
+  "eventParams",
+  "eventProperties",
+  "dataLayerParams",
+  "goalParams",
+  "fields",
+  "tagIds"
+];
+var ARRAY_OWNERS = ["", "body"];
+function dropUnsetOptionals(sideEffect, path) {
+  return OPTIONAL_STRINGS.flatMap((key) => {
+    if (!(key in sideEffect) || sideEffect[key] !== null && sideEffect[key] !== "") return [];
+    delete sideEffect[key];
+    return [{ path, change: `dropped \`${key}\` (an optional string is absent, never null)` }];
+  });
+}
+function fillNulledArrays(target, prefix, path) {
+  return ARRAY_FIELDS.flatMap((key) => {
+    if (!(key in target) || target[key] !== null) return [];
+    target[key] = [];
+    return [{ path, change: `\`${prefix}${key}: null\` \u2192 \`[]\`` }];
+  });
+}
+function tidyEmailRecipients(sideEffect, path) {
+  if (sideEffect.type !== "email") return [];
+  const config = sideEffect.encryptedConfig;
+  if (!config || typeof config !== "object" || Array.isArray(config)) return [];
+  const raw = config.email;
+  if (typeof raw !== "string" || looksLikeUnresolvedVariable(raw)) return [];
+  const { to, invalid } = parseEmailRecipients(raw);
+  if (invalid.length > 0 || to.length === 0) return [];
+  const tidied = to.join(", ");
+  if (tidied === raw) return [];
+  config.email = tidied;
+  return [{ path, change: "tidied the recipient list's spacing and separators" }];
+}
+function sideEffectsOf(node) {
+  if (!Array.isArray(node.sideEffects)) return [];
+  return node.sideEffects.filter(
+    (sideEffect) => Boolean(sideEffect) && typeof sideEffect === "object"
+  );
+}
+function normalizeSideEffect(sideEffect, where) {
+  const path = `${where} \u2192 ${String(sideEffect.id ?? "side effect")}`;
+  const arrays = ARRAY_OWNERS.flatMap((owner) => {
+    const target = owner ? sideEffect[owner] : sideEffect;
+    if (!target || typeof target !== "object") return [];
+    return fillNulledArrays(target, owner ? `${owner}.` : "", path);
+  });
+  return [...dropUnsetOptionals(sideEffect, path), ...arrays, ...tidyEmailRecipients(sideEffect, path)];
+}
+function normalizeFlowTree(tree) {
+  const changes = [];
+  for (const node of walkNodes(tree)) {
+    const where = typeof node.name === "string" && node.name ? String(node.name) : String(node.id ?? "node");
+    if (!("condition" in node)) {
+      node.condition = null;
+      changes.push({ path: where, change: "added the missing `condition: null`" });
+    }
+    for (const sideEffect of sideEffectsOf(node)) {
+      changes.push(...normalizeSideEffect(sideEffect, where));
+    }
+  }
+  return changes;
+}
+registerSchema({
+  command: "flows.normalize",
+  description: "Fix the shapes a form file is allowed to get slightly wrong: a nulled optional string, a nulled array, a missing condition. Runs automatically before a commit; you rarely need to call it.",
+  args: {
+    slug: { type: "positional", description: "Form slug. Omit to check every form.", required: false },
+    write: {
+      type: "boolean",
+      description: "Apply the fixes. Without it, reports and changes nothing",
+      required: false
+    }
+  }
+});
+var normalizeCommand = defineCommand({
+  meta: {
+    name: "normalize",
+    description: "Repair the shapes a form file is allowed to get slightly wrong. Example: baker flows normalize contact --write"
+  },
+  args: {
+    // `required: false` matters: citty makes a positional required by default,
+    // so without it the documented bare `baker flows normalize` printed a wall
+    // of usage text and exited 1 instead of checking every form.
+    slug: { type: "positional", description: "Form slug (omit for every form)", required: false },
+    write: { type: "boolean", description: "Apply the fixes" }
+  },
+  run: ({ args }) => {
+    const slugs = args.slug ? [String(args.slug)] : listFlowSlugs();
+    const forms = slugs.flatMap((slug) => {
+      const tree = readFlowTree(slug);
+      const changes = normalizeFlowTree(tree);
+      if (changes.length === 0) return [];
+      if (args.write === true) writeFlowTree(slug, tree);
+      return [{ slug, path: flowDataPath(slug), changes }];
+    });
+    const total = forms.reduce((sum, form) => sum + form.changes.length, 0);
+    writeJson({
+      ok: true,
+      data: { forms, changed: total, written: args.write === true },
+      hints: total === 0 ? ["Nothing to fix."] : args.write === true ? [`Fixed ${total} field(s).`] : [`${total} field(s) can be fixed. Re-run with --write.`]
+    });
+  }
+});
+export {
+  normalizeCommand,
+  normalizeFlowTree
+};
+//# sourceMappingURL=normalize-L2YLADVY.js.map

package/dist/options-4E7HRXDT.js

@@ -0,0 +1,121 @@
+import {
+  destinationRefusal
+} from "./chunk-HVXY4XHT.js";
+import "./chunk-DARR7VGA.js";
+import "./chunk-ILBL7RHT.js";
+import {
+  failApi
+} from "./chunk-FSLFQHWG.js";
+import {
+  FLOW_AGENT_DESTINATION_KINDS
+} from "./chunk-IDYAVGCS.js";
+import "./chunk-GXDLWBOY.js";
+import "./chunk-TEINLN64.js";
+import "./chunk-ZJWUBJYQ.js";
+import "./chunk-NE4F3FHN.js";
+import {
+  ApiError,
+  apiPost
+} from "./chunk-PCKVSSVT.js";
+import "./chunk-MCM3HMNZ.js";
+import "./chunk-UW36KPPH.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-NU7JSWVA.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/flows/options.ts
+import { defineCommand } from "citty";
+var HUBSPOT_KINDS = {
+  hubspot: "baker hubspot forms list",
+  hubspotForm: "baker hubspot forms list",
+  hubspotMeeting: "baker hubspot meetings list"
+};
+function optionsHints(data) {
+  const { kind, options } = data;
+  if (kind === "pipedrive" || kind === "goHighlevelContact") {
+    return [
+      `Nothing to choose: the connected account is the destination. Wire it: baker flows connect <slug> --side-effect <id> (or --all --type ${kind}).`
+    ];
+  }
+  if (kind === "googleSpreadsheet") {
+    return [
+      "These are the only spreadsheets Baker can reach: ones someone chose for a Form before, and ones Baker created. Pick one: baker flows connect <slug> --side-effect <id> --resource <id> [--tab <name>].",
+      'None fits? Create one yourself: baker flows connect <slug> --side-effect <id> --new-sheet "<Form name> leads" --columns "Name,Email,\u2026". Only when the user wants their own existing sheet: request_flow_input.'
+    ];
+  }
+  const empty = options.length === 0 ? ["The account has none. Tell the user what to create there, or skip this step \u2014 do not invent one."] : [];
+  return [
+    ...empty,
+    `Fill the step: baker flows connect <slug> --node <stepId> --resource <id> (or --all --type ${kind}). One clear match \u2192 use it; several plausible \u2192 ask the user which.`
+  ];
+}
+registerSchema({
+  command: "flows.options",
+  description: "What a Form step or destination can be filled with, read from the connected account: Calendly events, SavvyCal links, GoHighLevel calendars and forms, the Google spreadsheets Baker can reach. Pipedrive and GoHighLevel contact have nothing to choose \u2014 the account is the destination. Next: `baker flows connect <slug> --node|--side-effect <id> --resource <id>`. HubSpot has its own: `baker hubspot forms list` / `meetings list`.",
+  args: {
+    kind: {
+      type: "positional",
+      description: `One of: ${FLOW_AGENT_DESTINATION_KINDS.join(", ")}`,
+      required: true
+    },
+    account: {
+      type: "string",
+      description: "Connection id, when more than one account of the platform is connected",
+      required: false
+    }
+  }
+});
+var optionsCommand = defineCommand({
+  meta: {
+    name: "options",
+    description: "What a step or destination can be filled with, from the connected account. Start here: baker flows options calendly"
+  },
+  args: {
+    kind: { type: "positional", description: FLOW_AGENT_DESTINATION_KINDS.join(" | "), required: true },
+    account: { type: "string", description: "Connection id when several are connected" }
+  },
+  run: async ({ args }) => {
+    const kind = String(args.kind);
+    const hubspot = HUBSPOT_KINDS[kind];
+    if (hubspot) {
+      writeJson({ ok: false, error: { code: "VALIDATION_ERROR", message: `HubSpot has its own list: ${hubspot}.` } });
+      process.exit(1);
+    }
+    if (!FLOW_AGENT_DESTINATION_KINDS.includes(kind)) {
+      writeJson({
+        ok: false,
+        error: {
+          code: "VALIDATION_ERROR",
+          message: `"${kind}" is not filled from a platform account.`,
+          fix: `Kinds: ${FLOW_AGENT_DESTINATION_KINDS.join(", ")}. Typed credentials (webhooks, Zapier, Crmble) go through request_flow_input.`
+        }
+      });
+      process.exit(1);
+    }
+    try {
+      const { data } = await apiPost("/api/flows/destinations/options", {
+        kind,
+        ...args.account ? { account: String(args.account) } : {}
+      });
+      writeJson({
+        ok: true,
+        data: { ...data, accounts: data.accounts.length > 1 ? data.accounts : void 0 },
+        hints: optionsHints(data)
+      });
+    } catch (err) {
+      const refusal = err instanceof ApiError ? destinationRefusal(kind, err) : null;
+      if (err instanceof ApiError && refusal !== null) {
+        writeJson({ ok: false, error: { code: refusal.code, message: err.message, fix: refusal.fix } });
+        process.exit(1);
+      }
+      failApi(err);
+    }
+  }
+});
+export {
+  optionsCommand,
+  optionsHints
+};
+//# sourceMappingURL=options-4E7HRXDT.js.map

package/dist/output-5NZNSC3O.js

@@ -0,0 +1,24 @@
+import {
+  TABLE_OUTPUT_FORMATS,
+  outputFormatRefusal,
+  resolveCustomerId,
+  toCsvRow,
+  writeAdsJson,
+  writeAdsOutput,
+  writeJsonEnvelope
+} from "./chunk-XNMSJP2X.js";
+import "./chunk-PCKVSSVT.js";
+import "./chunk-MCM3HMNZ.js";
+import "./chunk-UW36KPPH.js";
+import "./chunk-NU7JSWVA.js";
+import "./chunk-YQSBHWOI.js";
+export {
+  TABLE_OUTPUT_FORMATS,
+  outputFormatRefusal,
+  resolveCustomerId,
+  toCsvRow,
+  writeAdsJson,
+  writeAdsOutput,
+  writeJsonEnvelope
+};
+//# sourceMappingURL=output-5NZNSC3O.js.map

package/dist/page-YWEDNDHD.js

@@ -0,0 +1,105 @@
+import {
+  INSPIRATION_HINTS,
+  reportError,
+  staleCopyHint
+} from "./chunk-QSQGGONQ.js";
+import {
+  apiGet
+} from "./chunk-PCKVSSVT.js";
+import "./chunk-MCM3HMNZ.js";
+import "./chunk-UW36KPPH.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-NU7JSWVA.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/landing/inspiration/page.ts
+import { defineCommand } from "citty";
+registerSchema({
+  command: "landing.inspiration.page",
+  description: "Show a whole reference page as a sequence: every section top to bottom with its type and the idea behind it. This is the view to use when the question is how a good page is ORDERED rather than what one section looks like.",
+  args: {
+    id: {
+      type: "string",
+      description: "Page id \u2014 the `page_id` on any search result or favorites row",
+      required: true
+    },
+    full: {
+      type: "boolean",
+      description: "Add the transferable idea behind every section. A long page roughly triples the response",
+      required: false
+    }
+  }
+});
+var pageCommand = defineCommand({
+  meta: {
+    name: "page",
+    description: "Show how a reference page sequences its sections. Example: baker landing inspiration page j91xyz\u2026 \u2014 the blueprint, not the pixels."
+  },
+  args: {
+    id: { type: "positional", description: "Page id (the `page_id` on a search result)", required: true },
+    full: { type: "boolean", description: "Include why_it_works per section", required: false, default: false }
+  },
+  run: async ({ args }) => {
+    try {
+      const data = await apiGet("/api/landing-inspiration/page", { id: args.id });
+      if (data.status !== "indexed") {
+        writeJson({
+          ok: true,
+          data: { id: data.id, url: data.url, status: data.status, sections: [] },
+          hints: [
+            data.status === "error" ? "We couldn't read this page. Try a different address, or a different page on the same site." : "Still being studied \u2014 check back later in the turn or in a later one."
+          ]
+        });
+        return;
+      }
+      const full = args.full;
+      writeJson({
+        ok: true,
+        data: {
+          id: data.id,
+          url: data.url,
+          domain: data.domain,
+          title: data.title,
+          archetype: data.archetype,
+          stack: data.detectedStack,
+          page_fidelity: data.pageFidelity,
+          read_at: data.studiedAt ? new Date(data.studiedAt).toISOString().slice(0, 10) : null,
+          ...data.refreshFailedAt ? { refresh_failed_at: new Date(data.refreshFailedAt).toISOString().slice(0, 10) } : {},
+          blueprint: data.sectionOrder,
+          sections: data.sections.map((section) => ({
+            id: section.id,
+            position: section.index,
+            section: section.sectionType,
+            composition: section.composition,
+            look: section.visualRegister,
+            motion: section.motionSummary,
+            craft: section.craftScore,
+            // Behind --full. This command exists to answer an ordering
+            // question, and `blueprint` answers it in a line; a 600-character
+            // paragraph per section turned a 40-section page into ~5,900 tokens
+            // of material about individual sections nobody had chosen yet.
+            ...full ? { why_it_works: section.whyItWorks } : {}
+          }))
+        },
+        hints: [
+          "The blueprint is the section order top to bottom \u2014 the answer to 'how do good pages in this category sequence themselves'.",
+          "Use `baker landing inspiration view <section id>` for any section worth a closer look.",
+          ...full ? [] : ["Add --full for the idea behind every section, once you know which page you care about."],
+          INSPIRATION_HINTS.adapt,
+          ...[staleCopyHint(data.studiedAt, data.filedUrl)].filter((hint) => hint !== null),
+          ...data.refreshFailedAt ? [
+            "The last attempt to read this page again failed, so this is the earlier copy. Tell the user if the live page may differ."
+          ] : []
+        ]
+      });
+    } catch (error) {
+      reportError(error);
+    }
+  }
+});
+export {
+  pageCommand
+};
+//# sourceMappingURL=page-YWEDNDHD.js.map

package/dist/pages-WHX335W4.js

@@ -0,0 +1,66 @@
+import {
+  csvOrJson,
+  handleMetaError
+} from "./chunk-VSA63D2N.js";
+import {
+  writeAdsOutput,
+  writeJsonEnvelope
+} from "./chunk-XNMSJP2X.js";
+import {
+  NO_CACHE_ARG
+} from "./chunk-X7ZODEXJ.js";
+import {
+  apiGet
+} from "./chunk-PCKVSSVT.js";
+import "./chunk-MCM3HMNZ.js";
+import "./chunk-UW36KPPH.js";
+import "./chunk-NU7JSWVA.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/ads/meta/pages.ts
+import { defineCommand } from "citty";
+function pageSelectionHints(data) {
+  if (data.length === 0) return [];
+  const accountHint = "Use a Page only with an ad account listed in its promotingAccountIds. hasPageAccessToken must be true to read instant forms; null means Meta could not check it. Form reads also require the company's lead-ads permissions.";
+  if (data.length > 1) {
+    return [
+      accountHint,
+      "MULTIPLE Pages can run ads from the selected Meta ad accounts \u2014 do NOT guess. Confirm with the user which Page an ad should run from before passing --page to `creatives create`; a wrong Page publishes the ad under the wrong brand identity and staging will not catch it."
+    ];
+  }
+  return [accountHint];
+}
+var pagesCommand = defineCommand({
+  meta: {
+    name: "pages",
+    description: `List the Facebook Pages that the selected Meta ad accounts can promote, showing which accounts can promote each Page. Every Meta ad publishes from a Page, so match its promotingAccountIds to the target account. hasPageAccessToken shows whether the connected person can also read that Page's instant forms. If more than one Page is listed, confirm the brand with the user.
+
+Examples:
+  baker ads meta pages`
+  },
+  args: {
+    "no-cache": NO_CACHE_ARG,
+    output: { type: "string", description: "Output format", default: "json" }
+  },
+  run: async ({ args }) => {
+    try {
+      const params = {};
+      if (args["no-cache"]) params["skip-cache"] = "true";
+      const data = await apiGet("/api/ads/meta/pages", params);
+      const fmt = csvOrJson(args);
+      if (fmt !== "json") {
+        writeAdsOutput(data, fmt);
+        return;
+      }
+      const hints = pageSelectionHints(data);
+      writeJsonEnvelope(hints.length > 0 ? { ok: true, data, hints } : { ok: true, data });
+    } catch (err) {
+      handleMetaError(err);
+    }
+  }
+});
+export {
+  pageSelectionHints,
+  pagesCommand
+};
+//# sourceMappingURL=pages-WHX335W4.js.map

package/dist/performance-GUKG5TIN.js

@@ -0,0 +1,24 @@
+import {
+  definitionInsights,
+  parseDays,
+  performanceCommand,
+  withDefinitions
+} from "./chunk-UBEBUUTQ.js";
+import "./chunk-FSLFQHWG.js";
+import "./chunk-IDYAVGCS.js";
+import "./chunk-GXDLWBOY.js";
+import "./chunk-TEINLN64.js";
+import "./chunk-ZJWUBJYQ.js";
+import "./chunk-NE4F3FHN.js";
+import "./chunk-PCKVSSVT.js";
+import "./chunk-MCM3HMNZ.js";
+import "./chunk-UW36KPPH.js";
+import "./chunk-NU7JSWVA.js";
+import "./chunk-YQSBHWOI.js";
+export {
+  definitionInsights,
+  parseDays,
+  performanceCommand,
+  withDefinitions
+};
+//# sourceMappingURL=performance-GUKG5TIN.js.map

package/dist/pinterest-BRDL2KLT.js

@@ -0,0 +1,96 @@
+import {
+  AUTO_INGEST_MAX,
+  parseAutoIngest
+} from "./chunk-KKJ4KJCW.js";
+import {
+  ApiError,
+  apiPost
+} from "./chunk-PCKVSSVT.js";
+import "./chunk-MCM3HMNZ.js";
+import "./chunk-UW36KPPH.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-NU7JSWVA.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/images/pinterest.ts
+import { defineCommand } from "citty";
+registerSchema({
+  command: "images.pinterest",
+  description: "Pinterest image search via ScrapeCreators. Reference-grade real-world photography, product styling, interiors, fashion, food, and aesthetic mood boards. Inspect before placing \u2014 Pinterest is unverified, trademark-bearing web content.",
+  args: {
+    query: { type: "string", description: "Search query", required: true },
+    limit: { type: "number", description: "Max results (1-20, default 5)", required: false, default: 5 },
+    "auto-ingest": {
+      type: "number",
+      description: `Auto-ingest top N (0-${AUTO_INGEST_MAX.pinterest}, 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 the pin title)",
+      required: false
+    }
+  }
+});
+var pinterestCommand = defineCommand({
+  meta: {
+    name: "pinterest",
+    description: "Pinterest image search via ScrapeCreators ($0.00188/request). Best for photo-realistic reference imagery \u2014 lifestyle, interiors, fashion, food, product styling, and mood boards to brief AI generation against. \u26A0 Unverified, trademark-bearing web content \u2014 inspect and respect rights before placing on a customer page. Browse first; auto-ingest only the pins you commit to.\n\nExamples:\n  baker images pinterest 'scandinavian living room'\n  baker images pinterest 'minimalist skincare product photography' --limit 20\n  baker images pinterest 'cozy coffee shop interior' --auto-ingest 2 --context 'Mood reference for hero photography'"
+  },
+  args: {
+    query: { type: "positional", description: "Search query", required: false },
+    limit: { type: "string", description: "Max results (1-20)", required: false },
+    "auto-ingest": {
+      type: "string",
+      description: `Auto-ingest top N (0-${AUTO_INGEST_MAX.pinterest}) and return Baker-owned URLs on ingested hits`,
+      required: false
+    },
+    context: { type: "string", description: "Description context hint applied to auto-ingested hits", required: false }
+  },
+  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.limit) body.limit = Number(args.limit);
+      if (args["auto-ingest"] !== void 0) {
+        const parsed = parseAutoIngest(args["auto-ingest"], AUTO_INGEST_MAX.pinterest);
+        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.pinterest}.`
+              }
+            }
+          });
+          process.exit(1);
+        }
+        body.autoIngest = parsed.value;
+      }
+      if (args.context) body.descriptionContext = args.context;
+      const data = await apiPost("/api/images/pinterest", body);
+      writeJson({ ok: true, data });
+    } 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 {
+  pinterestCommand
+};
+//# sourceMappingURL=pinterest-BRDL2KLT.js.map

package/dist/pixels-3LBWIFAX.js

@@ -0,0 +1,108 @@
+import {
+  csvOrJson,
+  daysAgoIso,
+  handleMetaError,
+  resolveAccountIdArg,
+  todayIso
+} from "./chunk-VSA63D2N.js";
+import {
+  writeAdsJson,
+  writeAdsOutput
+} from "./chunk-XNMSJP2X.js";
+import {
+  NO_CACHE_ARG
+} from "./chunk-X7ZODEXJ.js";
+import {
+  apiGet
+} from "./chunk-PCKVSSVT.js";
+import "./chunk-MCM3HMNZ.js";
+import "./chunk-UW36KPPH.js";
+import "./chunk-NU7JSWVA.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/ads/meta/pixels.ts
+import { defineCommand } from "citty";
+var pixelsCommand = defineCommand({
+  meta: {
+    name: "pixels",
+    description: `List Meta Pixels for an ad account, or fetch firing stats for one pixel.
+
+Examples:
+  baker ads meta pixels --account-id act_123
+  baker ads meta pixels --account-id act_123 --pixel-id 9876 --stats --days 7`
+  },
+  args: {
+    "account-id": { type: "string", description: "Meta ad account ID" },
+    "pixel-id": { type: "string", description: "Pixel ID for --stats" },
+    stats: { type: "boolean", description: "Fetch firing stats for the pixel" },
+    aggregation: {
+      type: "string",
+      description: "stats aggregation: event|browser_type|host|pixel_fire",
+      default: "event"
+    },
+    days: { type: "string", description: "Lookback days for --stats (default 7)" },
+    "no-cache": NO_CACHE_ARG,
+    output: { type: "string", description: "Output format", default: "json" }
+  },
+  run: async ({ args }) => {
+    try {
+      if (args.stats) {
+        await runStats(args);
+        return;
+      }
+      await runList(args);
+    } catch (err) {
+      handleMetaError(err);
+    }
+  }
+});
+async function runStats(args) {
+  const pixelId = args["pixel-id"];
+  if (!pixelId) {
+    handleMetaError(new Error("--pixel-id is required when --stats is set"));
+  }
+  const days = args.days ? Number(args.days) : 7;
+  if (!Number.isInteger(days) || days <= 0 || days > 90) {
+    handleMetaError(new Error("--days must be a positive integer \u2264 90"));
+  }
+  const params = {
+    "pixel-id": pixelId,
+    aggregation: args.aggregation ?? "event",
+    "start-time": daysAgoIso(days),
+    "end-time": todayIso()
+  };
+  if (args["no-cache"]) params["skip-cache"] = "true";
+  const data = await apiGet("/api/ads/meta/pixel-stats", params);
+  emit(data, args);
+}
+async function runList(args) {
+  const accountId = resolveAccountIdArg(args);
+  const params = { "account-id": accountId };
+  if (args["no-cache"]) params["skip-cache"] = "true";
+  const { pixels, restrictedFields } = await apiGet("/api/ads/meta/pixels", params);
+  emit(pixels, args, pixelWarnings(restrictedFields));
+}
+function pixelWarnings(restrictedFields) {
+  if (restrictedFields.length === 0) {
+    return [];
+  }
+  return [
+    {
+      code: "PIXEL_FIELDS_RESTRICTED",
+      message: `Meta withheld ${restrictedFields.join(", ")} for these pixels \u2014 the connected user holds no role in the Business that owns them. IDs, names, creation and last-fired times are complete; install code and setup details are not. To get them, the client assigns the pixel to the connected user in Meta Business settings \u2192 Data sources \u2192 Datasets.`
+    }
+  ];
+}
+function emit(data, args, warnings = []) {
+  const fmt = csvOrJson(args);
+  if (fmt !== "json") {
+    writeAdsOutput(data, fmt);
+    return;
+  }
+  writeAdsJson({ ok: true, data, ...warnings.length > 0 ? { warnings } : {} });
+}
+export {
+  pixelWarnings,
+  pixelsCommand
+};
+//# sourceMappingURL=pixels-3LBWIFAX.js.map