@affset/mcp 0.1.0

package/dist/tools/listSubLabels.js

@@ -0,0 +1,31 @@
+import { mdCell } from "../lib/format.js";
+import { errorResult, textResult } from "../lib/toolResult.js";
+import { SUB_KEYS } from "../types.js";
+export const LIST_SUB_LABELS_DESCRIPTION = "List the tenant's display names for sub1–sub5 (traffic-source breakdown slots). " +
+    "Unlabeled slots show as the raw key. Used by get_stats column titles and " +
+    "tracking-link / zone-URL query params.";
+export const listSubLabelsInputSchema = {};
+export async function listSubLabels(client) {
+    try {
+        const settings = await client.get("/api/tenant");
+        const labels = settings.sub_labels ?? {};
+        const labeled = SUB_KEYS.filter((k) => (labels[k] ?? "").trim().length > 0);
+        const lines = [
+            `**Sub labels** — ${labeled.length} of ${SUB_KEYS.length} named`,
+            "",
+            "| Key | Label |",
+            "|---|---|",
+        ];
+        for (const key of SUB_KEYS) {
+            const label = labels[key]?.trim();
+            lines.push(`| \`${key}\` | ${label ? mdCell(label) : "_— (raw key)_"} |`);
+        }
+        lines.push("");
+        lines.push("_Set / clear with `set_sub_labels` (null or empty clears a slot)._");
+        return textResult(lines.join("\n"));
+    }
+    catch (err) {
+        return errorResult(err);
+    }
+}
+//# sourceMappingURL=listSubLabels.js.map

package/dist/tools/listTargetingRules.js

@@ -0,0 +1,69 @@
+import { z } from "zod";
+import { AffsetApiError } from "../client.js";
+import { mdCell } from "../lib/format.js";
+import { fetchTargetingRules, fetchTargetingTypes, UNENFORCED_TYPES } from "../lib/targeting.js";
+import { errorResult, textError, textResult } from "../lib/toolResult.js";
+export const LIST_TARGETING_RULES_DESCRIPTION = "List a campaign's targeting rules (type, method whitelist/blacklist, rule values). " +
+    "Rules gate /serve rotation; the direct tracking link does not enforce them. " +
+    "Call `list_targeting_types` for type ids/names.";
+export const listTargetingRulesInputSchema = {
+    campaign_id: z
+        .union([z.string().min(1), z.number().int()])
+        .describe("Campaign whose targeting rules to list."),
+};
+export async function listTargetingRules(client, args) {
+    try {
+        const campaignId = String(args.campaign_id).trim();
+        if (!campaignId)
+            return textError("campaign_id is required.");
+        const [rules, types] = await Promise.all([
+            fetchTargetingRules(client, campaignId),
+            // Names are a nicety; a rule list is still useful with bare type ids.
+            fetchTargetingTypes(client).catch(() => []),
+        ]);
+        const typeById = new Map(types.map((t) => [t.id, t]));
+        const dead = rules.filter((r) => {
+            const name = typeById.get(r.targeting_rule_type_id)?.name.toLowerCase();
+            return name !== undefined && UNENFORCED_TYPES[name] !== undefined;
+        });
+        return textResult([
+            `**Targeting rules** — campaign \`${campaignId}\` — ${rules.length} rule(s)`,
+            "",
+            renderRules(rules, typeById),
+            ...(dead.length ? ["", ...deadRuleWarnings(dead, typeById)] : []),
+            "",
+            "_Enforced on `/serve` rotation only — not on direct tracking links._",
+            "_Manage with `set_targeting_rule` / `remove_targeting_rule`._",
+        ].join("\n"));
+    }
+    catch (err) {
+        if (err instanceof AffsetApiError && err.status === 404) {
+            return textError(`Campaign \`${String(args.campaign_id).trim()}\` not found in this namespace.`);
+        }
+        return errorResult(err);
+    }
+}
+function renderRules(rules, typeById) {
+    if (rules.length === 0) {
+        return "_No targeting rules — campaign is unrestricted on /serve._";
+    }
+    const lines = ["| Id | Type | Method | Rule |", "|---|---|---|---|"];
+    for (const r of rules) {
+        const t = typeById.get(r.targeting_rule_type_id);
+        const typeLabel = t
+            ? `${mdCell(t.name)} (${r.targeting_rule_type_id})`
+            : String(r.targeting_rule_type_id);
+        const inert = t && UNENFORCED_TYPES[t.name.toLowerCase()] ? " ⚠️" : "";
+        lines.push(`| ${r.id ?? "—"} | ${typeLabel}${inert} | ${mdCell(r.targeting_method)} | ${mdCell(r.rule)} |`);
+    }
+    return lines.join("\n");
+}
+/**
+ * Rules of a seeded-but-unevaluated type read as working targeting. Saying so on
+ * every listing is the only place an operator would find out.
+ */
+function deadRuleWarnings(dead, typeById) {
+    const names = [...new Set(dead.map((r) => typeById.get(r.targeting_rule_type_id).name))];
+    return names.map((name) => `⚠️ \`${name}\` — ${UNENFORCED_TYPES[name.toLowerCase()]}. This rule has no effect.`);
+}
+//# sourceMappingURL=listTargetingRules.js.map

