@affset/mcp 0.1.0 → 0.2.0

package/dist/server.js

@@ -1,316 +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 { 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("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/createCampaign.js

@@ -13,7 +13,8 @@ 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). " +
+    "— it must already exist as a team member (same as the Advertiser dropdown in the dashboard); " +
+    "create one first with create_team_member if needed. " +
     "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 " +
@@ -29,7 +30,7 @@ export const createCampaignInputSchema = {
         .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."),
+        "Advertiser dropdown. List candidates with list_team, or create one with create_team_member."),
     offer_url: z
         .string()
         .min(1)

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/createTeamMember.js

@@ -0,0 +1,204 @@
+import { z } from "zod";
+import { mdCell } from "../lib/format.js";
+import { errorResult, textError, textResult } from "../lib/toolResult.js";
+/** Matches lite-adserver's TENANT_ROLES. */
+const TENANT_ROLES = [
+    "owner",
+    "manager",
+    "advertiser_manager",
+    "publisher_manager",
+    "advertiser",
+    "publisher",
+];
+/** manager_email is only meaningful for these two roles. */
+const MANAGED_ROLES = ["advertiser", "publisher"];
+const PERMISSION_VALUES = ["read", "write"];
+const MAX_EPOCH_MS = 8_640_000_000_000_000;
+/** affset tokens are `sk_live_` + 64 hex (~72 chars). Bound what we echo into model context. */
+const MAX_TOKEN_LENGTH = 200;
+export const CREATE_TEAM_MEMBER_DESCRIPTION = "Invite a team member: create a user API key with an email in the current namespace — " +
+    'the same operation as the dashboard\'s "Add Team Member". Requires owner/manager, or a ' +
+    "scoped manager role (publisher_manager / advertiser_manager), which can only create its " +
+    "own managed role (publisher / advertiser respectively) assigned to itself — the API " +
+    "enforces this, not this tool, so a scoped manager's role/manager_email args may be " +
+    "overridden. Returns the new member's plaintext API key ONCE, in the confirmed response " +
+    "— it is not shown again by list_team, which deliberately never echoes tokens, so copy " +
+    "it now and send it to them over a private channel. Does not send an invite email; the " +
+    "API key is the credential, handed over out of band. " +
+    "DRY-RUN by default; pass confirm=true to apply.";
+export const createTeamMemberInputSchema = {
+    email: z
+        .string()
+        .trim()
+        .email()
+        .describe("New team member's email — their login / API identity."),
+    role: z
+        .enum(TENANT_ROLES)
+        .describe("owner | manager | advertiser_manager | publisher_manager | advertiser | publisher. " +
+        "What your own API key's role is allowed to create is enforced by the API."),
+    manager_email: z
+        .string()
+        .trim()
+        .email()
+        .optional()
+        .describe("Assign to a publisher_manager / advertiser_manager. Only valid with role=publisher or " +
+        "role=advertiser. A scoped manager key ignores this and assigns itself instead."),
+    permissions: z
+        .array(z.enum(PERMISSION_VALUES))
+        .nonempty()
+        .optional()
+        .describe('Defaults to ["read","write"] (matches the dashboard\'s default). "read" is always included.'),
+    expires_at: z
+        .number()
+        .int()
+        .positive()
+        .max(MAX_EPOCH_MS)
+        .optional()
+        .describe("Optional future expiry as epoch milliseconds. Omit for a key that never expires."),
+    confirm: z
+        .boolean()
+        .default(false)
+        .describe("false = dry-run preview (default). true = create the member and issue the key."),
+};
+export async function createTeamMember(client, args) {
+    try {
+        const email = args.email.trim();
+        if (!email)
+            return textError("email is required.");
+        const managerEmail = args.manager_email?.trim();
+        if (args.manager_email !== undefined && !managerEmail) {
+            return textError("manager_email must not be blank when provided.");
+        }
+        if (managerEmail !== undefined && !MANAGED_ROLES.includes(args.role)) {
+            return textError("manager_email is only allowed with role=publisher or role=advertiser.");
+        }
+        const expiryError = validateExpiry(args.expires_at);
+        if (expiryError)
+            return textError(expiryError);
+        const permissions = normalizePermissions(args.permissions);
+        const expiresNote = args.expires_at !== undefined ? fmtDay(args.expires_at) : "never";
+        const summaryTable = [
+            "| Field | Value |",
+            "|---|---|",
+            `| Email | ${mdCell(email)} |`,
+            `| Role | ${mdCell(args.role)} |`,
+            `| Manager | ${mdCell(managerEmail ?? "—")} |`,
+            `| Permissions | ${permissions.join(", ")} |`,
+            `| Expires | ${mdCell(expiresNote)} |`,
+        ].join("\n");
+        if (!args.confirm) {
+            return textResult([
+                "**Dry run** — would create a team member with:",
+                "",
+                summaryTable,
+                "",
+                "Call again with `confirm: true` to create it and issue the API key. A scoped " +
+                    "manager key (publisher_manager / advertiser_manager) can only create its own " +
+                    "managed role, assigned to itself — the fields above may be overridden by the API.",
+            ].join("\n"));
+        }
+        const body = { email, role: args.role, permissions };
+        if (managerEmail !== undefined)
+            body.manager_email = managerEmail;
+        if (args.expires_at !== undefined)
+            body.expires_at = args.expires_at;
+        // Treat the response as untrusted at runtime. Most importantly, do not let a
+        // malformed optional field throw after the non-idempotent POST succeeded: that
+        // would report an error and make a duplicate retry look appropriate.
+        const rawCreated = await client.post("/api/api-keys?type=user", body);
+        const created = isRecord(rawCreated) ? rawCreated : {};
+        const createdEmail = stringField(created.email, email);
+        const createdRole = stringField(created.role, args.role);
+        const createdManager = nullableStringField(created.manager_email, managerEmail ?? "—");
+        const createdPermissions = permissionFields(created.permissions, permissions);
+        const createdExpiry = expiryField(created.expires_at, expiresNote);
+        const token = extractToken(created.token);
+        const result = [
+            `✅ Team member **${mdCell(createdEmail)}** created.`,
+            "",
+            "| Field | Value |",
+            "|---|---|",
+            `| Email | ${mdCell(createdEmail)} |`,
+            `| Role | ${mdCell(createdRole)} |`,
+            `| Manager | ${mdCell(createdManager)} |`,
+            `| Permissions | ${createdPermissions.map(mdCell).join(", ")} |`,
+            `| Expires | ${mdCell(createdExpiry)} |`,
+            "",
+        ];
+        if (token) {
+            result.push("**API key** (shown once here — treat it like a password, send it over a private channel):", secretBlock(token), "`list_team` will show this person from now on, but never their token. If it leaks, " +
+                "revoke access from the dashboard's Team page.");
+        }
+        else {
+            result.push("⚠️ The member was created, but the API response did not include a usable API key. " +
+                "Do not retry this create call: that could create a duplicate. Retrieve or rotate " +
+                "the key from the dashboard's Team page.");
+        }
+        return textResult(result.join("\n"));
+    }
+    catch (err) {
+        return errorResult(err);
+    }
+}
+function normalizePermissions(raw) {
+    const set = new Set(raw && raw.length > 0 ? raw : PERMISSION_VALUES);
+    set.add("read");
+    return PERMISSION_VALUES.filter((permission) => set.has(permission));
+}
+function fmtDay(ms) {
+    return new Date(ms).toISOString().split("T", 1)[0];
+}
+function validateExpiry(ms) {
+    if (ms === undefined)
+        return null;
+    if (!Number.isInteger(ms) || ms <= 0 || ms > MAX_EPOCH_MS) {
+        return "expires_at must be a valid positive epoch-millisecond timestamp.";
+    }
+    if (ms <= Date.now())
+        return "expires_at must be in the future.";
+    return null;
+}
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function extractToken(value) {
+    if (typeof value !== "string")
+        return null;
+    const token = value.trim();
+    if (!token || token.length > MAX_TOKEN_LENGTH)
+        return null;
+    return token;
+}
+function stringField(value, fallback) {
+    return typeof value === "string" && value.trim() ? value : fallback;
+}
+function nullableStringField(value, fallback) {
+    if (value === null)
+        return "—";
+    return stringField(value, fallback);
+}
+function permissionFields(value, fallback) {
+    if (!Array.isArray(value))
+        return fallback;
+    const permissions = value.filter((permission) => typeof permission === "string" && permission.trim() !== "");
+    return permissions.length > 0 ? permissions : fallback;
+}
+function expiryField(value, fallback) {
+    if (value === null)
+        return "never";
+    if (typeof value !== "number" || !Number.isFinite(value))
+        return fallback;
+    try {
+        return fmtDay(value);
+    }
+    catch {
+        return fallback;
+    }
+}
+/** Use a fence longer than any backtick run in the secret, so it cannot close the block. */
+function secretBlock(secret) {
+    const longestRun = Math.max(0, ...(secret.match(/`+/g) ?? []).map((run) => run.length));
+    const fence = "`".repeat(Math.max(3, longestRun + 1));
+    return `${fence}\n${secret}\n${fence}`;
+}
+//# sourceMappingURL=createTeamMember.js.map

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 {};