@affset/mcp 0.1.0

package/dist/tools/setSubLabels.js

@@ -0,0 +1,102 @@
+import { z } from "zod";
+import { mdCell } from "../lib/format.js";
+import { displayValue, renderDiff } from "../lib/patch.js";
+import { errorResult, textError, textResult } from "../lib/toolResult.js";
+import { SUB_KEYS } from "../types.js";
+/** Matches lite-adserver SUB_LABEL_MAX_LENGTH. */
+const SUB_LABEL_MAX = 40;
+const clearableLabel = z.union([z.string().max(SUB_LABEL_MAX), z.null()]);
+export const SET_SUB_LABELS_DESCRIPTION = "Set or clear tenant display names for sub1–sub5. Partial update — only provided " +
+    'keys change; pass null or "" to clear a label. Max 40 chars each. DRY-RUN by ' +
+    "default; pass confirm=true to apply. Affects stats column titles and link helpers.";
+export const setSubLabelsInputSchema = {
+    sub1: clearableLabel.optional().describe('Display name for sub1, or null/"" to clear.'),
+    sub2: clearableLabel.optional().describe('Display name for sub2, or null/"" to clear.'),
+    sub3: clearableLabel.optional().describe('Display name for sub3, or null/"" to clear.'),
+    sub4: clearableLabel.optional().describe('Display name for sub4, or null/"" to clear.'),
+    sub5: clearableLabel.optional().describe('Display name for sub5, or null/"" to clear.'),
+    confirm: z.boolean().default(false).describe("false = dry-run preview (default). true = apply."),
+};
+export async function setSubLabels(client, args) {
+    try {
+        const patch = buildPatch(args);
+        if ("error" in patch)
+            return textError(patch.error);
+        if (Object.keys(patch.updates).length === 0) {
+            return textError('Provide at least one of sub1..sub5 to set or clear (null/"" clears).');
+        }
+        const settings = await client.get("/api/tenant");
+        const current = settings.sub_labels ?? {};
+        const changes = diffLabels(current, patch.updates);
+        if (changes.length === 0) {
+            return textResult("Nothing to change — provided sub labels already match current values.");
+        }
+        if (!args.confirm) {
+            return textResult([
+                "**Dry run** — would update tenant sub labels.",
+                "",
+                renderDiff(changes),
+                "",
+                "Call again with `confirm: true` to apply.",
+            ].join("\n"));
+        }
+        const updated = await client.put("/api/tenant", {
+            sub_labels: patch.updates,
+        });
+        const next = updated.sub_labels ?? {};
+        return textResult(["✅ Sub labels updated.", "", renderDiff(changes), "", renderFinal(next)].join("\n"));
+    }
+    catch (err) {
+        return errorResult(err);
+    }
+}
+function buildPatch(args) {
+    const updates = {};
+    for (const key of SUB_KEYS) {
+        if (!(key in args) || args[key] === undefined)
+            continue;
+        const raw = args[key];
+        if (raw === null) {
+            updates[key] = null;
+            continue;
+        }
+        const trimmed = raw.trim();
+        if (trimmed.length === 0) {
+            updates[key] = null;
+            continue;
+        }
+        if (trimmed.length > SUB_LABEL_MAX) {
+            return {
+                error: `${key} must be at most ${SUB_LABEL_MAX} characters (got ${trimmed.length}).`,
+            };
+        }
+        updates[key] = trimmed;
+    }
+    return { updates };
+}
+function diffLabels(current, updates) {
+    const changes = [];
+    for (const key of SUB_KEYS) {
+        if (!(key in updates))
+            continue;
+        const from = current[key]?.trim() || null;
+        const to = updates[key] ?? null;
+        if (from === to)
+            continue;
+        changes.push({
+            field: key,
+            from: from ? mdCell(from) : displayValue(null),
+            to: to ? mdCell(to) : displayValue(null),
+        });
+    }
+    return changes;
+}
+function renderFinal(labels) {
+    const lines = ["| Key | Label |", "|---|---|"];
+    for (const key of SUB_KEYS) {
+        const label = labels[key]?.trim();
+        lines.push(`| \`${key}\` | ${label ? mdCell(label) : "_—_"} |`);
+    }
+    return lines.join("\n");
+}
+//# sourceMappingURL=setSubLabels.js.map

package/dist/tools/setTargetingRule.js

