@affset/mcp 0.1.0

package/dist/tools/createCampaign.js

@@ -0,0 +1,211 @@
+import { z } from "zod";
+import { AffsetApiError } from "../client.js";
+import { mdCell, moneyPrecise } from "../lib/format.js";
+import { buildTrackingLink, fetchTenantIntegration } from "../lib/integrationUrls.js";
+import { errorResult, textError, textResult } from "../lib/toolResult.js";
+import { httpUrlError } from "../lib/urls.js";
+import { resolveZone, zonePostbackNote } from "../lib/zones.js";
+/** Geo targeting-rule-type id (matches the core migration seed). */
+const GEO_RULE_TYPE_ID = 1;
+/** Matches lite-adserver PAYOUT_MIN / PAYOUT_MAX. */
+const PAYOUT_MIN = 0.00001;
+const PAYOUT_MAX = 9999.99999;
+const NAME_MAX = 120;
+export const CREATE_CAMPAIGN_DESCRIPTION = "Create a campaign (offer) in the current namespace from a compact spec: advertiser " +
+    "email, offer URL, geo whitelist, payout, name. The advertiser (user_email) is required " +
+    "— it must already exist as a team member (same as the Advertiser dropdown in the dashboard). " +
+    "Everything else gets media-buying defaults: CPA model, " +
+    "rate 0 (no internal advertiser billing), created paused, a global payout rule when " +
+    "payout is given, and a ready-to-use tracking link prefilled with the sub convention " +
+    "(source_click_id + sub1..sub5, named by the tenant's sub labels). The campaign is " +
+    "created paused, so activate it before sending traffic through either URL. " +
+    "Geo whitelist applies to /serve rotation only; the tracking link itself is not geo-gated. " +
+    "DRY-RUN by default; pass confirm=true to apply. No money is spent by this call; the " +
+    "result echoes exactly what was created.";
+export const createCampaignInputSchema = {
+    user_email: z
+        .string()
+        .trim()
+        .email()
+        .describe("Advertiser email that owns this campaign (required — the API rejects the call without it). " +
+        "Must already exist as a team member with the advertiser role; same as the dashboard's " +
+        "Advertiser dropdown. List candidates with list_team."),
+    offer_url: z
+        .string()
+        .min(1)
+        .describe("Offer / lander URL the click redirects to. May carry {click_id} (affset's click id, " +
+        "for S2S postback back into affset) and {sub1}..{sub5} macros."),
+    name: z
+        .string()
+        .min(1)
+        .max(NAME_MAX)
+        .optional()
+        .describe("Campaign name / funnel tag. Default: derived from offer host, geo and payout."),
+    geo: z
+        .array(z.string().length(2))
+        .nonempty()
+        .optional()
+        .describe('Geo whitelist as ISO 3166-1 alpha-2 codes, e.g. ["BR"] or ["BR","MX"]. Omit for worldwide. ' +
+        "Applies to /serve rotation only — the tracking link is not geo-gated."),
+    payout: z
+        .number()
+        .min(PAYOUT_MIN)
+        .max(PAYOUT_MAX)
+        .optional()
+        .describe(`Offer payout per conversion in USD (${PAYOUT_MIN}–${PAYOUT_MAX}; creates the campaign's global payout rule).`),
+    zone_id: z
+        .string()
+        .trim()
+        .min(1)
+        .optional()
+        .describe("Traffic-source zone for the tracking link. Optional when the namespace has exactly " +
+        "one active zone — it is picked automatically; otherwise the tool lists zones to choose from."),
+    confirm: z
+        .boolean()
+        .default(false)
+        .describe("false = dry-run preview (default). true = create the campaign."),
+};
+export async function createCampaign(client, config, args) {
+    try {
+        // 1. Validate the compact spec locally (clear errors beat API 400s).
+        const urlErr = httpUrlError(args.offer_url, "offer_url");
+        if (urlErr)
+            return textError(urlErr);
+        const offerUrl = new URL(args.offer_url);
+        const geo = normalizeGeo(args.geo);
+        if ("error" in geo)
+            return textError(geo.error);
+        const geoCodes = geo.codes;
+        // 2. Resolve zone + tenant integration settings (link base, sub labels) in parallel.
+        //    Safe for dry-run — both are reads.
+        const [zoneResult, integration] = await Promise.all([
+            resolveZone(client, args.zone_id),
+            fetchTenantIntegration(client, config),
+        ]);
+        if ("error" in zoneResult) {
+            return textError(zoneResult.error);
+        }
+        const { zone, inactiveWarning } = zoneResult;
+        const name = args.name?.trim() || defaultName(offerUrl, geoCodes, args.payout);
+        const geoNote = geoCodes.length
+            ? `${geoCodes.join(", ")} (whitelist; enforced on /serve, not on the tracking link)`
+            : "worldwide (no geo rule)";
+        const payoutPreview = args.payout !== undefined
+            ? `${moneyPrecise(args.payout)} per conversion (global rule)`
+            : "_none set — add one to track revenue and use {payout} in postbacks_";
+        const summaryTable = [
+            "| Field | Value |",
+            "|---|---|",
+            `| Name | ${mdCell(name)} |`,
+            `| Advertiser | ${mdCell(args.user_email)} |`,
+            `| Offer URL | ${mdCell(args.offer_url)} |`,
+            `| Geo | ${geoNote} |`,
+            `| Payout | ${payoutPreview} |`,
+            `| Model | CPA, rate 0 (defaults — no internal advertiser billing) |`,
+            `| Status | paused (activate before sending traffic through either URL) |`,
+            `| Zone | ${mdCell(zone.name)} (\`${zone.id}\`) — ${zonePostbackNote(zone)} |`,
+        ].join("\n");
+        if (!args.confirm) {
+            return textResult([
+                "**Dry run** — would create a campaign with:",
+                "",
+                summaryTable,
+                ...(inactiveWarning ? ["", inactiveWarning] : []),
+                "",
+                "Call again with `confirm: true` to create it. The tracking link is returned after create.",
+            ].join("\n"));
+        }
+        // 3. Create the campaign with media-buying defaults. rate stays 0 so internal
+        //    advertiser billing/budget enforcement is untouched; revenue comes from the
+        //    payout rule. The API forces status=paused on create.
+        const created = await client.post("/api/campaigns", {
+            name,
+            user_email: args.user_email.trim(),
+            redirect_url: args.offer_url,
+            payment_model: "cpa",
+            rate: 0,
+            start_date: Date.now(),
+            targeting_rules: geoCodes.length
+                ? [
+                    {
+                        targeting_rule_type_id: GEO_RULE_TYPE_ID,
+                        targeting_method: "whitelist",
+                        rule: geoCodes.join(","),
+                    },
+                ]
+                : [],
+        });
+        // 4. Global payout rule (zone_id null). Failure here must not hide the created
+        //    campaign — report it as a warning instead of failing the whole call.
+        let payoutNote = "_none set — add one to track revenue and use {payout} in postbacks_";
+        if (args.payout !== undefined) {
+            try {
+                await client.post(`/api/campaigns/${created.id}/payout_rules`, { payout: args.payout });
+                payoutNote = `${moneyPrecise(args.payout)} per conversion (global rule)`;
+            }
+            catch (err) {
+                const message = err instanceof AffsetApiError ? err.message : String(err);
+                payoutNote = `⚠️ campaign created, but setting the payout rule failed: ${message}`;
+            }
+        }
+        // 5. Ready-to-paste tracking link with the sub convention prefilled.
+        const trackingLink = buildTrackingLink(integration.baseUrl, created.id, zone.id, {
+            subLabels: integration.subLabels,
+        });
+        return textResult([
+            `✅ Campaign **${mdCell(created.name)}** created (id \`${created.id}\`).`,
+            "",
+            "| Field | Value |",
+            "|---|---|",
+            `| Advertiser | ${mdCell(args.user_email)} |`,
+            `| Offer URL | ${mdCell(args.offer_url)} |`,
+            `| Geo | ${geoNote} |`,
+            `| Payout | ${payoutNote} |`,
+            `| Model | CPA, rate 0 (defaults — no internal advertiser billing) |`,
+            `| Status | ${created.status || "paused"} (activate before sending traffic through either URL) |`,
+            `| Zone | ${mdCell(zone.name)} (\`${zone.id}\`) — ${zonePostbackNote(zone)} |`,
+            ...(inactiveWarning ? ["", inactiveWarning] : []),
+            "",
+            "**Tracking link** (give this to the traffic source):",
+            "```",
+            trackingLink,
+            "```",
+            "Replace each `{…}` placeholder with the source's macro; `{clickid}` is already " +
+                "correct for RichAds. Drop sub slots you don't need. Append `&cost={cost}` " +
+                "(the network's cost macro) to import media cost for ROI. This link returns " +
+                "404 while the campaign is paused; run it with `set_campaign_status` before use.",
+            "",
+            "_Only defaults were set — use `set_targeting_rule`, `set_payout_rule`, and budget fields on `update_campaign` for the rest._",
+            "_Need this link again later, or the rotating /serve URL instead? `get_tracking_link` / `get_zone_url`._",
+        ].join("\n"));
+    }
+    catch (err) {
+        return errorResult(err);
+    }
+}
+function normalizeGeo(raw) {
+    const codes = [];
+    const seen = new Set();
+    for (const entry of raw ?? []) {
+        const code = entry.trim().toUpperCase();
+        if (!/^[A-Z]{2}$/.test(code)) {
+            return { error: `geo entries must be 2-letter ISO country codes, got "${entry}".` };
+        }
+        if (!seen.has(code)) {
+            seen.add(code);
+            codes.push(code);
+        }
+    }
+    return { codes };
+}
+/** "offer.com BR $2" — a name the buyer can recognise in a list without opening it. */
+function defaultName(offerUrl, geo, payout) {
+    const parts = [offerUrl.hostname.replace(/^www\./, "")];
+    if (geo.length)
+        parts.push(geo.join("+"));
+    if (payout !== undefined)
+        parts.push(moneyPrecise(payout).replace(/\.?0+$/, ""));
+    const name = parts.join(" ");
+    return name.length <= NAME_MAX ? name : `${name.slice(0, NAME_MAX - 1)}…`;
+}
+//# sourceMappingURL=createCampaign.js.map

