@koda-sl/baker-cli 0.462.0 → 0.463.0

package/dist/accounts-H7CCSJAR.js

@@ -0,0 +1,114 @@
+import {
+  connectedResourceHints
+} from "./chunk-P4NSJS54.js";
+import {
+  AVAILABLE_ARG,
+  writeAvailableAccounts
+} from "./chunk-BWHBYH3H.js";
+import {
+  cacheGet,
+  cacheSet,
+  handleConnectionError,
+  needsConnectionFix,
+  writeAdsJson,
+  writeAdsOutput,
+  writeJsonEnvelope
+} from "./chunk-3ITK2SBF.js";
+import {
+  ApiError,
+  apiGet
+} from "./chunk-TU6CHBNF.js";
+import "./chunk-E6VWLJVK.js";
+import "./chunk-7HD4SFUW.js";
+import {
+  registerSchema
+} from "./chunk-V2PX6XX5.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/ads/google/accounts.ts
+import { defineCommand } from "citty";
+registerSchema({
+  command: "ads.google.accounts",
+  description: "List the Google Ads accounts this company connected \u2014 there can be several, and every one of them is yours to work in. Returns accounts with id, name, access_type (direct or managed), level in the hierarchy, and optional manager_id for managed accounts. Run this first to find account IDs for other commands.",
+  args: {
+    "no-cache": { type: "boolean", description: "Skip cache, hit API directly", required: false },
+    output: { type: "string", description: "Format: json|csv|md", required: false, default: "json" },
+    available: AVAILABLE_ARG
+  }
+});
+function accountHints(accounts) {
+  return connectedResourceHints({
+    plural: "Google Ads accounts",
+    singular: "Google Ads account",
+    flag: "--customer-id",
+    resources: accounts.map((account) => ({ id: account.id, label: account.name }))
+  });
+}
+function handleAccountsError(err) {
+  if (err instanceof ApiError) {
+    if (needsConnectionFix(err.code, err.message)) {
+      handleConnectionError("google_ads", err.message);
+    }
+    const envelope = {
+      ok: false,
+      error: {
+        code: err.code,
+        message: err.message,
+        fix: {
+          action: "reject",
+          explanation: err.message
+        },
+        retryable: false
+      }
+    };
+    writeAdsJson(envelope);
+    process.exit(1);
+  }
+  writeAdsJson({ ok: false, error: { code: "NETWORK_ERROR", message: "Unexpected error" } });
+  process.exit(1);
+}
+var accountsCommand = defineCommand({
+  meta: {
+    name: "accounts",
+    description: `List accessible Google Ads accounts. Returns customer IDs needed for all other commands.
+
+Examples:
+  baker ads google accounts
+  baker ads google accounts --available   # every account the login reaches, selected or not`
+  },
+  args: {
+    "no-cache": { type: "boolean", description: "Skip cache", required: false },
+    output: { type: "string", description: "Format: json|csv|md", required: false, default: "json" },
+    available: AVAILABLE_ARG
+  },
+  run: async ({ args }) => {
+    if (args.available) return writeAvailableAccounts("google-ads", handleAccountsError);
+    const useCache = !args["no-cache"];
+    if (useCache) {
+      const cached = cacheGet("accounts", "list");
+      if (cached) {
+        writeJsonEnvelope({ ok: true, data: cached.data, cached: true, hints: accountHints(cached.data) });
+        return;
+      }
+    }
+    try {
+      const params = !useCache ? { "skip-cache": "true" } : void 0;
+      const data = await apiGet("/api/ads/google/accounts", params);
+      if (useCache) {
+        cacheSet("accounts", "list", data, 60 * 60 * 1e3);
+      }
+      const format = args.output || "json";
+      if (format !== "json") {
+        writeAdsOutput(data, format);
+        return;
+      }
+      writeJsonEnvelope({ ok: true, data, hints: accountHints(data) });
+    } catch (err) {
+      handleAccountsError(err);
+    }
+  }
+});
+export {
+  accountsCommand
+};
+//# sourceMappingURL=accounts-H7CCSJAR.js.map

package/dist/accounts-XX2PF2L2.js

