@koda-sl/baker-cli 0.525.0 → 0.527.0

package/README.md

@@ -44,6 +44,7 @@ export BAKER_CHAT_ID="<chat-id>"
 - `BAKER_GOOGLE_ADS_CUSTOMER_ID` — default Google Ads customer ID (10 digits). Used when `--customer-id` is not passed. If neither is set and the account has exactly one Google Ads customer, it is auto-selected.
 - `BAKER_GA4_PROPERTY_ID` — default GA4 property ID. Used when `--property-id` is not passed. If neither is set and exactly one property is connected, it is auto-selected.
 - `BAKER_GSC_SITE_URL` — default GSC site URL. Used when `--site-url` is not passed. If neither is set and exactly one site is verified, it is auto-selected.
+- `BAKER_META_AD_ACCOUNT_ID` — default Meta ad account ID (`act_<n>` or the bare number). Used when `--account-id` is not passed. If neither is set and exactly one Meta ad account is connected, it is auto-selected; with several, the command refuses with `MISSING_ACCOUNT_ID` and lists them.
 - `BAKER_X_ADS_ACCOUNT_ID` — default X Ads account ID (base36). Used when `--account-id` is not passed. If neither is set and exactly one X Ads account is connected, it is auto-selected.
 - `BAKER_CHAT_ID` — chat context for staged Work Action commands and staged Scheduled agent create/update/delete/unstage. `scheduled-agents run` does not require it. When set, it is also sent as an `x-baker-chat-id` header on every request, so library additions that apply immediately (images, videos, followed brands) are listed in that chat's changes as already applied.
 - `BAKER_THREAD_ID` — set per turn by the sandbox. Sent as an `x-baker-thread-id` header alongside the chat header, so the tools a command reports or changes are those of whoever sent this turn, even while someone else writes in another thread of the same chat.
@@ -110,7 +111,12 @@ looked like it had filtered or narrowed a result was in fact answering the unfil
 question — and nothing in the output said so. Both spellings of an option work
 (`--run-id` and `--run-id`), as they always did. The error's `fix` names the exact call
 that lists every option: `baker schema <command>` (`check_schema`) when the command
-registers a schema, `baker <command> --help` (`check_help`) when it does not.
+registers a schema, `baker <command> --help` (`check_help`) when it does not. An option
+that names one of the command's positionals (`actions complete --id X`, `ads google query --query "SELECT …"`)
+gets `use_positional`, a `correctedCommand` with the value written bare, `usage` (the call's shape:
+`<id>` positional, `--note <note>` required) and `validOptions`. `baker schema <command>` types those
+arguments `positional`, from the command's own declaration, and prints the same `usage`, with the
+subcommand a group needs (`<create|update|delete>`).
 
 ### Narrowing a result: `--fields`
 

package/dist/account-2G3IT7J4.js

@@ -0,0 +1,82 @@
+import {
+  csvOrJson,
+  handleLinkedinError,
+  resolveAccountIdArg
+} from "./chunk-364TCROV.js";
+import {
+  writeAdsJson,
+  writeAdsOutput
+} from "./chunk-HPDGVK6R.js";
+import {
+  NO_CACHE_ARG
+} from "./chunk-X3HPRECW.js";
+import "./chunk-HVJJEQDQ.js";
+import "./chunk-QV6AST5T.js";
+import "./chunk-WCU362Z6.js";
+import "./chunk-GIWHHCD6.js";
+import "./chunk-SOPVIIUW.js";
+import "./chunk-G4FG5EQO.js";
+import "./chunk-NSBNIPIW.js";
+import "./chunk-46YLDIQG.js";
+import {
+  apiGet
+} from "./chunk-B4UVJCJ4.js";
+import "./chunk-AFQF6ISC.js";
+import "./chunk-52IYZCRS.js";
+import "./chunk-FSGJSREN.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/ads/linkedin/account.ts
+import { defineCommand } from "citty";
+var accountDetailCommand = defineCommand({
+  meta: {
+    name: "detail",
+    description: `Single LinkedIn ad account detail (currency, status, type).
+
+Examples:
+  baker ads linkedin account --account-id 503001492
+  baker ads linkedin account --account-urn urn:li:sponsoredAccount:503001492 --output md`
+  },
+  args: {
+    "account-id": { type: "string", description: "Numeric account ID or urn:li:sponsoredAccount:N" },
+    "account-urn": { type: "string", description: "Alias for --account-id" },
+    "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["no-cache"]) params["skip-cache"] = "true";
+      const data = await apiGet("/api/ads/linkedin/account", params);
+      const fmt = csvOrJson(args);
+      if (fmt !== "json") {
+        writeAdsOutput([data], fmt);
+        return;
+      }
+      writeAdsJson({ ok: true, data });
+    } catch (err) {
+      handleLinkedinError(err);
+    }
+  }
+});
+var accountCommand = defineCommand({
+  meta: {
+    name: "account",
+    description: `LinkedIn ad account: its detail, and the settings that apply across every ad set in it.
+
+Examples:
+  baker ads linkedin account --account-id 503001492                          \u2014 currency, status, type
+  baker ads linkedin account url-params --param utm_source=linkedin          \u2014 UTMs for every ad in the account`
+  },
+  subCommands: {
+    detail: accountDetailCommand,
+    "url-params": () => import("./write-commands-V77MD5SC.js").then((m) => m.accountUrlParamsCommand)
+  },
+  args: accountDetailCommand.args,
+  default: "detail"
+});
+export {
+  accountCommand
+};
+//# sourceMappingURL=account-2G3IT7J4.js.map

