@koda-sl/baker-cli 0.463.0 → 0.465.0

package/dist/languages-7X5PROWY.js

@@ -0,0 +1,55 @@
+import {
+  writeResearchJson
+} from "./chunk-AVMJDODA.js";
+import "./chunk-T2MH5SCT.js";
+import "./chunk-7LWVWFIV.js";
+import "./chunk-7DIIZUZO.js";
+import {
+  registerSchema
+} from "./chunk-SHVQFDNY.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-7X5PROWY.js.map

package/dist/languages-Q7NLDV5C.js

@@ -0,0 +1,40 @@
+import {
+  GOOGLE_ADS_LANGUAGES
+} from "./chunk-FEELV5IV.js";
+import "./chunk-7VHPAGPK.js";
+import {
+  writeAdsJson
+} from "./chunk-VAX5ITZ5.js";
+import "./chunk-ML7DLFFY.js";
+import "./chunk-T2MH5SCT.js";
+import "./chunk-7LWVWFIV.js";
+import "./chunk-7DIIZUZO.js";
+import {
+  registerSchema
+} from "./chunk-SHVQFDNY.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-Q7NLDV5C.js.map

package/dist/launches-HXMKMYJX.js

@@ -0,0 +1,108 @@
+import {
+  reportError,
+  splitList
+} from "./chunk-L7OTZTWV.js";
+import {
+  apiGet
+} from "./chunk-T2MH5SCT.js";
+import "./chunk-7LWVWFIV.js";
+import "./chunk-7DIIZUZO.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-SHVQFDNY.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-HXMKMYJX.js.map

package/dist/layerize-SYLRTQ3A.js

@@ -0,0 +1,190 @@
+import {
+  ApiError,
+  apiGet,
+  apiPost
+} from "./chunk-T2MH5SCT.js";
+import "./chunk-7LWVWFIV.js";
+import "./chunk-7DIIZUZO.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-SHVQFDNY.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-SYLRTQ3A.js.map

package/dist/leads-RQG6LB7K.js