@@ -0,0 +1,76 @@
+import {
+  csvOrJson,
+  handleLinkedinError
+} from "./chunk-AHCNBKHP.js";
+import {
+  connectedResourceHints
+} from "./chunk-P4NSJS54.js";
+import {
+  AVAILABLE_ARG,
+  writeAvailableAccounts
+} from "./chunk-BWHBYH3H.js";
+import {
+  writeAdsOutput,
+  writeJsonEnvelope
+} from "./chunk-3ITK2SBF.js";
+import {
+  NO_CACHE_ARG
+} from "./chunk-X7ZODEXJ.js";
+import "./chunk-ZJVHZHYP.js";
+import "./chunk-GXDLWBOY.js";
+import "./chunk-XQIOCIDO.js";
+import "./chunk-ML7DLFFY.js";
+import {
+  apiGet
+} from "./chunk-TU6CHBNF.js";
+import "./chunk-E6VWLJVK.js";
+import "./chunk-7HD4SFUW.js";
+import "./chunk-V2PX6XX5.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/ads/linkedin/accounts.ts
+import { defineCommand } from "citty";
+function accountHints(accounts) {
+  return connectedResourceHints({
+    plural: "LinkedIn ad accounts",
+    singular: "LinkedIn ad account",
+    flag: "--account-id",
+    resources: accounts.map((account) => ({ id: account.externalId, label: account.name }))
+  });
+}
+var accountsCommand = defineCommand({
+  meta: {
+    name: "accounts",
+    description: `List LinkedIn ad accounts in this company's connected scope.
+
+Examples:
+  baker ads linkedin accounts
+  baker ads linkedin accounts --output csv
+  baker ads linkedin accounts --available   # every account the login reaches, selected or not`
+  },
+  args: {
+    "no-cache": NO_CACHE_ARG,
+    output: { type: "string", description: "Output format: json|csv|jsonl|md", default: "json" },
+    available: AVAILABLE_ARG
+  },
+  run: async ({ args }) => {
+    if (args.available) return writeAvailableAccounts("linkedin", handleLinkedinError);
+    try {
+      const params = {};
+      if (args["no-cache"]) params["skip-cache"] = "true";
+      const data = await apiGet("/api/ads/linkedin/accounts", params);
+      const fmt = csvOrJson(args);
+      if (fmt !== "json") {
+        writeAdsOutput(data, fmt);
+        return;
+      }
+      writeJsonEnvelope({ ok: true, data, hints: accountHints(data) });
+    } catch (err) {
+      handleLinkedinError(err);
+    }
+  }
+});
+export {
+  accountsCommand
+};
+//# sourceMappingURL=accounts-XX2PF2L2.js.map

package/dist/actions-TIKIRMXD.js

