@koda-sl/baker-cli 0.465.0 → 0.466.0

package/dist/landings-U3DAXGGO.js

@@ -0,0 +1,151 @@
+import {
+  reportError,
+  splitList
+} from "./chunk-PUG75EC5.js";
+import {
+  apiGet,
+  apiPost
+} from "./chunk-P5NYZ236.js";
+import "./chunk-7JB56IVP.js";
+import "./chunk-XMS5K54U.js";
+import {
+  LANDING_ANALYSE_BATCH,
+  registerSchema,
+  writeJson
+} from "./chunk-MEBOQXW3.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/winning-ads/landings.ts
+import { defineCommand } from "citty";
+registerSchema({
+  command: "winning-ads.landings",
+  description: "Every landing page one brand's ads send people to, the ones in use now first (a short or tracking link counts as the page it opens; Instant Forms, chats, app stores and social profiles are not pages): how many ads point there, how many still run, platforms, when each was used (`used`: one stretch per run of ads, `\u2192 now` while running), `address_only` on an address only Google search ads print (Google publishes no search ad's real destination, and the path need not exist \u2014 not analysed), and \u2014 once analysed \u2014 the page's headline, value propositions, offer, pricing, CTAs, proof, audience and sections in order. Compact by default; --full returns every field, the ads behind each page and its screenshot. --analyse studies the top pages not yet analysed (a few minutes each).",
+  args: {
+    advertiser: { type: "string", description: "Advertiser id (from `advertisers` or `following`)", required: true },
+    platform: { type: "string", description: "Only this platform: meta|linkedin|tiktok|google", required: false },
+    full: { type: "boolean", description: "Every field of every page", required: false, default: false },
+    analyse: {
+      type: "boolean",
+      description: `Analyse the top ${LANDING_ANALYSE_BATCH} pages not analysed yet (or those named in --pages)`,
+      required: false,
+      default: false
+    },
+    pages: {
+      type: "string",
+      description: `With --analyse: comma list of page urls to analyse instead (max ${LANDING_ANALYSE_BATCH})`,
+      required: false
+    }
+  }
+});
+var COMPACT_PAGES = 20;
+var COMPACT_VALUE_PROPS = 3;
+var day = (iso) => iso.slice(0, 10);
+function compactPage(p) {
+  const pitch = p.analysis.pitch;
+  return {
+    url: p.canonical_url,
+    in_use_now: p.active_ads > 0,
+    ads: p.ads,
+    running: p.active_ads,
+    platforms: p.platforms,
+    used: p.windows.map((w) => `${day(w.from)} \u2192 ${w.to ? day(w.to) : "now"}`),
+    last_seen_at: p.last_seen_at,
+    ...p.address_only ? { address_only: true } : {},
+    analysis: p.analysis.status,
+    ...pitch ? {
+      headline: pitch.headline,
+      value_propositions: pitch.value_propositions.slice(0, COMPACT_VALUE_PROPS),
+      offer: pitch.offer
+    } : {}
+  };
+}
+function compactLandings(report) {
+  return {
+    advertiser_id: report.advertiser_id,
+    total_pages: report.total_pages,
+    analysed: report.pages.filter((p) => p.analysis.status === "ready").length,
+    pages: report.pages.slice(0, COMPACT_PAGES).map(compactPage)
+  };
+}
+function pagesToAnalyse(report) {
+  return report.pages.filter((p) => !p.address_only && (p.analysis.status === "not_analysed" || p.analysis.status === "failed")).slice(0, LANDING_ANALYSE_BATCH).map((p) => p.canonical_url);
+}
+function landingsHints(report, advertiser) {
+  const hints = [];
+  const top = report.pages.slice(0, COMPACT_PAGES);
+  const pending = top.filter((p) => !p.address_only && p.analysis.status === "not_analysed").length;
+  const addressOnly = report.pages.filter((p) => p.address_only).length;
+  const analysing = report.pages.filter((p) => p.analysis.status === "analysing").length;
+  if (report.pages.length === 0) {
+    hints.push("No ad of this brand links to a landing page yet.");
+    return hints;
+  }
+  if (addressOnly > 0) {
+    hints.push(
+      `${addressOnly} ${addressOnly === 1 ? "address" : "addresses"} only Google search ads show (\`address_only\`): Google publishes no search ad's destination, only the address printed on it, whose path the brand types freely and need not exist. Quote it as the address the ad shows, never as a page the ads lead to; it is not analysed.`
+    );
+  }
+  if (pending > 0) {
+    hints.push(
+      `${pending} of the top pages are not analysed yet: \`baker winning-ads landings ${advertiser} --analyse\` studies the top ${LANDING_ANALYSE_BATCH} (value propositions, offer, pricing, proof, sections). It takes a few minutes; run this again to read them.`
+    );
+  }
+  if (analysing > 0) {
+    hints.push(`${analysing} pages are being analysed now: run this again in a few minutes.`);
+  }
+  if (report.pages.some((p) => p.analysis.status === "ready")) {
+    hints.push(
+      "--full returns each analysed page's whole read: pricing, CTAs, proof, audience and its sections in order."
+    );
+  }
+  return hints;
+}
+var landingsCommand = defineCommand({
+  meta: {
+    name: "landings",
+    description: "Every landing page a brand's ads point to, with how the page sells once analysed. Start here: baker winning-ads landings adv_123 (--analyse to study the top pages not analysed yet, --full for everything)"
+  },
+  args: {
+    advertiser: { type: "positional", description: "Advertiser id", required: true },
+    platform: { type: "string", description: "Only this platform: meta|linkedin|tiktok|google", required: false },
+    full: { type: "boolean", description: "Every field of every page", required: false, default: false },
+    analyse: {
+      type: "boolean",
+      description: `Analyse the top ${LANDING_ANALYSE_BATCH} pages not analysed yet`,
+      required: false,
+      default: false
+    },
+    pages: { type: "string", description: "With --analyse: comma list of page urls to analyse", required: false }
+  },
+  run: async ({ args }) => {
+    try {
+      const advertiser = String(args.advertiser);
+      const params = { advertiser };
+      if (args.platform) params.platform = String(args.platform);
+      let report = await apiGet("/api/ad-library/landing-pages", params);
+      let started;
+      if (args.analyse) {
+        const named = args.pages ? splitList(String(args.pages)) : [];
+        const urls = named.length > 0 ? named.slice(0, LANDING_ANALYSE_BATCH) : pagesToAnalyse(report);
+        if (urls.length > 0) {
+          started = (await apiPost("/api/ad-library/landing-pages/analyse", { urls })).pages;
+          report = await apiGet("/api/ad-library/landing-pages", params);
+        }
+      }
+      writeJson({
+        ok: true,
+        data: { ...args.full ? report : compactLandings(report), ...started ? { analyse: started } : {} },
+        hints: landingsHints(report, advertiser)
+      });
+    } catch (err) {
+      reportError(err);
+    }
+  }
+});
+export {
+  compactLandings,
+  landingsCommand,
+  landingsHints,
+  pagesToAnalyse
+};
+//# sourceMappingURL=landings-U3DAXGGO.js.map