package/dist/tools/listTargetingTypes.js

@@ -0,0 +1,39 @@
+import { mdCell } from "../lib/format.js";
+import { fetchTargetingTypes, UNENFORCED_TYPES } from "../lib/targeting.js";
+import { errorResult, textResult } from "../lib/toolResult.js";
+export const LIST_TARGETING_TYPES_DESCRIPTION = "List targeting rule types available in this tenant (id, name, description), " +
+    "flagging the seeded types the /serve path does not actually evaluate. " +
+    "Use the id (or name) when setting campaign targeting rules. Enforced types: " +
+    "geo, device_type, zone_id, os, browser, unique_users.";
+export const listTargetingTypesInputSchema = {};
+export async function listTargetingTypes(client) {
+    try {
+        const types = await fetchTargetingTypes(client);
+        if (types.length === 0) {
+            return textResult("_No targeting rule types found._");
+        }
+        const lines = [
+            `**Targeting rule types** — ${types.length}`,
+            "",
+            "| Id | Name | Enforced | Description |",
+            "|--:|---|---|---|",
+        ];
+        for (const t of types) {
+            const unenforced = UNENFORCED_TYPES[t.name.toLowerCase()];
+            lines.push(`| ${t.id} | ${mdCell(t.name)} | ${unenforced ? "**no**" : "yes"} | ` +
+                `${mdCell(unenforced ?? t.description ?? "—")} |`);
+        }
+        lines.push("");
+        lines.push("_Use these ids with `set_targeting_rule` / `list_targeting_rules`. " +
+            "`rule` is usually a comma-separated list (e.g. geo: `BR,MX`; " +
+            "unique_users: `visits/hours`)._");
+        lines.push("_Values are matched exactly and case-sensitively at serve time (geo from " +
+            "`CF-IPCountry`, os/browser from the user agent); `set_targeting_rule` " +
+            "normalises what it can and rejects what could never match._");
+        return textResult(lines.join("\n"));
+    }
+    catch (err) {
+        return errorResult(err);
+    }
+}
+//# sourceMappingURL=listTargetingTypes.js.map

package/dist/tools/listTeam.js