@@ -0,0 +1,55 @@
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/actions/index.ts
+import { defineCommand } from "citty";
+var actionsCommand = defineCommand({
+  meta: {
+    name: "actions",
+    description: `Manage action items for the current chat. Subcommands: list, log, draft, get, status, claim, release, create, update, complete, discard, reopen, assign, members, link, unlink.
+
+Lifecycle: claim an action before working on it. Stage create/update/complete/discard/reopen/assign/link via this CLI; they apply when the chat is published. Release if you decide not to work on it after all.
+
+Staged vs published: create/update/complete/discard/link are STAGED in this chat's draft and are invisible to \`list\`/\`status\` until the chat publishes. Review them with \`actions draft\` before finishing. To drop a staged op, use \`actions draft remove <ref>\` \u2014 never stage \`complete\` to delete a staged action (that publishes it as already-completed, leaving a duplicate).
+
+Examples:
+  baker actions list                          # bucketed view of PUBLISHED actions
+  baker actions log                            # actions COMPLETED today, with what was done (client report)
+  baker actions log --since 7d                 # everything completed in the last 7 days
+  baker actions draft                         # review what THIS chat has staged (pre-publish)
+  baker actions draft remove temp_hero         # drop a staged create (cascades its complete/link ops)
+  baker actions draft clear                    # drop everything staged in this chat
+  baker actions status temp_hero jx123         # batch resolve real IDs and temp_* refs
+  baker actions tags list                      # available tags (defaults + company custom)
+  baker actions claim <id>
+  baker actions create --name "Build hero" --tags landing,creative --description "..."
+  baker actions complete <id>
+  baker actions discard <id> --reason "obsolete"
+  baker actions reopen <id>                    # a completed Task back to the backlog (on publish)
+  baker actions members                        # who a Task can be assigned to
+  baker actions assign <id> --to maria@empresa.com   # staged; --to none unassigns
+Full guide: __tooling__/docs/tools/baker/actions.md`
+  },
+  subCommands: {
+    list: () => import("./list-BICE2Q6G.js").then((m) => m.listCommand),
+    log: () => import("./log-7YJU6MWI.js").then((m) => m.logCommand),
+    draft: () => import("./draft-WTYL2S3J.js").then((m) => m.draftCommand),
+    get: () => import("./get-GWPFR76J.js").then((m) => m.getCommand),
+    status: () => import("./status-3HMFZSSD.js").then((m) => m.statusCommand),
+    claim: () => import("./claim-HKZRVUEB.js").then((m) => m.claimCommand),
+    release: () => import("./release-6B6I7457.js").then((m) => m.releaseCommand),
+    create: () => import("./create-PBLEUFJY.js").then((m) => m.createCommand),
+    update: () => import("./update-HLUOVJDY.js").then((m) => m.updateCommand),
+    complete: () => import("./complete-AOPPLUPV.js").then((m) => m.completeCommand),
+    discard: () => import("./discard-VZ3KAEDI.js").then((m) => m.discardCommand),
+    reopen: () => import("./reopen-LBLJKNFN.js").then((m) => m.reopenCommand),
+    assign: () => import("./assign-XSZCE3C6.js").then((m) => m.assignCommand),
+    members: () => import("./members-4E5YI66V.js").then((m) => m.membersCommand),
+    link: () => import("./link-GMJWAK6E.js").then((m) => m.linkCommand),
+    unlink: () => import("./unlink-K6NQEDYZ.js").then((m) => m.unlinkCommand),
+    tags: () => import("./tags-UAW4322P.js").then((m) => m.tagsCommand)
+  }
+});
+export {
+  actionsCommand
+};
+//# sourceMappingURL=actions-TIKIRMXD.js.map

package/dist/active-entities-ULXKTF4L.js