package/dist/languages-KEB6NUWX.js

@@ -0,0 +1,55 @@
+import {
+  writeResearchJson
+} from "./chunk-PM7ZSDKG.js";
+import "./chunk-P5NYZ236.js";
+import "./chunk-7JB56IVP.js";
+import "./chunk-XMS5K54U.js";
+import {
+  registerSchema
+} from "./chunk-MEBOQXW3.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/research/languages.ts
+import { defineCommand } from "citty";
+registerSchema({
+  command: "research.languages",
+  description: "List all supported language codes for --language flag in research commands.",
+  args: {}
+});
+var LANGUAGES = [
+  { code: "en", name: "english" },
+  { code: "es", name: "spanish" },
+  { code: "fr", name: "french" },
+  { code: "de", name: "german" },
+  { code: "it", name: "italian" },
+  { code: "pt", name: "portuguese" },
+  { code: "nl", name: "dutch" },
+  { code: "ja", name: "japanese" },
+  { code: "ko", name: "korean" },
+  { code: "zh", name: "chinese" },
+  { code: "ar", name: "arabic" },
+  { code: "ru", name: "russian" },
+  { code: "pl", name: "polish" },
+  { code: "tr", name: "turkish" },
+  { code: "sv", name: "swedish" },
+  { code: "no", name: "norwegian" },
+  { code: "da", name: "danish" },
+  { code: "fi", name: "finnish" }
+];
+var FIELDS = {
+  code: "Language code to pass as --language",
+  name: "Language name (also accepted by --language)"
+};
+var languagesCommand = defineCommand({
+  meta: {
+    name: "languages",
+    description: "List all supported language codes for --language flag."
+  },
+  run: () => {
+    writeResearchJson({ ok: true, data: LANGUAGES, fields: FIELDS });
+  }
+});
+export {
+  languagesCommand
+};
+//# sourceMappingURL=languages-KEB6NUWX.js.map

