@koda-sl/baker-cli 0.567.0 → 0.569.0-dev.1b455b3fe

package/README.md

@@ -491,7 +491,7 @@ Never total or count from a response carrying it — re-run with `--all --out da
 | `jsonl`    | a `{"_baker_warning":{…}}` line first and last |
 | `--out`    | the file summary carries `complete: true|false`, every warning, and the `notice` |
 
-The same lines also go to stderr. A read with nothing to report prints none of it.
+Each warning is printed once, on stdout — never also on stderr — so `--output json … 2>&1` stays one parseable document. A read with nothing to report prints none of it.
 
 **Response (with pagination):**
 
@@ -564,9 +564,9 @@ The same lines also go to stderr. A read with nothing to report prints none of i
 | `campaign-simulations` / `keyword-bid-simulations` | Google's what-if points (budget, tCPA, tROAS, CPC bid) | — |
 | `campaigns`, `budgets`, `ad-groups`, `keywords`, `ads`, `assets`, `asset-groups`, `audiences`, `conversion-actions`, `bidding-strategies`, `labels`, `campaign-criteria`, `ad-group-criteria`, `ad-group-bid-modifiers`, `account-exclusions`, `shared-sets`, `campaign-negative-keywords`, `ad-group-negative-keywords` | Inventories behind the `<thing> list` commands | — |
 
-Every preset except the negatives lists and `account-summary` filters to **actually-serving entities** by default — the full status chain (`campaign.status = 'ENABLED' AND ad_group.status = 'ENABLED' AND ad_group_ad.status = 'ENABLED'`, as applicable) — and selects the status columns so you can see them. Pass `--include-paused` to widen to `!= 'REMOVED'` (keeps paused, still drops removed). Raw GAQL (no `--preset`) has no such default: a query over a serving-hierarchy resource without a status filter emits a `SERVING_SCOPE` warning reminding you to add the chain, because Google Ads has no single serving flag.
+Every preset except the negatives lists and `account-summary` filters to **actually-serving entities** by default — the full status chain (`campaign.status = 'ENABLED' AND ad_group.status = 'ENABLED' AND ad_group_ad.status = 'ENABLED'`, as applicable) — and selects the status columns so you can see them. Pass `--include-paused` to widen to `!= 'REMOVED'` (keeps paused, still drops removed). Raw GAQL (no `--preset`) has no such default: a query over a serving-hierarchy resource without a status filter emits a `SERVING_SCOPE` warning reminding you to add the chain, because Google Ads has no single serving flag — unless its WHERE names the entities by id (`campaign.id = …` or `IN (…)`).
 
-**Conversion rates across campaigns are not comparable by default.** `metrics.conversions` is a sum over whatever conversion actions are primary for each campaign, and those differ campaign by campaign — a webinar registration in one, an info request in the next. A read that selects a conversion metric, is not segmented by conversion action, and is not pinned to one campaign (`WHERE campaign.id = …`) comes back with a `CONVERSION_MIX` warning: a total across those rows adds different events, and one campaign's rate is not comparable with another's. `--preset conversions-by-action` is the read that settles it. Like every other warning it travels in `--output csv|jsonl|md` and on the `--out` file summary.
+**Conversion rates across campaigns are not comparable by default.** `metrics.conversions` is a sum over whatever conversion actions are primary for each campaign, and those differ campaign by campaign — a webinar registration in one, an info request in the next. A read that selects a conversion metric, is not segmented by conversion action, and is not pinned to one campaign (`WHERE campaign.id = …`) comes back with a `CONVERSION_MIX` warning when at least two of its rows carry a conversion (a page with more to read, or an `--out` file, is judged on the statement alone): a total across those rows adds different events, and one campaign's rate is not comparable with another's. `--preset conversions-by-action` is the read that settles it. Like every other warning it travels in `--output csv|jsonl|md` and on the `--out` file summary.
 
 **"Eligible (Limited)" keywords:** an enabled keyword that barely shows is invisible in the performance presets — near-zero impressions look the same whether it is outbid, low quality, or rarely searched. `--preset keyword-serving` reads the signals behind Google Ads' status column: `ad_group_criterion.primary_status` and `primary_status_reasons` (the status enum has no `LIMITED` value — "(Limited)" lives in the reasons while the status stays `ELIGIBLE`), `position_estimates.first_page_cpc_micros` (the number in "Below first page bid (€3.63)"), the max CPC actually in force and where it comes from, quality score split into ad relevance / landing page / expected CTR, approval status, and `system_serving_status`. Any read whose rows carry those fields — preset or raw GAQL — comes back with a `KEYWORD_SERVING_LIMITED` warning naming the affected keywords (each by its ad group, since one keyword's copies share a criterion id) and the bid each would need. Below-first-page-bid and low-quality want opposite fixes (raise the bid vs. improve relevance), so the warning reports them separately. On `--out` the verdict is folded across pages as they stream to disk and returned on the file summary; like every other warning it also travels in `--output csv|jsonl|md`.
 
@@ -943,7 +943,7 @@ baker ads linkedin draft show --chat <chat-id> li_temp_ab12
 baker tag-manager draft show --chat <chat-id> gtm_temp_ab12
 baker actions draft --chat <chat-id>
 
-# Move another open chat's staged Google Ads changes into this chat (and out of that one)
+# Move another unpublished chat's staged Google Ads changes into this chat (and out of that one)
 baker ads google draft import --from-chat <chat-id>                      # every staged change
 baker ads google draft import --from-chat <chat-id> --exclude g_temp_a   # all but these (and what depends on them)
 baker ads google draft import --from-chat <chat-id> --refs g_temp_b      # only these (and what they are tied to)
@@ -981,9 +981,9 @@ Command groups: `account` (update), `budgets` (create/update/remove), `campaigns
 
 **Tracking warnings** — Tag Manager stage, amend, list and show responses provide repair hints whenever warnings remain. The compact `tag-manager draft list` prints the warnings beside their changes. Resolve the intended event role and technical gaps, then read the draft again before finishing; progress and diagnostics are not counted just to clear an alert. Adding and then removing a conversion that was never live cancels that proposal, so it disappears from the review.
 
