@affset/mcp 0.1.1 → 0.3.0

package/dist/tools/setTargetingRule.d.ts

@@ -0,0 +1,21 @@
+import { z } from "zod";
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { type AffsetClient } from "../client.js";
+import { type TargetingMethod } from "../lib/targeting.js";
+export declare const SET_TARGETING_RULE_DESCRIPTION: string;
+export declare const setTargetingRuleInputSchema: {
+    campaign_id: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
+    type: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
+    method: z.ZodEnum<["whitelist", "blacklist"]>;
+    rule: z.ZodString;
+    confirm: z.ZodDefault<z.ZodBoolean>;
+};
+type SetTargetingRuleArgs = {
+    campaign_id: string | number;
+    type: string | number;
+    method: TargetingMethod;
+    rule: string;
+    confirm: boolean;
+};
+export declare function setTargetingRule(client: AffsetClient, args: SetTargetingRuleArgs): Promise<CallToolResult>;
+export {};

package/dist/tools/updateCampaign.d.ts

@@ -0,0 +1,35 @@
+import { z } from "zod";
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { type AffsetClient } from "../client.js";
+import { CAMPAIGN_STATUSES, PACING_VALUES, PAYMENT_MODELS } from "../types.js";
+export declare const UPDATE_CAMPAIGN_DESCRIPTION: string;
+export declare const updateCampaignInputSchema: {
+    campaign_id: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
+    name: z.ZodOptional<z.ZodString>;
+    redirect_url: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodEnum<["active", "paused", "archived"]>>;
+    payment_model: z.ZodOptional<z.ZodEnum<["cpa", "cpm"]>>;
+    rate: z.ZodOptional<z.ZodNumber>;
+    start_date: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodNull]>>;
+    end_date: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodNull]>>;
+    daily_budget: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodNull]>>;
+    total_budget: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodNull]>>;
+    pacing: z.ZodOptional<z.ZodEnum<["asap", "even"]>>;
+    confirm: z.ZodDefault<z.ZodBoolean>;
+};
+type UpdateCampaignArgs = {
+    campaign_id: string | number;
+    name?: string;
+    redirect_url?: string;
+    status?: (typeof CAMPAIGN_STATUSES)[number];
+    payment_model?: (typeof PAYMENT_MODELS)[number];
+    rate?: number;
+    start_date?: string | number | null;
+    end_date?: string | number | null;
+    daily_budget?: number | null;
+    total_budget?: number | null;
+    pacing?: (typeof PACING_VALUES)[number];
+    confirm: boolean;
+};
+export declare function updateCampaign(client: AffsetClient, args: UpdateCampaignArgs): Promise<CallToolResult>;
+export {};

package/dist/tools/updateTrafficSource.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 UPDATE_TRAFFIC_SOURCE_DESCRIPTION: string;
+export declare const updateTrafficSourceInputSchema: {
+    traffic_source_id: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    tracking_template: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNull]>>;
+    postback_template: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNull]>>;
+    api_token: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNull]>>;
+    status: z.ZodOptional<z.ZodEnum<["active", "archived"]>>;
+    confirm: z.ZodDefault<z.ZodBoolean>;
+};
+type UpdateTrafficSourceArgs = {
+    traffic_source_id: string;
+    name?: string;
+    tracking_template?: string | null;
+    postback_template?: string | null;
+    api_token?: string | null;
+    status?: (typeof TRAFFIC_SOURCE_STATUSES)[number];
+    confirm: boolean;
+};
+export declare function updateTrafficSource(client: AffsetClient, args: UpdateTrafficSourceArgs): Promise<CallToolResult>;
+export {};

package/dist/tools/updateTrafficSource.js