package/dist/tools/createZone.js

@@ -0,0 +1,117 @@
+import { z } from "zod";
+import { mdCell } from "../lib/format.js";
+import { errorResult, textError, textResult } from "../lib/toolResult.js";
+import { httpUrlError } from "../lib/urls.js";
+export const CREATE_ZONE_DESCRIPTION = "Create a traffic-source zone in the current namespace. Requires a name; optional " +
+    "postback_url (where conversions are reported back — include {source_click_id}), " +
+    "site_url, traffic_back_url, and user_email (publisher owner). Status is always " +
+    "active on create. Counts against the plan's zone limit (402 if exceeded). " +
+    "DRY-RUN by default; pass confirm=true to apply.";
+export const createZoneInputSchema = {
+    name: z.string().min(1).max(200).describe("Zone display name (traffic source / placement)."),
+    postback_url: z
+        .string()
+        .min(1)
+        .optional()
+        .describe("S2S postback URL for the traffic source. Should include {source_click_id} so " +
+        "conversions can be attributed back to the source click."),
+    site_url: z.string().min(1).optional().describe("Optional site / inventory URL."),
+    traffic_back_url: z
+        .string()
+        .min(1)
+        .optional()
+        .describe("Optional traffic-back / fallback URL when no campaign can serve."),
+    user_email: z
+        .string()
+        .email()
+        .optional()
+        .describe("Optional publisher email to own this zone (owner/manager only)."),
+    confirm: z
+        .boolean()
+        .default(false)
+        .describe("false = dry-run preview (default). true = create the zone."),
+};
+export async function createZone(client, args) {
+    try {
+        const name = args.name.trim();
+        if (!name)
+            return textError("name is required.");
+        for (const [label, value] of [
+            ["postback_url", args.postback_url],
+            ["site_url", args.site_url],
+            ["traffic_back_url", args.traffic_back_url],
+        ]) {
+            if (value !== undefined) {
+                const err = httpUrlError(value, label);
+                if (err)
+                    return textError(err);
+            }
+        }
+        const postback = args.postback_url;
+        const postbackNote = !postback
+            ? "⚠️ none — set postback_url (with {source_click_id}) or the source will not see conversions"
+            : !postback.includes("{source_click_id}")
+                ? `${mdCell(postback)} — ⚠️ missing \`{source_click_id}\``
+                : mdCell(postback);
+        const summaryTable = [
+            "| Field | Value |",
+            "|---|---|",
+            `| Name | ${mdCell(name)} |`,
+            `| Status | active (forced on create) |`,
+            `| Postback | ${postbackNote} |`,
+            `| Site | ${mdCell(args.site_url ?? "—")} |`,
+            `| Traffic back | ${mdCell(args.traffic_back_url ?? "—")} |`,
+            `| Publisher | ${mdCell(args.user_email ?? "—")} |`,
+        ].join("\n");
+        if (!args.confirm) {
+            return textResult([
+                "**Dry run** — would create a zone with:",
+                "",
+                summaryTable,
+                "",
+                "Call again with `confirm: true` to create it. Counts against the plan's zone limit.",
+            ].join("\n"));
+        }
+        const body = { name };
+        if (args.postback_url !== undefined)
+            body.postback_url = args.postback_url;
+        if (args.site_url !== undefined)
+            body.site_url = args.site_url;
+        if (args.traffic_back_url !== undefined)
+            body.traffic_back_url = args.traffic_back_url;
+        if (args.user_email !== undefined)
+            body.user_email = args.user_email;
+        const created = await client.post("/api/zones", body);
+        // Create response is sparse — fetch full row for the echo.
+        let zone = null;
+        try {
+            zone = await client.get(`/api/zones/${encodeURIComponent(created.id)}`);
+        }
+        catch {
+            // Non-fatal; fall back to the create payload.
+        }
+        const createdPostback = zone?.postback_url ?? args.postback_url;
+        const createdPostbackNote = !createdPostback
+            ? "⚠️ none — set postback_url (with {source_click_id}) or the source will not see conversions"
+            : !createdPostback.includes("{source_click_id}")
+                ? `${mdCell(createdPostback)} — ⚠️ missing \`{source_click_id}\``
+                : mdCell(createdPostback);
+        return textResult([
+            `✅ Zone **${mdCell(zone?.name ?? name)}** created (id \`${created.id}\`).`,
+            "",
+            "| Field | Value |",
+            "|---|---|",
+            `| Status | ${zone?.status ?? created.status} (forced active on create) |`,
+            `| Postback | ${createdPostbackNote} |`,
+            `| Site | ${mdCell(zone?.site_url ?? args.site_url ?? "—")} |`,
+            `| Traffic back | ${mdCell(zone?.traffic_back_url ?? args.traffic_back_url ?? "—")} |`,
+            `| Publisher | ${mdCell(zone?.user_email ?? args.user_email ?? "—")} |`,
+            "",
+            "Use this zone id with `create_campaign` (or pass it as zone_id) for tracking links.",
+        ].join("\n"));
+    }
+    catch (err) {
+        return errorResult(err);
+    }
+}
+//# sourceMappingURL=createZone.js.map