@@ -0,0 +1,125 @@
+import { z } from "zod";
+import { AffsetApiError } from "../client.js";
+import { mdCell } from "../lib/format.js";
+import { displayValue, renderDiff } from "../lib/patch.js";
+import { fetchTargetingRules, fetchTargetingTypes, normalizeRuleValue, resolveTargetingType, syncTargetingRules, toSyncPayload, UNENFORCED_TYPES, } from "../lib/targeting.js";
+import { errorResult, textError, textResult } from "../lib/toolResult.js";
+export const SET_TARGETING_RULE_DESCRIPTION = "Upsert one targeting rule on a campaign (safe merge — other rules are kept). " +
+    "Identify the type by id or name (e.g. geo, zone_id, device_type, os, browser, " +
+    "unique_users). If a rule with the same type + method already exists it is updated; " +
+    "otherwise a new one is added. `rule` is comma-separated values (geo: BR,MX; " +
+    "unique_users: visits/hours). Values are normalised to what /serve matches — an " +
+    "unmatched whitelist stops delivery. DRY-RUN by default; pass confirm=true to apply.";
+export const setTargetingRuleInputSchema = {
+    campaign_id: z.union([z.string().min(1), z.number().int()]).describe("Campaign to edit."),
+    type: z
+        .union([z.string().min(1), z.number().int()])
+        .describe('Targeting type id (number) or name (e.g. "geo", "zone_id", "device_type"). ' +
+        "Call list_targeting_types for the catalog."),
+    method: z.enum(["whitelist", "blacklist"]).describe("whitelist or blacklist."),
+    rule: z
+        .string()
+        .min(1)
+        .describe('Rule value(s). Usually comma-separated (e.g. "BR,MX", zone UUIDs, "desktop"). ' +
+        'unique_users uses "visits/hours".'),
+    confirm: z.boolean().default(false).describe("false = dry-run preview (default). true = apply."),
+};
+export async function setTargetingRule(client, args) {
+    try {
+        const campaignId = String(args.campaign_id).trim();
+        if (!campaignId)
+            return textError("campaign_id is required.");
+        const [types, current] = await Promise.all([
+            fetchTargetingTypes(client),
+            fetchTargetingRules(client, campaignId),
+        ]);
+        const resolved = resolveTargetingType(types, args.type);
+        if ("error" in resolved)
+            return textError(resolved.error);
+        const type = resolved.type;
+        const unenforced = UNENFORCED_TYPES[type.name.toLowerCase()];
+        if (unenforced) {
+            return textError(`\`${type.name}\` rules are stored by the API but ${unenforced}. ` +
+                "Setting one here would read as working targeting while the campaign keeps buying, " +
+                "so this tool does not write it.");
+        }
+        const normalized = normalizeRuleValue(type.name, args.rule);
+        if ("error" in normalized)
+            return textError(normalized.error);
+        const ruleValue = normalized.value;
+        const existing = current.find((r) => r.targeting_rule_type_id === type.id && r.targeting_method === args.method);
+        if (existing && existing.rule === ruleValue) {
+            return textResult(`Nothing to change — campaign \`${campaignId}\` already has ` +
+                `${mdCell(type.name)} ${args.method} = \`${mdCell(ruleValue)}\` ` +
+                `(rule id \`${existing.id}\`).`);
+        }
+        const diff = renderDiff([
+            {
+                field: `${type.name} (${args.method})`,
+                from: existing ? existing.rule : displayValue(null),
+                to: ruleValue,
+            },
+        ]);
+        const notes = [
+            ...normalized.notes,
+            ...opposingRuleNote(current, type.id, type.name, args.method),
+        ];
+        if (!args.confirm) {
+            const verb = existing ? "update" : "add";
+            return textResult([
+                `**Dry run** — would ${verb} targeting on campaign \`${campaignId}\`.`,
+                "",
+                diff,
+                ...(notes.length ? ["", ...notes] : []),
+                "",
+                `Type: ${mdCell(type.name)} (id ${type.id}). Other rules stay untouched.`,
+                "",
+                "Call again with `confirm: true` to apply.",
+            ].join("\n"));
+        }
+        const applied = await syncTargetingRules(client, campaignId, upsertRule(current, type.id, args.method, ruleValue));
+        const written = applied.find((r) => r.targeting_rule_type_id === type.id && r.targeting_method === args.method);
+        return textResult([
+            `✅ Targeting ${existing ? "updated" : "added"} on campaign \`${campaignId}\`` +
+                (written?.id != null ? ` (rule id \`${written.id}\`)` : "") +
+                ".",
+            "",
+            diff,
+            ...(notes.length ? ["", ...notes] : []),
+        ].join("\n"));
+    }
+    catch (err) {
+        if (err instanceof AffsetApiError && err.status === 404) {
+            return textError(`Campaign \`${String(args.campaign_id).trim()}\` not found in this namespace.`);
+        }
+        return errorResult(err);
+    }
+}
+/**
+ * A whitelist and a blacklist of the same type both apply, and the blacklist
+ * wins on any overlap — easy to set by accident when the intent was to replace
+ * the other one.
+ */
+function opposingRuleNote(rules, typeId, typeName, method) {
+    const opposite = method === "whitelist" ? "blacklist" : "whitelist";
+    const other = rules.find((r) => r.targeting_rule_type_id === typeId && r.targeting_method === opposite);
+    if (!other)
+        return [];
+    return [
+        `⚠️ Campaign also has a ${typeName} **${opposite}** (\`${mdCell(other.rule)}\`) — ` +
+            `both apply. Use \`remove_targeting_rule\` if it should be replaced instead.`,
+    ];
+}
+/** Echo every existing rule (with id) and upsert the matching type+method slot. */
+function upsertRule(rules, typeId, method, rule) {
+    const next = toSyncPayload(rules);
+    const target = next.find((r) => r.targeting_rule_type_id === typeId && r.targeting_method === method);
+    if (target) {
+        target.rule = rule;
+    }
+    else {
+        next.push({ targeting_rule_type_id: typeId, targeting_method: method, rule });
+    }
+    return next;
+}
+//# sourceMappingURL=setTargetingRule.js.map