@@ -0,0 +1,171 @@
+import { z } from "zod";
+import { AffsetApiError } from "../client.js";
+import { SOURCE_CLICK_ID_PARAM, templateHasParam } from "../lib/integrationUrls.js";
+import { displayValue, renderDiff } from "../lib/patch.js";
+import { errorResult, textError, textResult } from "../lib/toolResult.js";
+import { httpUrlError } from "../lib/urls.js";
+import { TRAFFIC_SOURCE_STATUSES, } from "../types.js";
+const NAME_MAX = 200;
+const TEMPLATE_MAX = 2000;
+const TOKEN_MAX = 500;
+/** Zod: replacement string, or null to clear. */
+const clearableTemplate = z.union([z.string().max(TEMPLATE_MAX), z.null()]);
+export const UPDATE_TRAFFIC_SOURCE_DESCRIPTION = "Update a traffic source (name, tracking_template, postback_template, api_token, " +
+    'status). Partial update — only provided fields change; pass null (or "") to clear a ' +
+    "template or the stored api_token. Zones linked to the source pick the new tracking " +
+    "template up immediately in get_zone_url/get_tracking_link. " +
+    "DRY-RUN by default; pass confirm=true to apply.";
+export const updateTrafficSourceInputSchema = {
+    traffic_source_id: z.string().trim().min(1).describe("Traffic source id to update."),
+    name: z
+        .string()
+        .trim()
+        .min(1)
+        .max(NAME_MAX)
+        .optional()
+        .describe("New display name (unique per tenant)."),
+    tracking_template: clearableTemplate
+        .optional()
+        .describe("New tracking template (query string appended to the zone URL; must not start " +
+        "with ? or &), or null to clear it."),
+    postback_template: clearableTemplate
+        .optional()
+        .describe("New postback template (http(s) URL with our macros), or null to clear it."),
+    api_token: z
+        .union([z.string().max(TOKEN_MAX), z.null()])
+        .optional()
+        .describe('Replacement network API credential (stored write-only), or null/"" to clear the ' +
+        "stored one. Omit to leave it unchanged."),
+    status: z
+        .enum(TRAFFIC_SOURCE_STATUSES)
+        .optional()
+        .describe("active or archived. Archiving keeps the source linked to its zones — deletion is " +
+        "only possible once no zone references it."),
+    confirm: z
+        .boolean()
+        .default(false)
+        .describe("false = dry-run preview (default). true = apply the update."),
+};
+export async function updateTrafficSource(client, args) {
+    try {
+        const patch = buildPatch(args);
+        if ("error" in patch)
+            return textError(patch.error);
+        if (Object.keys(patch.body).length === 0) {
+            return textError("Provide at least one field to update: name, tracking_template, " +
+                "postback_template, api_token, status.");
+        }
+        let existing;
+        try {
+            existing = await client.get(`/api/traffic-sources/${encodeURIComponent(args.traffic_source_id)}`);
+        }
+        catch (err) {
+            if (err instanceof AffsetApiError && err.status === 404) {
+                return textError(`Traffic source \`${args.traffic_source_id}\` not found in this namespace.`);
+            }
+            throw err;
+        }
+        const changes = diffSource(existing, patch.body);
+        if (changes.length === 0) {
+            return textResult(`Nothing to change on traffic source \`${existing.id}\` (${existing.name}) — ` +
+                "provided fields already match current values.");
+        }
+        const warnings = [];
+        const linkedZones = existing.linked_zones ?? 0;
+        if ("tracking_template" in patch.body && linkedZones > 0) {
+            warnings.push(`The new tracking template applies to the ${linkedZones} linked ` +
+                `zone${linkedZones === 1 ? "" : "s"} the next time a URL is rendered — links ` +
+                "already pasted into network campaigns keep their old parameters until replaced.");
+        }
+        if (typeof patch.body.tracking_template === "string" &&
+            patch.body.tracking_template !== "" &&
+            !templateHasParam(patch.body.tracking_template, SOURCE_CLICK_ID_PARAM)) {
+            warnings.push("⚠️ The new tracking template has no `source_click_id=` parameter — the " +
+                "network's click token will not be captured on linked zones' URLs.");
+        }
+        if (patch.body.status === "archived" && existing.status !== "archived") {
+            warnings.push("Archived sources stay linked to their zones and keep rendering their template; " +
+                "archiving only hides the source from active pickers.");
+        }
+        if (!args.confirm) {
+            return textResult([
+                `**Dry run** — would update traffic source \`${existing.id}\` (${existing.name}).`,
+                "",
+                renderDiff(changes),
+                ...(warnings.length ? ["", ...warnings] : []),
+                "",
+                "Call again with `confirm: true` to apply.",
+            ].join("\n"));
+        }
+        const updated = await client.put(`/api/traffic-sources/${encodeURIComponent(args.traffic_source_id)}`, patch.body);
+        return textResult([
+            `✅ Traffic source \`${updated.id}\` updated.`,
+            "",
+            renderDiff(changes),
+            ...(warnings.length ? ["", ...warnings] : []),
+        ].join("\n"));
+    }
+    catch (err) {
+        return errorResult(err);
+    }
+}
+function buildPatch(args) {
+    const body = {};
+    if (args.name !== undefined)
+        body.name = args.name;
+    if (args.status !== undefined)
+        body.status = args.status;
+    // Templates clear with "" — the server rejects null for them (api_token is the
+    // one field where null also clears).
+    if (args.tracking_template !== undefined) {
+        const value = args.tracking_template === null ? "" : args.tracking_template.trim();
+        if (value && /^[?&]/.test(value)) {
+            return {
+                error: "tracking_template must not start with ? or & — it is appended after ? automatically.",
+            };
+        }
+        body.tracking_template = value;
+    }
+    if (args.postback_template !== undefined) {
+        const value = args.postback_template === null ? "" : args.postback_template.trim();
+        if (value) {
+            const err = httpUrlError(value, "postback_template");
+            if (err)
+                return { error: err };
+        }
+        body.postback_template = value;
+    }
+    if (args.api_token !== undefined) {
+        body.api_token = args.api_token === null ? null : args.api_token.trim();
+    }
+    return { body };
+}
+/**
+ * api_token never round-trips: the existing row only carries has_api_token, and
+ * the diff must not echo the new value either.
+ */
+function diffSource(existing, body) {
+    const changes = [];
+    for (const [field, to] of Object.entries(body)) {
+        if (field === "api_token") {
+            const from = existing.has_api_token ? "(set)" : "(none)";
+            const toDisplay = to === null || to === "" ? "(cleared)" : "(set — write-only)";
+            if (existing.has_api_token && (to === null || to === "")) {
+                changes.push({ field, from, to: toDisplay });
+            }
+            else if (to !== null && to !== "") {
+                changes.push({ field, from, to: toDisplay });
+            }
+            else if (!existing.has_api_token && (to === null || to === "")) {
+                // Clearing an absent token is a no-op; skip so "nothing to change" stays honest.
+            }
+            continue;
+        }
+        const from = existing[field];
+        if (String(from ?? "") === String(to ?? ""))
+            continue;
+        changes.push({ field, from: displayValue(from ?? null), to: displayValue(to) });
+    }
+    return changes;
+}
+//# sourceMappingURL=updateTrafficSource.js.map