@@ -0,0 +1,57 @@
+import { z } from "zod";
+import { mdCell } from "../lib/format.js";
+import { errorResult } from "../lib/toolResult.js";
+export const LIST_TEAM_DESCRIPTION = "List team members (user API keys) in the current namespace: email, role, " +
+    "manager, created/expiry. Never returns API tokens. Requires owner/manager " +
+    "(or a scoped manager role).";
+export const listTeamInputSchema = {
+    role: z
+        .string()
+        .min(1)
+        .optional()
+        .describe("Optional role filter, e.g. owner, manager, publisher, advertiser, " +
+        "publisher_manager, advertiser_manager."),
+    include_expired: z
+        .boolean()
+        .default(false)
+        .describe("Include members whose expires_at is in the past. Default false."),
+};
+export async function listTeam(client, args) {
+    try {
+        // Team members are user-typed API keys — there is no /api/team endpoint.
+        const members = await client.get("/api/api-keys", { type: "user" });
+        const list = Array.isArray(members) ? members : [];
+        const now = Date.now();
+        let filtered = list;
+        if (args.role) {
+            const role = args.role.trim().toLowerCase();
+            filtered = filtered.filter((m) => (m.role ?? "").toLowerCase() === role);
+        }
+        if (!args.include_expired) {
+            filtered = filtered.filter((m) => m.expires_at == null || m.expires_at > now);
+        }
+        const head = `**Team** — ${filtered.length} member(s)` +
+            (filtered.length !== list.length ? ` (of ${list.length} total keys)` : "") +
+            ".";
+        return {
+            content: [{ type: "text", text: `${head}\n\n${renderTable(filtered, now)}` }],
+        };
+    }
+    catch (err) {
+        return errorResult(err);
+    }
+}
+function renderTable(members, now) {
+    if (members.length === 0)
+        return "_No team members matched._";
+    const lines = ["| Email | Role | Manager | Created | Expires |", "|---|---|---|---|---|"];
+    for (const m of members) {
+        const expired = m.expires_at != null && m.expires_at <= now;
+        lines.push(`| ${mdCell(m.email ?? "(no email)")} | ${mdCell(m.role)} | ${mdCell(m.manager_email ?? "—")} | ${fmtDay(m.created_at)} | ${m.expires_at == null ? "—" : `${fmtDay(m.expires_at)}${expired ? " (expired)" : ""}`} |`);
+    }
+    return lines.join("\n");
+}
+function fmtDay(ms) {
+    return new Date(ms).toISOString().slice(0, 10);
+}
+//# sourceMappingURL=listTeam.js.map

package/dist/tools/listZones.js

@@ -0,0 +1,70 @@
+import { z } from "zod";
+import { mdCell } from "../lib/format.js";
+import { errorResult } from "../lib/toolResult.js";
+import { ZONE_STATUSES } from "../types.js";
+export const LIST_ZONES_DESCRIPTION = "List traffic-source zones in the current namespace. Filter by status and optionally " +
+    "by name (client-side contains match). Returns id, name, status, postback_url, " +
+    "site_url, publisher. Paginated (default 20, max 100).";
+export const listZonesInputSchema = {
+    status: z.enum(ZONE_STATUSES).optional().describe("Filter by zone status."),
+    name_contains: z
+        .string()
+        .min(1)
+        .optional()
+        .describe("Case-insensitive substring match on zone name (client-side)."),
+    limit: z.number().int().min(1).max(100).default(20).describe("Page size (1–100). Default 20."),
+    offset: z.number().int().min(0).default(0).describe("Pagination offset. Default 0."),
+    sort: z
+        .enum(["name", "created_at", "site_url"])
+        .default("created_at")
+        .describe("Sort field. Default created_at."),
+    order: z.enum(["asc", "desc"]).default("desc").describe("Sort order. Default desc."),
+};
+export async function listZones(client, args) {
+    try {
+        const data = await client.get("/api/zones", {
+            status: args.status,
+            limit: args.limit,
+            offset: args.offset,
+            sort: args.sort,
+            order: args.order,
+        });
+        let zones = data.zones ?? [];
+        const needle = args.name_contains?.trim().toLowerCase();
+        if (needle) {
+            zones = zones.filter((z) => z.name.toLowerCase().includes(needle));
+        }
+        const pagination = data.pagination;
+        const total = pagination?.total ?? zones.length;
+        const shown = zones.length;
+        const filterNote = needle
+            ? ` (name contains "${args.name_contains}" → ${shown} on this page)`
+            : "";
+        const head = `**Zones** — showing ${shown} of total ${total}${filterNote}` +
+            (pagination?.has_more ? `. More available (offset ${args.offset + args.limit}).` : ".");
+        return {
+            content: [{ type: "text", text: `${head}\n\n${renderTable(zones)}` }],
+        };
+    }
+    catch (err) {
+        return errorResult(err);
+    }
+}
+function renderTable(zones) {
+    if (zones.length === 0)
+        return "_No zones matched._";
+    const lines = [
+        "| ID | Name | Status | Postback | Site | Publisher |",
+        "|---|---|---|---|---|---|",
+    ];
+    for (const z of zones) {
+        lines.push(`| \`${z.id}\` | ${mdCell(z.name)} | ${z.status} | ${z.postback_url ? mdCell(shortUrl(z.postback_url)) : "⚠️ none"} | ${mdCell(shortUrl(z.site_url))} | ${mdCell(z.user_email ?? "—")} |`);
+    }
+    return lines.join("\n");
+}
+function shortUrl(url) {
+    if (!url)
+        return "—";
+    return url.length > 40 ? `${url.slice(0, 37)}…` : url;
+}
+//# sourceMappingURL=listZones.js.map