package/dist/tools/updateCampaign.js

@@ -0,0 +1,218 @@
+import { z } from "zod";
+import { AffsetApiError } from "../client.js";
+import { displayValue, renderDiff } from "../lib/patch.js";
+import { money } from "../lib/format.js";
+import { parseCampaignDateBound } from "../lib/time.js";
+import { errorResult, textError, textResult } from "../lib/toolResult.js";
+import { httpUrlError } from "../lib/urls.js";
+import { CAMPAIGN_STATUSES, PACING_VALUES, PAYMENT_MODELS, } from "../types.js";
+export const UPDATE_CAMPAIGN_DESCRIPTION = "Update a campaign (partial): name, offer URL (redirect_url), status, rate, " +
+    "payment_model, start/end dates, daily/total budget, pacing. DRY-RUN by default; " +
+    "pass confirm=true to apply. For run/pause prefer set_campaign_status. Activating " +
+    "a paused campaign can hit the plan's active-campaign limit (402). Targeting rules " +
+    "and payout rules are separate tools.";
+export const updateCampaignInputSchema = {
+    campaign_id: z.union([z.string().min(1), z.number().int()]).describe("Campaign id to update."),
+    name: z.string().min(1).max(200).optional().describe("New campaign name."),
+    redirect_url: z
+        .string()
+        .min(1)
+        .optional()
+        .describe("Offer / lander URL (redirect target). http(s) required."),
+    status: z
+        .enum(CAMPAIGN_STATUSES)
+        .optional()
+        .describe("active | paused | archived. active enters /serve rotation (plan limit)."),
+    payment_model: z.enum(PAYMENT_MODELS).optional().describe("cpa or cpm."),
+    rate: z
+        .number()
+        .min(0)
+        .optional()
+        .describe("Internal advertiser rate (usually 0 for media-buying)."),
+    start_date: z
+        .union([z.string(), z.number(), z.null()])
+        .optional()
+        .describe("Start bound: YYYY-MM-DD (tenant-local start of day), ISO timestamp with Z/UTC offset, epoch ms, or null to clear."),
+    end_date: z
+        .union([z.string(), z.number(), z.null()])
+        .optional()
+        .describe("End bound: YYYY-MM-DD (tenant-local end of day), ISO timestamp with Z/UTC offset, epoch ms, or null to clear."),
+    daily_budget: z
+        .union([z.number().min(0), z.null()])
+        .optional()
+        .describe("Daily budget cap in USD, or null to clear."),
+    total_budget: z
+        .union([z.number().min(0), z.null()])
+        .optional()
+        .describe("Total budget cap in USD, or null to clear."),
+    pacing: z.enum(PACING_VALUES).optional().describe("Budget pacing: asap or even."),
+    confirm: z
+        .boolean()
+        .default(false)
+        .describe("false = dry-run preview (default). true = apply the update."),
+};
+export async function updateCampaign(client, args) {
+    try {
+        const campaignId = String(args.campaign_id).trim();
+        if (!campaignId)
+            return textError("campaign_id is required.");
+        const needsTenantTimezone = [args.start_date, args.end_date].some((value) => typeof value === "string" && /^\d{4}-\d{2}-\d{2}$/.test(value.trim()));
+        const timeZone = needsTenantTimezone ? await client.getRequiredTenantTimezone() : "UTC";
+        const patch = buildPatch(args, timeZone);
+        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, redirect_url, status, payment_model, " +
+                "rate, start_date, end_date, daily_budget, total_budget, pacing.");
+        }
+        let existing;
+        try {
+            existing = 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 dateError = validateDateOrder(existing, patch.body);
+        if (dateError)
+            return textError(dateError);
+        const changes = diffCampaign(existing, patch.body);
+        if (changes.length === 0) {
+            return textResult(`Nothing to change on campaign \`${existing.id}\` (${existing.name}) — ` +
+                "provided fields already match current values.");
+        }
+        const warnings = buildWarnings(existing, patch.body);
+        if (!args.confirm) {
+            return textResult([
+                `**Dry run** — would update campaign \`${existing.id}\` (${existing.name}).`,
+                "",
+                renderDiff(changes),
+                ...(warnings.length ? ["", ...warnings] : []),
+                "",
+                "Call again with `confirm: true` to apply.",
+            ].join("\n"));
+        }
+        const updated = await client.put(`/api/campaigns/${encodeURIComponent(campaignId)}`, patch.body);
+        return textResult([
+            `✅ Campaign \`${updated.id}\` updated.`,
+            "",
+            renderDiff(changes),
+            ...(warnings.length ? ["", ...warnings] : []),
+        ].join("\n"));
+    }
+    catch (err) {
+        return errorResult(err);
+    }
+}
+function buildPatch(args, timeZone) {
+    const body = {};
+    if (args.name !== undefined) {
+        const name = args.name.trim();
+        if (!name)
+            return { error: "name must be a non-empty string." };
+        body.name = name;
+    }
+    if (args.redirect_url !== undefined) {
+        const err = httpUrlError(args.redirect_url, "redirect_url");
+        if (err)
+            return { error: err };
+        body.redirect_url = args.redirect_url;
+    }
+    if (args.status !== undefined)
+        body.status = args.status;
+    if (args.payment_model !== undefined)
+        body.payment_model = args.payment_model;
+    if (args.rate !== undefined)
+        body.rate = args.rate;
+    if (args.pacing !== undefined)
+        body.pacing = args.pacing;
+    if (args.daily_budget !== undefined)
+        body.daily_budget = args.daily_budget;
+    if (args.total_budget !== undefined)
+        body.total_budget = args.total_budget;
+    if (args.start_date !== undefined) {
+        const parsed = parseDateBound(args.start_date, "start_date", timeZone);
+        if ("error" in parsed)
+            return parsed;
+        body.start_date = parsed.value;
+    }
+    if (args.end_date !== undefined) {
+        const parsed = parseDateBound(args.end_date, "end_date", timeZone);
+        if ("error" in parsed)
+            return parsed;
+        body.end_date = parsed.value;
+    }
+    return { body };
+}
+/**
+ * YYYY-MM-DD → tenant-local start-of-day for start_date, end-of-day for end_date
+ * (so "end 2026-07-25" keeps the campaign live through that calendar day).
+ */
+function parseDateBound(value, label, timeZone) {
+    try {
+        return {
+            value: parseCampaignDateBound(value, label === "start_date" ? "start" : "end", timeZone),
+        };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { error: `Invalid ${label}: ${message}` };
+    }
+}
+/** Reject inverted ranges against the patch and/or the existing campaign. */
+function validateDateOrder(existing, body) {
+    const start = body.start_date !== undefined ? body.start_date : (existing.start_date ?? null);
+    const end = body.end_date !== undefined ? body.end_date : (existing.end_date ?? null);
+    if (typeof start === "number" && typeof end === "number" && end <= start) {
+        return "end_date must be after start_date.";
+    }
+    return undefined;
+}
+function diffCampaign(existing, body) {
+    const changes = [];
+    for (const [field, to] of Object.entries(body)) {
+        const from = existing[field];
+        if (normalizeCompare(from) === normalizeCompare(to))
+            continue;
+        changes.push({
+            field,
+            from: formatField(field, from),
+            to: formatField(field, to),
+        });
+    }
+    return changes;
+}
+function normalizeCompare(value) {
+    if (value === undefined || value === null)
+        return "";
+    return String(value);
+}
+function formatField(field, value) {
+    if (value === undefined || value === null)
+        return displayValue(value ?? null);
+    if ((field === "daily_budget" || field === "total_budget" || field === "rate") &&
+        typeof value === "number") {
+        return field === "rate" ? String(value) : money(value);
+    }
+    if ((field === "start_date" || field === "end_date") && typeof value === "number") {
+        return new Date(value).toISOString();
+    }
+    return displayValue(value);
+}
+function buildWarnings(existing, body) {
+    const warnings = [];
+    if (body.status === "active" && existing.status !== "active") {
+        warnings.push("⚠️ Activating enables direct tracking links, enters `/serve` rotation, and counts against the plan's " +
+            "**active campaigns** limit (API returns 402 if exceeded).");
+    }
+    if (body.status === "archived" && existing.status !== "archived") {
+        warnings.push("⚠️ Archiving disables direct tracking links and removes the campaign from /serve.");
+    }
+    if (body.redirect_url !== undefined && body.redirect_url !== existing.redirect_url) {
+        warnings.push("⚠️ Changing redirect_url changes where clicks land immediately.");
+    }
+    return warnings;
+}
+//# sourceMappingURL=updateCampaign.js.map

