@affset/mcp 0.1.1 → 0.2.0

package/dist/server.js

@@ -1,328 +1,13 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { AffsetClient } from "./client.js";
-import { getStats, getStatsInputSchema, GET_STATS_DESCRIPTION } from "./tools/getStats.js";
-import { cutZones, cutZonesInputSchema, CUT_ZONES_DESCRIPTION } from "./tools/cutZones.js";
-import { createCampaign, createCampaignInputSchema, CREATE_CAMPAIGN_DESCRIPTION, } from "./tools/createCampaign.js";
-import { listCampaigns, listCampaignsInputSchema, LIST_CAMPAIGNS_DESCRIPTION, } from "./tools/listCampaigns.js";
-import { listZones, listZonesInputSchema, LIST_ZONES_DESCRIPTION } from "./tools/listZones.js";
-import { listTeam, listTeamInputSchema, LIST_TEAM_DESCRIPTION } from "./tools/listTeam.js";
-import { createTeamMember, createTeamMemberInputSchema, CREATE_TEAM_MEMBER_DESCRIPTION, } from "./tools/createTeamMember.js";
-import { createZone, createZoneInputSchema, CREATE_ZONE_DESCRIPTION } from "./tools/createZone.js";
-import { getZoneUrl, getZoneUrlInputSchema, GET_ZONE_URL_DESCRIPTION } from "./tools/getZoneUrl.js";
-import { getTrackingLink, getTrackingLinkInputSchema, GET_TRACKING_LINK_DESCRIPTION, } from "./tools/getTrackingLink.js";
-import { updateZone, updateZoneInputSchema, UPDATE_ZONE_DESCRIPTION } from "./tools/updateZone.js";
-import { updateCampaign, updateCampaignInputSchema, UPDATE_CAMPAIGN_DESCRIPTION, } from "./tools/updateCampaign.js";
-import { setCampaignStatus, setCampaignStatusInputSchema, SET_CAMPAIGN_STATUS_DESCRIPTION, } from "./tools/setCampaignStatus.js";
-import { listPayoutRules, listPayoutRulesInputSchema, LIST_PAYOUT_RULES_DESCRIPTION, } from "./tools/listPayoutRules.js";
-import { setPayoutRule, setPayoutRuleInputSchema, SET_PAYOUT_RULE_DESCRIPTION, } from "./tools/setPayoutRule.js";
-import { deletePayoutRule, deletePayoutRuleInputSchema, DELETE_PAYOUT_RULE_DESCRIPTION, } from "./tools/deletePayoutRule.js";
-import { setPayoutGoal, setPayoutGoalInputSchema, SET_PAYOUT_GOAL_DESCRIPTION, } from "./tools/setPayoutGoal.js";
-import { listTargetingTypes, listTargetingTypesInputSchema, LIST_TARGETING_TYPES_DESCRIPTION, } from "./tools/listTargetingTypes.js";
-import { listTargetingRules, listTargetingRulesInputSchema, LIST_TARGETING_RULES_DESCRIPTION, } from "./tools/listTargetingRules.js";
-import { setTargetingRule, setTargetingRuleInputSchema, SET_TARGETING_RULE_DESCRIPTION, } from "./tools/setTargetingRule.js";
-import { removeTargetingRule, removeTargetingRuleInputSchema, REMOVE_TARGETING_RULE_DESCRIPTION, } from "./tools/removeTargetingRule.js";
-import { listSubLabels, listSubLabelsInputSchema, LIST_SUB_LABELS_DESCRIPTION, } from "./tools/listSubLabels.js";
-import { setSubLabels, setSubLabelsInputSchema, SET_SUB_LABELS_DESCRIPTION, } from "./tools/setSubLabels.js";
-import { listConversions, listConversionsInputSchema, LIST_CONVERSIONS_DESCRIPTION, } from "./tools/listConversions.js";
-import { whoami, whoamiInputSchema, WHOAMI_DESCRIPTION } from "./tools/whoami.js";
-import { createRequire } from "node:module";
-const require = createRequire(import.meta.url);
-const { version: VERSION } = require("../package.json");
+import { registerAffsetTools } from "./registerTools.js";
+import { VERSION } from "./version.js";
 /** Build the MCP server with the affset tools registered against `config`. */
 export function createServer(config) {
-    const client = new AffsetClient(config);
     const server = new McpServer({
         name: "affset-mcp",
         version: VERSION,
     });
-    // Registers every tool as normal, then immediately removes anything that isn't
-    // readOnlyHint:true when AFFSET_READ_ONLY is set — a mutation tool never has a
-    // chance to appear in tools/list or be called. See AFFSET_READ_ONLY in the README
-    // for why this exists (untrusted third-party data can reach model context via
-    // list_conversions/get_stats, so mutation tools are an injection blast-radius
-    // control, not just a UI nicety).
-    const registerTool = (name, toolConfig, cb) => {
-        const tool = server.registerTool(name, toolConfig, cb);
-        if (config.readOnly && toolConfig.annotations?.readOnlyHint !== true) {
-            tool.remove();
-        }
-        return tool;
-    };
-    registerTool("whoami", {
-        title: "Show the tenant this MCP is bound to",
-        description: WHOAMI_DESCRIPTION,
-        inputSchema: whoamiInputSchema,
-        annotations: {
-            readOnlyHint: true,
-            destructiveHint: false,
-            idempotentHint: true,
-            openWorldHint: true,
-        },
-    }, () => whoami(client, config));
-    registerTool("get_stats", {
-        title: "Get affset stats",
-        description: GET_STATS_DESCRIPTION,
-        inputSchema: getStatsInputSchema,
-        annotations: {
-            readOnlyHint: true,
-            destructiveHint: false,
-            idempotentHint: true,
-            openWorldHint: true,
-        },
-    }, (args) => getStats(client, args));
-    registerTool("list_campaigns", {
-        title: "List campaigns",
-        description: LIST_CAMPAIGNS_DESCRIPTION,
-        inputSchema: listCampaignsInputSchema,
-        annotations: {
-            readOnlyHint: true,
-            destructiveHint: false,
-            idempotentHint: true,
-            openWorldHint: true,
-        },
-    }, (args) => listCampaigns(client, args));
-    registerTool("list_zones", {
-        title: "List zones",
-        description: LIST_ZONES_DESCRIPTION,
-        inputSchema: listZonesInputSchema,
-        annotations: {
-            readOnlyHint: true,
-            destructiveHint: false,
-            idempotentHint: true,
-            openWorldHint: true,
-        },
-    }, (args) => listZones(client, args));
-    registerTool("list_team", {
-        title: "List team members",
-        description: LIST_TEAM_DESCRIPTION,
-        inputSchema: listTeamInputSchema,
-        annotations: {
-            readOnlyHint: true,
-            destructiveHint: false,
-            idempotentHint: true,
-            openWorldHint: true,
-        },
-    }, (args) => listTeam(client, args));
-    registerTool("create_team_member", {
-        title: "Invite a team member",
-        description: CREATE_TEAM_MEMBER_DESCRIPTION,
-        inputSchema: createTeamMemberInputSchema,
-        annotations: {
-            readOnlyHint: false,
-            destructiveHint: false,
-            idempotentHint: false,
-            openWorldHint: true,
-        },
-    }, (args) => createTeamMember(client, args));
-    registerTool("get_zone_url", {
-        title: "Get the zone URL for a traffic source",
-        description: GET_ZONE_URL_DESCRIPTION,
-        inputSchema: getZoneUrlInputSchema,
-        annotations: {
-            readOnlyHint: true,
-            destructiveHint: false,
-            idempotentHint: true,
-            openWorldHint: true,
-        },
-    }, (args) => getZoneUrl(client, config, args));
-    registerTool("get_tracking_link", {
-        title: "Get a campaign's tracking link",
-        description: GET_TRACKING_LINK_DESCRIPTION,
-        inputSchema: getTrackingLinkInputSchema,
-        annotations: {
-            readOnlyHint: true,
-            destructiveHint: false,
-            idempotentHint: true,
-            openWorldHint: true,
-        },
-    }, (args) => getTrackingLink(client, config, args));
-    registerTool("create_campaign", {
-        title: "Create a campaign",
-        description: CREATE_CAMPAIGN_DESCRIPTION,
-        inputSchema: createCampaignInputSchema,
-        annotations: {
-            readOnlyHint: false,
-            destructiveHint: false,
-            idempotentHint: false,
-            openWorldHint: true,
-        },
-    }, (args) => createCampaign(client, config, args));
-    registerTool("update_campaign", {
-        title: "Update a campaign",
-        description: UPDATE_CAMPAIGN_DESCRIPTION,
-        inputSchema: updateCampaignInputSchema,
-        annotations: {
-            readOnlyHint: false,
-            destructiveHint: true,
-            idempotentHint: false,
-            openWorldHint: true,
-        },
-    }, (args) => updateCampaign(client, args));
-    registerTool("set_campaign_status", {
-        title: "Run or pause a campaign",
-        description: SET_CAMPAIGN_STATUS_DESCRIPTION,
-        inputSchema: setCampaignStatusInputSchema,
-        annotations: {
-            readOnlyHint: false,
-            destructiveHint: true,
-            idempotentHint: false,
-            openWorldHint: true,
-        },
-    }, (args) => setCampaignStatus(client, args));
-    registerTool("create_zone", {
-        title: "Create a zone",
-        description: CREATE_ZONE_DESCRIPTION,
-        inputSchema: createZoneInputSchema,
-        annotations: {
-            readOnlyHint: false,
-            destructiveHint: false,
-            idempotentHint: false,
-            openWorldHint: true,
-        },
-    }, (args) => createZone(client, args));
-    registerTool("update_zone", {
-        title: "Update a zone",
-        description: UPDATE_ZONE_DESCRIPTION,
-        inputSchema: updateZoneInputSchema,
-        annotations: {
-            readOnlyHint: false,
-            destructiveHint: true,
-            idempotentHint: false,
-            openWorldHint: true,
-        },
-    }, (args) => updateZone(client, args));
-    registerTool("cut_zones", {
-        title: "Cut underperforming zones",
-        description: CUT_ZONES_DESCRIPTION,
-        inputSchema: cutZonesInputSchema,
-        annotations: {
-            readOnlyHint: false,
-            destructiveHint: true,
-            idempotentHint: false,
-            openWorldHint: true,
-        },
-    }, (args) => cutZones(client, args));
-    registerTool("list_payout_rules", {
-        title: "List payout rules",
-        description: LIST_PAYOUT_RULES_DESCRIPTION,
-        inputSchema: listPayoutRulesInputSchema,
-        annotations: {
-            readOnlyHint: true,
-            destructiveHint: false,
-            idempotentHint: true,
-            openWorldHint: true,
-        },
-    }, (args) => listPayoutRules(client, args));
-    registerTool("set_payout_rule", {
-        title: "Set a payout rule",
-        description: SET_PAYOUT_RULE_DESCRIPTION,
-        inputSchema: setPayoutRuleInputSchema,
-        annotations: {
-            readOnlyHint: false,
-            destructiveHint: true,
-            idempotentHint: false,
-            openWorldHint: true,
-        },
-    }, (args) => setPayoutRule(client, args));
-    registerTool("delete_payout_rule", {
-        title: "Delete a payout rule",
-        description: DELETE_PAYOUT_RULE_DESCRIPTION,
-        inputSchema: deletePayoutRuleInputSchema,
-        annotations: {
-            readOnlyHint: false,
-            destructiveHint: true,
-            idempotentHint: false,
-            openWorldHint: true,
-        },
-    }, (args) => deletePayoutRule(client, args));
-    registerTool("set_payout_goal", {
-        title: "Set payout goal type",
-        description: SET_PAYOUT_GOAL_DESCRIPTION,
-        inputSchema: setPayoutGoalInputSchema,
-        annotations: {
-            readOnlyHint: false,
-            destructiveHint: true,
-            idempotentHint: false,
-            openWorldHint: true,
-        },
-    }, (args) => setPayoutGoal(client, args));
-    registerTool("list_targeting_types", {
-        title: "List targeting rule types",
-        description: LIST_TARGETING_TYPES_DESCRIPTION,
-        inputSchema: listTargetingTypesInputSchema,
-        annotations: {
-            readOnlyHint: true,
-            destructiveHint: false,
-            idempotentHint: true,
-            openWorldHint: true,
-        },
-    }, () => listTargetingTypes(client));
-    registerTool("list_targeting_rules", {
-        title: "List campaign targeting rules",
-        description: LIST_TARGETING_RULES_DESCRIPTION,
-        inputSchema: listTargetingRulesInputSchema,
-        annotations: {
-            readOnlyHint: true,
-            destructiveHint: false,
-            idempotentHint: true,
-            openWorldHint: true,
-        },
-    }, (args) => listTargetingRules(client, args));
-    registerTool("set_targeting_rule", {
-        title: "Set a targeting rule",
-        description: SET_TARGETING_RULE_DESCRIPTION,
-        inputSchema: setTargetingRuleInputSchema,
-        annotations: {
-            readOnlyHint: false,
-            destructiveHint: true,
-            idempotentHint: false,
-            openWorldHint: true,
-        },
-    }, (args) => setTargetingRule(client, args));
-    registerTool("remove_targeting_rule", {
-        title: "Remove a targeting rule",
-        description: REMOVE_TARGETING_RULE_DESCRIPTION,
-        inputSchema: removeTargetingRuleInputSchema,
-        annotations: {
-            readOnlyHint: false,
-            destructiveHint: true,
-            idempotentHint: false,
-            openWorldHint: true,
-        },
-    }, (args) => removeTargetingRule(client, args));
-    registerTool("list_sub_labels", {
-        title: "List sub labels",
-        description: LIST_SUB_LABELS_DESCRIPTION,
-        inputSchema: listSubLabelsInputSchema,
-        annotations: {
-            readOnlyHint: true,
-            destructiveHint: false,
-            idempotentHint: true,
-            openWorldHint: true,
-        },
-    }, () => listSubLabels(client));
-    registerTool("set_sub_labels", {
-        title: "Set sub labels",
-        description: SET_SUB_LABELS_DESCRIPTION,
-        inputSchema: setSubLabelsInputSchema,
-        annotations: {
-            readOnlyHint: false,
-            destructiveHint: true,
-            idempotentHint: false,
-            openWorldHint: true,
-        },
-    }, (args) => setSubLabels(client, args));
-    registerTool("list_conversions", {
-        title: "List conversions",
-        description: LIST_CONVERSIONS_DESCRIPTION,
-        inputSchema: listConversionsInputSchema,
-        annotations: {
-            readOnlyHint: true,
-            destructiveHint: false,
-            idempotentHint: true,
-            openWorldHint: true,
-        },
-    }, (args) => listConversions(client, args));
+    registerAffsetTools(server, config);
     return server;
 }
 //# sourceMappingURL=server.js.map