package/dist/tools/updateZone.d.ts

@@ -0,0 +1,27 @@
+import { z } from "zod";
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { type AffsetClient } from "../client.js";
+import { ZONE_STATUSES } from "../types.js";
+export declare const UPDATE_ZONE_DESCRIPTION: string;
+export declare const updateZoneInputSchema: {
+    zone_id: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodEnum<["active", "inactive"]>>;
+    postback_url: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNull]>>;
+    site_url: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNull]>>;
+    traffic_back_url: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNull]>>;
+    traffic_source_id: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNull]>>;
+    confirm: z.ZodDefault<z.ZodBoolean>;
+};
+type UpdateZoneArgs = {
+    zone_id: string;
+    name?: string;
+    status?: (typeof ZONE_STATUSES)[number];
+    postback_url?: string | null;
+    site_url?: string | null;
+    traffic_back_url?: string | null;
+    traffic_source_id?: string | null;
+    confirm: boolean;
+};
+export declare function updateZone(client: AffsetClient, args: UpdateZoneArgs): Promise<CallToolResult>;
+export {};

package/dist/tools/updateZone.js

@@ -6,8 +6,10 @@ import { httpUrlError } from "../lib/urls.js";
 import { ZONE_STATUSES } from "../types.js";
 /** Zod: optional http(s) URL, or null to clear. */
 const clearableUrl = z.union([z.string().min(1), z.null()]);