package/dist/tools/updateZone.js

@@ -0,0 +1,118 @@
+import { z } from "zod";
+import { AffsetApiError } from "../client.js";
+import { displayValue, renderDiff } from "../lib/patch.js";
+import { errorResult, textError, textResult } from "../lib/toolResult.js";
+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. " +
+    "DRY-RUN by default; pass confirm=true to apply.";
+export const updateZoneInputSchema = {
+    zone_id: z.string().min(1).describe("Zone id to update."),
+    name: z.string().min(1).max(200).optional().describe("New display name."),
+    status: z.enum(ZONE_STATUSES).optional().describe("active or inactive."),
+    postback_url: clearableUrl
+        .optional()
+        .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."),
+    confirm: z
+        .boolean()
+        .default(false)
+        .describe("false = dry-run preview (default). true = apply the update."),
+};
+export async function updateZone(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, status, postback_url, site_url, traffic_back_url.");
+        }
+        let existing;
+        try {
+            existing = await client.get(`/api/zones/${encodeURIComponent(args.zone_id)}`);
+        }
+        catch (err) {
+            if (err instanceof AffsetApiError && err.status === 404) {
+                return textError(`Zone \`${args.zone_id}\` not found in this namespace.`);
+            }
+            throw err;
+        }
+        const changes = diffZone(existing, patch.body);
+        if (changes.length === 0) {
+            return textResult(`Nothing to change on zone \`${existing.id}\` (${existing.name}) — ` +
+                "provided fields already match current values.");
+        }
+        const warnings = [];
+        if (patch.body.status === "inactive" && existing.status !== "inactive") {
+            warnings.push("⚠️ Setting status to **inactive** makes both /serve and direct tracking links " +
+                "for this zone return 404 until it is reactivated.");
+        }
+        if ("postback_url" in patch.body &&
+            (patch.body.postback_url === null || patch.body.postback_url === "")) {
+            warnings.push("⚠️ Clearing postback_url means the traffic source will stop receiving conversion postbacks.");
+        }
+        else if (typeof patch.body.postback_url === "string" &&
+            !patch.body.postback_url.includes("{source_click_id}")) {
+            warnings.push("⚠️ postback_url has no `{source_click_id}` — the source may not attribute conversions.");
+        }
+        if (!args.confirm) {
+            return textResult([
+                `**Dry run** — would update zone \`${existing.id}\` (${existing.name}).`,
+                "",
+                renderDiff(changes),
+                ...(warnings.length ? ["", ...warnings] : []),
+                "",
+                "Call again with `confirm: true` to apply.",
+            ].join("\n"));
+        }
+        const updated = await client.put(`/api/zones/${encodeURIComponent(args.zone_id)}`, patch.body);
+        return textResult([
+            `✅ Zone \`${updated.id}\` updated.`,
+            "",
+            renderDiff(changes),
+            ...(warnings.length ? ["", ...warnings] : []),
+        ].join("\n"));
+    }
+    catch (err) {
+        return errorResult(err);
+    }
+}
+function buildPatch(args) {
+    const body = {};
+    if (args.name !== undefined) {
+        const name = args.name.trim();
+        if (!name)
+            return { error: "name must be a non-empty string." };
+        body.name = name;
+    }
+    if (args.status !== undefined)
+        body.status = args.status;
+    for (const key of ["postback_url", "site_url", "traffic_back_url"]) {
+        if (args[key] === undefined)
+            continue;
+        if (args[key] === null) {
+            body[key] = null;
+            continue;
+        }
+        const err = httpUrlError(args[key], key);
+        if (err)
+            return { error: err };
+        body[key] = args[key];
+    }
+    return { body };
+}
+function diffZone(existing, body) {
+    const changes = [];
+    for (const [field, to] of Object.entries(body)) {
+        const from = existing[field];
+        if (String(from ?? "") === String(to ?? ""))
+            continue;
+        changes.push({ field, from: displayValue(from ?? null), to: displayValue(to) });
+    }
+    return changes;
+}
+//# sourceMappingURL=updateZone.js.map

