@koda-sl/baker-cli 0.497.0 → 0.498.0

package/README.md

@@ -178,6 +178,20 @@ Multi-platform ad commands. Google, Meta, and LinkedIn support both reads and **
 
 ---
 
+### `baker ads terms`
+
+Whether an ad account (and its Facebook Pages) has accepted the platform terms that customer lists, buyer audiences, conversion uploads with email or phone, website audiences and lead forms need. Read live; per term: `status` (`accepted` | `not_accepted` | `unknown`), what needs it, who can accept it, numbered steps and a link. `--full` adds the field each status was read from.
+
+```bash
+baker ads terms --platform google --account-id 1234567890
+baker ads terms --platform meta --account-id act_123 --page-id 456
+baker ads terms --platform linkedin --account-id 513852526
+```
+
+A staging command refused for terms a person still has to accept answers `error.code: PLATFORM_TERMS_NOT_ACCEPTED` with the steps and link in `error.fix`.
+
+---
+
 ### `baker ads google accounts`
 
 List the Google Ads accounts selected for this company. Run this first to find account IDs.
@@ -4208,6 +4222,8 @@ baker actions create --name "Build hero" --priority high --tags landing,creative
 # fuller fan-out hint: re-read the draft and merge actions that touch the same system into one.
 # If no --tags are passed, create emits a MISSING --tags hint — the action is invisible to the backlog's tag filter.
 # If no --priority is passed, create emits a MISSING --priority hint — the action ranks as normal/medium in the do-first order.
+# If the name or description holds a shell name such as /bin/bash or bash where a `$0` stood (double quotes let the
+# shell expand `$` amounts), create leads with a hint to fix it with `baker actions update <tempId>` in single quotes.
 baker actions update <action-id> --name "Better name" --tags google-ads,strategy  # --tags REPLACES the set; '' clears
 baker actions update <action-id> --priority urgent                              # urgent|high|medium|low; 'none' clears
 baker actions update <tempId> --description "..."   # a tempId from `create` in THIS chat edits the still-staged task in place
@@ -4450,6 +4466,122 @@ No write surface against HubSpot itself — a form's fields, redirect, or consen
 
 ---
 