-**Reading an earlier chat's changes** — `draft list` and `draft show` take `--chat <chat-id>` to read another chat in the same company instead of the current one. Every staged-draft family accepts it: `ads google|meta|linkedin draft list|show`, `tag-manager draft list|show`, `actions draft`, `tags draft`, and `scheduled-agents list|get` (`list` leaves briefs out; `get <id>` or `list --full` returns them). A published draft is kept in full, so this returns what that chat actually wrote — every headline, bid and target — plus each op's outcome and error. Use it when asked to redo or reapply earlier work rather than reconstructing copy from a summary. Read-only: staging, `amend`, `remove` and `clear` stay bound to `BAKER_CHAT_ID`, so one chat can never edit another's draft — the exceptions are `baker chats import` and `ads google draft import`, below, which take changes out of the other chat as they move them here. To re-run only the changes a publish failed to land, use the chat's **Retry** control in the dashboard — it re-sends exactly those and leaves the ones that applied untouched.
+**Reading an earlier chat's changes** — `draft list` and `draft show` take `--chat <chat-id>` to read another chat in the same company instead of the current one. Every staged-draft family accepts it: `ads google|meta|linkedin draft list|show`, `tag-manager draft list|show`, `actions draft`, `tags draft`, and `scheduled-agents list|get` (`list` leaves briefs out; `get <id>` or `list --full` returns them). A published draft is kept in full, so this returns what that chat actually wrote — every headline, bid and target — plus each op's outcome and error. Use it when asked to redo or reapply earlier work rather than reconstructing copy from a summary. Read-only: staging, `amend`, `remove` and `clear` stay bound to `BAKER_CHAT_ID`, so one chat can never edit another's draft — the exceptions are `baker chats import` and `ads google draft import`, below, which take changes out of the other chat as they move them here. To bring here only the changes a published chat's publish failed to land, use `baker chats import --from-chat <chat-id> --failed` — it stages exactly those on every ad platform and leaves the ones that applied untouched.
 
