@koda-sl/baker-cli 0.499.0 → 0.501.0-dev.6e96f50b9

package/dist/performance-TALH5EGT.js

@@ -0,0 +1,25 @@
+import {
+  definitionInsights,
+  parseDays,
+  performanceCommand,
+  withDefinitions
+} from "./chunk-L6EZRWI5.js";
+import "./chunk-4IYLTR6P.js";
+import "./chunk-MWD6JTOY.js";
+import "./chunk-CAZGM2NX.js";
+import "./chunk-NZS3KEQ2.js";
+import "./chunk-GIWHHCD6.js";
+import "./chunk-UI6BKYQD.js";
+import "./chunk-PTRCB7AR.js";
+import "./chunk-X7VQFLHI.js";
+import "./chunk-LU4HI4KI.js";
+import "./chunk-LGK7UWBN.js";
+import "./chunk-Q7US4OOA.js";
+import "./chunk-YQSBHWOI.js";
+export {
+  definitionInsights,
+  parseDays,
+  performanceCommand,
+  withDefinitions
+};
+//# sourceMappingURL=performance-TALH5EGT.js.map

package/dist/pixels-YGOGQ7SS.js

@@ -0,0 +1,60 @@
+import {
+  schemaArgs,
+  stageChatgptOp
+} from "./chunk-66TFWT5I.js";
+import {
+  CHATGPT_ADS_REFERENCE
+} from "./chunk-ZEKW4FKU.js";
+import "./chunk-ZRP7Y2DM.js";
+import "./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/pixels.ts
+import { defineCommand } from "citty";
+var CREATE_ARGS = {
+  name: { type: "string", description: "What the pixel is called in Ads Manager, e.g. withbaker.com", required: true }
+};
+function pixelCreateOp(args) {
+  return { kind: "pixel.create", payload: { name: typeof args.name === "string" ? args.name.trim() : args.name } };
+}
+registerSchema({
+  command: "ads.chatgpt.pixels.create",
+  description: "Stage a new website pixel for the account, applied when the chat is published. Read `conversions` first: an account usually needs one pixel, installed on every page, and a second splits the site's events.",
+  args: schemaArgs(CREATE_ARGS)
+});
+var pixelsCreateCommand = defineCommand({
+  meta: {
+    name: "create",
+    description: `Stage a new website pixel (applies when the chat is published).
+
+Example:
+  baker ads chatgpt pixels create --name "withbaker.com"`
+  },
+  args: CREATE_ARGS,
+  run: async ({ args }) => {
+    await stageChatgptOp(pixelCreateOp(args), CHATGPT_ADS_REFERENCE.conversions, (staged) => [
+      `Define what it counts with \`baker ads chatgpt conversions create --pixel ${staged.ref} --name \u2026 --event \u2026\`.`,
+      "After the publish, read its Pixel ID with `baker ads chatgpt conversions` and install it on the site's pages as a tracking tag."
+    ]);
+  }
+});
+var pixelsCommand = defineCommand({
+  meta: {
+    name: "pixels",
+    description: `Website pixels \u2014 what a site installs so ChatGPT Ads can count its conversions. Read them with \`baker ads chatgpt conversions\`.
+
+Example:
+  baker ads chatgpt pixels create --name "withbaker.com"`
+  },
+  subCommands: { create: pixelsCreateCommand }
+});
+export {
+  pixelCreateOp,
+  pixelsCommand
+};
+//# sourceMappingURL=pixels-YGOGQ7SS.js.map

package/dist/plan-O2TTEUIW.js