package/dist/tools/whoami.js

@@ -0,0 +1,42 @@
+import { mdCell } from "../lib/format.js";
+import { textResult } from "../lib/toolResult.js";
+export const WHOAMI_DESCRIPTION = "Return the tenant this MCP server is bound to: namespace, API base URL, and the " +
+    "derived dashboard URL (https://{namespace}.affset.com) — everything you need to " +
+    "hand the operator a working deep link, or to pick the right host for a URL you " +
+    "were about to guess. Also reports the tenant's company name, timezone and custom " +
+    "API domain when the /api/tenant read succeeds. Read-only, no side effects. " +
+    "Call this once at the start of a session instead of guessing the namespace from " +
+    "the owner's email — one MCP instance = exactly one tenant, and that binding is " +
+    "already fixed at startup.";
+export const whoamiInputSchema = {};
+export async function whoami(client, config) {
+    const dashboardUrl = `https://${config.namespace}.affset.com`;
+    // Tenant fetch is best-effort: config values are enough on their own.
+    let tenant = null;
+    let tenantError = null;
+    try {
+        tenant = await client.get("/api/tenant");
+    }
+    catch (err) {
+        tenantError = err instanceof Error ? err.message : String(err);
+    }
+    const customApiDomain = tenant?.custom_api_domain?.trim() || "";
+    const lines = [
+        `**Tenant** \`${mdCell(config.namespace)}\``,
+        "",
+        "| Field | Value |",
+        "|---|---|",
+        `| Namespace | \`${mdCell(config.namespace)}\` |`,
+        `| Dashboard | ${dashboardUrl} |`,
+        `| API base URL | ${mdCell(config.baseUrl)} |`,
+        `| Custom API domain | ${customApiDomain ? mdCell(customApiDomain) : "_(not set — API base is the effective public origin)_"} |`,
+        `| Company | ${tenant?.company ? mdCell(tenant.company) : "—"} |`,
+        `| Timezone | ${tenant?.timezone ? mdCell(tenant.timezone) : "—"} |`,
+    ];
+    if (tenantError) {
+        lines.push("");
+        lines.push(`⚠️ Could not read /api/tenant: ${mdCell(tenantError)}. Namespace / dashboard / API base above still valid (from local config).`);
+    }
+    return textResult(lines.join("\n"));
+}
+//# sourceMappingURL=whoami.js.map

package/dist/types.js

@@ -0,0 +1,18 @@
+/** Shapes of the affset tenant API responses this server consumes. */
+/** The five traffic-source breakdown keys. */
+export const SUB_KEYS = ["sub1", "sub2", "sub3", "sub4", "sub5"];
+/** Valid `group_by` dimensions accepted by `GET /api/stats`. */
+export const GROUP_BY_VALUES = [
+    "date",
+    "campaign_id",
+    "zone_id",
+    "country",
+    "conversion_type",
+    "publisher_email",
+    ...SUB_KEYS,
+];
+export const CAMPAIGN_STATUSES = ["active", "paused", "archived"];
+export const ZONE_STATUSES = ["active", "inactive"];
+export const PAYMENT_MODELS = ["cpa", "cpm"];
+export const PACING_VALUES = ["asap", "even"];
+//# sourceMappingURL=types.js.map