@affset/mcp 0.1.1 → 0.3.0

package/dist/runtimeConfig.js

@@ -0,0 +1,93 @@
+export const MIN_REQUEST_TIMEOUT_MS = 1_000;
+export const MAX_REQUEST_TIMEOUT_MS = 300_000;
+const NAMESPACE_RE = /^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/;
+function isLoopbackHost(hostname) {
+    return (hostname === "localhost" ||
+        hostname === "127.0.0.1" ||
+        hostname === "::1" ||
+        hostname.endsWith(".localhost"));
+}
+/** Parse and normalize an HTTP(S) origin, refusing cleartext remote hosts. */
+export function parseOriginUrl(raw, name, carriesApiKey = false) {
+    const normalized = raw.replace(/\/+$/, "");
+    let parsed;
+    try {
+        parsed = new URL(normalized);
+    }
+    catch {
+        throw new Error(`${name} is not a valid URL: ${raw}`);
+    }
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+        throw new Error(`${name} must be http(s), got ${parsed.protocol}`);
+    }
+    if (parsed.username || parsed.password) {
+        throw new Error(`${name} must not contain embedded credentials.`);
+    }
+    if ((parsed.pathname !== "/" && parsed.pathname !== "") || parsed.search || parsed.hash) {
+        throw new Error(`${name} must be an origin only (scheme, host, and optional port; no path, query, or fragment).`);
+    }
+    if (parsed.protocol === "http:" && !isLoopbackHost(parsed.hostname)) {
+        const cleartextHint = carriesApiKey ? " — plain http would send the API key in cleartext" : "";
+        throw new Error(`${name} must be https for a non-local host (got http://${parsed.hostname})${cleartextHint}.`);
+    }
+    return parsed;
+}
+/** Validate a namespace using the same rules as tenant signup. */
+export function validateNamespace(namespace, name) {
+    if (namespace.length < 3 || namespace.length > 63) {
+        throw new Error(`${name} must be 3–63 characters.`);
+    }
+    if (!NAMESPACE_RE.test(namespace) || namespace.includes("--")) {
+        throw new Error(`${name} must be lowercase letters, numbers, and hyphens only ` +
+            "(no leading/trailing or consecutive hyphens).");
+    }
+}
+function requiredString(value, name) {
+    if (typeof value !== "string" || value.trim() === "") {
+        throw new Error(`${name} must be a non-empty string.`);
+    }
+    return value.trim();
+}
+/** Reject empty keys and CR/LF so a value cannot split HTTP headers. */
+export function validateApiKey(value, name) {
+    const apiKey = requiredString(value, name);
+    if (/\r|\n/.test(apiKey)) {
+        throw new Error(`${name} must not contain line breaks.`);
+    }
+    return apiKey;
+}
+/**
+ * Validate and normalize config supplied through the public library API.
+ *
+ * TypeScript types are not a runtime security boundary. Hosted transports can
+ * source these values from deployment config or grant records, so fail before
+ * registering tools if a malformed value could leak a bearer key or silently
+ * disable the read-only boundary.
+ */
+export function normalizeRuntimeConfig(config) {
+    if (config === null || typeof config !== "object") {
+        throw new Error("config must be an object.");
+    }
+    const baseUrl = parseOriginUrl(requiredString(config.baseUrl, "config.baseUrl"), "config.baseUrl", true).origin;
+    const docsBaseUrl = parseOriginUrl(requiredString(config.docsBaseUrl, "config.docsBaseUrl"), "config.docsBaseUrl").origin;
+    const apiKey = validateApiKey(config.apiKey, "config.apiKey");
+    const namespace = requiredString(config.namespace, "config.namespace");
+    validateNamespace(namespace, "config.namespace");
+    if (!Number.isSafeInteger(config.requestTimeoutMs) ||
+        config.requestTimeoutMs < MIN_REQUEST_TIMEOUT_MS ||
+        config.requestTimeoutMs > MAX_REQUEST_TIMEOUT_MS) {
+        throw new Error(`config.requestTimeoutMs must be an integer between ${MIN_REQUEST_TIMEOUT_MS} and ${MAX_REQUEST_TIMEOUT_MS}.`);
+    }
+    if (typeof config.readOnly !== "boolean") {
+        throw new Error("config.readOnly must be a boolean.");
+    }
+    return {
+        baseUrl,
+        docsBaseUrl,
+        apiKey,
+        namespace,
+        requestTimeoutMs: config.requestTimeoutMs,
+        readOnly: config.readOnly,
+    };
+}
+//# sourceMappingURL=runtimeConfig.js.map