@@ -0,0 +1,103 @@
+import {
+  parseXApiError
+} from "./chunk-M6UNISGO.js";
+import {
+  resolveXAccountId
+} from "./chunk-W6WLVU4M.js";
+import {
+  cacheGet,
+  cacheSet,
+  writeAdsJson
+} from "./chunk-3ITK2SBF.js";
+import {
+  ApiError,
+  apiPost
+} from "./chunk-TU6CHBNF.js";
+import "./chunk-E6VWLJVK.js";
+import "./chunk-7HD4SFUW.js";
+import {
+  registerSchema
+} from "./chunk-V2PX6XX5.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/ads/x/active-entities.ts
+import { defineCommand } from "citty";
+registerSchema({
+  command: "ads.x.activeEntities",
+  description: "List entities (campaigns/line items) that had metric activity within a time range. Use this to narrow which entities to query for stats. Time range max 90 days. Times must be ISO 8601 hour-aligned.",
+  args: {
+    "account-id": { type: "string", description: "X Ads account ID", required: false },
+    entity: { type: "string", description: "CAMPAIGN | LINE_ITEM | PROMOTED_TWEET", required: true },
+    "start-time": { type: "string", description: "ISO 8601 hour-aligned start", required: true },
+    "end-time": { type: "string", description: "ISO 8601 hour-aligned end", required: true },
+    "campaign-ids": { type: "string", description: "CSV of campaign IDs", required: false },
+    "line-item-ids": { type: "string", description: "CSV of line item IDs", required: false },
+    "funding-instrument-ids": { type: "string", description: "CSV of funding instrument IDs", required: false },
+    "no-cache": { type: "boolean", description: "Skip cache", required: false }
+  }
+});
+function parseCsv(v) {
+  if (typeof v !== "string" || v.length === 0) return void 0;
+  const parts = v.split(",").map((s) => s.trim()).filter(Boolean);
+  return parts.length > 0 ? parts : void 0;
+}
+var activeEntitiesCommand = defineCommand({
+  meta: {
+    name: "active-entities",
+    description: `List entities with metric activity in a time range.
+
+Examples:
+  baker ads x active-entities --account-id 18ce53xyz --entity LINE_ITEM \\
+    --start-time 2026-04-30T00:00:00Z --end-time 2026-05-07T00:00:00Z`
+  },
+  args: {
+    "account-id": { type: "string", description: "X Ads account ID", required: false },
+    entity: { type: "string", description: "CAMPAIGN | LINE_ITEM | PROMOTED_TWEET", required: true },
+    "start-time": { type: "string", description: "ISO 8601 hour-aligned start", required: true },
+    "end-time": { type: "string", description: "ISO 8601 hour-aligned end", required: true },
+    "campaign-ids": { type: "string", description: "CSV of campaign IDs", required: false },
+    "line-item-ids": { type: "string", description: "CSV of line item IDs", required: false },
+    "funding-instrument-ids": { type: "string", description: "CSV of funding instrument IDs", required: false },
+    "no-cache": { type: "boolean", description: "Skip cache", required: false }
+  },
+  run: async ({ args }) => {
+    const accountId = await resolveXAccountId(args);
+    const useCache = !args["no-cache"];
+    const body = {
+      accountId,
+      entity: args.entity,
+      startTime: args["start-time"],
+      endTime: args["end-time"],
+      fundingInstrumentIds: parseCsv(args["funding-instrument-ids"]),
+      campaignIds: parseCsv(args["campaign-ids"]),
+      lineItemIds: parseCsv(args["line-item-ids"]),
+      skipCache: !useCache || void 0
+    };
+    const cacheKey = `active-entities:${JSON.stringify(body)}`;
+    if (useCache) {
+      const cached = cacheGet("x-account-data", cacheKey);
+      if (cached) {
+        writeAdsJson({ ok: true, data: cached.data, cached: true });
+        return;
+      }
+    }
+    try {
+      const data = await apiPost("/api/ads/x/active-entities", body);
+      if (useCache) {
+        cacheSet("x-account-data", cacheKey, data, 5 * 60 * 1e3);
+      }
+      writeAdsJson({ ok: true, data });
+    } catch (err) {
+      if (err instanceof ApiError) {
+        writeAdsJson(parseXApiError(err.message, accountId));
+        process.exit(1);
+      }
+      writeAdsJson({ ok: false, error: { code: "NETWORK_ERROR", message: "Unexpected error" } });
+      process.exit(1);
+    }
+  }
+});
+export {
+  activeEntitiesCommand
+};
+//# sourceMappingURL=active-entities-ULXKTF4L.js.map

package/dist/activities-7IKJCYDQ.js

@@ -0,0 +1,74 @@
+import {
+  META_LIST_SHAPE_ARGS,
+  registerMetaListSchema,
+  shapeMetaListRows,
+  writeMetaListRows
+} from "./chunk-HYXXESU3.js";
+import {
+  csvOrJson,
+  handleMetaError,
+  resolveAccountIdArg
+} from "./chunk-XTVUANXP.js";
+import "./chunk-3ITK2SBF.js";
+import {
+  NO_CACHE_ARG
+} from "./chunk-X7ZODEXJ.js";
+import "./chunk-KIGGMKAE.js";
+import {
+  apiGet
+} from "./chunk-TU6CHBNF.js";
+import "./chunk-E6VWLJVK.js";
+import "./chunk-7HD4SFUW.js";
+import "./chunk-V2PX6XX5.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/ads/meta/activities.ts
+import { defineCommand } from "citty";
+var listArgs = {
+  "account-id": { type: "string", description: "Meta ad account ID" },
+  days: { type: "string", description: "Lookback days (default 7)" },
+  limit: { type: "string", description: "Max rows" },
+  "no-cache": NO_CACHE_ARG,
+  ...META_LIST_SHAPE_ARGS
+};
+registerMetaListSchema(
+  "activities",
+  "Account change log, as a table by default, one row per event: event_time, event_type, actor_name, object_type, object_name, object_id, and change ('old \u2192 new' when the change is a single value). Start here: baker ads meta activities --account-id act_123 --days 2. --fields event_time,object_name,extra_data or --full for the raw change payload; --output json returns the rows in the envelope.",
+  listArgs
+);
+var activitiesCommand = defineCommand({
+  meta: {
+    name: "activities",
+    description: `Audit log of recent ad-account changes (created, paused, edited). Default lookback 7 days,
+~90 day retention server-side.
+
+A table by default, one row per event: event_time, event_type, actor_name, object_type,
+object_name, object_id, and change ("old \u2192 new" when the change is a single value: status,
+name, budget, goal). --fields takes dotted paths (extra_data holds the raw change); --full returns
+every field Meta sent; --output json returns the rows as JSON.
+
+Examples:
+  baker ads meta activities --account-id act_123 --days 14
+  baker ads meta activities --account-id act_123 --days 2 --output json
+  baker ads meta activities --account-id act_123 --fields event_time,object_name,extra_data`
+  },
+  args: listArgs,
+  run: async ({ args }) => {
+    const accountId = resolveAccountIdArg(args);
+    try {
+      const params = { "account-id": accountId };
+      if (args.days) params.days = args.days;
+      if (args.limit) params.limit = args.limit;
+      if (args["no-cache"]) params["skip-cache"] = "true";
+      const data = await apiGet("/api/ads/meta/activities", params);
+      const shaped = shapeMetaListRows("activities", data, args);
+      writeMetaListRows("activities", shaped, csvOrJson(args));
+    } catch (err) {
+      handleMetaError(err);
+    }
+  }
+});
+export {
+  activitiesCommand
+};
+//# sourceMappingURL=activities-7IKJCYDQ.js.map