package/dist/tools/createCampaign.d.ts

@@ -0,0 +1,25 @@
+import { z } from "zod";
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { type AffsetClient } from "../client.js";
+import type { Config } from "../runtimeConfig.js";
+export declare const CREATE_CAMPAIGN_DESCRIPTION: string;
+export declare const createCampaignInputSchema: {
+    user_email: z.ZodString;
+    offer_url: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    geo: z.ZodOptional<z.ZodArray<z.ZodString, "atleastone">>;
+    payout: z.ZodOptional<z.ZodNumber>;
+    zone_id: z.ZodOptional<z.ZodString>;
+    confirm: z.ZodDefault<z.ZodBoolean>;
+};
+type CreateCampaignArgs = {
+    user_email: string;
+    offer_url: string;
+    name?: string;
+    geo?: string[];
+    payout?: number;
+    zone_id?: string;
+    confirm: boolean;
+};
+export declare function createCampaign(client: AffsetClient, config: Config, args: CreateCampaignArgs): Promise<CallToolResult>;
+export {};

package/dist/tools/createTeamMember.d.ts

@@ -0,0 +1,26 @@
+import { z } from "zod";
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import type { AffsetClient } from "../client.js";
+/** Matches lite-adserver's TENANT_ROLES. */
+declare const TENANT_ROLES: readonly ["owner", "manager", "advertiser_manager", "publisher_manager", "advertiser", "publisher"];
+type TenantRole = (typeof TENANT_ROLES)[number];
+declare const PERMISSION_VALUES: readonly ["read", "write"];
+export declare const CREATE_TEAM_MEMBER_DESCRIPTION: string;
+export declare const createTeamMemberInputSchema: {
+    email: z.ZodString;
+    role: z.ZodEnum<["owner", "manager", "advertiser_manager", "publisher_manager", "advertiser", "publisher"]>;
+    manager_email: z.ZodOptional<z.ZodString>;
+    permissions: z.ZodOptional<z.ZodArray<z.ZodEnum<["read", "write"]>, "atleastone">>;
+    expires_at: z.ZodOptional<z.ZodNumber>;
+    confirm: z.ZodDefault<z.ZodBoolean>;
+};
+type CreateTeamMemberArgs = {
+    email: string;
+    role: TenantRole;
+    manager_email?: string;
+    permissions?: (typeof PERMISSION_VALUES)[number][];
+    expires_at?: number;
+    confirm: boolean;
+};
+export declare function createTeamMember(client: AffsetClient, args: CreateTeamMemberArgs): Promise<CallToolResult>;
+export {};