package/dist/server.d.ts

@@ -0,0 +1,4 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { Config } from "./runtimeConfig.js";
+/** Build the MCP server with the affset tools registered against `config`. */
+export declare function createServer(config: Config): McpServer;

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

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import { AffsetApiError } from "../client.js";
 import { mdCell, moneyPrecise } from "../lib/format.js";
-import { buildTrackingLink, fetchTenantIntegration } from "../lib/integrationUrls.js";
+import { buildTrackingLink, fetchTenantIntegration, resolveLinkedSource, } 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";
@@ -17,8 +17,9 @@ export const CREATE_CAMPAIGN_DESCRIPTION = "Create a campaign (offer) in the cur
     "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 " +
-    "(source_click_id + sub1..sub5, named by the tenant's sub labels). The campaign is " +
+    "payout is given, and a ready-to-use tracking link. A zone linked to a traffic source " +
+    "uses that source's tracking template; otherwise the link is 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 " +
@@ -87,6 +88,7 @@ export async function createCampaign(client, config, args) {
             return textError(zoneResult.error);
         }
         const { zone, inactiveWarning } = zoneResult;
+        const linked = await resolveLinkedSource(client, zone, false);
         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)`
@@ -105,6 +107,7 @@ export async function createCampaign(client, config, args) {
             `| 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)} |`,
+            ...(linked.sourceLabel ? [`| Traffic source | ${linked.sourceLabel} |`] : []),
         ].join("\n");
         if (!args.confirm) {
             return textResult([
@@ -112,6 +115,7 @@ export async function createCampaign(client, config, args) {
                 "",
                 summaryTable,
                 ...(inactiveWarning ? ["", inactiveWarning] : []),
+                ...linked.notes.flatMap((note) => ["", note]),
                 "",
                 "Call again with `confirm: true` to create it. The tracking link is returned after create.",
             ].join("\n"));
@@ -149,9 +153,11 @@ export async function createCampaign(client, config, args) {
                 payoutNote = `⚠️ campaign created, but setting the payout rule failed: ${message}`;
             }
         }
-        // 5. Ready-to-paste tracking link with the sub convention prefilled.
+        // 5. Ready-to-paste tracking link: linked source template when present,
+        //    otherwise the generic sub convention.
         const trackingLink = buildTrackingLink(integration.baseUrl, created.id, zone.id, {
             subLabels: integration.subLabels,
+            template: linked.template,
         });
         return textResult([
             `✅ Campaign **${mdCell(created.name)}** created (id \`${created.id}\`).`,
@@ -165,16 +171,22 @@ export async function createCampaign(client, config, args) {
             `| 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)} |`,
+            ...(linked.sourceLabel ? [`| Traffic source | ${linked.sourceLabel} |`] : []),
             ...(inactiveWarning ? ["", inactiveWarning] : []),
+            ...linked.notes.flatMap((note) => ["", note]),
             "",
             "**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.",
+            linked.template !== undefined
+                ? "Query parameters come from the linked source's tracking template. Edit them " +
+                    "with `update_traffic_source`. This link returns 404 while the campaign is " +
+                    "paused; run it with `set_campaign_status` before use."
+                : "Replace each `{…}` placeholder with the source's macro and drop sub slots you " +
+                    "don't need. Append `&cost=<network 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`._",

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/createTrafficSource.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 { TRAFFIC_SOURCE_STATUSES } from "../types.js";
+export declare const CREATE_TRAFFIC_SOURCE_DESCRIPTION: string;
+export declare const createTrafficSourceInputSchema: {
+    name: z.ZodString;
+    preset: z.ZodOptional<z.ZodString>;
+    tracking_template: z.ZodOptional<z.ZodString>;
+    postback_template: z.ZodOptional<z.ZodString>;
+    api_token: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodEnum<["active", "archived"]>>;
+    confirm: z.ZodDefault<z.ZodBoolean>;
+};
+type CreateTrafficSourceArgs = {
+    name: string;
+    preset?: string;
+    tracking_template?: string;
+    postback_template?: string;
+    api_token?: string;
+    status?: (typeof TRAFFIC_SOURCE_STATUSES)[number];
+    confirm: boolean;
+};
+export declare function createTrafficSource(client: AffsetClient, args: CreateTrafficSourceArgs): Promise<CallToolResult>;
+export {};