package/dist/account-CQJFUII3.js

@@ -0,0 +1,139 @@
+import {
+  handleMetaError,
+  resolveAccountIdArg
+} from "./chunk-BN4TDL5L.js";
+import "./chunk-QALAJNBG.js";
+import {
+  writeJsonEnvelope
+} from "./chunk-HPDGVK6R.js";
+import {
+  NO_CACHE_ARG
+} from "./chunk-X3HPRECW.js";
+import {
+  apiGet
+} from "./chunk-B4UVJCJ4.js";
+import "./chunk-AFQF6ISC.js";
+import "./chunk-52IYZCRS.js";
+import "./chunk-FSGJSREN.js";
+import "./chunk-YQSBHWOI.js";
+
+// ../api/src/ads-meta/accountHealth.ts
+var ACCOUNT_STATUS = {
+  1: "ACTIVE",
+  2: "DISABLED",
+  3: "UNSETTLED",
+  7: "PENDING_RISK_REVIEW",
+  8: "PENDING_SETTLEMENT",
+  9: "IN_GRACE_PERIOD",
+  100: "PENDING_CLOSURE",
+  101: "CLOSED",
+  201: "ANY_ACTIVE",
+  202: "ANY_CLOSED"
+};
+var DISABLE_REASON = {
+  1: "ads integrity policy",
+  2: "ads IP review",
+  3: "payment risk",
+  4: "gray account shut down",
+  5: "ads AFC review",
+  6: "business integrity review",
+  7: "permanently closed",
+  8: "unused reseller account",
+  9: "unused account",
+  10: "umbrella ad account",
+  11: "Business Manager integrity policy",
+  12: "misrepresented ad account",
+  13: "legal entity de-share",
+  14: "thread review",
+  15: "compromised ad account"
+};
+var DELIVERS_ANYWAY = /* @__PURE__ */ new Set([1, 9]);
+function statusBlocker(account) {
+  const status = account.account_status;
+  if (status === void 0 || status === 1) return void 0;
+  const name = ACCOUNT_STATUS[status] ?? `status ${status}`;
+  const reason = account.disable_reason ? DISABLE_REASON[account.disable_reason] : void 0;
+  const why = reason ? ` (${reason})` : "";
+  if (DELIVERS_ANYWAY.has(status)) {
+    return `the ad account is ${name}${why}: a payment failed and Meta stops delivery when the grace period ends \u2014 the account owner settles it in Meta Billing`;
+  }
+  return `the ad account is ${name}${why}, so nothing on it delivers \u2014 only the account owner can resolve that with Meta (Account Quality / Billing)`;
+}
+function metaAccountDeliveryBlockers(account) {
+  const blockers = [];
+  const status = statusBlocker(account);
+  if (status) blockers.push(status);
+  const hasFunding = Boolean(account.funding_source || account.funding_source_details?.id);
+  if (!hasFunding && !account.is_prepay_account) {
+    blockers.push(
+      "the ad account has no payment method, so Meta accepts its ads but delivers none (they wait in PENDING_BILLING_INFO) \u2014 the account owner adds one in Meta Billing"
+    );
+  }
+  if (spendCapReached(account)) {
+    blockers.push(
+      "the ad account has reached its spending limit, so Meta stops delivering every ad on it \u2014 an admin raises or removes the limit in Meta Billing \u2192 Payment settings, or Baker can change it as part of a chat"
+    );
+  }
+  return blockers;
+}
+function spendCapReached(account) {
+  const cap = Number(account.spend_cap ?? "0");
+  const spent = Number(account.amount_spent ?? "0");
+  return Number.isFinite(cap) && Number.isFinite(spent) && cap > 0 && spent >= cap;
+}
+
+// src/commands/ads/meta/account.ts
+import { defineCommand } from "citty";
+var accountCommand = defineCommand({
+  meta: {
+    name: "account",
+    description: `Show single Meta ad account detail (currency, timezone, balance, business) and whether it can deliver:
+a hint names a disabled account or a missing payment method, which Meta never refuses at publish \u2014 its ads just never run.
+\`bakerPermissions\` says which per-company Meta permissions (leadAds, catalog, pagePosts) are switched on for this
+company and held by the connection; a hint names any that still needs the user to reconnect Meta.
+
+Examples:
+  baker ads meta account --account-id act_123
+  BAKER_META_AD_ACCOUNT_ID=act_123 baker ads meta account`
+  },
+  args: {
+    "account-id": { type: "string", description: "Meta ad account ID (act_...)" },
+    "no-cache": NO_CACHE_ARG
+  },
+  run: async ({ args }) => {
+    const accountId = await resolveAccountIdArg(args);
+    try {
+      const params = { "account-id": accountId };
+      if (args["no-cache"]) params["skip-cache"] = "true";
+      const data = await apiGet("/api/ads/meta/account", params);
+      const permissionHints = data.bakerPermissions ? accountPermissionHints(data.bakerPermissions) : [];
+      writeJsonEnvelope({ ok: true, data, hints: [...accountDeliveryHints(data), ...permissionHints] });
+    } catch (err) {
+      handleMetaError(err);
+    }
+  }
+});
+function accountDeliveryHints(account) {
+  const blockers = metaAccountDeliveryBlockers(account);
+  if (blockers.length === 0) return ["The account can deliver: it is active and has a payment method."];
+  return [
+    ...blockers.map((blocker) => `Cannot deliver: ${blocker}.`),
+    "Staging still works and publishing still applies the changes, but nothing serves until this is fixed \u2014 tell the user before they publish anything they expect to run."
+  ];
+}
+var PERMISSION_LABEL = {
+  leadAds: "Lead ads (instant forms and their leads)",
+  catalog: "Catalog changes",
+  pagePosts: "Facebook Page posts"
+};
+function accountPermissionHints(permissions) {
+  return Object.keys(PERMISSION_LABEL).filter((key) => permissions[key].reconnectNeeded).map(
+    (key) => `${PERMISSION_LABEL[key]}: switched on for this company, but this Meta connection predates it \u2014 ask the user to reconnect Meta in the dashboard before relying on it.`
+  );
+}
+export {
+  accountCommand,
+  accountDeliveryHints,
+  accountPermissionHints
+};
+//# sourceMappingURL=account-CQJFUII3.js.map

