@koda-sl/baker-cli 0.500.0 → 0.503.0

package/README.md

@@ -1169,6 +1169,13 @@ baker ads meta lead-forms spec 987654321 > form.json                  # a live f
 baker ads meta campaigns --account-id act_123                        # ACTIVE only by default
 baker ads meta ads --account-id act_123 --all-statuses               # widen to everything
 
+# "Raise it from 80 to 100 a day" — listed budgets are in cents, as Meta sends them (a hint
+# says so); --daily-budget takes whole currency. A raise past 3x the current budget is refused
+# (usually an amount copied in cents) until the person approves that exact raise in the chat
+# (the refusal gives the question to ask). The same applies on Google Ads, LinkedIn, X and ChatGPT Ads.
+baker ads meta adsets --campaign-id 6123                             # daily_budget "8000" is 80 EUR
+baker ads meta adsets update 6124 --daily-budget 100                  # summary: daily budget 80 → 100 EUR
+
 # "Find the October ad" — Meta matches the name, so only that row is read
 baker ads meta ads --account-id act_123 --all-statuses --name-contains octubre --fields id,name,adset_id,creative_id
 

package/dist/account-BINLFOMF.js

@@ -0,0 +1,80 @@
+import {
+  csvOrJson,
+  handleLinkedinError,
+  resolveAccountIdArg
+} from "./chunk-6EJES6SY.js";
+import {
+  writeAdsJson,
+  writeAdsOutput
+} from "./chunk-ZRP7Y2DM.js";
+import {
+  NO_CACHE_ARG
+} from "./chunk-AGBBTTKA.js";
+import "./chunk-JDJQKN27.js";
+import "./chunk-CAZGM2NX.js";
+import "./chunk-NZS3KEQ2.js";
+import "./chunk-GIWHHCD6.js";
+import "./chunk-UI6BKYQD.js";
+import "./chunk-2TOIY2WN.js";
+import {
+  apiGet
+} from "./chunk-X7VQFLHI.js";
+import "./chunk-LU4HI4KI.js";
+import "./chunk-LGK7UWBN.js";
+import "./chunk-Q7US4OOA.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/ads/linkedin/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-4TV7UNBY.js").then((m) => m.accountUrlParamsCommand)
+  },
+  args: accountDetailCommand.args,
+  default: "detail"
+});
+export {
+  accountCommand
+};
+//# sourceMappingURL=account-BINLFOMF.js.map

package/dist/account-WLQBAQMD.js

@@ -0,0 +1,80 @@
+import {
+  CHATGPT_ADS_REFERENCE,
+  runChatgptRead
+} from "./chunk-M7HD42M6.js";
+import "./chunk-ZRP7Y2DM.js";
+import {
+  apiGet
+} from "./chunk-X7VQFLHI.js";
+import "./chunk-LU4HI4KI.js";
+import "./chunk-LGK7UWBN.js";
+import {
+  registerSchema
+} from "./chunk-Q7US4OOA.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/ads/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-TU3WJRSI.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-WLQBAQMD.js.map

package/dist/account-assets-WZOYMT3C.js

@@ -0,0 +1,290 @@
+import {
+  csvOrJson,
+  handleMetaError,
+  resolveAccountIdArg
+} from "./chunk-B2POVFR2.js";
+import "./chunk-Y2JZX6JB.js";
+import {
+  writeAdsOutput,
+  writeJsonEnvelope
+} from "./chunk-ZRP7Y2DM.js";
+import {
+  NO_CACHE_ARG
+} from "./chunk-AGBBTTKA.js";
+import {
+  apiGet
+} from "./chunk-X7VQFLHI.js";
+import "./chunk-LU4HI4KI.js";
+import "./chunk-LGK7UWBN.js";
+import {
+  registerSchema
+} from "./chunk-Q7US4OOA.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/ads/meta/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 = 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 = 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 = 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. Baker fills both with the business name when they are missing; 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 = 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-QPJDD767.js").then((m) => m.labelsCreateCommand),
+    rename: () => import("./asset-writes-QPJDD767.js").then((m) => m.labelsRenameCommand),
+    delete: () => import("./asset-writes-QPJDD767.js").then((m) => m.labelsDeleteCommand),
+    attach: () => import("./asset-writes-QPJDD767.js").then((m) => m.labelsAttachCommand),
+    detach: () => import("./asset-writes-QPJDD767.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 = 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-WZOYMT3C.js.map