-**Bringing another chat's changes here** — `baker chats import --from-chat <chat-id>` moves everything it staged, on every surface (see `baker chats`). For Google Ads alone, with a choice of which changes: `baker ads google draft import --from-chat <chat-id>` moves the other chat's staged Google Ads changes into this chat's draft exactly as they were staged (same refs, same payloads) and **removes them from the other chat**, so the two can never publish the same change twice. `--refs a,b` moves only those, `--exclude a,b` leaves those behind; a change always moves with what it depends on and what depends on it (an asset and the link that attaches it go together), and a `--refs` or `--exclude` that names nothing is refused rather than read as "everything". The other chat must still be open; its other work stays where it is. Nothing moves when both chats change the same live entity (the refusal names it and how to keep both), when the two drafts together would stage one account-level conversion goal twice, or when together they would leave the account with no primary conversion action. Run `draft validate` afterwards.
+**Bringing another chat's changes here** — `baker chats import --from-chat <chat-id>` moves everything it staged, on every surface (see `baker chats`). For Google Ads alone, with a choice of which changes: `baker ads google draft import --from-chat <chat-id>` moves the other chat's staged Google Ads changes into this chat's draft exactly as they were staged (same refs, same payloads) and **removes them from the other chat**, so the two can never publish the same change twice. `--refs a,b` moves only those, `--exclude a,b` leaves those behind; a change always moves with what it depends on and what depends on it (an asset and the link that attaches it go together), and a `--refs` or `--exclude` that names nothing is refused rather than read as "everything". The other chat must not be published (open, publish failed or discarded); its other work stays where it is. Nothing moves when both chats change the same live entity (the refusal names it and how to keep both), when the two drafts together would stage one account-level conversion goal twice, or when together they would leave the account with no primary conversion action. Run `draft validate` afterwards.
 
 **Already-satisfied writes aren't staged** — an update or pause/resume whose every field already holds the requested value on the live account is dropped instead of staged: the envelope returns `"staged": false, "noop": true` with a `reason` ("this ad is already Paused on Google Ads"), plus a hint. This is a success, not an error — there is nothing to publish. Only a positively-read live snapshot can trigger it; a failed or empty read always stages. Batch responses list the dropped ops under `skipped`, and `count` reflects what actually entered the draft.
 
@@ -5033,15 +5033,16 @@ baker chats transcript --search "5.700"   # this chat's own earlier messages hol
 baker chats diff <id> --surface landings  # real file-level changes, landings only
 baker chats diff <id> --full              # include the unified-diff patch text
 baker chats diff <id> --live              # in-progress Session: read from its live workspace