package/dist/account-CQJFUII3.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../api/src/ads-meta/accountHealth.ts","../src/commands/ads/meta/account.ts"],"sourcesContent":["/**\n * Whether a Meta ad account can deliver at all — read off the account node.\n *\n * Meta stages and publishes ads on an account that cannot pay or is disabled\n * without a word: the docs say an account with no funding source can \"still\n * create ads but these ads will get no delivery\", and they sit in\n * PENDING_BILLING_INFO. Nothing in the publish answer says so, so the only\n * place to catch it is a read of the account before something goes live.\n */\n\n/** The account fields this reads (all in `ACCOUNT_FIELDS`). */\nexport interface MetaAccountHealthFields {\n  account_status?: number;\n  disable_reason?: number;\n  funding_source?: string;\n  funding_source_details?: { id?: string; display_string?: string; type?: number } | null;\n  is_prepay_account?: boolean;\n  /** Minor units as a string; \"0\" is no limit. */\n  spend_cap?: string;\n  amount_spent?: string;\n  /** What the person whose connection Baker uses may do on the account (MANAGE, ADVERTISE, ANALYZE, DRAFT). */\n  user_tasks?: string[];\n}\n\n/** `account_status` values, from the Ad Account reference (v25.0). 1 is the only one that delivers. */\nconst ACCOUNT_STATUS: Readonly<Record<number, string>> = {\n  1: \"ACTIVE\",\n  2: \"DISABLED\",\n  3: \"UNSETTLED\",\n  7: \"PENDING_RISK_REVIEW\",\n  8: \"PENDING_SETTLEMENT\",\n  9: \"IN_GRACE_PERIOD\",\n  100: \"PENDING_CLOSURE\",\n  101: \"CLOSED\",\n  201: \"ANY_ACTIVE\",\n  202: \"ANY_CLOSED\",\n};\n\n/** Why an account is disabled, when it is (`disable_reason`). */\nconst DISABLE_REASON: Readonly<Record<number, string>> = {\n  1: \"ads integrity policy\",\n  2: \"ads IP review\",\n  3: \"payment risk\",\n  4: \"gray account shut down\",\n  5: \"ads AFC review\",\n  6: \"business integrity review\",\n  7: \"permanently closed\",\n  8: \"unused reseller account\",\n  9: \"unused account\",\n  10: \"umbrella ad account\",\n  11: \"Business Manager integrity policy\",\n  12: \"misrepresented ad account\",\n  13: \"legal entity de-share\",\n  14: \"thread review\",\n  15: \"compromised ad account\",\n};\n\n/**\n * In grace period, Meta still delivers while a failed payment is retried, so\n * it is a warning that delivery is about to stop rather than a stop.\n */\nconst DELIVERS_ANYWAY = new Set([1, 9]);\n\nfunction statusBlocker(account: MetaAccountHealthFields): string | undefined {\n  const status = account.account_status;\n  if (status === undefined || status === 1) return undefined;\n  const name = ACCOUNT_STATUS[status] ?? `status ${status}`;\n  const reason = account.disable_reason ? DISABLE_REASON[account.disable_reason] : undefined;\n  const why = reason ? ` (${reason})` : \"\";\n  if (DELIVERS_ANYWAY.has(status)) {\n    return `the ad account is ${name}${why}: a payment failed and Meta stops delivery when the grace period ends — the account owner settles it in Meta Billing`;\n  }\n  return `the ad account is ${name}${why}, so nothing on it delivers — only the account owner can resolve that with Meta (Account Quality / Billing)`;\n}\n\n/**\n * Plain reasons this account will not deliver, empty when it can. Each names\n * who can fix it, since nothing Baker stages can.\n */\nexport function metaAccountDeliveryBlockers(account: MetaAccountHealthFields): string[] {\n  const blockers: string[] = [];\n  const status = statusBlocker(account);\n  if (status) blockers.push(status);\n  const hasFunding = Boolean(account.funding_source || account.funding_source_details?.id);\n  if (!hasFunding && !account.is_prepay_account) {\n    blockers.push(\n      \"the ad account has no payment method, so Meta accepts its ads but delivers none (they wait in PENDING_BILLING_INFO) — the account owner adds one in Meta Billing\",\n    );\n  }\n  if (spendCapReached(account)) {\n    blockers.push(\n      \"the ad account has reached its spending limit, so Meta stops delivering every ad on it — an admin raises or removes the limit in Meta Billing → Payment settings, or Baker can change it as part of a chat\",\n    );\n  }\n  return blockers;\n}\n\n/** `spend_cap` \"0\" (or absent) is no limit; a limit reached stops all delivery until it is raised. */\nfunction spendCapReached(account: MetaAccountHealthFields): boolean {\n  const cap = Number(account.spend_cap ?? \"0\");\n  const spent = Number(account.amount_spent ?? \"0\");\n  return Number.isFinite(cap) && Number.isFinite(spent) && cap > 0 && spent >= cap;\n}\n\n/** Statuses on which Meta takes no new ads or edits: only the account owner and Meta can change them. */\nconst REFUSES_WRITES = new Set([2, 101]);\n\n/** Where an account owner reads why Meta restricted an account and asks for a review. */\nexport const META_ACCOUNT_QUALITY_URL = \"https://www.facebook.com/accountquality\";\n\n/**\n * Why Meta will refuse this change on this account at publish, or `undefined`.\n *\n * Only explicit evidence refuses: an account whose status is missing from the\n * read says nothing. A `removal` (a delete, a pause) is let through, because it\n * takes nothing live and is what someone cleaning up a disabled account does.\n */\nexport function metaAccountWriteRefusal(\n  account: MetaAccountHealthFields,\n  change: \"change\" | \"removal\",\n): string | undefined {\n  return accessRefusal(account.user_tasks) ?? statusRefusal(account, change);\n}\n\n/** Tasks that let a person publish changes on an ad account; ANALYZE and DRAFT do not. */\nconst PUBLISHING_TASKS = new Set([\"MANAGE\", \"ADVERTISE\"]);\n\nfunction accessRefusal(tasks: readonly string[] | undefined): string | undefined {\n  if (!tasks || tasks.length === 0 || tasks.some((task) => PUBLISHING_TASKS.has(task))) return undefined;\n  return 'the person who connected Meta to Baker can only view this ad account, so Meta refuses every change Baker would publish on it — an admin of the ad account gives them the \"Manage campaigns\" permission in Meta Business settings → Ad accounts (https://business.facebook.com/settings/ad-accounts), then this can be staged again';\n}\n\nfunction statusRefusal(account: MetaAccountHealthFields, change: \"change\" | \"removal\"): string | undefined {\n  const status = account.account_status;\n  if (status === undefined || !REFUSES_WRITES.has(status) || change === \"removal\") return undefined;\n  const reason = account.disable_reason ? DISABLE_REASON[account.disable_reason] : undefined;\n  const why = reason ? ` (${reason})` : \"\";\n  return `the ad account is ${ACCOUNT_STATUS[status]}${why}, so Meta refuses new ads and edits on it — only the account owner can resolve that with Meta, in Account Quality (${META_ACCOUNT_QUALITY_URL}); nothing can be staged here until then`;\n}\n","import { type MetaAccountHealthFields, metaAccountDeliveryBlockers } from \"@baker/api/ads-meta/accountHealth\";\nimport type { MetaPermissionStates } from \"@baker/api/ads-meta/permissionGates\";\nimport { defineCommand } from \"citty\";\nimport { NO_CACHE_ARG } from \"../../../cache-flag.ts\";\nimport { apiGet } from \"../../../client.ts\";\nimport { writeJsonEnvelope } from \"../output.ts\";\nimport { handleMetaError, resolveAccountIdArg } from \"./shared.ts\";\n\nexport const accountCommand = defineCommand({\n  meta: {\n    name: \"account\",\n    description: `Show single Meta ad account detail (currency, timezone, balance, business) and whether it can deliver:\na hint names a disabled account or a missing payment method, which Meta never refuses at publish — its ads just never run.\n\\`bakerPermissions\\` says which per-company Meta permissions (leadAds, catalog, pagePosts) are switched on for this\ncompany and held by the connection; a hint names any that still needs the user to reconnect Meta.\n\nExamples:\n  baker ads meta account --account-id act_123\n  BAKER_META_AD_ACCOUNT_ID=act_123 baker ads meta account`,\n  },\n  args: {\n    \"account-id\": { type: \"string\", description: \"Meta ad account ID (act_...)\" },\n    \"no-cache\": NO_CACHE_ARG,\n  },\n  run: async ({ args }) => {\n    const accountId = await resolveAccountIdArg(args);\n    try {\n      const params: Record<string, string> = { \"account-id\": accountId };\n      if (args[\"no-cache\"]) params[\"skip-cache\"] = \"true\";\n      const data = await apiGet<\n        Record<string, unknown> & MetaAccountHealthFields & { bakerPermissions?: MetaPermissionStates }\n      >(\"/api/ads/meta/account\", params);\n      const permissionHints = data.bakerPermissions ? accountPermissionHints(data.bakerPermissions) : [];\n      writeJsonEnvelope({ ok: true, data, hints: [...accountDeliveryHints(data), ...permissionHints] });\n    } catch (err) {\n      handleMetaError(err);\n    }\n  },\n});\n\n/** Whether ads on this account can run at all, said once, in the words staging warns with. */\nexport function accountDeliveryHints(account: MetaAccountHealthFields): string[] {\n  const blockers = metaAccountDeliveryBlockers(account);\n  if (blockers.length === 0) return [\"The account can deliver: it is active and has a payment method.\"];\n  return [\n    ...blockers.map((blocker) => `Cannot deliver: ${blocker}.`),\n    \"Staging still works and publishing still applies the changes, but nothing serves until this is fixed — tell the user before they publish anything they expect to run.\",\n  ];\n}\n\nconst PERMISSION_LABEL: Record<keyof MetaPermissionStates, string> = {\n  leadAds: \"Lead ads (instant forms and their leads)\",\n  catalog: \"Catalog changes\",\n  pagePosts: \"Facebook Page posts\",\n};\n\n/** One hint per permission switched on for this company that the current Meta connection does not hold yet. */\nexport function accountPermissionHints(permissions: MetaPermissionStates): string[] {\n  return (Object.keys(PERMISSION_LABEL) as (keyof MetaPermissionStates)[])\n    .filter((key) => permissions[key].reconnectNeeded)\n    .map(\n      (key) =>\n        `${PERMISSION_LABEL[key]}: switched on for this company, but this Meta connection predates it — ask the user to reconnect Meta in the dashboard before relying on it.`,\n    );\n}\n"],"mappings":"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","names":[]}