package/dist/ad-group-writes-A6ICQ4FF.js

@@ -0,0 +1,170 @@
+import {
+  clearableArg,
+  compact,
+  failWriteValidation,
+  lowerArg,
+  microsFromArg,
+  productFiltersArg,
+  requireTarget,
+  schemaArgs,
+  stageChatgptOp,
+  statusCommand
+} from "./chunk-XZTEM2QG.js";
+import {
+  CHATGPT_ADS_REFERENCE
+} from "./chunk-HSTRHEEV.js";
+import "./chunk-3ITK2SBF.js";
+import "./chunk-TU6CHBNF.js";
+import "./chunk-E6VWLJVK.js";
+import "./chunk-7HD4SFUW.js";
+import {
+  registerSchema
+} from "./chunk-V2PX6XX5.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/ads/chatgpt/ad-group-writes.ts
+import { defineCommand } from "citty";
+var REFERENCE = CHATGPT_ADS_REFERENCE.adGroups;
+var SHARED_ARGS = {
+  name: { type: "string", description: "Ad group name (3+ characters)" },
+  description: { type: "string", description: "Internal description" },
+  "context-hints": {
+    type: "string",
+    description: "When the ad would be useful, short phrases separated by commas \u2014 or by | when a phrase has a comma. ChatGPT's counterpart to keywords, written in the language of the campaign's countries, as people ask ChatGPT. On update it replaces the whole list; none clears it"
+  },
+  "bid-strategy": {
+    type: "string",
+    description: "fixed_bid (default, needs --max-bid) | maximize_clicks | maximize_conversions"
+  },
+  "max-bid": { type: "string", description: "Bid in account currency, e.g. 2.50 \u2014 fixed_bid only" },
+  "tracking-template": {
+    type: "string",
+    description: "Query string added to this ad group's landing pages, e.g. ad_group_id={ad_group_id} \u2014 none clears"
+  },
+  "audience-bids": {
+    type: "string",
+    description: "Raise or lower the fixed bid for people in an audience: audience=multiplier pairs, 0.1 to 10, e.g. caud_123=1.5,caud_456=0.8. Audiences of ~25,000 people only; not in the EEA or Switzerland. On update it replaces them; none clears"
+  },
+  "product-filters": {
+    type: "string",
+    description: "Catalog campaigns only: which products it shows \u2014 e.g. brand in Acme; price lte 5000 (preview with `catalogs products`). On update it replaces the set; none shows the whole catalog"
+  },
+  status: { type: "string", description: "paused (default) | active" }
+};
+var CREATE_ARGS = {
+  ...SHARED_ARGS,
+  "campaign-id": { type: "string", description: "cmpn_\u2026 or a staged chatgpt_temp_ ref", required: true },
+  name: { type: "string", description: "Ad group name (3+ characters)", required: true }
+};
+var UPDATE_ARGS = {
+  id: { type: "positional", description: "Ad group id (adgrp_\u2026) or a staged chatgpt_temp_ ref", required: true },
+  ...SHARED_ARGS
+};
+function contextHintsArg(value) {
+  if (typeof value !== "string" || value.trim() === "") {
+    return void 0;
+  }
+  if (value.trim().toLowerCase() === "none") {
+    return [];
+  }
+  const separator = value.includes("|") ? "|" : ",";
+  return value.split(separator).map((hint) => hint.trim()).filter(Boolean);
+}
+function audienceBidsArg(value) {
+  if (typeof value !== "string" || value.trim() === "") {
+    return void 0;
+  }
+  if (value.trim().toLowerCase() === "none") {
+    return [];
+  }
+  return value.split(",").map((pair) => pair.trim()).filter(Boolean).map((pair) => {
+    const [audienceId = "", multiplier = ""] = pair.split("=").map((part) => part.trim());
+    const times = Number(multiplier.replace(",", "."));
+    if (!audienceId || !Number.isFinite(times)) {
+      failWriteValidation(`"${pair}" is not an audience bid \u2014 write audience=multiplier, e.g. caud_123=1.5`);
+    }
+    return { audienceId, multiplierMicros: Math.round(times * 1e6) };
+  });
+}
+function productSetArg(value) {
+  const filters = productFiltersArg(value);
+  return filters === void 0 ? void 0 : { filters };
+}
+function sharedPayload(args) {
+  return {
+    name: args.name,
+    description: args.description,
+    contextHints: contextHintsArg(args["context-hints"]),
+    bidStrategy: lowerArg(args["bid-strategy"]),
+    maxBidMicros: microsFromArg(args["max-bid"], "--max-bid"),
+    trackingTemplate: clearableArg(args["tracking-template"]),
+    productSet: productSetArg(args["product-filters"]),
+    audienceBidMultipliers: audienceBidsArg(args["audience-bids"]),
+    status: lowerArg(args.status)
+  };
+}
+function adGroupCreateOp(args) {
+  return { kind: "adGroup.create", payload: compact({ ...sharedPayload(args), campaignId: args["campaign-id"] }) };
+}
+registerSchema({
+  command: "ads.chatgpt.ad-groups.create",
+  description: "Stage a new ad group under a live campaign (cmpn_\u2026) or one staged in this chat (its chatgpt_temp_ ref). Context hints decide where the ad shows; a fixed bid needs --max-bid.",
+  args: schemaArgs(CREATE_ARGS)
+});
+var adGroupsCreateCommand = defineCommand({
+  meta: {
+    name: "create",
+    description: `Stage a new ad group (applies when the chat is published).
+
+Examples:
+  baker ads chatgpt ad-groups create --campaign-id cmpn_123 --name "Rooftop owners" --context-hints "solar panels for my house,cut my electricity bill" --max-bid 2.50
+  baker ads chatgpt ad-groups create --campaign-id chatgpt_temp_ab12 --name "Auto" --bid-strategy maximize_clicks`
+  },
+  args: CREATE_ARGS,
+  run: async ({ args }) => {
+    await stageChatgptOp(adGroupCreateOp(args), REFERENCE, (staged) => [
+      adGroupNextHint(staged.ref, args["product-filters"] !== void 0)
+    ]);
+  }
+});
+registerSchema({
+  command: "ads.chatgpt.ad-groups.update",
+  description: "Stage a change to an ad group \u2014 name, context hints, bid or status. --context-hints replaces the whole list: read the ad group first and pass every hint to keep.",
+  args: schemaArgs(UPDATE_ARGS)
+});
+var adGroupsUpdateCommand = defineCommand({
+  meta: {
+    name: "update",
+    description: `Stage a change to an ad group. --context-hints replaces the whole list.
+
+Examples:
+  baker ads chatgpt ad-groups update adgrp_123 --max-bid 3
+  baker ads chatgpt ad-groups update adgrp_123 --context-hints "solar panels,home battery,cut my electricity bill"`
+  },
+  args: UPDATE_ARGS,
+  run: async ({ args }) => {
+    await stageChatgptOp(
+      { kind: "adGroup.update", target: requireTarget(args, "id"), payload: compact(sharedPayload(args)) },
+      REFERENCE
+    );
+  }
+});
+var adGroupsPauseCommand = statusCommand("adGroup", "pause", REFERENCE);
+var adGroupsResumeCommand = statusCommand("adGroup", "resume", REFERENCE);
+var adGroupsArchiveCommand = statusCommand("adGroup", "archive", REFERENCE);
+function adGroupNextHint(ref, productFilters) {
+  const productAd = `baker ads chatgpt ads create-product --ad-group-id ${ref} --name "\u2026"`;
+  return productFilters ? `Next, give it its product ad: ${productAd}` : `Next, give it a card: baker ads chatgpt ads create --ad-group-id ${ref} --name "\u2026" --title "\u2026" --body "\u2026" --target-url https://\u2026 --image-url https://\u2026 \u2014 under a catalog campaign, its product ad instead: ${productAd}`;
+}
+export {
+  adGroupCreateOp,
+  adGroupNextHint,
+  adGroupsArchiveCommand,
+  adGroupsCreateCommand,
+  adGroupsPauseCommand,
+  adGroupsResumeCommand,
+  adGroupsUpdateCommand,
+  audienceBidsArg,
+  contextHintsArg
+};
+//# sourceMappingURL=ad-group-writes-A6ICQ4FF.js.map

