@koda-sl/baker-cli 0.500.0 → 0.503.0

package/dist/chunk-3MNNEPLV.js

@@ -0,0 +1,169 @@
+import {
+  parseXApiError
+} from "./chunk-FIN4ZXGJ.js";
+import {
+  resolveXAccountId
+} from "./chunk-7NF73SCB.js";
+import {
+  writeAdsJson,
+  writeJsonEnvelope
+} from "./chunk-ZRP7Y2DM.js";
+import {
+  X_DRAFT_BATCH_MAX,
+  xDraftOpInputSchema
+} from "./chunk-JDJQKN27.js";
+import {
+  ApiError,
+  apiPost
+} from "./chunk-X7VQFLHI.js";
+import {
+  requireChatId
+} from "./chunk-LGK7UWBN.js";
+
+// src/commands/ads/x/write-shared.ts
+function failWriteValidation(message) {
+  writeJsonEnvelope({ ok: false, error: { code: "VALIDATION_ERROR", message } });
+  process.exit(1);
+}
+function failPreflight(fields) {
+  writeJsonEnvelope({
+    ok: false,
+    error: {
+      code: "VALIDATION_ERROR",
+      message: fields.map((f) => f.path ? `${f.path}: ${f.message}` : f.message).join("; "),
+      fields,
+      fix: {
+        action: "reject",
+        explanation: "Fix the named fields and stage again. Nothing was staged \u2014 the draft is exactly as it was before this call."
+      }
+    }
+  });
+  process.exit(1);
+}
+function handleXWriteError(err, accountId) {
+  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);
+}
+function decimalPlaces(value) {
+  const [mantissa, exponent] = String(value).trim().split(/e/i);
+  const written = (mantissa?.split(".")[1] ?? "").length;
+  return Math.max(0, written - (exponent ? Number(exponent) : 0));
+}
+function parseXMoney(value) {
+  if (value === void 0 || value === "") {
+    return { ok: true, micros: void 0 };
+  }
+  const amount = Number(value);
+  if (!Number.isFinite(amount) || amount <= 0) {
+    return { ok: false, reason: "must be a positive amount, for example 12.50" };
+  }
+  if (decimalPlaces(value) > 6) {
+    return { ok: false, reason: "is finer than X can express \u2014 it takes whole micros" };
+  }
+  return { ok: true, micros: Math.round(amount * 1e6) };
+}
+function microsFromArg(value, flag) {
+  const parsed = parseXMoney(value);
+  if (!parsed.ok) {
+    failWriteValidation(`${flag} ${parsed.reason}`);
+  }
+  return parsed.micros;
+}
+function csvArg(value) {
+  if (typeof value !== "string" || value.length === 0) {
+    return void 0;
+  }
+  const parts = value.split(",").map((s) => s.trim()).filter(Boolean);
+  return parts.length > 0 ? parts : void 0;
+}
+function compact(payload) {
+  return Object.fromEntries(Object.entries(payload).filter(([, value]) => value !== void 0));
+}
+function batchNudge(data) {
+  const count = data?.sameKindStaged;
+  if (!count) {
+    return [];
+  }
+  return [
+    `${count} other change${count === 1 ? "" : "s"} of this kind and payload ${count === 1 ? "is" : "are"} already staged \u2014 pass every id to one call (\`--ids a,b,c\`) instead of one call each.`
+  ];
+}
+async function stageXOp(raw, hints) {
+  const preflight = xDraftOpInputSchema.safeParse(raw);
+  if (!preflight.success) {
+    failPreflight(preflight.error.issues.map((issue) => ({ path: issue.path.join("."), message: issue.message })));
+  }
+  const accountId = String(raw.accountId ?? "\u2014");
+  try {
+    const chatId = requireChatId();
+    const response = await apiPost("/api/ads/x/draft/stage", { chatId, op: preflight.data });
+    const allHints = [...batchNudge(response.data), ...hints ?? []];
+    writeJsonEnvelope(allHints.length > 0 ? { ...response, hints: allHints } : response);
+  } catch (err) {
+    handleXWriteError(err, accountId);
+  }
+}
+async function stageXOps(rawOps, hints) {
+  if (rawOps.length === 1 && rawOps[0]) {
+    await stageXOp(rawOps[0], hints);
+    return;
+  }
+  if (rawOps.length > X_DRAFT_BATCH_MAX) {
+    failWriteValidation(`at most ${X_DRAFT_BATCH_MAX} changes can be staged in one call`);
+  }
+  const ops = [];
+  for (const [index, raw] of rawOps.entries()) {
+    const preflight = xDraftOpInputSchema.safeParse(raw);
+    if (!preflight.success) {
+      failPreflight(
+        preflight.error.issues.map((issue) => ({
+          path: `ops[${index}]${issue.path.length > 0 ? `.${issue.path.join(".")}` : ""}`,
+          message: issue.message
+        }))
+      );
+    }
+    ops.push(preflight.data);
+  }
+  const accountId = String(rawOps[0]?.accountId ?? "\u2014");
+  try {
+    const chatId = requireChatId();
+    const response = await apiPost("/api/ads/x/draft/stage-batch", { chatId, ops });
+    writeJsonEnvelope(hints && hints.length > 0 ? { ...response, hints } : response);
+  } catch (err) {
+    handleXWriteError(err, accountId);
+  }
+}
+async function stageAccountId(args) {
+  return await resolveXAccountId(args);
+}
+function requireTarget(args, name) {
+  const value = args[name];
+  if (typeof value !== "string" || value.length === 0) {
+    failWriteValidation(`${name} is required`);
+  }
+  return value;
+}
+function requireTargets(args, name) {
+  const ids = csvArg(args[name]);
+  if (!ids) {
+    failWriteValidation(`${name} is required \u2014 pass one or more ids, comma-separated`);
+  }
+  return ids;
+}
+
+export {
+  failWriteValidation,
+  microsFromArg,
+  csvArg,
+  compact,
+  stageXOp,
+  stageXOps,
+  stageAccountId,
+  requireTarget,
+  requireTargets
+};
+//# sourceMappingURL=chunk-3MNNEPLV.js.map