package/dist/languages-R2GM7DRZ.js

@@ -0,0 +1,40 @@
+import {
+  GOOGLE_ADS_LANGUAGES
+} from "./chunk-FEELV5IV.js";
+import "./chunk-7VHPAGPK.js";
+import {
+  writeAdsJson
+} from "./chunk-SD5GDVDI.js";
+import "./chunk-ML7DLFFY.js";
+import "./chunk-P5NYZ236.js";
+import "./chunk-7JB56IVP.js";
+import "./chunk-XMS5K54U.js";
+import {
+  registerSchema
+} from "./chunk-MEBOQXW3.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/ads/google/keywords/languages.ts
+import { defineCommand } from "citty";
+registerSchema({
+  command: "ads.google.keywords.languages",
+  description: "List all supported language IDs for --language flag in Google Ads keyword commands.",
+  args: {}
+});
+var FIELDS = {
+  id: "Language ID to pass as --language",
+  name: "Language name"
+};
+var languagesCommand = defineCommand({
+  meta: {
+    name: "languages",
+    description: "List all supported language IDs for --language flag."
+  },
+  run: () => {
+    writeAdsJson({ ok: true, data: GOOGLE_ADS_LANGUAGES, fields: FIELDS });
+  }
+});
+export {
+  languagesCommand
+};
+//# sourceMappingURL=languages-R2GM7DRZ.js.map

package/dist/launches-DWNIU67A.js

@@ -0,0 +1,108 @@
+import {
+  reportError,
+  splitList
+} from "./chunk-PUG75EC5.js";
+import {
+  apiGet
+} from "./chunk-P5NYZ236.js";
+import "./chunk-7JB56IVP.js";
+import "./chunk-XMS5K54U.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-MEBOQXW3.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/winning-ads/launches.ts
+import { defineCommand } from "citty";
+registerSchema({
+  command: "winning-ads.launches",
+  description: 'What the brands you follow (or the ones named) launched in the last N days and which of those ads still run, each with its stage (new, testing, killed_early\u2026), and the tests each brand decided in that window (the version kept, what differed). The "what did competitors launch last week" report. Compact by default; --full lists every launch.',
+  args: {
+    since: { type: "number", description: "Days to look back, 1-90 (default 7)", required: false, default: 7 },
+    advertiser: {
+      type: "string",
+      description: "Comma list of advertiser ids instead of every followed brand",
+      required: false
+    },
+    platform: { type: "string", description: "Only this platform: meta|linkedin|tiktok|google", required: false },
+    full: { type: "boolean", description: "List every launch", required: false, default: false }
+  }
+});
+var COMPACT_LAUNCHES = 10;
+function compactLaunches(report, full) {
+  return {
+    since_days: report.since_days,
+    advertisers: report.advertisers.map((b) => ({
+      advertiser_id: b.advertiser_id,
+      label: b.label,
+      launched: b.launched,
+      still_running: b.still_running,
+      launches: (full ? b.launches : b.launches.slice(0, COMPACT_LAUNCHES)).map((l) => ({
+        ad_id: l.ad_id,
+        platform: l.platform,
+        format: l.format,
+        headline: l.headline,
+        first_seen_at: l.first_seen_at,
+        stage: l.stage,
+        ...full ? { media_url: l.media_url } : {}
+      })),
+      tests_decided: (b.tests_decided ?? []).map((t) => ({
+        concept: t.concept,
+        versions: t.versions,
+        kept_ad_id: t.winner_ad_id,
+        decided_at: t.decided_at ?? null,
+        what_differed: t.what_differed
+      }))
+    }))
+  };
+}
+function launchesHints(report, named) {
+  if (!named && report.following_count === 0) {
+    return ["You follow no brands yet: `baker winning-ads follow <domain>` adds one, or pass --advertiser <id>."];
+  }
+  if (report.advertisers.length === 0) {
+    return [`No launches in the last ${report.since_days} days. Widen the window with --since 30.`];
+  }
+  return [
+    "Stages: new \u22647 days, testing \u226421 days, proven \u226460 days, evergreen beyond, killed_early = stopped within 2 weeks (a lost test). tests_decided is what each brand learned in the window: the version it kept (kept_ad_id) and what differed. `baker winning-ads search --survived-test` finds the versions brands kept across the library."
+  ];
+}
+var launchesCommand = defineCommand({
+  meta: {
+    name: "launches",
+    description: "What competitors launched lately and what still runs. Start here: baker winning-ads launches --since 7 (every followed brand), or --advertiser adv_1,adv_2"
+  },
+  args: {
+    since: { type: "string", description: "Days to look back, 1-90 (default 7)", required: false },
+    advertiser: { type: "string", description: "Comma list of advertiser ids", required: false },
+    platform: { type: "string", description: "Only this platform: meta|linkedin|tiktok|google", required: false },
+    full: { type: "boolean", description: "List every launch", required: false, default: false }
+  },
+  run: async ({ args }) => {
+    try {
+      const named = splitList(args.advertiser);
+      const params = { since_days: String(args.since ?? 7) };
+      if (named.length > 0) {
+        params.advertiser = named.join(",");
+      }
+      if (args.platform) {
+        params.platform = String(args.platform);
+      }
+      const report = await apiGet("/api/ad-library/launches", params);
+      writeJson({
+        ok: true,
+        data: compactLaunches(report, Boolean(args.full)),
+        hints: launchesHints(report, named.length > 0)
+      });
+    } catch (err) {
+      reportError(err);
+    }
+  }
+});
+export {
+  compactLaunches,
+  launchesCommand,
+  launchesHints
+};
+//# sourceMappingURL=launches-DWNIU67A.js.map