package/dist/tools/createZone.d.ts

@@ -0,0 +1,22 @@
+import { z } from "zod";
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import type { AffsetClient } from "../client.js";
+export declare const CREATE_ZONE_DESCRIPTION: string;
+export declare const createZoneInputSchema: {
+    name: z.ZodString;
+    postback_url: z.ZodOptional<z.ZodString>;
+    site_url: z.ZodOptional<z.ZodString>;
+    traffic_back_url: z.ZodOptional<z.ZodString>;
+    user_email: z.ZodOptional<z.ZodString>;
+    confirm: z.ZodDefault<z.ZodBoolean>;
+};
+type CreateZoneArgs = {
+    name: string;
+    postback_url?: string;
+    site_url?: string;
+    traffic_back_url?: string;
+    user_email?: string;
+    confirm: boolean;
+};
+export declare function createZone(client: AffsetClient, args: CreateZoneArgs): Promise<CallToolResult>;
+export {};

package/dist/tools/cutZones.d.ts

@@ -0,0 +1,29 @@
+import { z } from "zod";
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import type { AffsetClient } from "../client.js";
+import { RANGE_PRESETS } from "../lib/time.js";
+export declare const CUT_ZONES_DESCRIPTION: string;
+export declare const cutZonesInputSchema: {
+    campaign_id: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
+    cr_max: z.ZodOptional<z.ZodNumber>;
+    spend_min: z.ZodOptional<z.ZodNumber>;
+    roi_max: z.ZodOptional<z.ZodNumber>;
+    min_clicks: z.ZodDefault<z.ZodNumber>;
+    range: z.ZodOptional<z.ZodEnum<["today", "yesterday", "last_7_days", "last_30_days", "this_month"]>>;
+    from: z.ZodOptional<z.ZodString>;
+    to: z.ZodOptional<z.ZodString>;
+    confirm: z.ZodDefault<z.ZodBoolean>;
+};
+type CutZonesArgs = {
+    campaign_id: string | number;
+    cr_max?: number;
+    spend_min?: number;
+    roi_max?: number;
+    min_clicks: number;
+    range?: (typeof RANGE_PRESETS)[number];
+    from?: string;
+    to?: string;
+    confirm: boolean;
+};
+export declare function cutZones(client: AffsetClient, args: CutZonesArgs): Promise<CallToolResult>;
+export {};