package/dist/tools/cutZones.js

@@ -0,0 +1,224 @@
+import { z } from "zod";
+import { resolveRange, RANGE_PRESETS } from "../lib/time.js";
+import { conversionRate, money, mdCell, pct, roi as fmtRoi } from "../lib/format.js";
+import { errorResult, textError, textResult } from "../lib/toolResult.js";
+/** Fallback zone targeting-rule-type id (matches the core migration seed). */
+const ZONE_RULE_TYPE_FALLBACK = 4;
+export const CUT_ZONES_DESCRIPTION = "Blacklist underperforming zones on a campaign based on thresholds (CR, spend, ROI). " +
+    "Evaluates zone stats over the given window and adds matching zones to the campaign's " +
+    "zone blacklist. DRY-RUN by default: it shows which zones would be cut and how the " +
+    "blacklist changes. Pass confirm=true to actually apply. `spend` means media_cost " +
+    "(your traffic cost). A zone is cut only if it matches ALL provided thresholds.";
+export const cutZonesInputSchema = {
+    campaign_id: z
+        .union([z.string().min(1), z.number().int()])
+        .describe("Campaign whose zone blacklist to edit."),
+    cr_max: z
+        .number()
+        .min(0)
+        .max(1)
+        .optional()
+        .describe("Cut zones with conversion rate BELOW this fraction (e.g. 0.002 = 0.2%)."),
+    spend_min: z
+        .number()
+        .min(0)
+        .optional()
+        .describe("Cut zones with media_cost ABOVE this many dollars (e.g. 5 = $5)."),
+    roi_max: z
+        .number()
+        .optional()
+        .describe("Cut zones with ROI BELOW this fraction (e.g. -0.3 = -30%). Needs cost data."),
+    min_clicks: z
+        .number()
+        .int()
+        .min(0)
+        .default(10)
+        .describe("Ignore zones with fewer clicks than this (significance guard). Default 10."),
+    range: z
+        .enum(RANGE_PRESETS)
+        .optional()
+        .describe("Evaluation window. Ignored if from/to are given. Defaults to last 7 days."),
+    from: z
+        .string()
+        .optional()
+        .describe("Explicit start bound: YYYY-MM-DD (tenant-local start of day), ISO timestamp with Z/UTC offset, or epoch ms."),
+    to: z
+        .string()
+        .optional()
+        .describe("Explicit end bound: YYYY-MM-DD (tenant-local end of day), ISO timestamp with Z/UTC offset, or epoch ms."),
+    confirm: z
+        .boolean()
+        .default(false)
+        .describe("false = dry-run preview (default). true = apply the blacklist changes."),
+};
+export async function cutZones(client, args) {
+    try {
+        const campaignId = String(args.campaign_id).trim();
+        if (!campaignId)
+            return textError("campaign_id is required.");
+        if (args.cr_max === undefined && args.spend_min === undefined && args.roi_max === undefined) {
+            return textError("Provide at least one threshold: cr_max, spend_min, or roi_max.");
+        }
+        const timeZone = await client.getTenantTimezone();
+        const { from, to, label } = resolveRange(args.range ?? "last_7_days", args.from, args.to, timeZone);
+        // 1. Zone-level stats for this campaign over the window.
+        const stats = await client.get("/api/stats", {
+            from,
+            to,
+            group_by: "zone_id",
+            campaign_ids: campaignId,
+        });
+        const rows = (stats.stats ?? []).filter((r) => (r.zone_id ?? "").trim() !== "");
+        // 2. Select candidates: enough clicks AND matches every provided threshold.
+        const candidates = rows.filter((r) => matchesThresholds(r, args));
+        // 3. Current targeting rules + the zone rule type id.
+        const [zoneTypeId, currentRules] = await Promise.all([
+            resolveZoneRuleTypeId(client),
+            fetchRules(client, campaignId),
+        ]);
+        const alreadyBlacklisted = collectBlacklistedZones(currentRules, zoneTypeId);
+        const zonesToAdd = candidates
+            .map((r) => r.zone_id)
+            .filter((z) => !alreadyBlacklisted.has(z));
+        const criteria = describeCriteria(args);
+        const preview = renderCandidates(candidates, alreadyBlacklisted);
+        const beforeCount = alreadyBlacklisted.size;
+        const afterCount = beforeCount + zonesToAdd.length;
+        const costNote = costDataNote(args, rows);
+        // 4a. Dry-run (default).
+        if (!args.confirm) {
+            const head = zonesToAdd.length > 0
+                ? `**Dry run** — ${zonesToAdd.length} zone(s) would be blacklisted on campaign \`${campaignId}\`.`
+                : `**Dry run** — no new zones to blacklist on campaign \`${campaignId}\`.`;
+            return textResult(`${head}\n_Window: ${label}. Criteria: ${criteria}._\n\n${preview}\n\n` +
+                `Zone blacklist: ${beforeCount} → ${afterCount}.` +
+                (zonesToAdd.length > 0 ? "\n\nCall again with `confirm: true` to apply." : "") +
+                costNote);
+        }
+        // 4b. Apply — re-fetch rules immediately before write to shrink the TOCTOU window
+        // (POST sync deletes any rule whose id is omitted).
+        if (zonesToAdd.length === 0) {
+            return textResult(`Nothing to apply — no new zones matched on campaign \`${campaignId}\`.\n_Criteria: ${criteria}._${costNote}`);
+        }
+        const freshRules = await fetchRules(client, campaignId);
+        const freshBlacklisted = collectBlacklistedZones(freshRules, zoneTypeId);
+        const freshToAdd = zonesToAdd.filter((z) => !freshBlacklisted.has(z));
+        if (freshToAdd.length === 0) {
+            return textResult(`Nothing to apply — matching zones are already blacklisted on campaign \`${campaignId}\`.`);
+        }
+        const nextRules = mergeBlacklist(freshRules, zoneTypeId, freshToAdd);
+        await client.post(`/api/campaigns/${encodeURIComponent(campaignId)}/targeting_rules`, nextRules);
+        const appliedBefore = freshBlacklisted.size;
+        const appliedAfter = appliedBefore + freshToAdd.length;
+        return textResult(`✅ Applied. Added ${freshToAdd.length} zone(s) to campaign \`${campaignId}\` blacklist ` +
+            `(${appliedBefore} → ${appliedAfter}).\n_Criteria: ${criteria}. Window: ${label}._\n\n${preview}`);
+    }
+    catch (err) {
+        return errorResult(err);
+    }
+}
+function matchesThresholds(r, args) {
+    if (r.clicks < args.min_clicks)
+        return false;
+    if (args.cr_max !== undefined && !(conversionRate(r) < args.cr_max))
+        return false;
+    if (args.spend_min !== undefined && !((r.media_cost ?? 0) > args.spend_min))
+        return false;
+    if (args.roi_max !== undefined &&
+        !(r.roi !== null && r.roi !== undefined && r.roi < args.roi_max)) {
+        return false;
+    }
+    return true;
+}
+function costDataNote(args, rows) {
+    const usedCostThreshold = args.spend_min !== undefined || args.roi_max !== undefined;
+    const hasAnyCost = rows.some((r) => (r.media_cost ?? 0) > 0);
+    if (usedCostThreshold && !hasAnyCost) {
+        return "\n\n⚠️ A cost/ROI threshold was set but no media_cost is present for these zones — nothing can match it yet.";
+    }
+    return "";
+}
+async function fetchRules(client, campaignId) {
+    const res = await client.get(`/api/campaigns/${encodeURIComponent(campaignId)}/targeting_rules`);
+    return res.targeting_rules ?? [];
+}
+/** Look up the zone_id targeting-rule-type id, falling back to the seed value. */
+async function resolveZoneRuleTypeId(client) {
+    try {
+        const res = await client.get("/api/targeting-rule-types");
+        const match = (res.targeting_rule_types ?? []).find((t) => t.name === "zone_id");
+        return match?.id ?? ZONE_RULE_TYPE_FALLBACK;
+    }
+    catch {
+        return ZONE_RULE_TYPE_FALLBACK;
+    }
+}
+function parseZoneList(rule) {
+    return rule
+        .split(",")
+        .map((z) => z.trim())
+        .filter((z) => z.length > 0);
+}
+/** Union of all zones across the campaign's zone-type blacklist rules. */
+function collectBlacklistedZones(rules, zoneTypeId) {
+    const zones = new Set();
+    for (const rule of rules) {
+        if (rule.targeting_rule_type_id === zoneTypeId && rule.targeting_method === "blacklist") {
+            for (const z of parseZoneList(rule.rule))
+                zones.add(z);
+        }
+    }
+    return zones;
+}
+/**
+ * Build the full rule array to POST. All existing rules are echoed back with
+ * their ids (the API deletes any it doesn't receive), and the new zones are
+ * merged into the first zone-type blacklist rule — or a new one is appended.
+ */
+function mergeBlacklist(rules, zoneTypeId, zonesToAdd) {
+    const next = rules.map((r) => ({
+        id: r.id,
+        targeting_rule_type_id: r.targeting_rule_type_id,
+        targeting_method: r.targeting_method,
+        rule: r.rule,
+    }));
+    const target = next.find((r) => r.targeting_rule_type_id === zoneTypeId && r.targeting_method === "blacklist");
+    if (target) {
+        const merged = new Set([...parseZoneList(target.rule), ...zonesToAdd]);
+        target.rule = [...merged].join(",");
+    }
+    else {
+        next.push({
+            targeting_rule_type_id: zoneTypeId,
+            targeting_method: "blacklist",
+            rule: zonesToAdd.join(","),
+        });
+    }
+    return next;
+}
+function describeCriteria(args) {
+    const parts = [];
+    if (args.cr_max !== undefined)
+        parts.push(`CR < ${pct(args.cr_max)}`);
+    if (args.spend_min !== undefined)
+        parts.push(`spend > ${money(args.spend_min)}`);
+    if (args.roi_max !== undefined)
+        parts.push(`ROI < ${fmtRoi(args.roi_max)}`);
+    parts.push(`min ${args.min_clicks} clicks`);
+    return parts.join(", ");
+}
+function renderCandidates(candidates, alreadyBlacklisted) {
+    if (candidates.length === 0)
+        return "_No zones matched._";
+    const lines = [
+        "| Zone | Clicks | Conv | CR | Cost | ROI | Status |",
+        "|---|--:|--:|--:|--:|--:|---|",
+    ];
+    for (const r of candidates) {
+        const zoneId = r.zone_id;
+        const status = alreadyBlacklisted.has(zoneId) ? "already blacklisted" : "will add";
+        lines.push(`| ${mdCell(r.zone_name ?? zoneId)} | ${r.clicks} | ${r.conversions} | ${pct(conversionRate(r))} | ${money(r.media_cost)} | ${fmtRoi(r.roi)} | ${status} |`);
+    }
+    return lines.join("\n");
+}
+//# sourceMappingURL=cutZones.js.map

