@koda-sl/baker-cli 0.498.0 → 0.500.0

package/dist/leads-GF24GM54.js

@@ -0,0 +1,538 @@
+import {
+  bareAccountId,
+  failWriteValidation,
+  loadJsonFileArg,
+  mergePayload,
+  requireTarget,
+  stageOp,
+  upper
+} from "./chunk-YIN6QNZD.js";
+import {
+  isMetaLeadAdsRefusal
+} from "./chunk-5B2WEPYR.js";
+import "./chunk-GDFJOCDO.js";
+import {
+  csvOrJson,
+  handleMetaError
+} from "./chunk-B2POVFR2.js";
+import {
+  repeatedValues
+} from "./chunk-ERSX3MKH.js";
+import "./chunk-KJZPCLQE.js";
+import "./chunk-4NZ47VXO.js";
+import "./chunk-D5FY4FAK.js";
+import "./chunk-QPESDKZC.js";
+import "./chunk-Y2JZX6JB.js";
+import {
+  writeAdsJson,
+  writeAdsOutput,
+  writeJsonEnvelope
+} from "./chunk-ZRP7Y2DM.js";
+import "./chunk-E44NXCTL.js";
+import "./chunk-EJGAJHLB.js";
+import "./chunk-LNNTHEL7.js";
+import "./chunk-FOMFU2RX.js";
+import "./chunk-PSGIHSNC.js";
+import "./chunk-PONLPYD7.js";
+import "./chunk-UI6BKYQD.js";
+import {
+  ApiError,
+  apiGet
+} from "./chunk-X7VQFLHI.js";
+import "./chunk-LU4HI4KI.js";
+import "./chunk-LGK7UWBN.js";
+import {
+  registerSchema
+} from "./chunk-Q7US4OOA.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/ads/meta/leads.ts
+import { defineCommand as defineCommand2 } from "citty";
+
+// src/commands/ads/meta/lead-form-writes.ts
+import { defineCommand } from "citty";
+var STAGED_NOTE = "Staged until publish \u2014 review with `baker ads meta draft`.";
+var str = (value) => typeof value === "string" && value.length > 0 ? value : void 0;
+function customQuestion(value) {
+  const [label = "", answers] = value.split("=>").map((part) => part.trim());
+  const options = answers?.split("|").map((answer) => answer.trim()).filter(Boolean).map((answer) => ({ value: answer }));
+  return { type: "CUSTOM", label, ...options && options.length > 0 ? { options } : {} };
+}
+function questionsFromFlags(args, rawArgs) {
+  const predefined = (str(args.questions) ?? "").split(",").map((type) => type.trim().toUpperCase()).filter(Boolean).map((type) => ({ type }));
+  const custom = repeatedValues(rawArgs, "question", args.question).map(customQuestion);
+  const all = [...predefined, ...custom];
+  return all.length > 0 ? all : void 0;
+}
+function introFromFlags(args, rawArgs) {
+  const content = repeatedValues(rawArgs, "intro-text", args["intro-text"]);
+  const set = {
+    ...str(args["intro-title"]) ? { title: str(args["intro-title"]) } : {},
+    ...content.length > 0 ? { style: content.length > 1 ? "LIST_STYLE" : "PARAGRAPH_STYLE", content } : {},
+    ...str(args["intro-button"]) ? { buttonText: str(args["intro-button"]) } : {}
+  };
+  return Object.keys(set).length > 0 ? set : void 0;
+}
+function thankYouFromFlags(args) {
+  const fields = {
+    title: str(args["thank-you-title"]),
+    body: str(args["thank-you-body"]),
+    buttonType: upper(args["thank-you-button"]),
+    buttonText: str(args["thank-you-button-text"]),
+    websiteUrl: str(args["thank-you-url"]),
+    businessPhoneNumber: str(args["thank-you-phone"]),
+    countryCode: upper(args["thank-you-country"])
+  };
+  const set = Object.fromEntries(Object.entries(fields).filter(([, value]) => value !== void 0));
+  return Object.keys(set).length > 0 ? set : void 0;
+}
+function trackingFromFlags(args, rawArgs) {
+  const pairs = repeatedValues(rawArgs, "tracking", args.tracking).map((pair) => {
+    const at = pair.indexOf("=");
+    if (at <= 0) failWriteValidation(`--tracking takes name=value, got "${pair}"`);
+    return [pair.slice(0, at).trim(), pair.slice(at + 1).trim()];
+  });
+  return pairs.length > 0 ? Object.fromEntries(pairs) : void 0;
+}
+function leadFormPayloadFromFlags(args, rawArgs) {
+  const quality = args["higher-intent"] ?? args["optimized-for-quality"];
+  return {
+    page_id: str(args["page-id"]),
+    name: str(args.name),
+    locale: upper(args.locale),
+    questionPageHeadline: str(args.headline),
+    questions: questionsFromFlags(args, rawArgs),
+    privacyPolicyUrl: str(args["privacy-policy-url"]),
+    privacyPolicyLinkText: str(args["privacy-link-text"]),
+    followUpActionUrl: str(args["follow-up-url"]),
+    optimizedForQuality: typeof quality === "boolean" ? quality : void 0,
+    intro: introFromFlags(args, rawArgs),
+    thankYou: thankYouFromFlags(args),
+    sharing: str(args.sharing)?.toLowerCase(),
+    smsVerification: args["sms-verification"] === true ? true : void 0,
+    trackingParameters: trackingFromFlags(args, rawArgs)
+  };
+}
+function formFileForStaging(raw) {
+  const data = raw.ok === true && "data" in raw ? raw.data : raw;
+  return data && typeof data === "object" && !Array.isArray(data) ? data : raw;
+}
+var SCREENS = ["intro", "thankYou"];
+function record(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function mergeOver(base, over) {
+  const merged = mergePayload(base, over);
+  for (const screen of SCREENS) {
+    const from = record(base[screen]);
+    const to = record(over[screen]);
+    if (from && to) merged[screen] = mergePayload(from, to);
+  }
+  return merged;
+}
+function mergeDuplicateSpec(live, changes, flags) {
+  return mergeOver(mergeOver(live, changes), flags);
+}
+var FORM_FLAG_ARGS = {
+  name: { type: "string", description: "Form name \u2014 unique among the Page's forms (archived ones count)" },
+  locale: {
+    type: "string",
+    description: "Form language, e.g. EN_US, ES_LA, PT_BR, FR_FR, DE_DE (Meta's 32) \u2014 Meta words its own questions in it"
+  },
+  headline: { type: "string", description: "Headline above the questions" },
+  questions: {
+    type: "string",
+    description: "Questions Meta words itself, comma-separated: FULL_NAME,EMAIL,PHONE,WORK_EMAIL,COMPANY_NAME,JOB_TITLE,CITY,ZIP,DOB\u2026"
+  },
+  question: {
+    type: "string",
+    description: 'A custom question, repeatable: "Question?" or multiple choice "Question? => Answer | Answer"'
+  },
+  "privacy-policy-url": { type: "string", description: "Public https privacy policy (required)" },
+  "privacy-link-text": { type: "string", description: "Words of the privacy link (\u226470, default Privacy Policy)" },
+  "follow-up-url": { type: "string", description: "https link of the default View website button" },
+  "higher-intent": {
+    type: "boolean",
+    description: "Higher intent: people review their answers before submitting (default: more volume)"
+  },
+  "optimized-for-quality": { type: "boolean", description: "Same as --higher-intent" },
+  "intro-title": { type: "string", description: "Intro screen title" },
+  "intro-text": { type: "string", description: "Intro paragraph; repeat for bullet points" },
+  "intro-button": { type: "string", description: "Intro screen button text" },
+  "thank-you-title": { type: "string", description: "Thank-you screen title" },
+  "thank-you-body": { type: "string", description: "Thank-you screen text" },
+  "thank-you-button": {
+    type: "string",
+    description: "VIEW_WEBSITE|DOWNLOAD|BOOK_ON_WEBSITE|CALL_BUSINESS|WHATSAPP|P2B_MESSENGER|PROMO_CODE|NONE"
+  },
+  "thank-you-button-text": { type: "string", description: "Thank-you button text" },
+  "thank-you-url": { type: "string", description: "Website the thank-you button opens" },
+  "thank-you-phone": { type: "string", description: "CALL_BUSINESS: phone number, e.g. +14155550100" },
+  "thank-you-country": { type: "string", description: "CALL_BUSINESS: the number's country, e.g. US" },
+  sharing: { type: "string", description: "restricted (only people shown the ad, Meta's default) | open" },
+  "sms-verification": { type: "boolean", description: "Confirm the PHONE answer with a text-message code" },
+  tracking: { type: "string", description: "name=value Meta adds to every lead, repeatable" }
+};
+var SCHEMA_FORM_ARGS = Object.fromEntries(
+  Object.entries(FORM_FLAG_ARGS).map(([key, arg]) => [key, { ...arg, required: false }])
+);
+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, and it is permanent (Meta archives, never deletes). Use the returned meta_temp_* ref as --lead-form on a creative in the same Session. --file takes the whole spec (questions with keys, options, inlineContext; intro; disclaimer with checkboxes; thankYou; sharing; trackingParameters).",
+  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
+    },
+    ...SCHEMA_FORM_ARGS,
+    file: {
+      type: "string",
+      description: "JSON file with the full form payload; flags override its keys",
+      required: false
+    }
+  }
+});
+var leadFormsCreateCommand = defineCommand({
+  meta: {
+    name: "create",
+    description: `Stage a Meta Instant Form on a Facebook Page. ${STAGED_NOTE} The form is permanent once published (archive it to retire it).
+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 --question "Budget? => Under 1k | 1k+" --privacy-policy-url https://example.com/privacy --follow-up-url https://example.com
+Full spec: --file form.json (see \`baker schema ads.meta.lead-forms.create\` and the ads-meta tool doc).`
+  },
+  args: {
+    "account-id": { type: "string", description: "Selected Meta ad account" },
+    "page-id": { type: "string", description: "Facebook Page ID" },
+    ...FORM_FLAG_ARGS,
+    file: { type: "string", description: "JSON form payload; flags override file keys" }
+  },
+  run: async ({ args, rawArgs }) => {
+    const accountId = bareAccountId(args);
+    const payload = mergePayload(
+      formFileForStaging(loadJsonFileArg(args.file)),
+      leadFormPayloadFromFlags(args, rawArgs)
+    );
+    await stageOp({ kind: "leadForm.create", accountId, payload }, [
+      "An ad opens it with `creatives create --cta SIGN_UP --lead-form <ref>` into an ad set with destination ON_AD."
+    ]);
+  }
+});
+registerSchema({
+  command: "ads.meta.lead-forms.spec",
+  description: "Read a live Instant Form as the exact payload `lead-forms create --file` takes \u2014 the starting point for a changed copy. Lists what could not be carried over.",
+  args: { id: { type: "positional", description: "Instant Form id", required: true } }
+});
+var leadFormsSpecCommand = defineCommand({
+  meta: {
+    name: "spec",
+    description: `A live form as the payload \`lead-forms create --file\` / \`lead-forms duplicate --file\` take.
+Example: baker ads meta lead-forms spec 1460955752594831 > form.json`
+  },
+  args: { id: { type: "positional", description: "Instant Form id", required: true } },
+  run: async ({ args }) => {
+    try {
+      const data = await apiGet("/api/ads/meta/lead-forms/spec", { "form-id": String(args.id) });
+      writeJsonEnvelope({
+        ok: true,
+        data: data.spec,
+        ...data.notCopied.length > 0 ? { hints: [`Not carried over: ${data.notCopied.join("; ")}`] } : {}
+      });
+    } catch (err) {
+      handleMetaError(err);
+    }
+  }
+});
+registerSchema({
+  command: "ads.meta.lead-forms.duplicate",
+  description: "Stage a NEW Instant Form copied from a live one, with changes \u2014 the only way Meta lets a form change (it keeps a form's questions, texts and settings as made). --file holds the changed keys; flags override both. Point ads at the copy, then archive the original.",
+  args: {
+    id: { type: "positional", description: "Instant Form id to copy", required: true },
+    "account-id": { type: "string", description: "Selected Meta ad account, act_<id>", required: true },
+    ...SCHEMA_FORM_ARGS,
+    name: { type: "string", description: "Name of the copy \u2014 unique on the Page", required: true },
+    file: { type: "string", description: "JSON with the keys to change (same shape as create)", required: false }
+  }
+});
+var leadFormsDuplicateCommand = defineCommand({
+  meta: {
+    name: "duplicate",
+    description: `Stage a changed copy of a live Instant Form (Meta changes nothing on an existing form). ${STAGED_NOTE}
+Example: baker ads meta lead-forms duplicate 1460955752594831 --account-id act_123 --name "Free audit (ES)" --locale ES_LA
+Then point the ads at the copy (\`creatives create --lead-form <ref>\`) and \`lead-forms archive <old id>\`.`
+  },
+  args: {
+    id: { type: "positional", description: "Instant Form id to copy", required: true },
+    "account-id": { type: "string", description: "Selected Meta ad account" },
+    ...FORM_FLAG_ARGS,
+    file: { type: "string", description: "JSON with the keys to change" }
+  },
+  run: async ({ args, rawArgs }) => {
+    const accountId = bareAccountId(args);
+    if (!str(args.name)) failWriteValidation("--name is required: Meta refuses a second form with the same name");
+    let source;
+    try {
+      source = await apiGet("/api/ads/meta/lead-forms/spec", { "form-id": String(args.id) });
+    } catch (err) {
+      handleMetaError(err);
+    }
+    const flags = leadFormPayloadFromFlags(args, rawArgs);
+    const payload = mergeDuplicateSpec(source.spec, formFileForStaging(loadJsonFileArg(args.file)), flags);
+    const notCopied = source.notCopied.length > 0 ? [`Not carried over: ${source.notCopied.join("; ")}`] : [];
+    await stageOp({ kind: "leadForm.create", accountId, payload }, [
+      ...notCopied,
+      `Point the ads at the copy, then \`baker ads meta lead-forms archive ${String(args.id)}\` to retire the original.`
+    ]);
+  }
+});
+function statusCommand(name, status, description) {
+  registerSchema({
+    command: `ads.meta.lead-forms.${name}`,
+    description,
+    args: {
+      id: { type: "positional", description: "Instant Form id", required: true },
+      "account-id": { type: "string", description: "Ad account the change is staged under", required: true }
+    }
+  });
+  return defineCommand({
+    meta: {
+      name,
+      description: `${description} ${STAGED_NOTE}
+Example: baker ads meta lead-forms ${name} 1460955752594831 --account-id act_123`
+    },
+    args: {
+      id: { type: "positional", description: "Instant Form id", required: true },
+      "account-id": { type: "string", description: "Numeric account ID or act_N" }
+    },
+    run: async ({ args }) => {
+      await stageOp({
+        kind: "leadForm.update",
+        accountId: bareAccountId(args),
+        target: requireTarget(args, "Instant Form"),
+        payload: { status }
+      });
+    }
+  });
+}
+var leadFormsArchiveCommand = statusCommand(
+  "archive",
+  "ARCHIVED",
+  "Archive an Instant Form: it leaves the Page's form library and no ad can use it. Meta never deletes a form; this is how one is retired."
+);
+var leadFormsUnarchiveCommand = statusCommand(
+  "unarchive",
+  "ACTIVE",
+  "Bring an archived Instant Form back so ads can use it again."
+);
+
+// src/commands/ads/meta/leads.ts
+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.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 },
+    "adset-id": { type: "string", description: "Read the leads of every ad in an ad set", required: false },
+    "campaign-id": { type: "string", description: "Read the leads of every ad in a campaign", 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 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 = defineCommand2({
+  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 = defineCommand2({
+  meta: {
+    name: "lead-forms",
+    description: `List Instant Forms on a Facebook Page, or stage a new one, a changed copy, an archive.
+A form is permanent on Meta and nothing on it changes once made: to change one, duplicate it with changes and archive the old 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
+  baker ads meta lead-forms spec 987654321                       \u2014 a live form as a create --file payload
+  baker ads meta lead-forms duplicate 987654321 --account-id act_123 --name "Free audit (ES)" --locale ES_LA
+  baker ads meta lead-forms archive 987654321 --account-id act_123`
+  },
+  args: leadFormsListArgs,
+  subCommands: {
+    list: leadFormsListCommand,
+    create: leadFormsCreateCommand,
+    spec: leadFormsSpecCommand,
+    duplicate: leadFormsDuplicateCommand,
+    archive: leadFormsArchiveCommand,
+    unarchive: leadFormsUnarchiveCommand
+  },
+  default: "list"
+});
+var leadsCommand = defineCommand2({
+  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 --adset-id 6123456780 --since 2026-08-01   # every ad in the ad set (Meta has no ad set edge)
+  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" },
+    "adset-id": { type: "string", description: "Read the leads of every ad in an ad set" },
+    "campaign-id": { type: "string", description: "Read the leads of every ad in a campaign" },
+    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 params = {};
+      for (const flag of ["form-id", "ad-id", "adset-id", "campaign-id"]) {
+        const value = args[flag];
+        if (typeof value === "string" && value.length > 0) params[flag] = value;
+      }
+      if (Object.keys(params).length !== 1) {
+        handleLeadsError(
+          new Error("Pass one of --form-id (from `baker ads meta lead-forms`), --ad-id, --adset-id or --campaign-id.")
+        );
+      }
+      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-GF24GM54.js.map

package/dist/leads-UHJS7VNH.js

@@ -0,0 +1,113 @@
+import {
+  csvOrJson,
+  handleLinkedinError,
+  resolveAccountIdArg
+} from "./chunk-I46D7YXI.js";
+import {
+  writeAdsJson,
+  writeAdsOutput
+} from "./chunk-ZRP7Y2DM.js";
+import {
+  NO_CACHE_ARG
+} from "./chunk-AGBBTTKA.js";
+import "./chunk-5MSRVAUZ.js";
+import "./chunk-CAZGM2NX.js";
+import "./chunk-NZS3KEQ2.js";
+import "./chunk-GIWHHCD6.js";
+import "./chunk-UI6BKYQD.js";
+import "./chunk-ERSL4WZT.js";
+import {
+  apiGet
+} from "./chunk-X7VQFLHI.js";
+import "./chunk-LU4HI4KI.js";
+import "./chunk-LGK7UWBN.js";
+import "./chunk-Q7US4OOA.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/ads/linkedin/leads.ts
+import { defineCommand } from "citty";
+var DAY_MS = 864e5;
+function epochMs(value, flag) {
+  const text = String(value);
+  const ms = /^\d+$/.test(text) ? Number(text) : Date.parse(text);
+  if (Number.isNaN(ms)) {
+    throw new Error(`${flag} must be YYYY-MM-DD or epoch ms, got ${text}`);
+  }
+  return ms;
+}
+function leadsParams(args, accountId) {
+  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 sinceMs = args["since-ms"] ? epochMs(args["since-ms"], "--since-ms") : args["since-days"] ? Date.now() - Number(args["since-days"]) * DAY_MS : void 0;
+  if (sinceMs) params["since-ms"] = String(sinceMs);
+  if (args.until) params["until-ms"] = String(epochMs(args.until, "--until"));
+  if (args["test-leads"]) params["test-leads"] = "true";
+  if (args.limit) params.limit = String(args.limit);
+  if (args["no-cache"]) params["skip-cache"] = "true";
+  return params;
+}
+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
+  baker ads linkedin leads --test-leads          # only the test leads Campaign Manager's preview submitted
+
+Answers come back with their question's label, and a multiple-choice answer as
+the option chosen. Form ids are the ones \`baker ads linkedin lead-forms\` lists.`
+  },
+  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)"
+    },
+    until: { type: "string", description: "Only responses submitted before this date (YYYY-MM-DD or epoch ms)" },
+    "test-leads": { type: "boolean", description: "Only test leads (submitted from a form preview)" },
+    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 = leadsParams(args, accountId);
+      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,
+          formName: r.formName ?? "",
+          campaignUrn: r.campaignUrn,
+          campaignName: r.campaignName ?? "",
+          testLead: r.testLead ?? false,
+          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-UHJS7VNH.js.map