package/dist/tools/deletePayoutRule.d.ts

@@ -0,0 +1,16 @@
+import { z } from "zod";
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { type AffsetClient } from "../client.js";
+export declare const DELETE_PAYOUT_RULE_DESCRIPTION: string;
+export declare const deletePayoutRuleInputSchema: {
+    campaign_id: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
+    zone_id: z.ZodOptional<z.ZodString>;
+    confirm: z.ZodDefault<z.ZodBoolean>;
+};
+type DeletePayoutRuleArgs = {
+    campaign_id: string | number;
+    zone_id?: string;
+    confirm: boolean;
+};
+export declare function deletePayoutRule(client: AffsetClient, args: DeletePayoutRuleArgs): Promise<CallToolResult>;
+export {};

package/dist/tools/getCampaign.d.ts

@@ -0,0 +1,12 @@
+import { z } from "zod";
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { type AffsetClient } from "../client.js";
+export declare const GET_CAMPAIGN_DESCRIPTION: string;
+export declare const getCampaignInputSchema: {
+    campaign_id: z.ZodUnion<[z.ZodEffects<z.ZodString, string, string>, z.ZodNumber]>;
+};
+type GetCampaignArgs = {
+    campaign_id: string | number;
+};
+export declare function getCampaign(client: AffsetClient, args: GetCampaignArgs): Promise<CallToolResult>;
+export {};