package/dist/tools/deletePayoutRule.js

@@ -0,0 +1,70 @@
+import { z } from "zod";
+import { AffsetApiError } from "../client.js";
+import { moneyPrecise } from "../lib/format.js";
+import { deletePayoutScope, fetchPayoutRules, findPayoutRule } from "../lib/payoutRules.js";
+import { errorResult, textError, textResult } from "../lib/toolResult.js";
+export const DELETE_PAYOUT_RULE_DESCRIPTION = "Delete a campaign payout rule (global or per-zone). Omit zone_id to delete the " +
+    "global rule; pass a zone UUID to delete that zone's override. DRY-RUN by default; " +
+    "pass confirm=true to apply. Without a global rule, conversions resolve to $0.";
+export const deletePayoutRuleInputSchema = {
+    campaign_id: z
+        .union([z.string().min(1), z.number().int()])
+        .describe("Campaign whose payout rule to delete."),
+    zone_id: z
+        .string()
+        .trim()
+        .min(1)
+        .optional()
+        .describe("Zone UUID of the zone-specific rule. Omit to delete the global rule."),
+    confirm: z.boolean().default(false).describe("false = dry-run preview (default). true = apply."),
+};
+export async function deletePayoutRule(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}\``;
+        const rules = await fetchPayoutRules(client, campaignId);
+        const existing = findPayoutRule(rules, zoneId);
+        if (!existing) {
+            return textError(`No ${scope} payout rule on campaign \`${campaignId}\`.`);
+        }
+        // Deleting the global rule while zone overrides remain leaves every other
+        // zone at $0 — worth saying before it is confirmed, not after.
+        const fallbackWarning = zoneId == null
+            ? "⚠️ Conversions on zones without their own override will resolve to **$0**."
+            : findPayoutRule(rules, null)
+                ? "Conversions on this zone fall back to the global payout."
+                : "⚠️ There is no global rule, so conversions on this zone will resolve to **$0**.";
+        if (!args.confirm) {
+            return textResult([
+                `**Dry run** — would delete ${scope} payout on campaign \`${campaignId}\`.`,
+                "",
+                `| Field | Value |`,
+                `|---|---|`,
+                `| Rule id | \`${existing.id}\` |`,
+                `| Payout | ${moneyPrecise(existing.payout)} |`,
+                `| Scope | ${scope} |`,
+                "",
+                fallbackWarning,
+                "",
+                "Call again with `confirm: true` to apply.",
+            ].join("\n"));
+        }
+        await deletePayoutScope(client, campaignId, zoneId);
+        return textResult([
+            `✅ Deleted ${scope} payout on campaign \`${campaignId}\` ` +
+                `(was ${moneyPrecise(existing.payout)}, rule id \`${existing.id}\`).`,
+            "",
+            fallbackWarning,
+        ].join("\n"));
+    }
+    catch (err) {
+        if (err instanceof AffsetApiError && err.status === 404) {
+            return textError(`Campaign \`${String(args.campaign_id).trim()}\` not found, or no matching payout rule.`);
+        }
+        return errorResult(err);
+    }
+}
+//# sourceMappingURL=deletePayoutRule.js.map