package/dist/tools/removeTargetingRule.js

@@ -0,0 +1,109 @@
+import { z } from "zod";
+import { AffsetApiError } from "../client.js";
+import { mdCell } from "../lib/format.js";
+import { fetchTargetingRules, fetchTargetingTypes, resolveTargetingType, syncTargetingRules, toSyncPayload, } from "../lib/targeting.js";
+import { errorResult, textError, textResult } from "../lib/toolResult.js";
+export const REMOVE_TARGETING_RULE_DESCRIPTION = "Remove one targeting rule from a campaign (safe merge — other rules are kept). " +
+    "Identify by rule_id, or by type + method. DRY-RUN by default; pass confirm=true to apply.";
+export const removeTargetingRuleInputSchema = {
+    campaign_id: z.union([z.string().min(1), z.number().int()]).describe("Campaign to edit."),
+    rule_id: z
+        .number()
+        .int()
+        .positive()
+        .optional()
+        .describe("Existing rule id (from list_targeting_rules). Prefer this when known."),
+    type: z
+        .union([z.string().min(1), z.number().int()])
+        .optional()
+        .describe("Targeting type id or name. Required with method when rule_id is omitted."),
+    method: z
+        .enum(["whitelist", "blacklist"])
+        .optional()
+        .describe("whitelist or blacklist. Required with type when rule_id is omitted."),
+    confirm: z.boolean().default(false).describe("false = dry-run preview (default). true = apply."),
+};
+export async function removeTargetingRule(client, args) {
+    try {
+        const campaignId = String(args.campaign_id).trim();
+        if (!campaignId)
+            return textError("campaign_id is required.");
+        if (args.rule_id == null && (args.type == null || args.method == null)) {
+            return textError("Provide rule_id, or both type and method, to identify the rule to remove.");
+        }
+        const [types, current] = await Promise.all([
+            fetchTargetingTypes(client),
+            fetchTargetingRules(client, campaignId),
+        ]);
+        const target = findTarget(types, current, args);
+        if ("error" in target)
+            return textError(target.error);
+        const rule = target.rule;
+        const typeName = types.find((t) => t.id === rule.targeting_rule_type_id)?.name ??
+            String(rule.targeting_rule_type_id);
+        if (!args.confirm) {
+            return textResult([
+                `**Dry run** — would remove targeting rule on campaign \`${campaignId}\`.`,
+                "",
+                "| Field | Value |",
+                "|---|---|",
+                `| Id | \`${rule.id ?? "—"}\` |`,
+                `| Type | ${mdCell(typeName)} (${rule.targeting_rule_type_id}) |`,
+                `| Method | ${mdCell(rule.targeting_method)} |`,
+                `| Rule | ${mdCell(rule.rule)} |`,
+                "",
+                removalNote(current, rule, typeName),
+                "",
+                "Other rules stay untouched. Call again with `confirm: true` to apply.",
+            ].join("\n"));
+        }
+        // Identity, not id: a rule row the API returned without an id must not take
+        // every other id-less row with it.
+        await syncTargetingRules(client, campaignId, toSyncPayload(current.filter((r) => r !== rule)));
+        return textResult(`✅ Removed ${mdCell(typeName)} ${rule.targeting_method} rule ` +
+            `\`${mdCell(rule.rule)}\` (id \`${rule.id ?? "—"}\`) from campaign \`${campaignId}\`.`);
+    }
+    catch (err) {
+        if (err instanceof AffsetApiError && err.status === 404) {
+            return textError(`Campaign \`${String(args.campaign_id).trim()}\` not found in this namespace.`);
+        }
+        return errorResult(err);
+    }
+}
+/** What the campaign is left targeting once this rule is gone. */
+function removalNote(rules, rule, typeName) {
+    const remaining = rules.filter((r) => r !== rule && r.targeting_rule_type_id === rule.targeting_rule_type_id);
+    if (remaining.length > 0) {
+        return `${typeName} stays gated by ${remaining.length} other rule(s) of the same type.`;
+    }
+    return rules.length === 1
+        ? "⚠️ This is the campaign's last rule — it becomes unrestricted on `/serve`."
+        : `${typeName} becomes unrestricted; other rule types still apply.`;
+}
+function findTarget(types, rules, args) {
+    if (args.rule_id != null) {
+        const match = rules.find((r) => r.id === args.rule_id);
+        if (!match) {
+            return { error: `No targeting rule with id \`${args.rule_id}\` on this campaign.` };
+        }
+        return { rule: match };
+    }
+    const resolved = resolveTargetingType(types, args.type);
+    if ("error" in resolved)
+        return resolved;
+    const matches = rules.filter((r) => r.targeting_rule_type_id === resolved.type.id && r.targeting_method === args.method);
+    if (matches.length === 0) {
+        return {
+            error: `No ${args.method} rule of type ${resolved.type.name} on this campaign.`,
+        };
+    }
+    if (matches.length > 1) {
+        const ids = matches.map((r) => `\`${r.id}\``).join(", ");
+        return {
+            error: `${matches.length} ${resolved.type.name} ${args.method} rules on this campaign ` +
+                `(${ids}) — pass rule_id to say which one to remove.`,
+        };
+    }
+    return { rule: matches[0] };
+}
+//# sourceMappingURL=removeTargetingRule.js.map

