@koda-sl/baker-cli 0.512.0 → 0.514.0-dev.555f7007e

package/dist/account-level-4SBYYHRS.js

@@ -0,0 +1,611 @@
+import {
+  dayPartingFromFlags
+} from "./chunk-7BUIOP36.js";
+import {
+  bareAccountId,
+  failWriteValidation,
+  loadJsonFileArg,
+  numberFlag,
+  requireTarget,
+  stageOp
+} from "./chunk-QDQZ62FL.js";
+import "./chunk-Q3GSVLE5.js";
+import "./chunk-GDFJOCDO.js";
+import {
+  handleMetaError
+} from "./chunk-B2POVFR2.js";
+import {
+  repeatedValues
+} from "./chunk-ERSX3MKH.js";
+import "./chunk-SCAGMX2I.js";
+import "./chunk-4NZ47VXO.js";
+import "./chunk-D5FY4FAK.js";
+import "./chunk-QPESDKZC.js";
+import "./chunk-Y2JZX6JB.js";
+import {
+  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-SOPVIIUW.js";
+import "./chunk-G4FG5EQO.js";
+import "./chunk-NSBNIPIW.js";
+import {
+  apiGet,
+  apiPost
+} 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/account-level.ts
+import { defineCommand } from "citty";
+var STAGED_NOTE = "Staged until publish \u2014 review with `baker ads meta draft`.";
+var schemaAccount = { type: "string", description: "Numeric account ID or act_N", required: false };
+function emit(data, hints = []) {
+  writeJsonEnvelope(hints.length > 0 ? { ok: true, data, hints } : { ok: true, data });
+}
+async function readEdge(params) {
+  return await apiGet("/api/ads/meta/account-edges", params);
+}
+registerSchema({
+  command: "ads.meta.account-settings",
+  description: "Stage a change to the ad account's own settings: its name or its account spending limit (set, remove, or count again from zero). Made at publish.",
+  args: {
+    "account-id": schemaAccount,
+    name: { type: "string", description: "New account name", required: false },
+    "spending-limit": {
+      type: "string",
+      description: "Account spending limit, major units (e.g. 5000)",
+      required: false
+    },
+    "remove-spending-limit": { type: "boolean", description: "Remove the spending limit", required: false },
+    "reset-spending-limit": { type: "boolean", description: "Count toward the limit again from zero", required: false },
+    "default-eu-advertiser": {
+      type: "string",
+      description: "Default EU (DSA) advertiser \u2014 who the ads are for \u2014 for new ad sets; pass with --default-eu-payer",
+      required: false
+    },
+    "default-eu-payer": {
+      type: "string",
+      description: "Default EU (DSA) payer for new ad sets; pass with --default-eu-advertiser",
+      required: false
+    },
+    "clear-default-eu": {
+      type: "boolean",
+      description: "Clear both the default EU advertiser and payer",
+      required: false
+    }
+  }
+});
+var accountSettingsCommand = defineCommand({
+  meta: {
+    name: "account-settings",
+    description: `Change the ad account's own settings \u2014 its name or its account spending limit. ${STAGED_NOTE}
+The limit counts spend from the moment it is set (Meta starts the count again), and every campaign on the account stops when it is reached. Ask the user before touching it \u2014 it is account-wide.
+Start here: baker ads meta account --account-id act_123 (shows spend_cap and amount_spent, in minor units)
+Example: baker ads meta account-settings --account-id act_123 --spending-limit 5000
+         baker ads meta account-settings --account-id act_123 --remove-spending-limit
+The EU (DSA) advertiser and payer new ad sets start with \u2014 both together, names from \`baker ads meta dsa-recommendations\` confirmed with the user:
+         baker ads meta account-settings --account-id act_123 --default-eu-advertiser "Acme SL" --default-eu-payer "Acme SL"`
+  },
+  args: {
+    "account-id": { type: "string", description: "Numeric account ID or act_N \u2014 the account itself" },
+    name: { type: "string", description: "New account name" },
+    "spending-limit": { type: "string", description: "Account spending limit in the account currency, e.g. 5000" },
+    "remove-spending-limit": { type: "boolean", description: "Take the account spending limit away" },
+    "reset-spending-limit": { type: "boolean", description: "Keep the limit and count spend toward it from zero" },
+    "default-eu-advertiser": {
+      type: "string",
+      description: "Default EU (DSA) advertiser for new ad sets \u2014 with --default-eu-payer (Meta keeps both or neither)"
+    },
+    "default-eu-payer": { type: "string", description: "Default EU (DSA) payer for new ad sets" },
+    "clear-default-eu": { type: "boolean", description: "Clear both the default EU advertiser and payer" }
+  },
+  run: async ({ args }) => {
+    const accountId = bareAccountId(args);
+    if (args["remove-spending-limit"] && args["reset-spending-limit"]) {
+      failWriteValidation("pass --remove-spending-limit OR --reset-spending-limit");
+    }
+    const action = args["remove-spending-limit"] ? "remove" : args["reset-spending-limit"] ? "reset" : void 0;
+    await stageOp({
+      kind: "adAccount.update",
+      accountId,
+      target: accountId,
+      payload: {
+        name: args.name,
+        spendCap: args["spending-limit"] ? { amount: String(args["spending-limit"]) } : void 0,
+        spendCapAction: action,
+        defaultDsaBeneficiary: args["default-eu-advertiser"],
+        defaultDsaPayor: args["default-eu-payer"],
+        clearDefaultDsa: args["clear-default-eu"] ? true : void 0
+      }
+    });
+  }
+});
+registerSchema({
+  command: "ads.meta.block-lists",
+  description: "The ad account's publisher block lists \u2014 websites and apps its ads stay off (Audience Network, in-stream). --full lists each list's sites.",
+  args: {
+    "account-id": schemaAccount,
+    full: { type: "boolean", description: "Include each list's sites and apps", required: false }
+  }
+});
+var blockListsListCommand = defineCommand({
+  meta: {
+    name: "list",
+    description: "Block lists on the ad account. Runs by default. Example: baker ads meta block-lists --account-id act_123 --full"
+  },
+  args: {
+    "account-id": { type: "string", description: "Numeric account ID or act_N" },
+    full: { type: "boolean", description: "Include each list's sites and apps" }
+  },
+  run: async ({ args }) => {
+    try {
+      const params = { edge: "block-lists", "account-id": bareAccountId(args) };
+      if (args.full) params.full = "true";
+      const rows = await readEdge(params);
+      emit(rows, [
+        "Keep an ad set off a list with `adsets create|update --block-list <id>` (repeatable); add sites with `block-lists add <id> --url \u2026`. Meta takes no site off a list and renames none \u2014 make a new list instead."
+      ]);
+    } catch (err) {
+      handleMetaError(err);
+    }
+  }
+});
+registerSchema({
+  command: "ads.meta.block-lists.create",
+  description: "Stage a new publisher block list on the ad account, with its sites and apps. Made at publish.",
+  args: {
+    "account-id": schemaAccount,
+    name: { type: "string", description: "List name", required: true },
+    url: { type: "string", description: "A site (example.com) or app store address \u2014 repeatable", required: false },
+    file: { type: "string", description: 'JSON file {"urls": [...]} for long lists', required: false }
+  }
+});
+function urlsFrom(args, rawArgs) {
+  const file = loadJsonFileArg(args.file);
+  const fromFile = Array.isArray(file.urls) ? file.urls.filter((u) => typeof u === "string") : [];
+  const urls = [...repeatedValues(rawArgs, "url", args.url), ...fromFile];
+  if (urls.length === 0) failWriteValidation('pass --url (repeatable) or --file with {"urls": [...]}');
+  return urls;
+}
+var blockListsCreateCommand = defineCommand({
+  meta: {
+    name: "create",
+    description: `Create a publisher block list. ${STAGED_NOTE}
+Example: baker ads meta block-lists create --account-id act_123 --name "No gambling sites" --url casino.example --url bets.example
+Then keep ad sets off it: baker ads meta adsets update <id> --block-list meta_temp_\u2026`
+  },
+  args: {
+    "account-id": { type: "string", description: "Numeric account ID or act_N" },
+    name: { type: "string", description: "List name", required: true },
+    url: { type: "string", description: "A site (example.com) or app store address \u2014 repeatable" },
+    file: { type: "string", description: 'JSON file {"urls": [...]} for a long list (up to 10,000)' }
+  },
+  run: async ({ args, rawArgs }) => {
+    await stageOp({
+      kind: "publisherBlockList.create",
+      accountId: bareAccountId(args),
+      payload: { name: args.name, urls: urlsFrom(args, rawArgs) }
+    });
+  }
+});
+registerSchema({
+  command: "ads.meta.block-lists.add",
+  description: "Stage adding sites and apps to a block list. Meta takes none off a list.",
+  args: {
+    id: { type: "positional", description: "Block list id", required: true },
+    "account-id": schemaAccount,
+    url: { type: "string", description: "A site or app store address \u2014 repeatable", required: false },
+    file: { type: "string", description: 'JSON file {"urls": [...]}', required: false }
+  }
+});
+var blockListsAddCommand = defineCommand({
+  meta: {
+    name: "add",
+    description: `Add sites and apps to a block list. ${STAGED_NOTE}
+Example: baker ads meta block-lists add 120249500506120208 --account-id act_123 --url spam.example`
+  },
+  args: {
+    id: { type: "positional", description: "Block list id", required: true },
+    "account-id": { type: "string", description: "Numeric account ID or act_N" },
+    url: { type: "string", description: "A site or app store address \u2014 repeatable" },
+    file: { type: "string", description: 'JSON file {"urls": [...]}' }
+  },
+  run: async ({ args, rawArgs }) => {
+    await stageOp({
+      kind: "publisherBlockList.update",
+      accountId: bareAccountId(args),
+      target: requireTarget(args, "block list"),
+      payload: { addUrls: urlsFrom(args, rawArgs) }
+    });
+  }
+});
+registerSchema({
+  command: "ads.meta.block-lists.delete",
+  description: "Stage deleting a block list. Ad sets that used it can show on its sites again.",
+  args: { id: { type: "positional", description: "Block list id", required: true }, "account-id": schemaAccount }
+});
+var blockListsDeleteCommand = defineCommand({
+  meta: {
+    name: "delete",
+    description: `Delete a block list \u2014 ad sets that used it can show on its sites and apps again. ${STAGED_NOTE}
+Example: baker ads meta block-lists delete 120249500506120208 --account-id act_123`
+  },
+  args: {
+    id: { type: "positional", description: "Block list id", required: true },
+    "account-id": { type: "string", description: "Numeric account ID or act_N" }
+  },
+  run: async ({ args }) => {
+    await stageOp({
+      kind: "publisherBlockList.update",
+      accountId: bareAccountId(args),
+      target: requireTarget(args, "block list"),
+      payload: { status: "DELETED" }
+    });
+  }
+});
+var blockListsCommand = defineCommand({
+  meta: {
+    name: "block-lists",
+    description: `Publisher block lists \u2014 websites and apps the ad account's ads stay off (Audience Network, in-stream).
+  baker ads meta block-lists --account-id act_123 [--full]
+  baker ads meta block-lists create --name \u2026 --url \u2026 | add <id> --url \u2026 | delete <id>
+An ad set uses a list with \`adsets create|update --block-list <id>\`; \`--content-filter FEED_STRICT\` and \`--exclude-publisher-category gambling\` set the rest of its brand safety.`
+  },
+  subCommands: {
+    list: blockListsListCommand,
+    create: blockListsCreateCommand,
+    add: blockListsAddCommand,
+    delete: blockListsDeleteCommand
+  },
+  args: {
+    "account-id": { type: "string", description: "Numeric account ID or act_N" },
+    full: { type: "boolean", description: "Include each list's sites and apps" }
+  },
+  default: "list"
+});
+registerSchema({
+  command: "ads.meta.reach-frequency",
+  description: "The ad account's reach-and-frequency quotes and reservations: reach, budget, dates, frequency cap, whether reserved and until when.",
+  args: { "account-id": schemaAccount }
+});
+var reachFrequencyListCommand = defineCommand({
+  meta: {
+    name: "list",
+    description: "Reach-and-frequency quotes on the ad account (reservation_status 1 = reserved, until expiration_time). Runs by default. Example: baker ads meta reach-frequency --account-id act_123"
+  },
+  args: { "account-id": { type: "string", description: "Numeric account ID or act_N" } },
+  run: async ({ args }) => {
+    try {
+      const rows = await readEdge({ edge: "reach-frequency", "account-id": bareAccountId(args) });
+      emit(rows, [
+        "Budgets here are in the account currency's minor units (cents). Reserve a quote with `reach-frequency reserve <id>`; a reserved campaign is `campaigns create --buying-type RESERVED` and its ad set `adsets create --reservation <reservation id>`."
+      ]);
+    } catch (err) {
+      handleMetaError(err);
+    }
+  }
+});
+registerSchema({
+  command: "ads.meta.reach-frequency.predict",
+  description: "Ask Meta for a reach-and-frequency quote: how many people a budget reaches (or what a reach costs) over fixed dates in one country, at a frequency cap. A forecast \u2014 holds nothing and spends nothing.",
+  args: {
+    "account-id": schemaAccount,
+    "page-id": { type: "string", description: "Facebook Page the ads run as", required: true },
+    budget: { type: "string", description: "Lifetime budget, major units (solves for reach)", required: false },
+    reach: { type: "string", description: "People to reach (solves for budget)", required: false },
+    start: { type: "string", description: "Start, ISO date-time", required: true },
+    end: { type: "string", description: "End, ISO date-time", required: true },
+    "frequency-cap": {
+      type: "string",
+      description: "Most times one person sees it per --frequency-days",
+      required: false
+    },
+    "frequency-days": { type: "string", description: "Days the cap counts over (default 7)", required: false },
+    objective: { type: "string", description: "REACH (default) | BRAND_AWARENESS | VIDEO_VIEWS | \u2026", required: false },
+    "optimization-goal": { type: "string", description: "Optional optimization goal", required: false },
+    "instagram-user": { type: "string", description: "Instagram account the ads run as", required: false },
+    "targeting-file": { type: "string", description: "Targeting JSON \u2014 ONE country", required: true },
+    schedule: { type: "string", description: 'Hours to run in, repeatable: "Mon-Fri 09-18"', required: false },
+    "target-frequency": {
+      type: "string",
+      description: "Balanced frequency: views per person per --target-frequency-days (OUTCOME_AWARENESS + REACH)",
+      required: false
+    },
+    "target-frequency-days": {
+      type: "string",
+      description: "Days the target counts over (default 7)",
+      required: false
+    },
+    "instream-package": {
+      type: "string",
+      description: "In-stream video packages, repeatable: NORMAL | PREMIUM | SPORTS | \u2026",
+      required: false
+    }
+  }
+});
+function unixSeconds(value, flag) {
+  const ms = typeof value === "string" ? Date.parse(value) : Number.NaN;
+  if (!Number.isFinite(ms)) failWriteValidation(`${flag} takes an ISO date-time, e.g. 2026-11-01T00:00:00Z`);
+  return Math.floor(ms / 1e3);
+}
+var reachFrequencyPredictCommand = defineCommand({
+  meta: {
+    name: "predict",
+    description: `Ask Meta what a reach-and-frequency buy would reach (or cost). A forecast: nothing is held or spent, and the quote expires on its own.
+Start here: baker ads meta account --account-id act_123 (the account needs CAN_USE_REACH_AND_FREQUENCY; Meta's floor is about 200,000 people per country)
+Example: baker ads meta reach-frequency predict --account-id act_123 --page-id 904238019441800 --budget 1000 --start 2026-11-01T00:00:00Z --end 2026-11-08T00:00:00Z --frequency-cap 2 --targeting-file t.json`
+  },
+  args: {
+    "account-id": { type: "string", description: "Numeric account ID or act_N" },
+    "page-id": { type: "string", description: "Facebook Page the ads run as \u2014 from `baker ads meta pages`" },
+    "instagram-user": { type: "string", description: "Instagram account the ads run as" },
+    budget: { type: "string", description: "Lifetime budget in the account currency (solves for reach)" },
+    reach: { type: "string", description: "People to reach (solves for budget)" },
+    start: { type: "string", description: "Start, ISO date-time" },
+    end: { type: "string", description: "End, ISO date-time (at most 90 days after the start)" },
+    "frequency-cap": { type: "string", description: "Most times one person sees the ads per --frequency-days" },
+    "frequency-days": { type: "string", description: "Days the cap counts over (default 7)" },
+    objective: {
+      type: "string",
+      description: "REACH (default) | BRAND_AWARENESS | VIDEO_VIEWS | POST_ENGAGEMENT | LINK_CLICKS | OUTCOME_AWARENESS | OUTCOME_ENGAGEMENT"
+    },
+    "optimization-goal": { type: "string", description: "Optional optimization goal" },
+    "targeting-file": { type: "string", description: "Targeting JSON (as for adsets create) \u2014 ONE country" },
+    schedule: {
+      type: "string",
+      description: 'Run only in these hours, repeatable: "<days> <from>-<to>", e.g. "Mon-Fri 09-18". Live, Meta stored day-parted quotes but answered status 18 (no reach) for them'
+    },
+    "target-frequency": {
+      type: "string",
+      description: "Balanced frequency: aim each person at this many views per --target-frequency-days (default 7) instead of a cap \u2014 needs --objective OUTCOME_AWARENESS and --optimization-goal REACH"
+    },
+    "target-frequency-days": { type: "string", description: "Days the target frequency counts over (default 7)" },
+    "instream-package": {
+      type: "string",
+      description: "In-stream video packages the ads may run in, repeatable: NORMAL | PREMIUM | SPORTS | ENTERTAINMENT | \u2026"
+    }
+  },
+  run: async ({ args, rawArgs }) => {
+    if (!args["targeting-file"]) failWriteValidation("pass --targeting-file (one country)");
+    const reach = numberFlag(args.reach, "--reach");
+    const instreamPackages = repeatedValues(rawArgs, "instream-package", args["instream-package"]).flatMap((value) => value.split(",")).map((value) => value.trim().toUpperCase()).filter(Boolean);
+    const body = {
+      accountId: bareAccountId(args),
+      solveFor: reach !== void 0 ? "budget" : "reach",
+      budget: args.budget,
+      reach,
+      start_time: unixSeconds(args.start, "--start"),
+      end_time: unixSeconds(args.end, "--end"),
+      frequencyCap: numberFlag(args["frequency-cap"], "--frequency-cap"),
+      frequencyCapDays: numberFlag(args["frequency-days"], "--frequency-days"),
+      objective: args.objective,
+      optimization_goal: args["optimization-goal"],
+      page_id: args["page-id"],
+      instagram_user_id: args["instagram-user"],
+      targeting: loadJsonFileArg(args["targeting-file"]),
+      targetFrequency: numberFlag(args["target-frequency"], "--target-frequency"),
+      targetFrequencyDays: numberFlag(args["target-frequency-days"], "--target-frequency-days"),
+      day_parting_schedule: dayPartingFromFlags(args, rawArgs),
+      instream_packages: instreamPackages.length > 0 ? instreamPackages : void 0
+    };
+    try {
+      const quote = await apiPost("/api/ads/meta/reach-frequency/predict", body);
+      const unanswered = quote.status === 1 ? [] : [
+        `Meta did not quote this (status ${String(quote.status)}, reach 0) \u2014 nothing to reserve. Live, a run ending before 6 AM account time on its last day came back this way: move --end later in the day, or widen the audience (Meta's floor is about 200,000 people), and ask again.`
+      ];
+      emit(quote, [
+        ...unanswered,
+        "external_reach / external_impression are what Meta forecasts; external_budget and the min/max bounds are in minor units (cents). To hold this price, `reach-frequency reserve <id>` (staged, made at publish)."
+      ]);
+    } catch (err) {
+      handleMetaError(err);
+    }
+  }
+});
+registerSchema({
+  command: "ads.meta.reach-frequency.reserve",
+  description: "Stage reserving a reach-and-frequency quote: Meta holds its price for about two weeks. Made at publish.",
+  args: { id: { type: "positional", description: "Quote id", required: true }, "account-id": schemaAccount }
+});
+var reachFrequencyReserveCommand = defineCommand({
+  meta: {
+    name: "reserve",
+    description: `Reserve a reach-and-frequency quote \u2014 Meta holds its price until the reservation expires. ${STAGED_NOTE}
+Then buy on it: campaigns create --buying-type RESERVED \u2026, adsets create --reservation meta_temp_\u2026 (no budget \u2014 it comes from the quote).
+Example: baker ads meta reach-frequency reserve 120249500564540208 --account-id act_123`
+  },
+  args: {
+    id: { type: "positional", description: "Quote id (from `reach-frequency predict` or the list)", required: true },
+    "account-id": { type: "string", description: "Numeric account ID or act_N" }
+  },
+  run: async ({ args }) => {
+    await stageOp({
+      kind: "reachFrequencyReservation.create",
+      accountId: bareAccountId(args),
+      payload: { prediction_id: requireTarget(args, "quote") }
+    });
+  }
+});
+registerSchema({
+  command: "ads.meta.reach-frequency.cancel",
+  description: "Stage cancelling a reach-and-frequency reservation, releasing its price. Made at publish.",
+  args: { id: { type: "positional", description: "Reservation id", required: true }, "account-id": schemaAccount }
+});
+var reachFrequencyCancelCommand = defineCommand({
+  meta: {
+    name: "cancel",
+    description: `Cancel a reach-and-frequency reservation. ${STAGED_NOTE}
+Example: baker ads meta reach-frequency cancel 120249500569290208 --account-id act_123`
+  },
+  args: {
+    id: { type: "positional", description: "Reservation id", required: true },
+    "account-id": { type: "string", description: "Numeric account ID or act_N" }
+  },
+  run: async ({ args }) => {
+    await stageOp({
+      kind: "reachFrequencyReservation.update",
+      accountId: bareAccountId(args),
+      target: requireTarget(args, "reservation"),
+      payload: { status: "CANCELLED" }
+    });
+  }
+});
+var reachFrequencyCommand = defineCommand({
+  meta: {
+    name: "reach-frequency",
+    description: `Reach and frequency buying (Reservation): a fixed reach at a fixed price over fixed dates.
+  baker ads meta reach-frequency --account-id act_123                         \u2014 quotes and reservations
+  baker ads meta reach-frequency predict --budget 1000 --start \u2026 --end \u2026 --targeting-file t.json \u2014 a quote (holds nothing)
+  baker ads meta reach-frequency reserve <quote id>  |  cancel <reservation id>  \u2014 staged, made at publish`
+  },
+  subCommands: {
+    list: reachFrequencyListCommand,
+    predict: reachFrequencyPredictCommand,
+    reserve: reachFrequencyReserveCommand,
+    cancel: reachFrequencyCancelCommand
+  },
+  args: { "account-id": { type: "string", description: "Numeric account ID or act_N" } },
+  default: "list"
+});
+registerSchema({
+  command: "ads.meta.page-posts",
+  description: "A Facebook Page's recent posts, with is_eligible_for_promotion \u2014 the posts a `creatives create --type existing_post --post-id` can boost.",
+  args: { "page-id": { type: "string", description: "Facebook Page id", required: true } }
+});
+var pagePostsCommand = defineCommand({
+  meta: {
+    name: "page-posts",
+    description: `A Facebook Page's recent posts, for boosting one as an ad (keeps its likes and comments).
+Example: baker ads meta page-posts --page-id 904238019441800
+Then: baker ads meta creatives create --type existing_post --post-id <id> (only a post with is_eligible_for_promotion: true)`
+  },
+  args: { "page-id": { type: "string", description: "Facebook Page id \u2014 from `baker ads meta pages`" } },
+  run: async ({ args }) => {
+    if (!args["page-id"]) failWriteValidation("pass --page-id (from `baker ads meta pages`)");
+    try {
+      const rows = await readEdge({ edge: "page-posts", "page-id": String(args["page-id"]) });
+      emit(rows, [
+        "Boost one with `creatives create --type existing_post --post-id <id>`; is_eligible_for_promotion false means Meta will not run it as an ad."
+      ]);
+    } catch (err) {
+      handleMetaError(err);
+    }
+  }
+});
+registerSchema({
+  command: "ads.meta.instagram-media",
+  description: "An Instagram account's posts, for boosting one as an ad (`creatives create --type existing_post --instagram-media-id`).",
+  args: { "instagram-user": { type: "string", description: "Instagram account id", required: true } }
+});
+var instagramMediaCommand = defineCommand({
+  meta: {
+    name: "instagram-media",
+    description: `An Instagram account's posts, for boosting one as an ad.
+Example: baker ads meta instagram-media --instagram-user 17841478810711864
+Then: baker ads meta creatives create --type existing_post --instagram-media-id <id> --page <brand page> --instagram-user <id>`
+  },
+  args: {
+    "instagram-user": {
+      type: "string",
+      description: "Instagram account id \u2014 from `baker ads meta instagram-accounts`"
+    }
+  },
+  run: async ({ args }) => {
+    if (!args["instagram-user"])
+      failWriteValidation("pass --instagram-user (from `baker ads meta instagram-accounts`)");
+    try {
+      emit(await readEdge({ edge: "instagram-media", "instagram-user": String(args["instagram-user"]) }));
+    } catch (err) {
+      handleMetaError(err);
+    }
+  }
+});
+registerSchema({
+  command: "ads.meta.comments",
+  description: "The comments on an ad's post (Facebook). Needs Meta permissions the connection may not hold \u2014 a refusal says so; moderation then happens in Meta Business Suite.",
+  args: {
+    "ad-id": { type: "string", description: "Ad id", required: true },
+    full: { type: "boolean", description: "Include who wrote each and its replies count", required: false }
+  }
+});
+var commentsCommand = defineCommand({
+  meta: {
+    name: "comments",
+    description: `The comments people left on an ad's post.
+Example: baker ads meta comments --ad-id 120211234567890
+Reading needs a Meta permission Baker's connection does not ask for yet; when Meta refuses, say moderation happens in Meta Business Suite and carry on.`
+  },
+  args: {
+    "ad-id": { type: "string", description: "Ad id \u2014 from `baker ads meta ads`" },
+    full: { type: "boolean", description: "Include who wrote each comment" }
+  },
+  run: async ({ args }) => {
+    if (!args["ad-id"]) failWriteValidation("pass --ad-id (from `baker ads meta ads`)");
+    try {
+      const params = { "ad-id": String(args["ad-id"]) };
+      if (args.full) params.full = "true";
+      emit(await apiGet("/api/ads/meta/ad-comments", params));
+    } catch (err) {
+      handleMetaError(err);
+    }
+  }
+});
+var ACCOUNT_DETAILS = {
+  recommendations: "Meta's suggestions for the account (often empty)",
+  users: "the people on the account and their tasks (MANAGE, ADVERTISE, ANALYZE, DRAFT) \u2014 read only",
+  "account-controls": "account-wide Advantage+ controls: the minimum age, locations and placements every Advantage+ campaign keeps to \u2014 read only",
+  playables: "playable ads (HTML) uploaded for app ads \u2014 read only",
+  "place-page-sets": "store-location page sets for local ads \u2014 read only"
+};
+registerSchema({
+  command: "ads.meta.account-details",
+  description: `What else belongs to the ad account, read live \u2014 --show one of: ${Object.entries(ACCOUNT_DETAILS).map(([name, what]) => `${name} (${what})`).join("; ")}.`,
+  args: {
+    "account-id": schemaAccount,
+    show: { type: "string", description: Object.keys(ACCOUNT_DETAILS).join("|"), required: true }
+  }
+});
+var accountDetailsCommand = defineCommand({
+  meta: {
+    name: "account-details",
+    description: `What else belongs to the ad account, read live. Nothing here is changed by Baker.
+Example: baker ads meta account-details --account-id act_123 --show users
+--show ${Object.keys(ACCOUNT_DETAILS).join(" | ")}`
+  },
+  args: {
+    "account-id": { type: "string", description: "Numeric account ID or act_N" },
+    show: { type: "string", description: Object.keys(ACCOUNT_DETAILS).join(" | ") }
+  },
+  run: async ({ args }) => {
+    const show = String(args.show ?? "");
+    if (!(show in ACCOUNT_DETAILS)) {
+      failWriteValidation(`--show takes ${Object.keys(ACCOUNT_DETAILS).join(", ")}`);
+    }
+    try {
+      const rows = await readEdge({ edge: show, "account-id": bareAccountId(args) });
+      emit(rows, rows.length === 0 ? [`No ${show} on this ad account.`] : []);
+    } catch (err) {
+      handleMetaError(err);
+    }
+  }
+});
+export {
+  accountDetailsCommand,
+  accountSettingsCommand,
+  blockListsCommand,
+  commentsCommand,
+  instagramMediaCommand,
+  pagePostsCommand,
+  reachFrequencyCommand
+};
+//# sourceMappingURL=account-level-4SBYYHRS.js.map