-baker chats import --from-chat <id>       # move another open Session's staged changes here
+baker chats import --from-chat <id>       # bring another unpublished Session's files + staged changes here
+baker chats import --from-chat <id> --failed  # a published Session's ad changes that failed to apply
 ```
 
 **`list` flags:** `--status active|archived|all` (default `all`), `--limit` (1-100, default 20), `--full` (include each Session's full change list), `--search <words>` (Sessions whose title or conversation holds any of the words, newest first; each row carries the `match` it was found by).
 **`view`:** returns the unified `effects` — git content (`content`, `creatives`) AND DB-only effects that never touch the repo (`actions`, `scheduledAgents`, `tags`, `ads.{google,meta,linkedin,x}`, `tagManager`, `ga4`, `shopify`, `activeCampaign`, `funnel` (with the ways in it added or removed, `triggersAdded`/`triggersRemoved`), `conversions`, `conversionSends`, `eventSources`), plus `otherChanges` for every other change the Session made (A/B tests, recipes, library images), each resolved to real detail and flagged `staged` (in-progress draft) vs applied. Plus `kickoff`, `outputs` counts, `threads`, `commits`, `diffAvailable`, and `publish` — what the Publish left behind (`failedTotal`) and the changes that went through but read back differently on the platform afterwards (`unconfirmedTotal`, `surfaces[].unconfirmedChanges`); a hint names either.
 **`transcript` flags:** no id reads this chat's own conversation; `--search <text>` (only messages holding it, case-insensitive, over the whole conversation), `--role user|assistant`, `--turns` (each user message and the agent's closing message of that turn), `--limit` (1-1000, default 100, most recent), `--full` (untruncated text). Returns `entries` (`role` + `text`) and `truncated`.
-**`diff` flags:** `--surface knowledge|company|brand|landings|flows|creatives`, `--full` (patch text per file), `--live` (read an in-progress Session's changes from its live workspace). Returns `available`, `source` (`published`|`live`), `files` (`path`, `surface`, `status`, `additions`, `deletions`, `patch`), and `truncated` when a large live diff was capped.
+**`diff` flags:** `--surface knowledge|company|brand|landings|flows|creatives`, `--full` (patch text per file), `--live` (read an in-progress Session's changes from its live workspace). The `/api/chats/diff` route also takes `gitPatch` with `live`, returning the whole change as one `git apply`-ready patch (binary files included) — what `import` applies. Returns `available`, `source` (`published`|`live`), `files` (`path`, `surface`, `status`, `additions`, `deletions`, `patch`), and `truncated` when a large live diff was capped.
 
-**`import --from-chat <id> [--only <surfaces>]`:** moves what another **open** Session has staged and not published into this one (`BAKER_CHAT_ID`), exactly as staged, and removes it from that Session — so publishing both can never apply a change twice. It moves every staged surface — Google, Meta, LinkedIn, X and ChatGPT Ads, Shopify, Tag Manager, Google Analytics, tracking tags, Tasks, scheduled agents, ActiveCampaign, site settings, ad goals, the funnel, conversions, conversion sends, event sources and lead routes — or only those `--only` names (comma-separated; surfaces whose changes name each other must be named together). A clash anywhere moves nothing, and the error names each one: both Sessions changing the same thing, ads sending people to a page only the other Session built, or tags its edited Forms may use. Returns `surfaces` (`surface`, `moved`, and `left: { count, reason }` for what stayed, such as an A/B test whose variant page that Session built) and `filesStayed`, the file changes (Knowledge, pages, Forms) that never move; hints say what to do about each. If the other Session changes during the move, part of it may move and `left` says what stayed. A Session opened by a product running out of stock is refused: its ad pauses turn back on by themselves only when it publishes. To move only some Google Ads changes, use `baker ads google draft import --refs|--exclude`.
+**`import --from-chat <id> [--only <surfaces>] [--failed]`:** brings what another Session did and never published — open, its publish failed, or discarded — into this one (`BAKER_CHAT_ID`), exactly, and removes it from that Session, so publishing both can never apply a change twice. Its **file changes** are read from its workspace as one patch and applied here with `git apply` (all or none; a file both Sessions changed differently refuses the import and is named; a discarded Session's files are gone and the result says so). Every **staged surface** moves as staged — Google, Meta, LinkedIn, X and ChatGPT Ads, Shopify, Tag Manager, Google Analytics, tracking tags, Tasks, scheduled agents, ActiveCampaign, site settings, ad goals, the funnel, conversions, conversion sends, event sources and lead routes — or only those `--only` names (comma-separated, no files; surfaces whose changes name each other must be named together). A clash anywhere moves nothing, and the error names each one; when the staged move is refused, the applied files are taken back out. Returns `surfaces` (`surface`, `moved`, and `left: { count, reason }` for what stayed), `filesStayed`, and `carried` — the other Session (not an open one) held nothing more and can no longer be published. `--failed` takes a **published** Session instead: the Google Ads, Meta, LinkedIn, X and ChatGPT changes its publish could not apply (failed, or skipped behind a failure) are staged here as they were, naming a parent that did apply by its real id and renaming a temporary ref this chat already uses, and are removed from that Session so its Retry cannot apply them twice. A Session opened by a product running out of stock is refused: its ad pauses turn back on by themselves only when it publishes. To move only some Google Ads changes, use `baker ads google draft import --refs|--exclude`.
 
 A Session's effects live in two places: **git content** (files — landings, creatives, flows, brand, knowledge) and **DB-only effects** (Actions, Tags, ad-platform writes — never in the repo). `view` unifies BOTH. `diff` covers the git content (the actual file patches): a **published** Session reads from the commit merged to `main` (durable); an **in-progress** Session has no commit yet, so pass **`--live`** to read its changes straight from the running workspace (it wakes the Session's Runtime; only works while it still exists — a discarded Session's workspace is gone). Use `view` for the complete picture, `diff` (or `diff --live`) to read the real file content.
 

package/dist/account-JREYXYNE.js

@@ -0,0 +1,82 @@
+import {
+  CHATGPT_ADS_REFERENCE,
+  runChatgptRead
+} from "./chunk-3JOGDGGP.js";
+import "./chunk-MK4HCMEA.js";
+import "./chunk-SOPVIIUW.js";
+import "./chunk-G4FG5EQO.js";
+import {
+  apiGet
+} from "./chunk-QEREDRZO.js";
+import "./chunk-JXTNP3B5.js";
+import "./chunk-45D6WRCJ.js";
+import {
+  registerSchema
+} from "./chunk-CCYZJMZ7.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-IUIXIVRC.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-JREYXYNE.js.map

package/dist/account-OUKPRB7C.js

@@ -0,0 +1,139 @@
+import {
+  handleMetaError,
+  resolveAccountIdArg
+} from "./chunk-7TVVYP7K.js";
+import "./chunk-QALAJNBG.js";
+import {
+  writeJsonEnvelope
+} from "./chunk-MK4HCMEA.js";
+import {
+  NO_CACHE_ARG
+} from "./chunk-GO6ISZUZ.js";
+import {
+  apiGet
+} from "./chunk-QEREDRZO.js";
+import "./chunk-JXTNP3B5.js";
+import "./chunk-45D6WRCJ.js";
+import "./chunk-CCYZJMZ7.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-OUKPRB7C.js.map

package/dist/account-WN5MJ5QN.js

@@ -0,0 +1,82 @@
+import {
+  csvOrJson,
+  handleLinkedinError,
+  resolveAccountIdArg
+} from "./chunk-34MZGC2Y.js";
+import {
+  writeAdsJson,
+  writeAdsOutput
+} from "./chunk-MK4HCMEA.js";
+import {
+  NO_CACHE_ARG
+} from "./chunk-GO6ISZUZ.js";
+import "./chunk-YOHGEF2N.js";
+import "./chunk-QV6AST5T.js";
+import "./chunk-WCU362Z6.js";
+import "./chunk-GIWHHCD6.js";
+import "./chunk-SOPVIIUW.js";
+import "./chunk-G4FG5EQO.js";
+import "./chunk-R7XDGNZD.js";
+import "./chunk-IMS53EQU.js";
+import {
+  apiGet
+} from "./chunk-QEREDRZO.js";
+import "./chunk-JXTNP3B5.js";
+import "./chunk-45D6WRCJ.js";
+import "./chunk-CCYZJMZ7.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-HFP5KLYZ.js").then((m) => m.accountUrlParamsCommand)
+  },
+  args: accountDetailCommand.args,
+  default: "detail"
+});
+export {
+  accountCommand
+};
+//# sourceMappingURL=account-WN5MJ5QN.js.map