package/dist/tools/setCampaignStatus.js

@@ -0,0 +1,32 @@
+import { z } from "zod";
+import { updateCampaign } from "./updateCampaign.js";
+/** Media-buyer verbs → API status. */
+export const CAMPAIGN_ACTIONS = ["run", "pause"];
+const ACTION_TO_STATUS = {
+    run: "active",
+    pause: "paused",
+};
+export const SET_CAMPAIGN_STATUS_DESCRIPTION = "Run (activate) or pause a campaign. 'run' enters /serve zone rotation and counts " +
+    "against the plan's active-campaign limit (402 if exceeded). 'pause' removes the " +
+    "campaign from active serving, so both /serve selection and direct tracking links stop. DRY-RUN by " +
+    "default; pass confirm=true to apply. For name/offer/budget edits use update_campaign.";
+export const setCampaignStatusInputSchema = {
+    campaign_id: z
+        .union([z.string().min(1), z.number().int()])
+        .describe("Campaign id to run or pause."),
+    action: z
+        .enum(CAMPAIGN_ACTIONS)
+        .describe("run = active serving. pause = both /serve and direct tracking links stop."),
+    confirm: z
+        .boolean()
+        .default(false)
+        .describe("false = dry-run preview (default). true = apply the status change."),
+};
+export async function setCampaignStatus(client, args) {
+    return updateCampaign(client, {
+        campaign_id: args.campaign_id,
+        status: ACTION_TO_STATUS[args.action],
+        confirm: args.confirm,
+    });
+}
+//# sourceMappingURL=setCampaignStatus.js.map

package/dist/tools/setPayoutGoal.js