-export const UPDATE_ZONE_DESCRIPTION = "Update a traffic-source zone (name, status, postback_url, site_url, traffic_back_url). " +
-    "Partial update — only provided fields change. Pass null for a URL field to clear it. " +
+export const UPDATE_ZONE_DESCRIPTION = "Update a traffic-source zone (name, status, postback_url, site_url, traffic_back_url, " +
+    "traffic_source_id). Partial update — only provided fields change. Pass null for a URL " +
+    "field or traffic_source_id to clear it. Linking a traffic source makes " +
+    "get_zone_url/get_tracking_link render its tracking template. " +
     "DRY-RUN by default; pass confirm=true to apply.";
 export const updateZoneInputSchema = {
     zone_id: z.string().min(1).describe("Zone id to update."),
@@ -18,6 +20,11 @@ export const updateZoneInputSchema = {
         .describe("S2S postback URL, or null to clear. Prefer including {source_click_id}."),
     site_url: clearableUrl.optional().describe("Site URL, or null to clear."),
     traffic_back_url: clearableUrl.optional().describe("Traffic-back URL, or null to clear."),
+    traffic_source_id: z
+        .union([z.string().trim().min(1), z.null()])
+        .optional()
+        .describe("Traffic source to link (see list_traffic_sources; must be in this namespace), " +
+        "or null to unlink."),
     confirm: z
         .boolean()
         .default(false)
@@ -29,7 +36,8 @@ export async function updateZone(client, args) {
         if ("error" in patch)
             return textError(patch.error);
         if (Object.keys(patch.body).length === 0) {
-            return textError("Provide at least one field to update: name, status, postback_url, site_url, traffic_back_url.");
+            return textError("Provide at least one field to update: name, status, postback_url, site_url, " +
+                "traffic_back_url, traffic_source_id.");
         }
         let existing;
         try {
@@ -103,6 +111,8 @@ function buildPatch(args) {
             return { error: err };
         body[key] = args[key];
     }
+    if (args.traffic_source_id !== undefined)
+        body.traffic_source_id = args.traffic_source_id;
     return { body };
 }
 function diffZone(existing, body) {

package/dist/tools/whoami.d.ts

@@ -0,0 +1,6 @@
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import type { AffsetClient } from "../client.js";
+import type { Config } from "../runtimeConfig.js";
+export declare const WHOAMI_DESCRIPTION: string;
+export declare const whoamiInputSchema: {};
+export declare function whoami(client: AffsetClient, config: Config): Promise<CallToolResult>;

package/dist/types.d.ts

@@ -0,0 +1,257 @@
+/** Shapes of the affset tenant API responses this server consumes. */
+/** A single grouped row from `GET /api/stats`. */
+export interface StatRow {
+    date?: string;
+    campaign_id?: string;
+    campaign_name?: string | null;
+    zone_id?: string;
+    zone_name?: string | null;
+    country?: string | null;
+    conversion_type?: string | null;
+    publisher_email?: string | null;
+    advertiser_email?: string | null;
+    sub1?: string | null;
+    sub2?: string | null;
+    sub3?: string | null;
+    sub4?: string | null;
+    sub5?: string | null;
+    impressions: number;
+    fallbacks: number;
+    unsold: number;
+    clicks: number;
+    conversions: number;
+    spend?: number;
+    payout?: number;
+    media_cost?: number;
+    /** (payout - media_cost) / media_cost; null when the slice carries no cost. */
+    roi?: number | null;
+}
+export interface StatsResponse {
+    stats: StatRow[];
+    period: {
+        from: number;
+        to: number;
+    };
+    /** Tenant display names for sub1..sub5 (e.g. sub1 -> "Zone"); {} when none set. */
+    sub_labels?: SubLabels;
+}
+export interface Pagination {
+    total: number;
+    limit: number;
+    offset: number;
+    has_more: boolean;
+}
+/**
+ * One conversion from GET /api/conversions.
+ *
+ * spend/payout are absent (key missing) when the caller's role may not see them —
+ * publisher-side roles lose `spend`, advertiser-side roles lose `payout`. `null`
+ * is different: the column is visible and simply has no amount recorded. Consumers
+ * that treat "no payout" as a signal have to tell the two apart.
+ */
+export interface Conversion {
+    ad_event_id: string;
+    namespace?: string;
+    click_id: string | null;
+    payload: string | null;
+    spend?: number | null;
+    payout?: number | null;
+    source_click_id?: string | null;
+    sub1?: string | null;
+    sub2?: string | null;
+    sub3?: string | null;
+    sub4?: string | null;
+    sub5?: string | null;
+    /** Unix ms when the conversion was recorded. */
+    created_at: number;
+}
+export interface ConversionsResponse {
+    conversions: Conversion[];
+    pagination: Pagination;
+}
+/** Campaign row from list/get. */
+export interface Campaign {
+    id: number;
+    name: string;
+    status: string;
+    redirect_url?: string | null;
+    payment_model?: string;
+    rate?: number;
+    start_date?: number | null;
+    end_date?: number | null;
+    user_email?: string | null;
+    daily_budget?: number | null;
+    total_budget?: number | null;
+    pacing?: string;
+    budget_paused?: number;
+    budget_pause_reason?: string | null;
+    silent?: number;
+    payout_goal_type?: string | null;
+    created_at?: number;
+    updated_at?: number;
+    targeting_rules?: TargetingRule[];
+}
+/** Response of POST /api/campaigns. */
+export interface CreateCampaignResponse {
+    id: number;
+    name: string;
+    status: string;
+    created_at: number;
+}
+export interface CampaignsResponse {
+    campaigns: Campaign[];
+    pagination: Pagination;
+}
+export interface Zone {
+    id: string;
+    name: string;
+    status: string;
+    site_url?: string | null;
+    traffic_back_url?: string | null;
+    postback_url?: string | null;
+    user_email?: string | null;
+    manager_email?: string | null;
+    /** Linked traffic source; its tracking template drives the URL tools. */
+    traffic_source_id?: string | null;
+    traffic_source_name?: string | null;
+    created_at?: number;
+    updated_at?: number;
+}
+export interface ZonesResponse {
+    zones: Zone[];
+    pagination: Pagination;
+}
+export interface CreateZoneResponse {
+    id: string;
+    status: string;
+    created_at: number;
+}
+export interface UpdateZoneResponse {
+    id: string;
+    updated_at: number;
+}
+export interface UpdateCampaignResponse {
+    id: number;
+    updated_at: number;
+}
+/**
+ * One row from GET /api/traffic-sources. The stored network API credential is
+ * write-only — reads carry `has_api_token`, never the token itself.
+ */
+export interface TrafficSource {
+    id: string;
+    name: string;
+    preset: string | null;
+    tracking_template: string;
+    postback_template: string;
+    has_api_token: boolean;
+    status: string;
+    created_at?: number;
+    updated_at?: number;
+    /** Present on GET /api/traffic-sources/{id} only. */
+    linked_zones?: number;
+}
+export interface TrafficSourcesResponse {
+    traffic_sources: TrafficSource[];
+    pagination: Pagination;
+}
+export interface CreateTrafficSourceResponse {
+    id: string;
+    status: string;
+    created_at: number;
+}
+export interface UpdateTrafficSourceResponse {
+    id: string;
+    updated_at: number;
+}
+/** One entry from GET /api/traffic-source-presets. */
+export interface TrafficSourcePreset {
+    id: string;
+    name: string;
+    doc_url: string;
+    tracking_template: string;
+    postback_template: string;
+    sub_meanings: Partial<Record<SubKey, string>>;
+    notes: string;
+}
+export interface TrafficSourcePresetsResponse {
+    presets: TrafficSourcePreset[];
+}
+/** Subset of GET /api/tenant this server reads. */
+export interface TenantSettingsResponse {
+    company?: string;
+    /** IANA name; every date the tools render or resolve is in this zone. */
+    timezone?: string;
+    sub_labels?: SubLabels;
+    /** Tenant's own API domain; "" when unset. Integration URLs must use it. */
+    custom_api_domain?: string;
+}
+/** One payout rule from GET/POST /api/campaigns/{id}/payout_rules. */
+export interface PayoutRule {
+    id: number;
+    campaign_id: number;
+    zone_id: string | null;
+    payout: number;
+    created_at?: number;
+}
+export interface PayoutRulesResponse {
+    payout_rules: PayoutRule[];
+}
+/**
+ * One team member from GET /api/api-keys?type=user, or the response of
+ * POST /api/api-keys?type=user (create).
+ *
+ * `token` is present in both. It is not a one-time secret — affset returns it
+ * on every list call to a permitted role, same as the dashboard's "Copy token"
+ * button — but `list_team` deliberately never echoes it anyway, since a
+ * browsing-style "show my team" query is a bad place for live credentials to
+ * repeatedly pass through model context. `create_team_member` is the
+ * considered exception: it echoes the token exactly once, on the one call
+ * that just minted it for the operator to hand to that person.
+ */
+export interface TeamMember {
+    token?: string;
+    namespace?: string;
+    user_id?: string;
+    email: string | null;
+    role: string;
+    created_at: number;
+    expires_at?: number;
+    permissions?: string[];
+    manager_email?: string;
+}
+/** Response of POST /api/api-keys?type=user — same shape as TeamMember, token always present. */
+export type CreateTeamMemberResponse = TeamMember & {
+    token: string;
+};
+export interface TargetingRule {
+    id?: number;
+    campaign_id?: string | number;
+    targeting_rule_type_id: number;
+    targeting_method: "whitelist" | "blacklist";
+    rule: string;
+}
+export interface TargetingRulesResponse {
+    targeting_rules: TargetingRule[];
+}
+export interface TargetingRuleType {
+    id: number;
+    name: string;
+    description?: string | null;
+}
+export interface TargetingRuleTypesResponse {
+    targeting_rule_types: TargetingRuleType[];
+}
+/** The five traffic-source breakdown keys. */
+export declare const SUB_KEYS: readonly ["sub1", "sub2", "sub3", "sub4", "sub5"];
+export type SubKey = (typeof SUB_KEYS)[number];
+/** Tenant display names for sub slots; only labeled slots are present. */
+export type SubLabels = Partial<Record<SubKey, string>>;
+/** Valid `group_by` dimensions accepted by `GET /api/stats`. */
+export declare const GROUP_BY_VALUES: readonly ["date", "campaign_id", "zone_id", "country", "conversion_type", "publisher_email", "advertiser_email", "sub1", "sub2", "sub3", "sub4", "sub5"];
+export type GroupBy = (typeof GROUP_BY_VALUES)[number];
+export declare const CAMPAIGN_STATUSES: readonly ["active", "paused", "archived"];
+export declare const ZONE_STATUSES: readonly ["active", "inactive"];
+export declare const TRAFFIC_SOURCE_STATUSES: readonly ["active", "archived"];
+export declare const PAYMENT_MODELS: readonly ["cpa", "cpm"];
+export declare const PACING_VALUES: readonly ["asap", "even"];

package/dist/types.js

@@ -9,10 +9,12 @@ export const GROUP_BY_VALUES = [
     "country",
     "conversion_type",
     "publisher_email",
+    "advertiser_email",
     ...SUB_KEYS,
 ];
 export const CAMPAIGN_STATUSES = ["active", "paused", "archived"];
 export const ZONE_STATUSES = ["active", "inactive"];
+export const TRAFFIC_SOURCE_STATUSES = ["active", "archived"];
 export const PAYMENT_MODELS = ["cpa", "cpm"];
 export const PACING_VALUES = ["asap", "even"];
 //# sourceMappingURL=types.js.map

package/dist/version.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Package version, duplicated from package.json so the core stays importable
+ * on runtimes without Node's module APIs (Workers). createRequire-reading
+ * package.json here would break bundlers; a sync test guards the duplicate
+ * (see registerTools.test.ts).
+ */
+export declare const VERSION = "0.3.0";

package/dist/version.js

@@ -0,0 +1,8 @@
+/**
+ * Package version, duplicated from package.json so the core stays importable
+ * on runtimes without Node's module APIs (Workers). createRequire-reading
+ * package.json here would break bundlers; a sync test guards the duplicate
+ * (see registerTools.test.ts).
+ */
+export const VERSION = "0.3.0";
+//# sourceMappingURL=version.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@affset/mcp",
-  "version": "0.1.1",
+  "version": "0.3.0",
   "mcpName": "io.github.affset/mcp",
   "description": "MCP server for the affset ad platform — stats, campaigns, zones, payouts, targeting, sub labels, and team from your chat client.",
   "type": "module",
@@ -20,6 +20,19 @@
   "bin": {
     "affset-mcp": "dist/index.js"
   },
+  "main": "./dist/core.js",
+  "types": "./dist/core.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/core.d.ts",
+      "default": "./dist/core.js"
+    },
+    "./core": {
+      "types": "./dist/core.d.ts",
+      "default": "./dist/core.js"
+    },
+    "./package.json": "./package.json"
+  },
   "files": [
     "dist",
     "!dist/**/*.test.*",
@@ -28,7 +41,7 @@
     ".env.example"
   ],
   "engines": {
-    "node": ">=18"
+    "node": ">=22.13.0"
   },
   "scripts": {
     "build": "tsc",