package/dist/layerize-4BG3ROAK.js

@@ -0,0 +1,190 @@
+import {
+  ApiError,
+  apiGet,
+  apiPost
+} from "./chunk-P5NYZ236.js";
+import "./chunk-7JB56IVP.js";
+import "./chunk-XMS5K54U.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-MEBOQXW3.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/images/layerize.ts
+import { defineCommand } from "citty";
+registerSchema({
+  command: "images.layerize",
+  description: "Split a library image into editable layers: transparent PNG cutouts for each element, plus any headline recovered as EDITABLE TEXT with its font, size, colour and position. Waits for completion by default. Costs credits.",
+  args: {
+    "image-id": { type: "string", description: "Library image ID to split", required: true },
+    instructions: {
+      type: "string",
+      description: "Optional steer for what to separate, e.g. 'keep the bottle and its shadow as one layer'",
+      required: false
+    },
+    full: { type: "boolean", description: "Include geometry and typography for every layer", required: false },
+    "max-wait": {
+      type: "number",
+      description: "Max wait ms (default 240000 = 4 min). Set 0 to fire-and-forget.",
+      required: false,
+      default: 24e4
+    }
+  }
+});
+var POLL_INTERVAL_MS = 4e3;
+function compact(doc) {
+  return {
+    layeredImageId: doc.layeredImageId,
+    imageId: doc.imageId,
+    status: doc.status,
+    canvas: { width: doc.width, height: doc.height },
+    layers: doc.layers.map((layer) => ({
+      id: layer.id,
+      kind: layer.kind,
+      name: layer.name,
+      ...layer.url ? { url: layer.url } : {},
+      ...layer.text ? { text: layer.text.content } : {}
+    }))
+  };
+}
+function hintsFor(doc) {
+  const hints = [];
+  const text = doc.layers.filter((layer) => layer.kind === "text");
+  const art = doc.layers.filter((layer) => layer.kind === "art" && layer.id !== "layer-base");
+  if (text.length > 0) {
+    hints.push(
+      `${text.length} text layer(s) recovered as editable copy \u2014 run with --full for the font, size and colour to reuse when rewriting it.`
+    );
+  }
+  if (art.length > 0) {
+    hints.push(
+      `Each art layer's url is a transparent PNG on the media host: wire one straight into a canvas composition to reuse that element on its own.`
+    );
+  }
+  hints.push(
+    '"Original image" is the flat picture kept underneath. The model separates what was VISIBLE and does not repaint what sat behind a subject, so moving one can leave a gap.'
+  );
+  return hints;
+}
+async function pollUntilSettled(imageId, maxWait) {
+  const start = Date.now();
+  while (Date.now() - start < maxWait) {
+    await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
+    const doc = await apiGet("/api/images/layers", { imageId });
+    if (doc.status !== "splitting") return doc;
+  }
+  return null;
+}
+var layerizeCommand = defineCommand({
+  meta: {
+    name: "layerize",
+    description: "Split a library image into editable layers \u2014 transparent cutouts per element, plus any baked-in headline recovered as editable text with its typography.\n\nStart here: baker images layerize j571abc123def\nExample: baker images layerize j571abc123def --full\nExample: baker images layerize j571abc123def --instructions 'keep the product and its shadow together'"
+  },
+  args: {
+    "image-id": { type: "positional", description: "Library image ID", required: false },
+    instructions: { type: "string", description: "Optional steer for what to separate", required: false },
+    full: { type: "boolean", description: "Include geometry and typography", required: false },
+    "max-wait": { type: "string", description: "Max wait ms (default 240000, 0 = no wait)", required: false }
+  },
+  run: async ({ args }) => {
+    try {
+      const imageId = args["image-id"];
+      if (!imageId) {
+        writeJson({ ok: false, error: { code: "VALIDATION_ERROR", message: "image-id is required" } });
+        process.exit(1);
+      }
+      const maxWait = args["max-wait"] ? Number(args["max-wait"]) : 24e4;
+      const full = Boolean(args.full);
+      const started = await apiPost("/api/images/layerize", {
+        imageId,
+        instructions: args.instructions
+      });
+      const settled = maxWait === 0 || started.status !== "splitting" ? started : await pollUntilSettled(imageId, maxWait);
+      if (!settled) {
+        writeJson({
+          ok: false,
+          error: {
+            code: "TIMEOUT",
+            message: `Layers not ready within ${maxWait}ms`,
+            fix: `The split is still running. Read it later with: baker images layers ${imageId}`
+          }
+        });
+        process.exit(1);
+      }
+      if (settled.status === "failed") {
+        writeJson({
+          ok: false,
+          error: {
+            code: "IMAGE_PROCESSING_ERROR",
+            message: settled.error ?? "That image couldn't be split into layers",
+            fix: "Run the same command again \u2014 this provider rejects a valid request intermittently. If it fails twice more, carry on without layers."
+          }
+        });
+        process.exit(1);
+      }
+      writeJson({ ok: true, data: full ? settled : compact(settled), hints: hintsFor(settled) });
+    } 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: err instanceof Error ? err.message : "Unexpected error" }
+      });
+      process.exit(1);
+    }
+  }
+});
+registerSchema({
+  command: "images.layers",
+  description: "Read the layers of an image already split with `images layerize` \u2014 free, no provider call. Use it to see what an ad says and what its pieces are.",
+  args: {
+    "image-id": { type: "string", description: "Library image ID", required: true },
+    full: { type: "boolean", description: "Include geometry and typography for every layer", required: false }
+  }
+});
+var layersCommand = defineCommand({
+  meta: {
+    name: "layers",
+    description: "Read the layers of an image that has already been split. Free \u2014 no provider call.\n\nStart here: baker images layers j571abc123def\nExample: baker images layers j571abc123def --full"
+  },
+  args: {
+    "image-id": { type: "positional", description: "Library image ID", required: false },
+    full: { type: "boolean", description: "Include geometry and typography", required: false }
+  },
+  run: async ({ args }) => {
+    try {
+      const imageId = args["image-id"];
+      if (!imageId) {
+        writeJson({ ok: false, error: { code: "VALIDATION_ERROR", message: "image-id is required" } });
+        process.exit(1);
+      }
+      const doc = await apiGet("/api/images/layers", { imageId });
+      writeJson({ ok: true, data: args.full ? doc : compact(doc), hints: hintsFor(doc) });
+    } catch (err) {
+      if (err instanceof ApiError) {
+        writeJson({
+          ok: false,
+          error: {
+            code: err.code,
+            message: err.message,
+            ...err.code === "NOT_FOUND" ? { fix: `Split it first: baker images layerize ${args["image-id"]}` } : {}
+          }
+        });
+        process.exit(1);
+      }
+      writeJson({
+        ok: false,
+        error: { code: "INTERNAL_ERROR", message: err instanceof Error ? err.message : "Unexpected error" }
+      });
+      process.exit(1);
+    }
+  }
+});
+export {
+  layerizeCommand,
+  layersCommand
+};
+//# sourceMappingURL=layerize-4BG3ROAK.js.map