@@ -0,0 +1,69 @@
+import { z } from "zod";
+import { AffsetApiError } from "../client.js";
+import { mdCell } from "../lib/format.js";
+import { displayValue, renderDiff } from "../lib/patch.js";
+import { errorResult, textError, textResult } from "../lib/toolResult.js";
+export const SET_PAYOUT_GOAL_DESCRIPTION = "Set or clear a campaign's payout_goal_type (goal-based conversions). When set, " +
+    "spend and payout apply only when the conversion pixel's `type=` exactly matches; " +
+    "other types are still recorded with $0. Pass null (or empty string) to clear. " +
+    "DRY-RUN by default; pass confirm=true to apply.";
+export const setPayoutGoalInputSchema = {
+    campaign_id: z
+        .union([z.string().min(1), z.number().int()])
+        .describe("Campaign to set the payout goal type on."),
+    goal_type: z
+        .union([z.string(), z.null()])
+        .describe('Goal type string (e.g. "deposit", "lead", "purchase"), or null/"" to clear.'),
+    confirm: z.boolean().default(false).describe("false = dry-run preview (default). true = apply."),
+};
+export async function setPayoutGoal(client, args) {
+    try {
+        const campaignId = String(args.campaign_id).trim();
+        if (!campaignId)
+            return textError("campaign_id is required.");
+        const next = args.goal_type == null ? null : args.goal_type.trim() || null;
+        let existing;
+        try {
+            existing = await client.get(`/api/campaigns/${encodeURIComponent(campaignId)}`);
+        }
+        catch (err) {
+            if (err instanceof AffsetApiError && err.status === 404) {
+                return textError(`Campaign \`${campaignId}\` not found in this namespace.`);
+            }
+            throw err;
+        }
+        const from = existing.payout_goal_type?.trim() || null;
+        if (from === next) {
+            return textResult(`Nothing to change on campaign \`${existing.id}\` (${mdCell(existing.name)}) — ` +
+                `payout_goal_type is already ${displayValue(from)}.`);
+        }
+        const diff = renderDiff([
+            {
+                field: "payout_goal_type",
+                from: displayValue(from),
+                to: displayValue(next),
+            },
+        ]);
+        if (!args.confirm) {
+            return textResult([
+                `**Dry run** — would update payout_goal_type on campaign \`${existing.id}\` (${mdCell(existing.name)}).`,
+                "",
+                diff,
+                "",
+                next
+                    ? `⚠️ Only conversions with pixel \`type=${next}\` will get spend/payout; others stay $0.`
+                    : "Clearing the goal type means every conversion type gets the resolved payout.",
+                "",
+                "Call again with `confirm: true` to apply.",
+            ].join("\n"));
+        }
+        await client.put(`/api/campaigns/${encodeURIComponent(campaignId)}`, {
+            payout_goal_type: next,
+        });
+        return textResult([`✅ Campaign \`${existing.id}\` payout_goal_type updated.`, "", diff].join("\n"));
+    }
+    catch (err) {
+        return errorResult(err);
+    }
+}
+//# sourceMappingURL=setPayoutGoal.js.map

package/dist/tools/setPayoutRule.js