package/dist/account-ULC5N7SI.js

@@ -0,0 +1,82 @@
+import {
+  CHATGPT_ADS_REFERENCE,
+  runChatgptRead
+} from "./chunk-SNDHR5QA.js";
+import "./chunk-HPDGVK6R.js";
+import "./chunk-SOPVIIUW.js";
+import "./chunk-G4FG5EQO.js";
+import {
+  apiGet
+} from "./chunk-B4UVJCJ4.js";
+import "./chunk-AFQF6ISC.js";
+import "./chunk-52IYZCRS.js";
+import {
+  registerSchema
+} from "./chunk-FSGJSREN.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/ads/chatgpt/account.ts
+import { defineCommand } from "citty";
+registerSchema({
+  command: "ads.chatgpt.account",
+  description: "The connected ChatGPT Ads account: name, currency, timezone, status, and the brand and account reviews that decide whether anything in it can serve.",
+  args: {
+    full: { type: "boolean", description: "Return ChatGPT Ads' own account object", required: false }
+  }
+});
+function accountHints(account) {
+  const hints = [];
+  if (account.brandReview.status !== "approved") {
+    const reason = account.brandReview.reason ? ` (${account.brandReview.reason})` : "";
+    hints.push(
+      `Brand review is ${account.brandReview.status}${reason}: nothing in this account serves until it is approved. Fix it in ChatGPT Ads Manager before changing campaigns.`
+    );
+  }
+  if (account.accountReview && account.accountReview.status !== "approved") {
+    hints.push(`A separate account review is ${account.accountReview.status}; delivery can wait on it too.`);
+  }
+  if (account.status === "paused") {
+    hints.push("The whole account is paused, so no campaign in it serves whatever its own status says.");
+  }
+  return hints;
+}
+var SHOW_ARGS = {
+  full: { type: "boolean", description: "Return ChatGPT Ads' own account object", required: false }
+};
+var accountShowCommand = defineCommand({
+  meta: {
+    name: "show",
+    description: "The connected ChatGPT Ads account. Example: baker ads chatgpt account"
+  },
+  args: SHOW_ARGS,
+  run: async ({ args }) => {
+    await runChatgptRead(
+      CHATGPT_ADS_REFERENCE.account,
+      () => apiGet("/api/ads/chatgpt/account", args.full ? { full: "true" } : void 0),
+      (account) => args.full ? [] : accountHints(account)
+    );
+  }
+});
+var accountCommand = defineCommand({
+  meta: {
+    name: "account",
+    description: `The connected ChatGPT Ads account. Start here: currency and timezone for every figure, and whether reviews let anything serve.
+
+Examples:
+  baker ads chatgpt account
+  baker ads chatgpt account --full
+  baker ads chatgpt account update --favicon-url https://example.com/icon.png   \u2014 staged; applies on publish`
+  },
+  subCommands: {
+    show: accountShowCommand,
+    update: () => import("./account-writes-WRGJC7VU.js").then((m) => m.accountUpdateCommand)
+  },
+  // A parent must never declare `run`: citty falls through to it after the matched subcommand.
+  args: SHOW_ARGS,
+  default: "show"
+});
+export {
+  accountCommand,
+  accountHints
+};
+//# sourceMappingURL=account-ULC5N7SI.js.map