@@ -0,0 +1,293 @@
+import {
+  bareAccountId,
+  loadJsonFileArg,
+  mergePayload,
+  stageOp
+} from "./chunk-EXSVOUU4.js";
+import {
+  isMetaLeadAdsRefusal
+} from "./chunk-GOJXKIFQ.js";
+import {
+  csvOrJson,
+  handleMetaError
+} from "./chunk-IKQE6HHT.js";
+import "./chunk-5LHDRP5F.js";
+import "./chunk-4NZ47VXO.js";
+import "./chunk-D5FY4FAK.js";
+import "./chunk-PAE5XKKY.js";
+import {
+  writeAdsJson,
+  writeAdsOutput,
+  writeJsonEnvelope
+} from "./chunk-VAX5ITZ5.js";
+import "./chunk-DZD3XEBO.js";
+import "./chunk-YOFHPTWU.js";
+import "./chunk-UVVY55HY.js";
+import "./chunk-GWKYXBZV.js";
+import "./chunk-ANAJIYDY.js";
+import "./chunk-QI42BRSW.js";
+import "./chunk-XQIOCIDO.js";
+import {
+  ApiError,
+  apiGet
+} from "./chunk-T2MH5SCT.js";
+import "./chunk-7LWVWFIV.js";
+import "./chunk-7DIIZUZO.js";
+import {
+  registerSchema
+} from "./chunk-SHVQFDNY.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/ads/meta/leads.ts
+import { defineCommand } from "citty";
+registerSchema({
+  command: "ads.meta.lead-forms",
+  description: "List the instant (lead) forms on a Facebook Page, with how many leads each has collected. Start here: a lead is fetched by form id. Use a Page from `baker ads meta pages` with hasPageAccessToken: true.",
+  args: {
+    "page-id": {
+      type: "string",
+      description: "Facebook Page ID \u2014 from `baker ads meta pages` with hasPageAccessToken: true",
+      required: true
+    },
+    full: { type: "boolean", description: "Include each form's questions", required: false },
+    output: { type: "string", description: "json|csv", required: false, default: "json" }
+  }
+});
+registerSchema({
+  command: "ads.meta.lead-forms.create",
+  description: "Start here to stage a Page-owned Meta Instant Form. The form is created only when this Session publishes. Use the returned meta_temp_* ref as --lead-form on a creative in the same Session.",
+  args: {
+    "account-id": { type: "string", description: "Selected Meta ad account, act_<id>", required: true },
+    "page-id": {
+      type: "string",
+      description: "Facebook Page that owns the form \u2014 choose one with this account in promotingAccountIds and hasPageAccessToken: true from `baker ads meta pages`",
+      required: true
+    },
+    name: { type: "string", description: "Form name", required: true },
+    questions: {
+      type: "string",
+      description: "Comma-separated Meta fields, e.g. FULL_NAME,EMAIL,PHONE",
+      required: true
+    },
+    "privacy-policy-url": { type: "string", description: "Public HTTPS privacy policy", required: true },
+    "follow-up-url": { type: "string", description: "Public HTTPS link after submission", required: true },
+    "optimized-for-quality": {
+      type: "boolean",
+      description: "Ask Meta to optimize form leads for quality",
+      required: false
+    },
+    file: {
+      type: "string",
+      description: "JSON file with full form payload, including thankYou and custom questions",
+      required: false
+    }
+  }
+});
+registerSchema({
+  command: "ads.meta.leads",
+  description: "Read the leads an instant form collected. Contact details (email, phone) come back masked; pass --full only when the raw values are genuinely needed, e.g. handing them to a CRM.",
+  args: {
+    "form-id": { type: "string", description: "Instant form ID \u2014 from `baker ads meta lead-forms`", required: false },
+    "ad-id": { type: "string", description: "Read the leads of one ad instead of a whole form", required: false },
+    since: { type: "string", description: "Earliest submission date, YYYY-MM-DD", required: false },
+    until: { type: "string", description: "Latest submission date, YYYY-MM-DD (inclusive)", required: false },
+    limit: { type: "string", description: "Leads per page (default 100, max 500)", required: false },
+    after: {
+      type: "string",
+      description: "Cursor from a previous call's nextCursor \u2014 fetches the following page",
+      required: false
+    },
+    full: { type: "boolean", description: "Return raw contact details instead of masked ones", required: false },
+    output: { type: "string", description: "json|csv", required: false, default: "json" }
+  }
+});
+var LEAD_FORMS_CAP = 500;
+function leadFormHints(forms) {
+  if (forms.length === 0) {
+    return ["This Page has NO instant forms. Nothing to read leads from \u2014 the form has to be created first."];
+  }
+  if (forms.length >= LEAD_FORMS_CAP) {
+    return [
+      `PARTIAL LIST \u2014 this Page has at least ${LEAD_FORMS_CAP} instant forms and only the first ${LEAD_FORMS_CAP} came back. Do not describe this as every form on the Page.`
+    ];
+  }
+  const empty = forms.filter((form) => (form.leads_count ?? 0) === 0);
+  if (empty.length === forms.length) {
+    return [
+      "Every form on this Page has collected 0 leads. That is a real, readable answer \u2014 the connection works. Do not retry and do not report it as a permissions problem."
+    ];
+  }
+  return [];
+}
+function handleLeadsError(err) {
+  if (err instanceof ApiError && err.code === "FORBIDDEN" && isMetaLeadAdsRefusal(err.message)) {
+    writeAdsJson({
+      ok: false,
+      error: {
+        code: err.code,
+        message: err.message,
+        fix: { action: "reject", explanation: err.message },
+        retryable: false
+      }
+    });
+    process.exit(1);
+  }
+  handleMetaError(err);
+}
+function leadPageHints(page, full) {
+  const hints = [];
+  if (page.nextCursor) {
+    hints.push(
+      `PARTIAL PAGE \u2014 more leads exist. This is ${page.leads.length} of an unknown larger number; do NOT report it as a total. Fetch the next page with \`--after ${page.nextCursor}\` (repeat until no nextCursor), or narrow the window with --since/--until.`
+    );
+  }
+  if (!full) {
+    hints.push(
+      "Answers that give contact details (email, phone, any question asking for one) are masked. Report on them as they are; pass --full only when the raw values have to leave Baker (a CRM hand-off), and never paste them into the chat otherwise."
+    );
+  }
+  hints.push(...page.hints ?? []);
+  return hints;
+}
+var leadFormsCreateCommand = defineCommand({
+  meta: {
+    name: "create",
+    description: `Stage a Meta Instant Form on a Facebook Page. The form appears in review and is created only when the Session publishes.
+Choose a Page with this account in promotingAccountIds and hasPageAccessToken: true from \`baker ads meta pages\`.
+Example: baker ads meta lead-forms create --account-id act_123 --page-id 456 --name "Free audit" --questions FULL_NAME,EMAIL,PHONE --privacy-policy-url https://example.com/privacy --follow-up-url https://example.com`
+  },
+  args: {
+    "account-id": { type: "string", description: "Selected Meta ad account" },
+    "page-id": { type: "string", description: "Facebook Page ID" },
+    name: { type: "string", description: "Form name" },
+    questions: { type: "string", description: "FULL_NAME,EMAIL,PHONE or other Meta fields" },
+    "privacy-policy-url": { type: "string", description: "HTTPS privacy policy" },
+    "follow-up-url": { type: "string", description: "HTTPS thank-you link" },
+    "optimized-for-quality": { type: "boolean", description: "Optimize form leads for quality" },
+    file: { type: "string", description: "JSON form payload; flags override file keys" }
+  },
+  run: async ({ args }) => {
+    const accountId = bareAccountId(args);
+    const payload = mergePayload(loadJsonFileArg(args.file), {
+      page_id: args["page-id"],
+      name: args.name,
+      questions: typeof args.questions === "string" ? args.questions.split(",").map((type) => ({ type: type.trim().toUpperCase() })) : void 0,
+      privacyPolicyUrl: args["privacy-policy-url"],
+      followUpActionUrl: args["follow-up-url"],
+      optimizedForQuality: args["optimized-for-quality"]
+    });
+    await stageOp({ kind: "leadForm.create", accountId, payload });
+  }
+});
+var leadFormsListArgs = {
+  "page-id": { type: "string", description: "Facebook Page ID" },
+  full: { type: "boolean", description: "Include each form's questions" },
+  output: { type: "string", description: "Output format", default: "json" }
+};
+var leadFormsListCommand = defineCommand({
+  meta: {
+    name: "list",
+    description: "List the Instant Forms on a Facebook Page, with lead counts. Choose a Page with hasPageAccessToken: true from `baker ads meta pages`. Pass --full to include questions."
+  },
+  args: leadFormsListArgs,
+  run: async ({ args }) => {
+    try {
+      const pageId = args["page-id"];
+      if (!pageId) {
+        handleLeadsError(
+          new Error(
+            "--page-id is required. Run `baker ads meta pages` and choose a Page with hasPageAccessToken: true."
+          )
+        );
+      }
+      const params = { "page-id": pageId };
+      if (args.full) params.full = "true";
+      const data = await apiGet("/api/ads/meta/lead-forms", params);
+      const fmt = csvOrJson(args);
+      if (fmt !== "json") {
+        writeAdsOutput(data, fmt);
+        return;
+      }
+      const hints = leadFormHints(data);
+      writeJsonEnvelope(hints.length > 0 ? { ok: true, data, hints } : { ok: true, data });
+    } catch (err) {
+      handleLeadsError(err);
+    }
+  }
+});
+var leadFormsCommand = defineCommand({
+  meta: {
+    name: "lead-forms",
+    description: `List Instant Forms on a Facebook Page or stage a new one.
+Examples:
+  baker ads meta lead-forms --page-id 100635183117758
+  baker ads meta lead-forms --page-id 100635183117758 --full
+  baker ads meta lead-forms create --account-id act_123 --page-id 555 --file form.json`
+  },
+  args: leadFormsListArgs,
+  subCommands: { list: leadFormsListCommand, create: leadFormsCreateCommand },
+  default: "list"
+});
+var leadsCommand = defineCommand({
+  meta: {
+    name: "leads",
+    description: `Read the leads an instant form collected. Every question comes back; email and phone answers are MASKED unless you pass --full, so you can report on what a form is collecting without moving contact details around.
+
+Examples:
+  baker ads meta leads --form-id 987654321
+  baker ads meta leads --form-id 987654321 --since 2026-08-01 --until 2026-08-31
+  baker ads meta leads --ad-id 6123456789 --limit 50
+  baker ads meta leads --form-id 987654321 --after <nextCursor>   # the next page
+  baker ads meta leads --form-id 987654321 --full            # raw contact details \u2014 only when handing leads over
+
+Results are PAGED. A response carrying \`nextCursor\` is not the whole set \u2014 follow it before reporting any total.`
+  },
+  args: {
+    "form-id": { type: "string", description: "Instant form ID (from `baker ads meta lead-forms`)" },
+    "ad-id": { type: "string", description: "Read one ad's leads instead of a whole form" },
+    since: { type: "string", description: "Earliest submission date, YYYY-MM-DD" },
+    until: { type: "string", description: "Latest submission date, YYYY-MM-DD (inclusive)" },
+    limit: { type: "string", description: "Leads per page (default 100, max 500)" },
+    after: { type: "string", description: "Cursor from a previous call's nextCursor" },
+    full: { type: "boolean", description: "Return raw contact details instead of masked ones" },
+    output: { type: "string", description: "Output format", default: "json" }
+  },
+  run: async ({ args }) => {
+    try {
+      const formId = args["form-id"];
+      const adId = args["ad-id"];
+      if (!formId && !adId) {
+        handleLeadsError(new Error("Pass --form-id (from `baker ads meta lead-forms`) or --ad-id."));
+      }
+      const params = {};
+      if (formId) params["form-id"] = formId;
+      if (adId) params["ad-id"] = adId;
+      if (args.since) params.since = args.since;
+      if (args.until) params.until = args.until;
+      if (args.limit) params.limit = String(args.limit);
+      if (args.after) params.after = String(args.after);
+      if (args.full) params.full = "true";
+      const page = await apiGet("/api/ads/meta/leads", params);
+      const fmt = csvOrJson(args);
+      if (fmt !== "json") {
+        writeAdsOutput(page.leads, fmt);
+        return;
+      }
+      writeJsonEnvelope({
+        ok: true,
+        data: page.leads,
+        ...page.nextCursor ? { nextCursor: page.nextCursor } : {},
+        hints: leadPageHints(page, args.full === true)
+      });
+    } catch (err) {
+      handleLeadsError(err);
+    }
+  }
+});
+export {
+  leadFormHints,
+  leadFormsCommand,
+  leadPageHints,
+  leadsCommand
+};
+//# sourceMappingURL=leads-RQG6LB7K.js.map