@@ -0,0 +1,207 @@
+import {
+  TAG_MANAGER_TIMEOUT_MS
+} from "./chunk-3GAR4AZK.js";
+import {
+  funnelStepSchema
+} from "./chunk-LAL4PKNJ.js";
+import {
+  trackingPlanErrorEnvelope
+} from "./chunk-VU5Z2V4S.js";
+import {
+  ANALYTICS_EVENT_DOORS,
+  parseEventKey
+} from "./chunk-DI44SZVP.js";
+import "./chunk-EDLZGTGN.js";
+import "./chunk-D5FY4FAK.js";
+import {
+  writeJsonEnvelope
+} from "./chunk-ZRP7Y2DM.js";
+import {
+  apiPost
+} from "./chunk-X7VQFLHI.js";
+import "./chunk-LU4HI4KI.js";
+import {
+  getEnv
+} from "./chunk-LGK7UWBN.js";
+import {
+  registerSchema
+} from "./chunk-Q7US4OOA.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/analytics/plan.ts
+import { readFileSync } from "fs";
+
+// ../api/src/analytics/trackingPlanWire.ts
+import { z as z2 } from "zod";
+
+// ../api/src/analytics/trackingPlan.ts
+import { z } from "zod";
+var text = z.string().trim().min(1).max(2e3);
+var key = z.string().trim().min(1).max(100);
+var webUrl = z.url().refine(
+  (value) => URL.canParse(value) && ["https:", "http:"].includes(new URL(value).protocol),
+  "Use a website address"
+);
+var trackingEventSchema = z.object({
+  eventKey: key.refine((value) => parseEventKey(value) !== null, "Use an existing Baker event key"),
+  name: text,
+  purpose: z.enum(["conversion", "progress", "diagnostic", "uncounted"]),
+  door: z.enum(ANALYTICS_EVENT_DOORS),
+  sourceEvent: key.optional(),
+  emitterEvidence: text.optional(),
+  status: z.enum(["prepared", "waiting", "published", "verified"]),
+  requirement: text.optional(),
+  owner: text.optional(),
+  verificationEvidence: text.optional()
+}).superRefine((event, ctx) => {
+  if (event.status === "waiting") {
+    if (!event.requirement || !event.owner)
+      ctx.addIssue({ code: "custom", message: "A waiting event needs its requirement and owner" });
+  } else if (!event.emitterEvidence) {
+    ctx.addIssue({ code: "custom", message: "A prepared event needs evidence that the source emits it" });
+  }
+  if (["published", "verified"].includes(event.status) && !event.verificationEvidence) {
+    ctx.addIssue({
+      code: "custom",
+      message: "Published or verified tracking needs evidence; a staged tag is only prepared"
+    });
+  }
+});
+var trackingJourneySchema = z.object({
+  key,
+  name: text,
+  entryUrls: z.array(webUrl).max(50),
+  destinationUrl: webUrl,
+  strategy: z.enum(["native", "embed", "api", "link"]),
+  status: z.enum(["supported", "waiting"]),
+  requiredFields: z.array(key).max(100),
+  attribution: text,
+  acceptanceEvidence: text.optional(),
+  continuationEvidence: text.optional(),
+  requirement: text.optional(),
+  owner: text.optional()
+}).superRefine((journey, ctx) => {
+  if (journey.strategy === "link" && journey.requiredFields.length > 0)
+    ctx.addIssue({
+      code: "custom",
+      message: "A link handoff must not capture details that the destination asks for again"
+    });
+  if (journey.status === "waiting" && (!journey.requirement || !journey.owner))
+    ctx.addIssue({ code: "custom", message: "A waiting journey needs its requirement and owner" });
+  if (journey.status === "supported" && journey.strategy === "api" && (!journey.acceptanceEvidence || !journey.continuationEvidence))
+    ctx.addIssue({
+      code: "custom",
+      message: "An API replacement needs accepted-submission and continuation evidence"
+    });
+});
+var trackingPlanSchema = z.object({
+  journeys: z.array(trackingJourneySchema).max(30),
+  events: z.array(trackingEventSchema).max(100)
+}).superRefine((plan, ctx) => {
+  for (const entries of [plan.journeys.map((journey) => journey.key), plan.events.map((event) => event.eventKey)]) {
+    if (new Set(entries).size !== entries.length)
+      ctx.addIssue({ code: "custom", message: "Each journey and event must appear once" });
+  }
+});
+
+// ../api/src/analytics/trackingPlanWire.ts
+var key2 = z2.string().trim().min(1).max(100);
+var variableName = z2.string().trim().min(1).max(200).refine((value) => !/[{}<>"'\\\r\n]/.test(value), "Use a plain container variable name");
+var trackingInstallationSchema = z2.object({
+  containerId: key2,
+  baseTagName: key2,
+  folderId: key2.optional(),
+  consent: z2.enum(["auto", "strict"]).default("auto"),
+  measure: z2.enum(["campaigns", "outcomes", "all"]).default("campaigns"),
+  events: z2.array(
+    z2.object({
+      eventKey: key2.refine((value) => parseEventKey(value) !== null, "Use an existing Baker event key"),
+      tagName: key2,
+      triggerId: key2,
+      properties: z2.record(key2, variableName).default({}),
+      eventIdVariable: variableName.optional()
+    })
+  ).max(50)
+});
+var trackingPlanRequestSchema = z2.object({
+  chatId: z2.string().optional(),
+  plan: trackingPlanSchema.optional(),
+  wireConversions: z2.boolean().default(false),
+  steps: z2.array(funnelStepSchema).max(30).optional(),
+  installation: trackingInstallationSchema.optional()
+}).superRefine((request, ctx) => {
+  if (!request.plan && (request.installation || request.wireConversions || request.steps))
+    ctx.addIssue({ code: "custom", message: "Preparation needs the agreed tracking plan" });
+});
+var trackingPlanResponseSchema = z2.object({
+  ok: z2.literal(true),
+  data: z2.object({ plan: trackingPlanSchema.nullable(), staged: z2.boolean() }),
+  hints: z2.array(z2.string()).optional()
+});
+
+// src/commands/analytics/plan.ts
+import { defineCommand } from "citty";
+var description = "Start here before building a replacement Form: read the agreed journeys, event names, purposes and readiness. --json @plan.json stages the complete plan, with optional wireConversions, funnel steps and a managed Tag Manager installation. Each event records its actual emitter or the missing change and owner. Prepared is not verified. See analytics.md for the contract. Repeating installation preparation replaces its own staged tags; applies only at Publish. --full includes evidence; the default keeps the decision inventory compact.";
+var args = {
+  json: {
+    type: "string",
+    description: "Preparation request as JSON or @path; omit to read the effective plan",
+    required: false
+  },
+  full: { type: "boolean", description: "Include all journey and verification evidence", required: false }
+};
+registerSchema({ command: "analytics.plan", description, args });
+var planCommand = defineCommand({
+  meta: { name: "plan", description },
+  args,
+  run: async ({ args: args2 }) => {
+    try {
+      const input = args2.json ? JSON.parse(args2.json.startsWith("@") ? readFileSync(args2.json.slice(1), "utf8") : args2.json) : {};
+      const parsed = trackingPlanRequestSchema.parse(input);
+      const body = { ...parsed, chatId: getEnv().BAKER_CHAT_ID };
+      const response = trackingPlanResponseSchema.parse(
+        // Preparing stages the Tag Manager install, which queues behind other companies' requests.
+        await apiPost("/api/analytics/plan", body, { timeoutMs: TAG_MANAGER_TIMEOUT_MS })
+      );
+      const plan = response.data.plan;
+      writeJsonEnvelope({
+        ...response,
+        data: {
+          ...response.data,
+          plan: args2.full || !plan ? plan : {
+            journeys: plan.journeys.map(
+              ({ key: key3, name, strategy, status, destinationUrl, requirement, owner }) => ({
+                key: key3,
+                name,
+                strategy,
+                status,
+                destinationUrl,
+                requirement,
+                owner
+              })
+            ),
+            events: plan.events.map(
+              ({ eventKey, name, purpose, door, sourceEvent, status, requirement, owner }) => ({
+                eventKey,
+                name,
+                purpose,
+                door,
+                sourceEvent,
+                status,
+                requirement,
+                owner
+              })
+            )
+          }
+        }
+      });
+    } catch (error) {
+      writeJsonEnvelope({ ok: false, error: trackingPlanErrorEnvelope(error) });
+      process.exitCode = 1;
+    }
+  }
+});
+export {
+  planCommand
+};
+//# sourceMappingURL=plan-O2TTEUIW.js.map

package/dist/posts-37LZKGWU.js

@@ -0,0 +1,34 @@
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/posts/index.ts
+import { defineCommand } from "citty";
+var postsCommand = defineCommand({
+  meta: {
+    name: "posts",
+    description: `The posts the company's followed accounts published \u2014 its own pages and its key people (CEO, CTO, head of sales\u2026) on LinkedIn, Instagram, TikTok, YouTube and Facebook \u2014 text-only ones included, with their likes, comments and views, and whether each can run as a paid ad (usable \xB7 needs the author's OK \xB7 can't). Accounts are followed with \`baker media-sources add\`. Subcommands: list, get, search, add, suggest, tag, refresh.
+
+Examples:
+  baker posts list --role ceo --usable needs_approval      # the CEO's posts a Thought Leader ad can boost
+  baker posts list --account linkedin:acme --sort engagement --since 2026-09-01
+  baker posts list --about-company                         # people's posts that name the company (ABM)
+  baker posts search "series A"
+  baker posts get <post-id>
+  baker posts add https://www.linkedin.com/posts/jane-doe_activity-7477679889043750912-K2pu
+  baker posts suggest <post-id> --verdict usable --note "Best-performing CEO post this month"
+  baker ads linkedin creatives create --format tla --post <post-id> --campaign <ad set>
+Full guide: __tooling__/docs/tools/baker/posts.md`
+  },
+  subCommands: {
+    list: () => import("./list-C3AQ4TMI.js").then((m) => m.listCommand),
+    get: () => import("./get-LYFN4SI7.js").then((m) => m.getCommand),
+    search: () => import("./search-MPY2OGDM.js").then((m) => m.searchCommand),
+    add: () => import("./add-RNU2PVXW.js").then((m) => m.addCommand),
+    suggest: () => import("./suggest-UIO2RDOC.js").then((m) => m.suggestCommand),
+    tag: () => import("./tag-LFYVMDNK.js").then((m) => m.tagCommand),
+    refresh: () => import("./refresh-E4JU2KR3.js").then((m) => m.refreshCommand)
+  }
+});
+export {
+  postsCommand
+};
+//# sourceMappingURL=posts-37LZKGWU.js.map

package/dist/promoted-tweet-writes-27RR3GOV.js

@@ -0,0 +1,181 @@
+import {
+  csvArg,
+  requireTargets,
+  stageAccountId,
+  stageXOp,
+  stageXOps
+} from "./chunk-DMPIWMDR.js";
+import "./chunk-FIN4ZXGJ.js";
+import "./chunk-7NF73SCB.js";
+import "./chunk-ZRP7Y2DM.js";
+import {
+  TARGETING_OPERATORS,
+  TARGETING_TYPES
+} from "./chunk-MWD6JTOY.js";
+import "./chunk-CAZGM2NX.js";
+import "./chunk-NZS3KEQ2.js";
+import "./chunk-GIWHHCD6.js";
+import "./chunk-UI6BKYQD.js";
+import "./chunk-PTRCB7AR.js";
+import "./chunk-X7VQFLHI.js";
+import "./chunk-LU4HI4KI.js";
+import "./chunk-LGK7UWBN.js";
+import {
+  registerSchema
+} from "./chunk-Q7US4OOA.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/ads/x/promoted-tweet-writes.ts
+import { defineCommand } from "citty";
+registerSchema({
+  command: "ads.x.promotedTweets.create",
+  description: "Stage promoting one or more existing posts in an X ad group. Takes post (tweet) ids \u2014 the numeric id from the post's URL, not a base36 ads id.",
+  args: {
+    "account-id": { type: "string", description: "X Ads account ID", required: false },
+    "line-item-id": {
+      type: "string",
+      description: "Ad group id, or an x_temp_* ref staged in this draft",
+      required: true
+    },
+    "tweet-ids": { type: "string", description: "CSV of post ids", required: true }
+  }
+});
+var promotedTweetsCreateCommand = defineCommand({
+  meta: {
+    name: "create",
+    description: `Stage promoting posts in an ad group (applies when the chat is published).
+
+Example:
+  baker ads x promoted-tweets create --line-item-id wiee9 --tweet-ids 2042198488033661285`
+  },
+  args: {
+    "account-id": { type: "string", description: "X Ads account ID" },
+    "line-item-id": { type: "string", description: "Ad group id or x_temp_* ref", required: true },
+    "tweet-ids": { type: "string", description: "CSV of post ids", required: true }
+  },
+  run: async ({ args }) => {
+    const accountId = await stageAccountId(args);
+    await stageXOp({
+      kind: "promotedTweet.create",
+      accountId,
+      payload: { lineItemId: args["line-item-id"], tweetIds: csvArg(args["tweet-ids"]) ?? [] }
+    });
+  }
+});
+registerSchema({
+  command: "ads.x.promotedTweets.remove",
+  description: "Stage removing one or more promoted posts. X has no pause for these \u2014 removal is the only way to stop one serving, and it cannot be undone (re-promoting creates a new association).",
+  args: {
+    ids: { type: "string", description: "Promoted-post ids, comma-separated", required: true },
+    "account-id": { type: "string", description: "X Ads account ID", required: false }
+  }
+});
+var promotedTweetsRemoveCommand = defineCommand({
+  meta: {
+    name: "remove",
+    description: `Stage removing promoted posts. Cannot be undone.
+
+Example:
+  baker ads x promoted-tweets remove ayyorn,ayyoro`
+  },
+  args: {
+    ids: { type: "positional", description: "Promoted-post ids, comma-separated", required: true },
+    "account-id": { type: "string", description: "X Ads account ID" }
+  },
+  run: async ({ args }) => {
+    const accountId = await stageAccountId(args);
+    await stageXOps(
+      requireTargets(args, "ids").map((id) => ({
+        kind: "promotedTweet.remove",
+        accountId,
+        target: id,
+        payload: {}
+      }))
+    );
+  }
+});
+registerSchema({
+  command: "ads.x.targetingCriteria.create",
+  description: `Stage one targeting criterion on an X ad group. One op per value, because X stores each criterion as its own entity. Look values up first with \`baker ads x targeting-constants\`.
+Types: ${TARGETING_TYPES.join(", ")}. Operators: ${TARGETING_OPERATORS.join(" (include) | ")} (exclude).`,
+  args: {
+    "account-id": { type: "string", description: "X Ads account ID", required: false },
+    "line-item-id": { type: "string", description: "Ad group id, or an x_temp_* ref", required: true },
+    type: { type: "string", description: TARGETING_TYPES.join(" | "), required: true },
+    value: {
+      type: "string",
+      description: "Targeting value \u2014 from `targeting-constants` for the lookup types",
+      required: true
+    },
+    operator: { type: "string", description: "EQ to include (default), NE to exclude", required: false }
+  }
+});
+var targetingCriteriaCreateCommand = defineCommand({
+  meta: {
+    name: "create",
+    description: `Stage one targeting criterion on an ad group.
+
+Examples:
+  baker ads x targeting-criteria create --line-item-id wiee9 --type LOCATION --value 96683cc9126741d1
+  baker ads x targeting-criteria create --line-item-id wiee9 --type INTEREST --value 25 --operator NE`
+  },
+  args: {
+    "account-id": { type: "string", description: "X Ads account ID" },
+    "line-item-id": { type: "string", description: "Ad group id or x_temp_* ref", required: true },
+    type: { type: "string", description: TARGETING_TYPES.join(" | "), required: true },
+    value: { type: "string", description: "Targeting value", required: true },
+    operator: { type: "string", description: "EQ (include) | NE (exclude)" }
+  },
+  run: async ({ args }) => {
+    const accountId = await stageAccountId(args);
+    await stageXOp({
+      kind: "targetingCriteria.create",
+      accountId,
+      payload: {
+        lineItemId: args["line-item-id"],
+        targetingType: args.type,
+        targetingValue: args.value,
+        ...args.operator ? { operatorType: args.operator } : {}
+      }
+    });
+  }
+});
+registerSchema({
+  command: "ads.x.targetingCriteria.remove",
+  description: "Stage removing one or more targeting criteria from an X ad group.",
+  args: {
+    ids: { type: "string", description: "Targeting criterion ids, comma-separated", required: true },
+    "account-id": { type: "string", description: "X Ads account ID", required: false }
+  }
+});
+var targetingCriteriaRemoveCommand = defineCommand({
+  meta: {
+    name: "remove",
+    description: `Stage removing targeting criteria.
+
+Example:
+  baker ads x targeting-criteria remove 1dmtken`
+  },
+  args: {
+    ids: { type: "positional", description: "Targeting criterion ids, comma-separated", required: true },
+    "account-id": { type: "string", description: "X Ads account ID" }
+  },
+  run: async ({ args }) => {
+    const accountId = await stageAccountId(args);
+    await stageXOps(
+      requireTargets(args, "ids").map((id) => ({
+        kind: "targetingCriteria.remove",
+        accountId,
+        target: id,
+        payload: {}
+      }))
+    );
+  }
+});
+export {
+  promotedTweetsCreateCommand,
+  promotedTweetsRemoveCommand,
+  targetingCriteriaCreateCommand,
+  targetingCriteriaRemoveCommand
+};
+//# sourceMappingURL=promoted-tweet-writes-27RR3GOV.js.map

package/dist/promoted-tweets-6XAIXBK5.js

@@ -0,0 +1,119 @@
+import {
+  parseXApiError
+} from "./chunk-FIN4ZXGJ.js";
+import {
+  resolveXAccountId
+} from "./chunk-7NF73SCB.js";
+import {
+  cacheGet,
+  cacheSet,
+  writeAdsJson,
+  writeAdsOutput
+} from "./chunk-ZRP7Y2DM.js";
+import {
+  ApiError,
+  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/x/promoted-tweets.ts
+import { defineCommand } from "citty";
+registerSchema({
+  command: "ads.x.promotedTweets",
+  description: "List promoted tweets for an X Ads account. Returns id, line_item_id, tweet_id, approval_status. Filter by line-item-ids (CSV).",
+  args: {
+    "account-id": { type: "string", description: "X Ads account ID", required: false },
+    "line-item-ids": { type: "string", description: "CSV of line item IDs", required: false },
+    "with-deleted": { type: "boolean", description: "Include deleted", required: false },
+    "no-cache": { type: "boolean", description: "Skip cache", required: false }
+  }
+});
+var promotedTweetsListCommand = defineCommand({
+  meta: {
+    name: "promoted-tweets",
+    description: `List X Ads promoted tweets.
+
+Examples:
+  baker ads x promoted-tweets --account-id 18ce53xyz --line-item-ids abc,def`
+  },
+  args: {
+    "account-id": { type: "string", description: "X Ads account ID", required: false },
+    "line-item-ids": { type: "string", description: "CSV of line item IDs", required: false },
+    "with-deleted": { type: "boolean", description: "Include deleted", required: false },
+    "no-cache": { type: "boolean", description: "Skip cache", required: false },
+    output: { type: "string", description: "Format: json|csv|md", required: false, default: "json" }
+  },
+  run: async ({ args }) => {
+    const accountId = await resolveXAccountId(args);
+    const useCache = !args["no-cache"];
+    const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+    const cacheKey = `promoted-tweets:${accountId}:${today}:${args["line-item-ids"] ?? ""}:${args["with-deleted"] ? "1" : "0"}`;
+    if (useCache) {
+      const cached = cacheGet("x-account-data", cacheKey);
+      if (cached) {
+        writeAdsJson({ ok: true, data: cached.data, cached: true });
+        return;
+      }
+    }
+    try {
+      const params = { "account-id": accountId };
+      if (args["line-item-ids"]) params["line-item-ids"] = args["line-item-ids"];
+      if (args["with-deleted"]) params["with-deleted"] = "true";
+      if (!useCache) params["skip-cache"] = "true";
+      const data = await apiGet("/api/ads/x/promoted-tweets", params);
+      if (useCache) {
+        cacheSet("x-account-data", cacheKey, data, 60 * 60 * 1e3);
+      }
+      const format = args.output || "json";
+      if (format !== "json") {
+        writeAdsOutput(data, format);
+        return;
+      }
+      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);
+    }
+  }
+});
+var promotedTweetsCommand = defineCommand({
+  meta: {
+    name: "promoted-tweets",
+    description: `Promoted posts \u2014 the association between a post and an ad group, which X Ads Manager calls an ad.
+
+There is no pause: removing the association is the only way to stop one serving,
+and it cannot be undone (re-promoting creates a new one). The post itself is
+never touched.
+
+Examples:
+  baker ads x promoted-tweets
+  baker ads x promoted-tweets create --line-item-id wiee9 --tweet-ids 2042198488033661285
+  baker ads x promoted-tweets remove ayyorn`
+  },
+  subCommands: {
+    list: promotedTweetsListCommand,
+    create: () => import("./promoted-tweet-writes-27RR3GOV.js").then((m) => m.promotedTweetsCreateCommand),
+    remove: () => import("./promoted-tweet-writes-27RR3GOV.js").then((m) => m.promotedTweetsRemoveCommand)
+  },
+  args: {
+    "account-id": { type: "string", description: "X Ads account ID" },
+    "line-item-ids": { type: "string", description: "CSV of line item IDs" },
+    "with-deleted": { type: "boolean", description: "Include deleted" },
+    "no-cache": { type: "boolean", description: "Skip cache" },
+    output: { type: "string", description: "Format: json|csv|md", default: "json" }
+  },
+  default: "list"
+});
+export {
+  promotedTweetsCommand
+};
+//# sourceMappingURL=promoted-tweets-6XAIXBK5.js.map