package/dist/ad-groups-F4VWE7BM.js

@@ -0,0 +1,68 @@
+import {
+  CHATGPT_ADS_REFERENCE,
+  runChatgptListRead
+} from "./chunk-HSTRHEEV.js";
+import "./chunk-3ITK2SBF.js";
+import "./chunk-TU6CHBNF.js";
+import "./chunk-E6VWLJVK.js";
+import "./chunk-7HD4SFUW.js";
+import {
+  registerSchema
+} from "./chunk-V2PX6XX5.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/ads/chatgpt/ad-groups.ts
+import { defineCommand } from "citty";
+var args = {
+  "campaign-id": { type: "string", description: "Only this campaign's ad groups (cmpn_\u2026)", required: false },
+  full: { type: "boolean", description: "Return ChatGPT Ads' own ad group objects", required: false }
+};
+registerSchema({
+  command: "ads.chatgpt.ad-groups",
+  description: "Ad groups in the connected ChatGPT Ads account, or in one campaign: bid strategy, billing event, max bid (currency units), context hints (when the ad should show \u2014 ChatGPT's counterpart to keywords) and serving issues.",
+  args
+});
+var adGroupsListCommand = defineCommand({
+  meta: {
+    name: "list",
+    description: "ChatGPT Ads ad groups. Example: baker ads chatgpt ad-groups --campaign-id cmpn_123"
+  },
+  args,
+  run: async ({ args: input }) => {
+    const params = {};
+    if (input["campaign-id"]) {
+      params["campaign-id"] = input["campaign-id"];
+    }
+    if (input.full) {
+      params.full = "true";
+    }
+    await runChatgptListRead(CHATGPT_ADS_REFERENCE.adGroups, "/api/ads/chatgpt/ad-groups", params);
+  }
+});
+var adGroupsCommand = defineCommand({
+  meta: {
+    name: "ad-groups",
+    description: `ChatGPT Ads ad groups: how each one bids and the context hints that decide where it shows \u2014 or stage a change that applies when the chat is published.
+
+Examples:
+  baker ads chatgpt ad-groups --campaign-id cmpn_123
+  baker ads chatgpt ad-groups create --campaign-id cmpn_123 --name "Rooftop owners" --context-hints "solar panels for my house" --max-bid 2.50
+  baker ads chatgpt ad-groups update adgrp_123 --max-bid 3
+  baker ads chatgpt ad-groups pause adgrp_123`
+  },
+  subCommands: {
+    list: adGroupsListCommand,
+    create: () => import("./ad-group-writes-A6ICQ4FF.js").then((m) => m.adGroupsCreateCommand),
+    update: () => import("./ad-group-writes-A6ICQ4FF.js").then((m) => m.adGroupsUpdateCommand),
+    pause: () => import("./ad-group-writes-A6ICQ4FF.js").then((m) => m.adGroupsPauseCommand),
+    resume: () => import("./ad-group-writes-A6ICQ4FF.js").then((m) => m.adGroupsResumeCommand),
+    archive: () => import("./ad-group-writes-A6ICQ4FF.js").then((m) => m.adGroupsArchiveCommand)
+  },
+  // A parent must never declare `run`: citty falls through to it after the matched subcommand.
+  args,
+  default: "list"
+});
+export {
+  adGroupsCommand
+};
+//# sourceMappingURL=ad-groups-F4VWE7BM.js.map