package/dist/tools/getCampaign.js

@@ -0,0 +1,150 @@
+import { z } from "zod";
+import { AffsetApiError } from "../client.js";
+import { formatInstant } from "../lib/time.js";
+import { mdCell, money, moneyPrecise } from "../lib/format.js";
+import { fetchPayoutRules } from "../lib/payoutRules.js";
+import { fetchTargetingRules, fetchTargetingTypes, UNENFORCED_TYPES } from "../lib/targeting.js";
+import { errorResult, textError, textResult } from "../lib/toolResult.js";
+export const GET_CAMPAIGN_DESCRIPTION = "Get one campaign's full record: every field (including the untruncated offer URL, " +
+    "exact schedule, budgets/pacing, silent-conversions flag, payout goal type) plus its " +
+    "targeting rules and payout rules in one call. `list_campaigns` renders a summary table " +
+    "(offer URL truncated, no dates/pacing/silent) meant for scanning many campaigns; use " +
+    "this when you need one campaign's complete data — e.g. before recreating it as a new " +
+    "campaign, or before editing it with `update_campaign`.";
+export const getCampaignInputSchema = {
+    campaign_id: z
+        .union([
+        z
+            .string()
+            .trim()
+            .regex(/^[1-9]\d*$/, "campaign_id must be a positive integer")
+            .refine((value) => Number.isSafeInteger(Number(value)), "campaign_id is too large"),
+        z.number().int().positive().max(Number.MAX_SAFE_INTEGER),
+    ])
+        .describe("Campaign id to fetch."),
+};
+export async function getCampaign(client, args) {
+    try {
+        const campaignId = String(args.campaign_id).trim();
+        if (!campaignId)
+            return textError("campaign_id is required.");
+        let campaign;
+        try {
+            campaign = 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 [targetingRules, payoutRules, targetingTypes, timeZone] = await Promise.all([
+            fetchTargetingRules(client, campaignId),
+            fetchPayoutRules(client, campaignId),
+            // Names are a nicety; the rule table still works with bare type ids.
+            fetchTargetingTypes(client).catch(() => []),
+            client.getTenantTimezone(),
+        ]);
+        const typeById = new Map(targetingTypes.map((t) => [t.id, t]));
+        const fmt = (ms) => ms == null ? "—" : `${formatInstant(ms, timeZone)} ${mdCell(timeZone)} (${ms} epoch ms)`;
+        const deadTargetingRules = targetingRules.filter((rule) => {
+            const name = typeById.get(rule.targeting_rule_type_id)?.name.toLowerCase();
+            return name !== undefined && UNENFORCED_TYPES[name] !== undefined;
+        });
+        const payoutGoal = campaign.payout_goal_type?.trim();
+        const fields = [
+            "| Field | Value |",
+            "|---|---|",
+            `| Id | ${campaign.id} |`,
+            `| Name | ${mdCell(campaign.name)} |`,
+            `| Status | ${mdCell(campaign.status)} |`,
+            `| Advertiser | ${mdCell(campaign.user_email ?? "—")} |`,
+            `| Offer URL | ${mdCell(campaign.redirect_url ?? "—")} |`,
+            `| Model | ${mdCell(campaign.payment_model ?? "—")} |`,
+            `| Rate | ${campaign.rate != null ? moneyPrecise(campaign.rate) : "—"} |`,
+            `| Start date | ${fmt(campaign.start_date)} |`,
+            `| End date | ${fmt(campaign.end_date)} |`,
+            `| Daily budget | ${money(campaign.daily_budget)} |`,
+            `| Total budget | ${money(campaign.total_budget)} |`,
+            `| Pacing | ${mdCell(campaign.pacing ?? "—")} |`,
+            `| Budget paused | ${formatBudgetPaused(campaign)} |`,
+            `| Silent conversions | ${formatFlag(campaign.silent)} |`,
+            `| Payout goal type | ${payoutGoal ? mdCell(payoutGoal) : "_none — every conversion type gets the resolved payout_"} |`,
+            `| Created | ${fmt(campaign.created_at)} |`,
+            `| Updated | ${fmt(campaign.updated_at)} |`,
+        ];
+        return textResult([
+            `**Campaign** \`${campaign.id}\` — ${mdCell(campaign.name)}`,
+            "",
+            fields.join("\n"),
+            "",
+            `**Targeting rules** (${targetingRules.length})`,
+            "",
+            renderTargetingRules(targetingRules, typeById),
+            ...(deadTargetingRules.length
+                ? ["", ...renderDeadTargetingWarnings(deadTargetingRules, typeById)]
+                : []),
+            "",
+            `**Payout rules** (${payoutRules.length})`,
+            "",
+            renderPayoutRules(payoutRules),
+            "",
+            "_Recreate elsewhere with `create_campaign` + `update_campaign`, then " +
+                "`set_targeting_rule` / `set_payout_rule` for each rule above._",
+            "_Manage this campaign with `update_campaign`, `set_campaign_status`, " +
+                "`set_targeting_rule`, `set_payout_rule`, `set_payout_goal`._",
+        ].join("\n"));
+    }
+    catch (err) {
+        return errorResult(err);
+    }
+}
+function formatFlag(value) {
+    if (value == null)
+        return "—";
+    return value ? "yes" : "no";
+}
+function formatBudgetPaused(campaign) {
+    if (campaign.budget_paused == null)
+        return "—";
+    if (!campaign.budget_paused)
+        return "no";
+    const reason = campaign.budget_pause_reason?.trim();
+    return reason ? `yes (${mdCell(reason)})` : "yes (reason unavailable)";
+}
+function renderTargetingRules(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");
+}
+function renderDeadTargetingWarnings(rules, typeById) {
+    const names = [...new Set(rules.map((rule) => typeById.get(rule.targeting_rule_type_id).name))];
+    return names.map((name) => `⚠️ \`${mdCell(name)}\` — ${UNENFORCED_TYPES[name.toLowerCase()]}. This rule has no effect.`);
+}
+function renderPayoutRules(rules) {
+    if (rules.length === 0) {
+        return "_No payout rules — conversions resolve to $0 until you set one._";
+    }
+    const lines = ["| Scope | Zone | Payout | Rule id |", "|---|---|--:|---|"];
+    for (const r of rules) {
+        const scope = r.zone_id == null ? "global" : "zone";
+        const zone = r.zone_id == null ? "—" : `\`${r.zone_id}\``;
+        lines.push(`| ${scope} | ${zone} | ${moneyPrecise(r.payout)} | \`${r.id}\` |`);
+    }
+    if (!rules.some((rule) => rule.zone_id == null)) {
+        lines.push("");
+        lines.push("_⚠️ No global rule — conversions from any zone without an override resolve to **$0**._");
+    }
+    return lines.join("\n");
+}
+//# sourceMappingURL=getCampaign.js.map

package/dist/tools/getStats.d.ts

@@ -0,0 +1,40 @@
+import { z } from "zod";
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import type { AffsetClient } from "../client.js";
+import { RANGE_PRESETS } from "../lib/time.js";
+import { type GroupBy } from "../types.js";
+export declare const GET_STATS_DESCRIPTION: string;
+export declare const getStatsInputSchema: {
+    group_by: z.ZodDefault<z.ZodEnum<["date", "campaign_id", "zone_id", "country", "conversion_type", "publisher_email", "advertiser_email", "sub1", "sub2", "sub3", "sub4", "sub5"]>>;
+    range: z.ZodOptional<z.ZodEnum<["today", "yesterday", "last_7_days", "last_30_days", "this_month"]>>;
+    from: z.ZodOptional<z.ZodString>;
+    to: z.ZodOptional<z.ZodString>;
+    campaign_ids: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    zone_ids: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    sub1: z.ZodOptional<z.ZodString>;
+    sub2: z.ZodOptional<z.ZodString>;
+    sub3: z.ZodOptional<z.ZodString>;
+    sub4: z.ZodOptional<z.ZodString>;
+    sub5: z.ZodOptional<z.ZodString>;
+    conversion_type: z.ZodOptional<z.ZodString>;
+    advertiser_email: z.ZodOptional<z.ZodString>;
+    publisher_email: z.ZodOptional<z.ZodString>;
+};
+type GetStatsArgs = {
+    group_by: GroupBy;
+    range?: (typeof RANGE_PRESETS)[number];
+    from?: string;
+    to?: string;
+    campaign_ids?: string[];
+    zone_ids?: string[];
+    sub1?: string;
+    sub2?: string;
+    sub3?: string;
+    sub4?: string;
+    sub5?: string;
+    conversion_type?: string;
+    advertiser_email?: string;
+    publisher_email?: string;
+};
+export declare function getStats(client: AffsetClient, args: GetStatsArgs): Promise<CallToolResult>;
+export {};