@@ -0,0 +1,119 @@
+import { z } from "zod";
+import { AffsetApiError } from "../client.js";
+import { moneyPrecise } from "../lib/format.js";
+import { displayValue, renderDiff } from "../lib/patch.js";
+import { createPayoutRule, fetchPayoutRules, findPayoutRule, replacePayout, } from "../lib/payoutRules.js";
+import { errorResult, textError, textResult } from "../lib/toolResult.js";
+/** Matches lite-adserver PAYOUT_MIN / PAYOUT_MAX. */
+const PAYOUT_MIN = 0.00001;
+const PAYOUT_MAX = 9999.99999;
+export const SET_PAYOUT_RULE_DESCRIPTION = "Set a campaign payout rule (global or per-zone). Upserts: if a rule already " +
+    "exists for that scope it is replaced (delete + create, with the old payout " +
+    "restored if the create fails). Omit zone_id for the global rule; pass a zone " +
+    "UUID for a zone override. DRY-RUN by default; pass confirm=true to apply.";
+export const setPayoutRuleInputSchema = {
+    campaign_id: z
+        .union([z.string().min(1), z.number().int()])
+        .describe("Campaign to set the payout rule on."),
+    payout: z
+        .number()
+        .min(PAYOUT_MIN)
+        .max(PAYOUT_MAX)
+        .describe(`Payout per conversion in USD (${PAYOUT_MIN}–${PAYOUT_MAX}).`),
+    zone_id: z
+        .string()
+        .trim()
+        .min(1)
+        .optional()
+        .describe("Zone UUID for a zone-specific override. Omit for the global rule."),
+    confirm: z.boolean().default(false).describe("false = dry-run preview (default). true = apply."),
+};
+export async function setPayoutRule(client, args) {
+    try {
+        const campaignId = String(args.campaign_id).trim();
+        if (!campaignId)
+            return textError("campaign_id is required.");
+        const zoneId = args.zone_id?.trim() || null;
+        const scope = zoneId == null ? "global" : `zone \`${zoneId}\``;
+        // The API stores payouts at 5 decimals; preview what will actually be stored.
+        const payout = Math.round(args.payout * 100000) / 100000;
+        const existing = findPayoutRule(await fetchPayoutRules(client, campaignId), zoneId);
+        const changes = buildChanges(existing, payout);
+        if (existing && changes.length === 0) {
+            return textResult(`Nothing to change — ${scope} payout on campaign \`${campaignId}\` ` +
+                `is already ${moneyPrecise(payout)}.`);
+        }
+        if (!args.confirm) {
+            const head = existing
+                ? `**Dry run** — would replace ${scope} payout on campaign \`${campaignId}\`.`
+                : `**Dry run** — would create ${scope} payout on campaign \`${campaignId}\`.`;
+            return textResult([
+                head,
+                "",
+                renderDiff(changes),
+                ...(payout !== args.payout
+                    ? ["", `_Rounded ${args.payout} → ${payout} (the API stores 5 decimals)._`]
+                    : []),
+                "",
+                "Call again with `confirm: true` to apply.",
+            ].join("\n"));
+        }
+        if (!existing) {
+            const created = await createPayoutRule(client, campaignId, zoneId, payout);
+            return textResult([
+                `✅ Created ${scope} payout on campaign \`${campaignId}\` (rule id \`${created.id}\`).`,
+                "",
+                renderDiff(changes),
+            ].join("\n"));
+        }
+        const result = await replacePayout(client, campaignId, zoneId, existing, payout);
+        if ("lost" in result) {
+            return textError([
+                `❌ Campaign \`${campaignId}\` now has **no ${scope} payout rule** — every ` +
+                    "conversion on that scope resolves to $0 until one is set.",
+                "",
+                `The old rule (${moneyPrecise(result.lost.payout)}) was deleted, the new payout ` +
+                    "failed to save, and restoring the old one failed too.",
+                "",
+                `- new payout: ${describeCause(result.cause)}`,
+                `- restore: ${describeCause(result.rollbackCause)}`,
+                "",
+                "Re-run this tool with `confirm: true` to set the payout again.",
+            ].join("\n"));
+        }
+        if ("rolledBack" in result) {
+            return textError([
+                `❌ Could not set ${scope} payout on campaign \`${campaignId}\`: ` +
+                    describeCause(result.cause),
+                "",
+                `The previous payout (${moneyPrecise(result.rolledBack.payout)}) was restored — ` +
+                    "nothing is serving at $0.",
+            ].join("\n"));
+        }
+        return textResult([
+            `✅ Replaced ${scope} payout on campaign \`${campaignId}\` (rule id \`${result.rule.id}\`).`,
+            "",
+            renderDiff(changes),
+        ].join("\n"));
+    }
+    catch (err) {
+        if (err instanceof AffsetApiError && err.status === 404) {
+            return textError(`Campaign \`${String(args.campaign_id).trim()}\` not found (or zone does not exist).`);
+        }
+        return errorResult(err);
+    }
+}
+function describeCause(err) {
+    if (err instanceof AffsetApiError)
+        return `affset API error (${err.status}): ${err.message}`;
+    return err instanceof Error ? err.message : String(err);
+}
+function buildChanges(existing, payout) {
+    if (!existing) {
+        return [{ field: "payout", from: displayValue(null), to: moneyPrecise(payout) }];
+    }
+    if (existing.payout === payout)
+        return [];
+    return [{ field: "payout", from: moneyPrecise(existing.payout), to: moneyPrecise(payout) }];
+}
+//# sourceMappingURL=setPayoutRule.js.map