+### Shopify buyer audiences
+
+`baker shopify audiences create --segment best|loyal|at_risk|new|one_time|all --to meta|google --account-id <id>` stages a Meta customer list audience or a Google Ads Customer Match list made of one of the store's buyer segments (`--name`, `--refresh daily|off`). At Publish Baker makes the audience and fills it with the buyers who accept marketing (email when subscribed to email, phone when subscribed to SMS), hashed; with `daily` it reads the segment again every day. The answer is counts only: `people`, `withConsent`, `willSend`. `baker shopify audiences list` shows every audience and its last update; `refresh <id>` updates one now; `remove <id>` stages stopping it and deleting it from the platform (`--keep-on-platform` only stops it).
+
+### Shopify sign-up offers
+
+`baker shopify signup-offers` lists active, ended and this chat's staged offers, permissions, codes given and recent refused sign-ups. Stage an offer with `baker shopify change signup-offer set welcome-10 --name "Welcome" --percent 10 --valid-days 14 --max-codes 1000`; use `--amount` instead of `--percent` for a fixed amount, `--products` or `--collections` for eligibility, and `--minimum`, `--ends`, `--prefix` or `--combines` for its terms. `--json` / `--file` also accept the terms. `baker shopify change signup-offer end welcome-10` stops giving new codes after Publish; existing codes keep their terms. Both changes require the user's approval.
+
+Forms use the `shopifyCustomer` side effect: map its `customer` fields with `baker flows map`, name an optional offer handle and show the result with `<ShopifySignupCode form="newsletter" />`. Email and SMS consent each require a separate optional, visible, initially unticked checkbox. Every lead receives at most one code for an offer; Shopify shows one discount per lead.
+
+### `baker shopify store | products | product | collections | stock | sales | buyers | buyer | countries | best-sellers | cohorts | segments | promotions | stock-holds`
+
+Read-only view of the company's **connected Shopify store**, from **Baker's own copy** of its catalog and the store's own orders — never a live call to Shopify. Baker keeps the copy current from the store (a change usually shows within about a minute) and checks the whole catalog daily; product photos are already in the image library.
+
+```bash
+baker shopify store                                # name, currency, home country, counts, prices by country, the Products page link
+baker shopify products --search "snowboard"        # what the store sells: price, sale price, stock, where it can be bought
+baker shopify products --stock out_of_stock        # --stock in_stock|partly_out|out_of_stock, --collection <handle|id>
+baker shopify products --limit 10 --cursor <c>     # page with meta.next_cursor (25 by default, up to 100)
+baker shopify product <id|handle|link>             # one product: options with buyUrl, prices by country, stock, photos, videos
+baker shopify product <handle> --content           # its whole details: description, custom fields, subscriptions, translations
+baker shopify product <handle> --field "Size chart" # one custom field, whole
+baker shopify product <handle> --quantity 2        # buy links that put 2 of the option in the cart
+baker shopify product <id> --out-of-stock          # only the options that are out of stock (page with --variants-cursor)
+baker shopify collections --search "summer"        # collections, with the handle --collection takes (--full: descriptions, images)
+baker shopify stock --limit 20                     # every product with every option out, and every product with some out
+baker shopify sales --days 7 --by campaign         # what sold and which campaigns brought it (--by day|product|campaign|landing)
+baker shopify sales --all --by weekday             # when buyers order, in the store's time (--by hour|month|month_of_year)
+baker shopify buyers --days 90 --by channel        # who buys: new and returning, repeat rate, segments, value per acquisition
+baker shopify buyer 1042                           # one numbered customer: profile, every order, what they bought
+baker shopify countries --country DE               # where buyers are: by country, a country's regions (--region for cities)
+baker shopify best-sellers --view repeat           # what sells (--view products|variants|trend|together|repeat|momentum)
+baker shopify segments                             # best, loyal, at risk, new, one-time, with this store's own rules
+baker shopify cohorts --months 12                  # buyers by first-order month: who came back, spend per buyer
+baker shopify promotions <id|handle|link>          # what advertises a product: ads (via page, buy link, landing), landings, Shopping
+baker shopify stock-holds --product <id>           # ads Baker paused because the product ran out: what to resume, and what to tell the user
+```
+
+**`meta.store`** is on every answer: `connection` (`connected` · `needs_reconnect` · `disconnected`), `catalog` (`starting` · `importing` · `ready` · `failed`, with `importProgress` while importing), `unreadable` (products Baker couldn't read; `unreadableCapped` past 100), `checksFailing` (Baker couldn't check the store for changes lately), `storefront` (`online_store`, or `own` for a store that sells through its own site) and `lastActivity` (when Baker last heard from the store — not a promise the copy is current). `hints[]` turn each of these into what to tell the user.
+**`store`:** `--full` adds the admin link and every country. `canChange` (`products`, `publishing`, `discounts`, `redirects`, `marketing`) says which kinds of store change the store allows Baker to stage; a `false` one is allowed by the user in Shopify. `capped: true` means a count stopped at its ceiling — `outOfStock` and `partlyOut` at 100, `collections` at 500 — so that count reads "that many or more"; a hint says which.
+**`products`:** `--search <words>`, `--collection <handle|id>`, `--stock`, `--limit <1-100>`, `--cursor`; `--full` adds vendor, type, option count, photo link, visibility and status. Every price, here and in `product` (`price`, `compareAt`, each option's price, `pricesByCountry`), is one string with its currency beside each amount: `"USD 785.95"`, `"USD 9.95 – USD 49.95"`. A row's `availability` is absent when the product is on the store, `link_only` when it is buyable only through its link, `not_for_sale` (with `status`) when it can't be bought on the online store.
+**`product`:** positional `<ref>` — the numeric id, the handle, a store product link (`…/products/<handle>`, even an all-digit handle), a Baker Products link, a Shopify admin product link (`admin.shopify.com/store/<shop>/products/<n>`), or `gid://shopify/Product/<n>`. Returns options (50 per page, `--variants-cursor` for more; 250 with `--full`), `outOptions` (up to 50, `outOptionsMore` for the rest), `pricesByCountry` when the store sells at more than one price, `photos[]` (`imageId` + a Baker-hosted `url`, never a Shopify link), `url` (the product's page in Baker) and `storeUrl` (the product's page on the store — never a buy button's link). `--full` adds the whole description, SEO, category, the admin link and each option's SKU, barcode, feed id and prices by country. `NOT_FOUND` carries a hint to search instead.
+
+**Details and buy links (`product`):** every option carries `buyUrl` — its buy link for ads, emails and messages (a landing places `<ShopifyProduct product="…" />` instead, which shows the options, price and stock and hands the shopper to the store), following the store's own setting (`buyDestination`: `checkout`, `store_cart` or `product_page`) — with `buyUrlKind`, `unavailable` when it can't be bought, and `notes` for what a link can't do (`password_protected`, `subscription_only`, `subscription_optional`, `own_storefront`, `details_pending`). `--quantity <1-99>` sets how many it adds. `videos[]` lists the product's videos in the library (`videoId`, `playbackId`); `contentSummary` names what else Baker keeps. `--content` adds `content`: the formatted description, every custom field by its name (long values previewed, `truncated: true`), the rating, subscriptions, bundle, YouTube/Vimeo and 3D links, translations, and `unreadable` for content the store owner hasn't let Baker read yet. `--field <name|namespace.key>` returns one field whole. `--full` adds `--content`, all three links per option and each option's weight, unit price, shipping and tax. `store` adds `buyDestination`, `passwordProtected`, `languages`, `policies` (`--full`: their text, and the store's brand).
+**`collections`:** `--search <words>`; each row has `handle`, Shopify's product count and, on a store with an online store, `onStore`.
+**`stock`:** `--collection`, `--limit <1-200>` (default 50 per list), `--full` (SKUs and Baker links). Options that keep selling at zero or don't track stock are not out of stock.
+**`sales`:** `--days <1-395>` (default 30), `--by day|product|campaign|landing` (default `day`), `--limit <1-100>`, `--full` (each row's source, medium, campaign, click platform, landing or product id). `data.totals` (`orders`, `sales`, `added`, `refunded`, `net`) in `data.currency`; `data.rows[]` with a `label` and, by campaign or landing, a `credit` (`campaign` · `order` · `landing` · `unattributed` · `before_baker` · `other`), adding up to the totals. A sale counts when it is paid, at what was received; by day and product each fact counts when it happened, by campaign and landing each order paid in the period carries what was added and refunded on it since. `meta.salesReporting` (`meta`, `google`: `baker` · `shopify_channel` · `undecided`) says who reports the sales to the ad platforms; `meta.history` is `importing` while past orders still come in.
+
+**`sales --by weekday|hour|month|month_of_year`:** orders placed in the period by when they were placed, in the store's timezone (`data.window.timezone`), from the store's whole order history — `--days` up to 3650 or `--all` (only these breakdowns take them).
+
+**Buyers, countries and best sellers** (`buyers`, `buyer`, `countries`, `best-sellers`, `cohorts`, `segments`) read the store's whole order history as Baker keeps it. Every answer carries `meta.window` (local `from`/`to`, `days` or `"all"`, the store's `timezone`), `meta.history` (`state`: `importing` · `done` · `failed` · `none`; `reach`: `all` or `60_days`; the first day held) and `meta.basis` (`all_orders`, or `last_60_days` when the store lets Baker read only its last 60 days — then a buyer whose earlier orders are older counts as new). The period is orders **placed** in it, with what was refunded on them since. A buyer is a numbered customer (`Customer #1042`) with a country, region and city — never a name or an email; guest orders count in money, never as buyers. Shared flags: `--days <1-3650>` (default 365) or `--all`, `--country <ISO2>`, `--full`.
+
+- **`buyers`:** `data.summary` (buyers, new and returning, guest orders, orders, net, average order, new/returning orders and net, repeat rate, median days to a second order), `data.segments`, `data.thresholds`, `data.buyers[]` (`--sort net|orders|recent|first`, `--limit`, `--offset`, `--segment best|loyal|at_risk|new|one_time`, `--channel <key>`), and with `--by campaign|channel` `data.acquisition.rows[]` (buyers whose first order is in the period, first-order net, lifetime net per buyer, average orders, repeat rate). Baker keeps no ad spend.
+- **`buyer <number>`:** `1042`, `#1042` or `Customer #1042`. A buyer erased by their store or merged into another answers `NOT_FOUND` "This buyer is no longer in Baker."
+- **`countries`:** `data.total`, `data.rows[]` (orders, buyers, new buyers, net, average order, share, growth against the period before, the currency paid in), `data.unknown` (no readable address) and `data.other` (past `--limit`), adding up to the total; `--country` for its regions, `--region` for a region's cities, `--product <id|handle>` for one product's orders and money.
+- **`best-sellers`:** `--view products` (default; units ordered beside refunded units, orders, buyers, revenue, refunds, refund rate, growth; `--sort units|revenue|orders`) · `variants` (with `--product`) · `trend` · `together` · `repeat` · `momentum`.
+- **`cohorts`:** `--months <3-36>` (default 12); retention at months 1, 2, 3, 6, 12 and net per buyer by month 12 (`--full`: every month).
+- **`segments`:** each segment's buyers, share, net, average orders, days since the last order, top countries and first products, and its rule in this store's numbers.
+
+**`promotions`:** positional `<ref>` like `product`. Reads the product, scans this workspace's `src/pages/*` (import graph, ≤ 300 pages, files ≤ 256 KB) for its buy link, `/products/<handle>`, an option id or a `<ShopifyProduct>` / `<ShopifyBuyButton>` naming it (evidence `buy_button`), then `POST /api/shopify/promotions` with the linked landings. `data.ads[]` (`platform`, `level` ad|asset_group, `name`, `campaign`, `status` active|paused, `via` product_page|buy_link|landing), `data.landings[]` (`published`, `via` links_to_product|visitors_went_on), `data.shopping[]`, `data.catalog_ads`, `data.checked` (`not_checked` names a platform it could not read). A read made outside a Session says so in `hints`: only a read that carried a Session and named an ad lets a scheduled agent on the product coming back in stock later stage turning a pause from it back on, for review. `--full` adds ids, accounts, campaign / ad group / ad set ids, the Google `resource`, the URL and `data.remembered`.
+
+**`stock-holds`:** `--product <ref>`, `--all` (resolved holds too). Compact: `data.resume[]` — the one command to stage per ad Baker may turn back on now (`{ ad, command }`); `data.tell_user[]` — one sentence per ad, and per piece of out-of-stock work still waiting for review, written for the marketer; `data.pages[]` — landings the out-of-stock run changed, with the `baker chats diff … --surface landings` read of those changes. With `--product` it speaks only of that product's ads, including the ones Baker did not pause when it ran out. `--full` adds the codes behind each sentence: `holds[]` with each `verdict` read live from the ad platform, `pending_sessions[]`, `recently_closed[]`, `not_paused[]`, `pages_changed[]`.
+
+**Refusals:** `NO_SHOPIFY_CONNECTION` — no store is connected; `error.fix.action` is `request_connection` (`{ platform: "shopify" }`). `SHOPIFY_NOT_AVAILABLE` — Shopify can't be connected on this Baker yet; `error.fix.action` is `continue_without`. Both exit 1.
+
+---
+
+### `baker shopify catalog audit`
+
+Checks products before Shopping, Performance Max or catalog ads: title, description, image, barcode or MPN and Google category from the store, and — when the company's Google Ads links a Merchant Center account — each option's price and stock there, whether it is listed at all, and Google's verdict on it. Read-only.
+
+```bash
+baker shopify catalog audit                       # 10 products, only what needs attention
+baker shopify catalog audit --cursor <next> --limit 20
+baker shopify catalog audit --merchant-id 123456  # when Google Ads links several Merchant Center accounts
+baker shopify catalog audit --full                # every check, passing ones included
+```
+
+### `baker shopify change | draft | changes | undo | tracking`
+
+**Changes to the connected store, staged on the Session (`BAKER_CHAT_ID`)** and made only when the user publishes it — reviewed first in the chat's Store tab. Nothing here calls Shopify to change anything mid-Session; every applied change can be put back by `undo`, through another publish.
+
+```bash
+baker shopify change product update the-snowboard --title "The Snowboard" --seo-title "…" --add-tags summer
+baker shopify change variant update 456 --sku SNOW-L --barcode 4006381333931 --weight 1.5 --weight-unit kg   # kg, g, lb or oz
+baker shopify change variant update 456 --price 18.95 --sale-price none          # money: the user says yes first
+baker shopify change field set product:the-snowboard custom.care --value "Hand wash"
+baker shopify change collection create --title "Summer boards" --products a,b    # shown on the online store unless --hidden
+baker shopify change collection hide summer-boards                                # also update, show, delete, add, remove
+baker shopify change discount create --code SPRING10 --percent 10 --ends <iso>   # money
+baker shopify change discount stop SPRING10                                       # money
+baker shopify change discount dates SPRING10 --starts <iso> --ends never          # money
+baker shopify change redirect create --from /old --to /new
+baker shopify change redirect remove /old
+baker shopify change campaign add --platform google-ads --account … --campaign … # show a Baker campaign in Shopify Marketing
+baker shopify change measurement reconnect                                        # the fix `tracking audit` names
+baker shopify change product update --json '[{"kind":"shopify.product.update","target":"<handle>","payload":{"addTags":["summer"]}}, …]'
+baker shopify draft list                                                          # also show <ref>, remove <ref>, clear
+baker shopify draft amend <ref> --patch '{…}'
+baker shopify changes --limit 20                                                  # applied changes, each with its changeId
+baker shopify undo <changeId>…                                                    # stage putting them back, as one batch
+baker shopify tracking audit                                                      # read-only: is the store's tracking right?
+```
+
+**Money.** A price, a sale price or a discount code changes money: the first call exits 1 with `NEEDS_USER_APPROVAL` and `error.fix.askUserQuestion` — the exact question to ask with AskUserQuestion. When the user answers "Yes, make these changes", run the same command again; a declined one is refused, still carrying the question in case the user asks for it again later. `amend` of a price asks again, and publish refuses any money change whose lines are not the approved ones.
+
+**Stage-time checks.** Each change is read against the live store when it is staged (the "before" the Store tab shows), checked, and refused with a reason the agent can act on — a collection whose undo could not rebuild it (rules, an image, custom fields, a discount or menu pointing at it), descriptions with scripts or frames, unknown products. Publish re-reads each target first: a change made in Shopify since staging is not overwritten; the op is marked failed with why. Up to 100 changes per call, 250 per Session.
+
+**Undo.** `changes` lists what Baker applied (`changeId`, `undoable`, why not). `undo` stages the inverses in one batch, read from the store as it was before each change; a money undo asks once for all its lines. A deleted collection comes back with the same address, content and products (as a new collection).
+
+**`tracking audit`:** reads only. `data.checks[]` (`measurement`, `theme_switch`, `visitor_on_orders`, `sales_reporting`, `consent`, `storefront`) each with a `status` and a `fix` that is `staged` (a command to stage), `merchant` (something the user does in Shopify) or `decision` (a choice only the user makes).
+
+**Refusals:** `SHOPIFY_PERMISSION_NEEDED` — the store has not allowed this kind of change yet; `error.fix.action` is `request_connection` (`{ platform: "shopify", reason }`) and the user allows it in Shopify. `NEEDS_USER_APPROVAL` — the money answer: `fix.action` `ask_user` with the question, or `continue_without` after a no. A payload with a key its kind doesn't take (`--json`, `draft amend --patch`) is refused naming the keys it takes. All exit 1.
+
+---
+
 ### `baker accounts influenced | engagement | warm | company | campaigns | crm`
 
 Account insights: which companies the LinkedIn ads are warming, and which CRM deals they influenced. Reads Baker's nightly copy of LinkedIn and the CRM, so it is fast and covers up to 24 months; nothing is changed anywhere. Every company has it once a LinkedIn ad account is chosen; before the first nightly read the reports are empty — read live with `baker ads linkedin companies`. `--start`/`--end` must be real calendar days within 24 calendar months; a bad flag or an unsupported `--output` exits 1 with `INVALID_ARGS`.

package/dist/account-263FLP5Y.js

@@ -0,0 +1,80 @@
+import {
+  CHATGPT_ADS_REFERENCE,
+  runChatgptRead
+} from "./chunk-ZFINQBE7.js";
+import "./chunk-KBSWQKOT.js";
+import {
+  apiGet
+} from "./chunk-AS46I4WH.js";
+import "./chunk-6UW4J6IU.js";
+import "./chunk-XOHXG5TG.js";
+import {
+  registerSchema
+} from "./chunk-AL6AEGWH.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-M274CK75.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-263FLP5Y.js.map

package/dist/account-Q3BRNQUW.js

@@ -0,0 +1,139 @@
+import {
+  handleMetaError,
+  resolveAccountIdArg
+} from "./chunk-W3H7CX5E.js";
+import "./chunk-Y2JZX6JB.js";
+import {
+  writeJsonEnvelope
+} from "./chunk-KBSWQKOT.js";
+import {
+  NO_CACHE_ARG
+} from "./chunk-Q6GYSW47.js";
+import {
+  apiGet
+} from "./chunk-AS46I4WH.js";
+import "./chunk-6UW4J6IU.js";
+import "./chunk-XOHXG5TG.js";
+import "./chunk-AL6AEGWH.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 = 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-Q3BRNQUW.js.map

package/dist/account-Q3BRNQUW.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 = 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-Y2NNZBQU.js

@@ -0,0 +1,80 @@
+import {
+  csvOrJson,
+  handleLinkedinError,
+  resolveAccountIdArg
+} from "./chunk-ASHCV6DO.js";
+import {
+  writeAdsJson,
+  writeAdsOutput
+} from "./chunk-KBSWQKOT.js";
+import {
+  NO_CACHE_ARG
+} from "./chunk-Q6GYSW47.js";
+import "./chunk-K5X62YHZ.js";
+import "./chunk-CAZGM2NX.js";
+import "./chunk-NZS3KEQ2.js";
+import "./chunk-GIWHHCD6.js";
+import "./chunk-UI6BKYQD.js";
+import "./chunk-ERSL4WZT.js";
+import {
+  apiGet
+} from "./chunk-AS46I4WH.js";
+import "./chunk-6UW4J6IU.js";
+import "./chunk-XOHXG5TG.js";
+import "./chunk-AL6AEGWH.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-EZH66GPE.js").then((m) => m.accountUrlParamsCommand)
+  },
+  args: accountDetailCommand.args,
+  default: "detail"
+});
+export {
+  accountCommand
+};
+//# sourceMappingURL=account-Y2NNZBQU.js.map