package/dist/account-assets-IDVG4DGK.js

@@ -0,0 +1,290 @@
+import {
+  csvOrJson,
+  handleMetaError,
+  resolveAccountIdArg
+} from "./chunk-BN4TDL5L.js";
+import "./chunk-QALAJNBG.js";
+import {
+  writeAdsOutput,
+  writeJsonEnvelope
+} from "./chunk-HPDGVK6R.js";
+import {
+  NO_CACHE_ARG
+} from "./chunk-X3HPRECW.js";
+import {
+  apiGet
+} from "./chunk-B4UVJCJ4.js";
+import "./chunk-AFQF6ISC.js";
+import "./chunk-52IYZCRS.js";
+import {
+  registerSchema
+} from "./chunk-FSGJSREN.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/ads/meta/account-assets.ts
+import { defineCommand } from "citty";
+function emit(rows, args, hints) {
+  const fmt = csvOrJson(args);
+  if (fmt !== "json") {
+    writeAdsOutput(rows, fmt, void 0, hints);
+    return;
+  }
+  writeJsonEnvelope(hints.length > 0 ? { ok: true, data: rows, hints } : { ok: true, data: rows });
+}
+async function read(path, params, args) {
+  if (args["no-cache"]) params["skip-cache"] = "true";
+  return await apiGet(path, params);
+}
+var outputArg = { type: "string", description: "json|csv|jsonl|md", default: "json" };
+var accountArg = { type: "string", description: "Meta ad account ID (act_...)" };
+var schemaAccount = { type: "string", description: "Meta ad account ID (act_123)", required: false };
+var schemaNoCache = { type: "boolean", description: "Bypass the cache", required: false };
+var schemaOutput = { type: "string", description: "json|csv|jsonl|md", required: false, default: "json" };
+function instagramIdentityHints(rows) {
+  if (rows.length === 0) {
+    return [
+      "No Instagram account is linked to this ad account or its Pages. A creative without --instagram-user cannot run in Instagram feeds, Stories or Reels \u2014 the account owner links one in Meta Business settings (Accounts \u2192 Instagram accounts) and assigns it to the ad account."
+    ];
+  }
+  const listed = rows.filter((row) => row.sources.includes("ad_account") || row.sources.includes("connected"));
+  const hints = ["Pass the id as `creatives create --instagram-user <id>`."];
+  if (listed.length > 0 && listed.length < rows.length) {
+    hints.push(
+      `Use one listed on the ad account (${listed.map((row) => row.username ?? row.id).join(", ")}): when the account lists any, staging refuses an identity it does not list.`
+    );
+  } else if (listed.length === 0) {
+    hints.push(
+      "Only Page identities are listed (page = the Page's linked Instagram account, page_backed = an Instagram presence Meta made for a Page with none). Meta accepts either as --instagram-user; a page_backed one shows the Page's name and picture on Instagram."
+    );
+  }
+  if (new Set(rows.map((row) => row.pageId).filter(Boolean)).size > 1) {
+    hints.push("Several Pages are involved \u2014 use the identity of the Page the creative runs from (--page).");
+  }
+  return hints;
+}
+registerSchema({
+  command: "ads.meta.instagram-accounts",
+  description: "The Instagram accounts an ad on this account can run as \u2014 the id `creatives create --instagram-user` takes. Lists accounts assigned or connected to the ad account and each promotable Page's linked or page-backed one.",
+  args: {
+    "account-id": schemaAccount,
+    "no-cache": schemaNoCache,
+    output: { type: "string", description: "json|csv", required: false, default: "json" }
+  }
+});
+var instagramAccountsCommand = defineCommand({
+  meta: {
+    name: "instagram-accounts",
+    description: "Instagram identities an ad can run as (the --instagram-user id). Start here before creatives create: baker ads meta instagram-accounts --account-id act_123"
+  },
+  args: { "account-id": accountArg, "no-cache": NO_CACHE_ARG, output: outputArg },
+  run: async ({ args }) => {
+    const accountId = await resolveAccountIdArg(args);
+    try {
+      const rows = await read(
+        "/api/ads/meta/instagram-accounts",
+        { "account-id": accountId },
+        args
+      );
+      emit(
+        rows.map((row) => ({ ...row, sources: row.sources.join(",") })),
+        args,
+        instagramIdentityHints(rows)
+      );
+    } catch (err) {
+      handleMetaError(err);
+    }
+  }
+});
+registerSchema({
+  command: "ads.meta.apps",
+  description: "The apps this ad account can promote (app installs / app engagement), with their store URLs \u2014 the application_id and object_store_url an app ad set's promoted_object takes.",
+  args: { "account-id": schemaAccount, "no-cache": schemaNoCache, output: schemaOutput }
+});
+var appsCommand = defineCommand({
+  meta: {
+    name: "apps",
+    description: "Apps the ad account can promote, for an app ad set's promoted_object. Example: baker ads meta apps --account-id act_123"
+  },
+  args: { "account-id": accountArg, "no-cache": NO_CACHE_ARG, output: outputArg },
+  run: async ({ args }) => {
+    const accountId = await resolveAccountIdArg(args);
+    try {
+      const rows = await read(
+        "/api/ads/meta/apps",
+        { "account-id": accountId },
+        args
+      );
+      emit(
+        rows.map((row) => ({ ...row })),
+        args,
+        rows.length > 0 ? [
+          'An app ad set promotes one: promoted_object {"application_id":"<id>","object_store_url":"<store url>"}. Use a real store URL (itunes / google_play); fb_canvas and instant_game are not app stores.'
+        ] : [
+          "No promotable apps. The app has to be registered in Meta for Developers and its owner has to add this ad account under the app's Advanced settings \u2192 Advertising accounts."
+        ]
+      );
+    } catch (err) {
+      handleMetaError(err);
+    }
+  }
+});
+registerSchema({
+  command: "ads.meta.dsa-recommendations",
+  description: "Names Meta suggests for the EU Digital Services Act disclosure (who benefits from and who pays for an ad) on this account.",
+  args: { "account-id": schemaAccount, "no-cache": schemaNoCache }
+});
+var dsaRecommendationsCommand = defineCommand({
+  meta: {
+    name: "dsa-recommendations",
+    description: "Meta's suggested DSA beneficiary/payor names for EU ad sets. Example: baker ads meta dsa-recommendations --account-id act_123"
+  },
+  args: { "account-id": accountArg, "no-cache": NO_CACHE_ARG },
+  run: async ({ args }) => {
+    const accountId = await resolveAccountIdArg(args);
+    try {
+      const names = await read("/api/ads/meta/dsa-recommendations", { "account-id": accountId }, args);
+      writeJsonEnvelope({
+        ok: true,
+        data: names,
+        hints: [
+          "An ad set reaching the EU needs dsa_beneficiary and dsa_payor. When they are missing Baker fills both from the ad account's saved EU advertiser and payer, else the first of these, else the business name; pass one of these instead when the user names someone else (an agency paying for a client)."
+        ]
+      });
+    } catch (err) {
+      handleMetaError(err);
+    }
+  }
+});
+function compactImage(row) {
+  return {
+    hash: row.hash,
+    name: row.name,
+    width: row.width,
+    height: row.height,
+    status: row.status,
+    created_time: row.created_time
+  };
+}
+registerSchema({
+  command: "ads.meta.images",
+  description: "The ad account's image library \u2014 each image_hash a creative can reuse without uploading again. --hash looks one up.",
+  args: {
+    "account-id": schemaAccount,
+    hash: { type: "string", description: "One image hash", required: false },
+    limit: { type: "string", description: "Max rows (default 500)", required: false },
+    full: { type: "boolean", description: "URLs, permalink and which creatives use it", required: false },
+    "no-cache": schemaNoCache,
+    output: schemaOutput
+  }
+});
+var imagesCommand = defineCommand({
+  meta: {
+    name: "images",
+    description: "Image library of the ad account (image hashes). Example: baker ads meta images --account-id act_123 --limit 20; --hash <hash> for one"
+  },
+  args: {
+    "account-id": accountArg,
+    hash: { type: "string", description: "Look up one image hash" },
+    limit: { type: "string", description: "Max rows (default 500)" },
+    full: { type: "boolean", description: "Every field: url, permalink_url, creatives" },
+    "no-cache": NO_CACHE_ARG,
+    output: outputArg
+  },
+  run: async ({ args }) => {
+    const accountId = await resolveAccountIdArg(args);
+    const params = { "account-id": accountId };
+    if (args.hash) params.hash = args.hash;
+    if (args.limit) params.limit = args.limit;
+    try {
+      const rows = await read("/api/ads/meta/images", params, args);
+      emit(args.full ? rows : rows.map(compactImage), args, [
+        "A creative reuses one with its hash (the `image_hash` of a creative file). To push a Baker-library image, stage `media upload` instead."
+      ]);
+    } catch (err) {
+      handleMetaError(err);
+    }
+  }
+});
+registerSchema({
+  command: "ads.meta.labels",
+  description: "Ad labels defined on the account (Meta's tags for campaigns, ad sets, ads and creatives).",
+  args: { "account-id": schemaAccount, "no-cache": schemaNoCache, output: schemaOutput }
+});
+var labelsListArgs = { "account-id": accountArg, "no-cache": NO_CACHE_ARG, output: outputArg };
+var labelsCommand = defineCommand({
+  meta: {
+    name: "labels",
+    description: `Ad labels on the account (list), or stage label writes: create, rename, delete, attach (file campaigns/ad sets/ads/creatives under one), detach.
+  baker ads meta labels --account-id act_123
+  baker ads meta labels create --name "Q4 launch"
+  baker ads meta labels attach <labelId|meta_temp_\u2026> --campaigns 6123,6124 --ads 6125`
+  },
+  subCommands: {
+    list: () => labelsListCommand,
+    create: () => import("./asset-writes-SSI3CO2A.js").then((m) => m.labelsCreateCommand),
+    rename: () => import("./asset-writes-SSI3CO2A.js").then((m) => m.labelsRenameCommand),
+    delete: () => import("./asset-writes-SSI3CO2A.js").then((m) => m.labelsDeleteCommand),
+    attach: () => import("./asset-writes-SSI3CO2A.js").then((m) => m.labelsAttachCommand),
+    detach: () => import("./asset-writes-SSI3CO2A.js").then((m) => m.labelsDetachCommand)
+  },
+  args: labelsListArgs,
+  default: "list"
+});
+var labelsListCommand = defineCommand({
+  meta: {
+    name: "list",
+    description: "Ad labels on the account. Runs by default. Example: baker ads meta labels --account-id act_123"
+  },
+  args: labelsListArgs,
+  run: async ({ args }) => {
+    const accountId = await resolveAccountIdArg(args);
+    try {
+      const rows = await read("/api/ads/meta/labels", { "account-id": accountId }, args);
+      emit(rows, args, rows.length === 0 ? ["This account has no ad labels."] : []);
+    } catch (err) {
+      handleMetaError(err);
+    }
+  }
+});
+registerSchema({
+  command: "ads.meta.high-demand-periods",
+  description: "The budget boosts (high-demand periods) set on a campaign or ad set: when each runs and by how much.",
+  args: {
+    "campaign-id": { type: "string", description: "Campaign or ad set ID", required: true },
+    "no-cache": schemaNoCache,
+    output: schemaOutput
+  }
+});
+var highDemandPeriodsCommand = defineCommand({
+  meta: {
+    name: "high-demand-periods",
+    description: "Budget boosts on a campaign or ad set. Example: baker ads meta high-demand-periods --campaign-id 6123 (stage new ones with --budget-boost on campaigns or adsets create|update)"
+  },
+  args: {
+    "campaign-id": { type: "string", description: "Campaign (or ad set) ID", required: true },
+    "no-cache": NO_CACHE_ARG,
+    output: outputArg
+  },
+  run: async ({ args }) => {
+    try {
+      const rows = await read(
+        "/api/ads/meta/high-demand-periods",
+        { "campaign-id": args["campaign-id"] },
+        args
+      );
+      emit(rows, args, rows.length === 0 ? ["No budget boosts on this campaign."] : []);
+    } catch (err) {
+      handleMetaError(err);
+    }
+  }
+});
+export {
+  appsCommand,
+  dsaRecommendationsCommand,
+  highDemandPeriodsCommand,
+  imagesCommand,
+  instagramAccountsCommand,
+  instagramIdentityHints,
+  labelsCommand
+};
+//# sourceMappingURL=account-assets-IDVG4DGK.js.map