package/dist/chunk-3SUBLZSS.js

@@ -0,0 +1,23 @@
+import {
+  creativesRunResponseSchema
+} from "./chunk-JDJQKN27.js";
+import {
+  ApiError,
+  apiPost
+} from "./chunk-X7VQFLHI.js";
+
+// src/commands/canvas/run-history.ts
+async function fetchRunRecord(runId, post = apiPost) {
+  try {
+    const response = await post("/api/creatives/run", { runId });
+    return creativesRunResponseSchema.parse(response).data;
+  } catch (e) {
+    if (e instanceof ApiError && e.code === "NOT_FOUND") return null;
+    throw e;
+  }
+}
+
+export {
+  fetchRunRecord
+};
+//# sourceMappingURL=chunk-3SUBLZSS.js.map

package/dist/chunk-3SYRNFRV.js

@@ -0,0 +1,275 @@
+import {
+  FLOW_ACCOUNT_ONLY_KINDS,
+  FLOW_AGENT_DESTINATION_KINDS,
+  FLOW_DELIVERY_SIDE_EFFECT_TYPES,
+  FLOW_RESOURCE_NODE_TYPES,
+  FLOW_SECRET_FIELDS,
+  flowCatalogEntry,
+  isFlowOauthSideEffect
+} from "./chunk-JDJQKN27.js";
+import {
+  apiPost
+} from "./chunk-X7VQFLHI.js";
+import {
+  writeJson
+} from "./chunk-Q7US4OOA.js";
+
+// src/commands/flows/shared.ts
+import { existsSync, readdirSync, readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+var FLOWS_DIR = "src/lib/flow-engine/flows";
+function flowsDir() {
+  let dir = process.cwd();
+  for (let i = 0; i < 6; i++) {
+    const candidate = join(dir, FLOWS_DIR);
+    if (existsSync(candidate)) {
+      return candidate;
+    }
+    const parent = join(dir, "..");
+    if (parent === dir) {
+      break;
+    }
+    dir = parent;
+  }
+  return join(process.cwd(), FLOWS_DIR);
+}
+function failLocal(message) {
+  writeJson({ ok: false, error: { code: "NOT_FOUND", message } });
+  process.exit(1);
+}
+function listFlowSlugs() {
+  const dir = flowsDir();
+  if (!existsSync(dir)) {
+    return [];
+  }
+  return readdirSync(dir, { withFileTypes: true }).filter((entry) => entry.isDirectory() && !entry.name.startsWith("_") && entry.name !== ".gitkeep").map((entry) => entry.name).sort();
+}
+function flowDataPath(slug) {
+  return join(flowsDir(), slug, "_data.json");
+}
+function writeFlowTree(slug, tree) {
+  writeFileSync(flowDataPath(slug), `${JSON.stringify(tree, null, 2)}
+`, "utf-8");
+}
+function walkNodes(node, acc = []) {
+  if (!node || typeof node !== "object") return acc;
+  acc.push(node);
+  if (Array.isArray(node.children)) {
+    for (const child of node.children) walkNodes(child, acc);
+  }
+  return acc;
+}
+function collectSideEffects(tree) {
+  return walkNodes(tree).flatMap(
+    (node) => Array.isArray(node.sideEffects) ? node.sideEffects.filter((sideEffect) => Boolean(sideEffect) && typeof sideEffect === "object").map((sideEffect) => ({ node, sideEffect })) : []
+  );
+}
+function sealedSideEffects(tree) {
+  return collectSideEffects(tree).flatMap(({ sideEffect }) => {
+    const { id, type, encryptedConfig } = sideEffect;
+    const sealed = typeof id === "string" && typeof type === "string" && FLOW_DELIVERY_SIDE_EFFECT_TYPES.includes(type) && typeof encryptedConfig === "string" && encryptedConfig.length > 0;
+    return sealed ? [{ sideEffectId: id, type, encryptedConfig }] : [];
+  });
+}
+function describeSettings(settings) {
+  if (typeof settings.email === "string") {
+    return `to ${settings.email}${typeof settings.subject === "string" ? ` \xB7 subject "${settings.subject}"` : ""}`;
+  }
+  return Object.entries(settings).filter(([, value]) => typeof value === "string" || typeof value === "number").map(([key, value]) => `${key}: ${String(value)}`).join(" \xB7 ");
+}
+function withSettings(rows, settingsById) {
+  return rows.map((row) => {
+    const settings = row.sideEffectId ? settingsById[row.sideEffectId] : void 0;
+    const described = settings ? describeSettings(settings) : "";
+    return described ? { ...row, status: `${row.status} \u2192 ${described}` } : row;
+  });
+}
+function flowExists(slug) {
+  return existsSync(join(flowsDir(), slug, "_data.json"));
+}
+function readFlowTree(slug) {
+  const path = join(flowsDir(), slug, "_data.json");
+  if (!existsSync(path)) {
+    failLocal(`No form "${slug}". Run "baker flows list" to see the forms in this workspace.`);
+  }
+  try {
+    return JSON.parse(readFileSync(path, "utf-8"));
+  } catch (error) {
+    failLocal(`Could not read form "${slug}": ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+function isConfigured(value) {
+  return typeof value === "string" && value.length > 0;
+}
+function nodeMeta(record) {
+  const nodeId = typeof record.id === "string" ? record.id : "";
+  const nodeName = typeof record.name === "string" ? record.name : void 0;
+  return { nodeId, ...nodeName ? { nodeName } : {} };
+}
+function widgetNodeStatus(record, meta) {
+  const nodeData = record.nodeData;
+  const nodeType = nodeData?.type;
+  if (typeof nodeType !== "string" || !FLOW_RESOURCE_NODE_TYPES.includes(nodeType)) {
+    return null;
+  }
+  const external = nodeData?.form?.external;
+  const selected = external != null && typeof external === "object";
+  const name = selected ? external.name : void 0;
+  return {
+    ...meta,
+    target: "node",
+    kind: nodeType,
+    status: selected ? `${nodeType} \u2014 selected${typeof name === "string" ? ` "${name}"` : ""}` : `${nodeType} \u2014 not selected`,
+    needsInput: !selected
+  };
+}
+function sideEffectNeedsInput(raw) {
+  const effect = raw;
+  const type = effect?.type;
+  if (typeof type !== "string" || !FLOW_DELIVERY_SIDE_EFFECT_TYPES.includes(type)) {
+    return false;
+  }
+  const configured = isConfigured(effect?.encryptedConfig);
+  if (!isFlowOauthSideEffect(type)) return !configured;
+  return !isConfigured(effect?.oauthProviderId) || !configured;
+}
+function trackingStatus(effect, type, meta) {
+  if (flowCatalogEntry("side-effect", type)?.owners?.tagIds !== "tags") return null;
+  const tags = Array.isArray(effect.tagIds) ? effect.tagIds.length : 0;
+  const event = typeof effect.eventName === "string" ? ` "${effect.eventName}"` : "";
+  return {
+    ...meta,
+    target: "sideEffect",
+    ...typeof effect.id === "string" ? { sideEffectId: effect.id } : {},
+    kind: type,
+    status: `${type}${event} \u2014 ${tags > 0 ? `[${tags} tag${tags === 1 ? "" : "s"}]` : "[no tag]"}`,
+    needsInput: false
+  };
+}
+function sideEffectStatus(raw, meta) {
+  const effect = raw;
+  const type = effect?.type;
+  if (typeof type !== "string") return null;
+  if (!FLOW_DELIVERY_SIDE_EFFECT_TYPES.includes(type)) {
+    return effect ? trackingStatus(effect, type, meta) : null;
+  }
+  const configured = isConfigured(effect?.encryptedConfig);
+  const oauth = isFlowOauthSideEffect(type);
+  const connected = isConfigured(effect?.oauthProviderId);
+  const needs = FLOW_SECRET_FIELDS[type];
+  const status = oauth ? `${type} \u2014 connection ${connected ? "[connected]" : "[needs connection]"}, config ${configured ? "[set]" : "[missing]"}` : configured ? `${type} \u2014 [configured]` : `${type} \u2014 [missing]${needs.length > 0 ? ` (needs: ${needs.join(", ")})` : ""}`;
+  return {
+    ...meta,
+    target: "sideEffect",
+    ...typeof effect?.id === "string" ? { sideEffectId: effect.id } : {},
+    kind: type,
+    status,
+    needsInput: sideEffectNeedsInput(effect)
+  };
+}
+function requestFlowInputCall(slug, status) {
+  const args = status.target === "node" ? `{ target: "node", flowSlug: "${slug}", nodeId: "${status.nodeId}", nodeType: "${status.kind}" }` : `{ target: "sideEffect", flowSlug: "${slug}", nodeId: "${status.nodeId}", sideEffectId: "${status.sideEffectId}", sideEffectType: "${status.kind}" }`;
+  const card = `request_flow_input with ${args}`;
+  const target = status.target === "node" ? `--node ${status.nodeId}` : `--side-effect ${status.sideEffectId}`;
+  const fallback = "only if nothing is connected or several could be meant";
+  if (status.kind === "email") {
+    return `baker flows connect ${slug} ${target} --email "<who receives each lead, comma-separated>" --subject "<New lead \u2014 the Form's name>"`;
+  }
+  if (status.kind === "httpWebhook") {
+    return `baker flows connect ${slug} ${target} --url <https address> \u2014 only a webhook that needs a token or password goes to the user: ${card}`;
+  }
+  if (status.kind === "hubspotForm") {
+    return `baker flows connect ${slug} ${target} --hubspot-form <formId from baker hubspot forms list> \u2014 ${fallback}: ${card}`;
+  }
+  if (status.kind === "hubspot" || status.kind === "hubspotMeeting") {
+    const list = status.kind === "hubspot" ? "forms view <id>" : "meetings view <slug>";
+    return `write \`baker hubspot ${list} --as-node\` into the step's form.external \u2014 ${fallback}: ${card}`;
+  }
+  if (FLOW_ACCOUNT_ONLY_KINDS.includes(status.kind)) {
+    return `baker flows connect ${slug} ${target} \u2014 ${fallback}: ${card}`;
+  }
+  if (FLOW_AGENT_DESTINATION_KINDS.includes(status.kind)) {
+    const sheet = status.kind === "googleSpreadsheet" ? ' (or --new-sheet "<title>" --columns "\u2026")' : "";
+    return `baker flows connect ${slug} ${target} --resource <id from baker flows options ${status.kind}>${sheet} \u2014 ${fallback}: ${card}`;
+  }
+  return card;
+}
+function collectConfigStatus(node, acc) {
+  if (!node || typeof node !== "object") {
+    return;
+  }
+  const record = node;
+  const meta = nodeMeta(record);
+  const widget = widgetNodeStatus(record, meta);
+  if (widget) {
+    acc.push(widget);
+  }
+  if (Array.isArray(record.sideEffects)) {
+    for (const raw of record.sideEffects) {
+      const status = sideEffectStatus(raw, meta);
+      if (status) {
+        acc.push(status);
+      }
+    }
+  }
+  if (Array.isArray(record.children)) {
+    for (const child of record.children) {
+      collectConfigStatus(child, acc);
+    }
+  }
+}
+function redactTree(node) {
+  if (Array.isArray(node)) {
+    return node.map(redactTree);
+  }
+  if (!node || typeof node !== "object") {
+    return node;
+  }
+  const out = {};
+  for (const [key, value] of Object.entries(node)) {
+    if (key === "encryptedConfig") {
+      out[key] = isConfigured(value) ? "[configured]" : value;
+    } else {
+      out[key] = redactTree(value);
+    }
+  }
+  return out;
+}
+function stepNameKey(name) {
+  return name.replace(/([a-z])([A-Z])/g, "$1_$2").replace(/[-\s]+/g, "_").toUpperCase();
+}
+function isUsableStepNameKey(key) {
+  return /^[\p{ID_Start}$_][\p{ID_Continue}$‌‍]*$/u.test(key);
+}
+async function readSettings(tree) {
+  const sealed = sealedSideEffects(tree);
+  if (sealed.length === 0) return {};
+  try {
+    const { data } = await apiPost("/api/flows/destinations/reveal", {
+      items: sealed.map(({ type, encryptedConfig }) => ({ type, encryptedConfig }))
+    });
+    return Object.fromEntries(sealed.map((item, index) => [item.sideEffectId, data.items[index] ?? null]));
+  } catch {
+    return null;
+  }
+}
+
+export {
+  flowsDir,
+  listFlowSlugs,
+  flowDataPath,
+  writeFlowTree,
+  walkNodes,
+  collectSideEffects,
+  withSettings,
+  flowExists,
+  readFlowTree,
+  sideEffectNeedsInput,
+  requestFlowInputCall,
+  collectConfigStatus,
+  redactTree,
+  stepNameKey,
+  isUsableStepNameKey,
+  readSettings
+};
+//# sourceMappingURL=chunk-3SYRNFRV.js.map

package/dist/chunk-4GAEB6NK.js

@@ -0,0 +1,228 @@
+import {
+  NUMERIC_ID_REGEX
+} from "./chunk-2TOIY2WN.js";
+
+// ../api/src/ads-google/change-history.ts
+var CHANGE_SCOPES = ["detail", "summary"];
+var CHANGE_SCOPE_MAX_DAYS = {
+  detail: 30,
+  summary: 90
+};
+var DEFAULT_CHANGE_DAYS = 7;
+var MAX_CHANGE_DAYS = CHANGE_SCOPE_MAX_DAYS.summary;
+function isChangeLookbackWithinReach(days, scope) {
+  return days <= CHANGE_SCOPE_MAX_DAYS[scope];
+}
+
+// ../api/src/ads-google/keyword-planning.ts
+import { z } from "zod";
+var ISO_DATE = /^\d{4}-\d{2}-\d{2}$/;
+var micros = z.number().int().positive();
+var FORECAST_MATCH_TYPES = ["EXACT", "PHRASE", "BROAD"];
+var googleForecastBiddingSchema = z.discriminatedUnion("strategy", [
+  z.object({ strategy: z.literal("MANUAL_CPC"), maxCpcBidMicros: micros, dailyBudgetMicros: micros.optional() }),
+  z.object({
+    strategy: z.literal("MAXIMIZE_CLICKS"),
+    dailyTargetSpendMicros: micros,
+    maxCpcBidCeilingMicros: micros.optional()
+  }),
+  z.object({ strategy: z.literal("MAXIMIZE_CONVERSIONS"), dailyTargetSpendMicros: micros })
+]);
+var googleKeywordForecastRequestSchema = z.object({
+  customerId: z.string().regex(NUMERIC_ID_REGEX, "customerId must be the bare numeric customer id"),
+  managerId: z.string().optional(),
+  /** One forecast ad group per entry; most forecasts are a single group. */
+  adGroups: z.array(
+    z.object({
+      keywords: z.array(z.object({ text: z.string().trim().min(1).max(80), matchType: z.enum(FORECAST_MATCH_TYPES) })).min(1)
+    })
+  ).min(1),
+  locationIds: z.array(z.string().regex(NUMERIC_ID_REGEX)).optional(),
+  languageId: z.string().regex(NUMERIC_ID_REGEX).optional(),
+  bidding: googleForecastBiddingSchema,
+  /** Must start in the future and end within a year. Without them Baker forecasts the 30 days from tomorrow. */
+  startDate: z.string().regex(ISO_DATE).optional(),
+  endDate: z.string().regex(ISO_DATE).optional(),
+  currencyCode: z.string().length(3).optional()
+}).refine((body) => body.startDate === void 0 === (body.endDate === void 0), {
+  message: "Give both --start and --end, or neither (the forecast then covers the 30 days from tomorrow)",
+  path: ["endDate"]
+});
+var KEYWORD_FORECAST_SOURCE = "keyword_planner_forecast";
+var googleKeywordForecastResponseSchema = z.object({
+  source: z.literal(KEYWORD_FORECAST_SOURCE),
+  period: z.object({ startDate: z.string(), endDate: z.string() }),
+  forecast_clicks: z.number().nullable(),
+  forecast_cost_micros: z.number().nullable(),
+  forecast_conversions: z.number().nullable(),
+  forecast_average_cpc_micros: z.number().nullable(),
+  forecast_average_cpa_micros: z.number().nullable()
+});
+var googleAdGroupThemesRequestSchema = z.object({
+  customerId: z.string().regex(NUMERIC_ID_REGEX, "customerId must be the bare numeric customer id"),
+  managerId: z.string().optional(),
+  keywords: z.array(z.string().trim().min(1)).min(1),
+  /** Existing ad groups to sort the keywords into: numeric ids or `customers/{cid}/adGroups/{id}`. */
+  adGroups: z.array(z.string().min(1)).min(1)
+});
+var googleAdGroupThemesResponseSchema = z.object({
+  suggestions: z.array(
+    z.object({
+      keyword: z.string(),
+      suggested_keyword: z.string(),
+      match_type: z.string(),
+      ad_group: z.string(),
+      campaign: z.string()
+    })
+  ),
+  unusable_ad_groups: z.array(z.object({ ad_group: z.string(), campaign: z.string() }))
+});
+
+// ../api/src/ads-google/url-options.ts
+import { z as z2 } from "zod";
+var URL_OPTION_LEVELS = ["account", "campaign", "ad_group", "ad"];
+var googleUrlOptionValueSchema = z2.discriminatedUnion("state", [
+  z2.object({ state: z2.literal("set"), value: z2.string() }),
+  z2.object({ state: z2.literal("not_set") }),
+  z2.object({ state: z2.literal("not_read"), reason: z2.string() })
+]);
+var googleUrlOptionsRequestSchema = z2.object({
+  customerId: z2.string().regex(NUMERIC_ID_REGEX, "customerId must be the bare numeric customer id"),
+  managerId: z2.string().optional(),
+  /** Compact by default: only campaigns that actually override the account. `full` lists every campaign. */
+  full: z2.boolean().optional(),
+  skipCache: z2.boolean().optional()
+});
+var googleUrlOptionsCampaignSchema = z2.object({
+  id: z2.string(),
+  name: z2.string(),
+  status: z2.string(),
+  final_url_suffix: googleUrlOptionValueSchema,
+  tracking_url_template: googleUrlOptionValueSchema
+});
+var googleUrlOptionsAdGroupSchema = z2.object({
+  id: z2.string(),
+  name: z2.string(),
+  status: z2.string(),
+  campaign_id: z2.string(),
+  final_url_suffix: googleUrlOptionValueSchema,
+  tracking_url_template: googleUrlOptionValueSchema
+});
+var googleUrlOptionsAdSchema = z2.object({
+  id: z2.string(),
+  status: z2.string(),
+  ad_group_id: z2.string(),
+  campaign_id: z2.string(),
+  final_url_suffix: googleUrlOptionValueSchema,
+  tracking_url_template: googleUrlOptionValueSchema
+});
+var googleUrlOptionsResponseSchema = z2.object({
+  customer_id: z2.string(),
+  account: z2.object({
+    level: z2.literal("account"),
+    read: z2.boolean(),
+    final_url_suffix: googleUrlOptionValueSchema,
+    tracking_url_template: googleUrlOptionValueSchema
+  }),
+  campaigns: z2.object({
+    level: z2.literal("campaign"),
+    read: z2.boolean(),
+    /** Campaigns actually observed. 0 with `read: true` means the account has no non-removed campaigns. */
+    campaigns_read: z2.number().int().nonnegative(),
+    /** Campaigns observed to carry no override of their own — an explicit finding, not an omission. */
+    campaigns_without_override: z2.number().int().nonnegative(),
+    overrides: z2.array(googleUrlOptionsCampaignSchema),
+    /** Compact mode only: campaigns read but not listed because they carry no override. */
+    omitted: z2.number().int().nonnegative()
+  }),
+  /**
+   * Ad groups and ads that carry an override of their own — read by asking Google only for the
+   * entities whose suffix or template IS NOT NULL, so an account of thousands of ads costs one page.
+   * `read: true` with no overrides is a finding: nothing at this level overrides the levels above.
+   * `truncated` means more overriding entities exist than one page listed.
+   */
+  ad_groups: z2.object({
+    level: z2.literal("ad_group"),
+    read: z2.boolean(),
+    overrides: z2.array(googleUrlOptionsAdGroupSchema),
+    truncated: z2.boolean()
+  }),
+  ads: z2.object({
+    level: z2.literal("ad"),
+    read: z2.boolean(),
+    overrides: z2.array(googleUrlOptionsAdSchema),
+    truncated: z2.boolean()
+  }),
+  /** Levels this command could not read. Nothing here may be reported as "not configured". */
+  levels_not_read: z2.array(z2.object({ level: z2.enum(URL_OPTION_LEVELS), reason: z2.string() }))
+});
+var ACCOUNT_URL_OPTIONS_LOCATION = "Google Ads UI \u2192 Admin \u2192 Account settings \u2192 Tracking (account-level tracking template and final URL suffix)";
+var ACCOUNT_URL_OPTIONS_STAGE_COMMAND = 'baker ads google account update --customer-id <id> --final-url-suffix "utm_agency=baker"';
+function isSet(value) {
+  return value.state === "set";
+}
+function entityOverrideHints(label, plural, field, level) {
+  if (!level.read) return [];
+  const hints = [];
+  const overriding = level.overrides.filter((entity) => isSet(entity.final_url_suffix));
+  if (overriding.length > 0) {
+    const named = overriding.slice(0, 5).map((entity) => entity.name || entity.id).join(", ");
+    hints.push(
+      `${overriding.length} ${label}(s) set their own final URL suffix (${named}${overriding.length > 5 ? ", \u2026" : ""}). It REPLACES the campaign and account suffix for every click through it, so an account-wide parameter must be added to theirs too.`
+    );
+  }
+  if (level.truncated) {
+    hints.push(
+      `More ${plural} override the URL options than one page lists \u2014 read them all with \`baker ads google query\` on ${field}.final_url_suffix IS NOT NULL --all before saying which ones do.`
+    );
+  }
+  return hints;
+}
+function urlOptionsHints(report) {
+  const hints = [];
+  const { account, campaigns } = report;
+  if (!account.read) {
+    hints.push(
+      "The account level did NOT read \u2014 its URL options are unknown, not empty. Re-run before telling the user anything about account-wide tagging."
+    );
+  } else if (account.final_url_suffix.state === "not_set") {
+    hints.push(
+      `No account-level final URL suffix is set. An account-wide parameter (agency/partner tagging such as utm_agency=\u2026) belongs at the account level so it reaches every ad \u2014 stage it with \`${ACCOUNT_URL_OPTIONS_STAGE_COMMAND}\` (applies at Publish; the user sees it under ${ACCOUNT_URL_OPTIONS_LOCATION}).`
+    );
+  }
+  if (!campaigns.read) {
+    hints.push(
+      "Campaign-level URL options did NOT read \u2014 do not report that no campaign overrides exist. Re-run before concluding."
+    );
+  } else {
+    const overriding = campaigns.overrides.filter((c) => isSet(c.final_url_suffix));
+    if (overriding.length > 0) {
+      const named = overriding.slice(0, 5).map((c) => c.name || c.id).join(", ");
+      hints.push(
+        `A campaign's final URL suffix REPLACES the account-level one for that campaign \u2014 it does not merge. ${overriding.length} campaign(s) set their own (${named}${overriding.length > 5 ? ", \u2026" : ""}) and will not pick up an account-wide parameter until their own suffix carries it too. Every other campaign read here inherits the account level normally.`
+      );
+    }
+  }
+  hints.push(...entityOverrideHints("ad group", "ad groups", "ad_group", report.ad_groups));
+  hints.push(...entityOverrideHints("ad", "ads", "ad_group_ad.ad", report.ads));
+  const overridingLevelsNotRead = report.levels_not_read.filter((level) => level.level !== "account");
+  if (overridingLevelsNotRead.length > 0) {
+    hints.push(
+      `Not read at this level: ${overridingLevelsNotRead.map((l) => l.level).join(", ")}. A suffix set there still wins over the levels above it.`
+    );
+  }
+  if (campaigns.omitted > 0) {
+    hints.push(`${campaigns.omitted} campaign(s) read with no override of their own are not listed \u2014 pass --full.`);
+  }
+  return hints;
+}
+
+export {
+  CHANGE_SCOPES,
+  CHANGE_SCOPE_MAX_DAYS,
+  DEFAULT_CHANGE_DAYS,
+  isChangeLookbackWithinReach,
+  googleKeywordForecastRequestSchema,
+  urlOptionsHints
+};
+//# sourceMappingURL=chunk-4GAEB6NK.js.map