package/dist/leads-NC6XYOVL.js

@@ -0,0 +1,89 @@
+import {
+  csvOrJson,
+  handleLinkedinError,
+  resolveAccountIdArg
+} from "./chunk-TFWB4PS5.js";
+import {
+  writeAdsJson,
+  writeAdsOutput
+} from "./chunk-SD5GDVDI.js";
+import {
+  NO_CACHE_ARG
+} from "./chunk-X7ZODEXJ.js";
+import "./chunk-ZJVHZHYP.js";
+import "./chunk-GXDLWBOY.js";
+import "./chunk-XQIOCIDO.js";
+import "./chunk-ML7DLFFY.js";
+import {
+  apiGet
+} from "./chunk-P5NYZ236.js";
+import "./chunk-7JB56IVP.js";
+import "./chunk-XMS5K54U.js";
+import "./chunk-MEBOQXW3.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/ads/linkedin/leads.ts
+import { defineCommand } from "citty";
+var DAY_MS = 864e5;
+var leadsCommand = defineCommand({
+  meta: {
+    name: "leads",
+    description: `List Lead Gen Form responses (playbook \xA707).
+
+LinkedIn retains LGF responses for 90 days only \u2014 sync to your CRM via this
+endpoint or you'll lose them.
+
+Examples:
+  baker ads linkedin leads --account-id 503001492
+  baker ads linkedin leads --account-id 503001492 --campaign-id 1234
+  baker ads linkedin leads --account-id 503001492 --form-id 5678 --since-days 7
+  baker ads linkedin leads --account-id 503001492 --output csv`
+  },
+  args: {
+    "account-id": { type: "string", description: "Numeric account ID or urn:li:sponsoredAccount:N" },
+    "account-urn": { type: "string", description: "Alias for --account-id" },
+    "form-id": { type: "string", description: "Filter by Lead Gen Form ID" },
+    "campaign-id": { type: "string", description: "Filter by campaign ID" },
+    "since-days": { type: "string", description: "Only responses submitted in the last N days" },
+    "since-ms": {
+      type: "string",
+      description: "Only responses submitted at or after this epoch ms (alternative to --since-days)"
+    },
+    limit: { type: "string", description: "Max rows (default: 500)" },
+    "no-cache": NO_CACHE_ARG,
+    output: { type: "string", description: "json|csv|jsonl|md", default: "json" }
+  },
+  run: async ({ args }) => {
+    const accountId = resolveAccountIdArg(args);
+    try {
+      const params = { "account-id": accountId };
+      if (args["form-id"]) params["form-id"] = String(args["form-id"]);
+      if (args["campaign-id"]) params["campaign-id"] = String(args["campaign-id"]);
+      const sinceDays = args["since-days"] ? Number(args["since-days"]) : void 0;
+      const sinceMs = args["since-ms"] ? Number(args["since-ms"]) : sinceDays ? Date.now() - sinceDays * DAY_MS : void 0;
+      if (sinceMs) params["since-ms"] = String(sinceMs);
+      if (args.limit) params.limit = String(args.limit);
+      if (args["no-cache"]) params["skip-cache"] = "true";
+      const data = await apiGet("/api/ads/linkedin/leads", params);
+      const fmt = csvOrJson(args);
+      if (fmt !== "json") {
+        const flat = data.map((r) => ({
+          id: r.id,
+          formId: r.formId,
+          campaignUrn: r.campaignUrn,
+          submittedAt: r.submittedAt ? new Date(r.submittedAt).toISOString() : "",
+          answers: (r.answers ?? []).map((a) => `${a.question}: ${a.answer}`).join(" | ")
+        }));
+        writeAdsOutput(flat, fmt);
+        return;
+      }
+      writeAdsJson({ ok: true, data });
+    } catch (err) {
+      handleLinkedinError(err);
+    }
+  }
+});
+export {
+  leadsCommand
+};
+//# sourceMappingURL=leads-NC6XYOVL.js.map