@sendinel/mcp-server 1.0.4 → 1.0.5

package/build/lib/svg-sanitize.js

@@ -0,0 +1,110 @@
+// Self-contained port of packages/dashboard/lib/validation/svg-sanitize.ts —
+// see ssrf-pinned-fetch.ts for why this is a copy, not a cross-package import.
+import { XMLBuilder, XMLParser, XMLValidator } from 'fast-xml-parser';
+// ALLOWLIST, not blocklist. A blocklist lets any tag it doesn't know about through —
+// and SVG has active-content vectors beyond the obvious <script>: animation elements
+// (<set>/<animate>/<animateTransform>) inject event handlers/hrefs at render time,
+// <use>/<image> pull external/data refs, <style> carries CSS injection, <a> carries
+// links. Only known-safe PRESENTATIONAL elements survive; everything else (and its
+// subtree) is dropped. DOM-free (fast-xml-parser) so it pulls no jsdom.
+const allowedTags = new Set([
+    'svg', 'g', 'defs', 'symbol', 'title', 'desc', 'a',
+    'path', 'rect', 'circle', 'ellipse', 'line', 'polyline', 'polygon',
+    'text', 'tspan', 'textpath',
+    'lineargradient', 'radialgradient', 'stop', 'pattern', 'clippath', 'mask', 'marker',
+    'filter', 'fedropshadow', 'fegaussianblur', 'fecolormatrix', 'feoffset', 'feblend',
+    'femerge', 'femergenode', 'fecomposite', 'feflood', 'fetile', 'feturbulence',
+    'fedisplacementmap', 'fespecularlighting', 'fediffuselighting', 'fepointlight',
+    'fespotlight', 'fedistantlight', 'fecomponenttransfer', 'fefunca', 'fefuncr',
+    'fefuncg', 'fefuncb', 'feconvolvematrix', 'femorphology',
+]);
+const urlAttributes = new Set(['href', 'xlink:href', 'src', 'xlink:src']);
+const parserOptions = {
+    allowBooleanAttributes: true,
+    ignoreAttributes: false,
+    parseAttributeValue: false,
+    parseTagValue: false,
+    trimValues: false,
+};
+const parser = new XMLParser(parserOptions);
+const builder = new XMLBuilder(parserOptions);
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function normalizeName(name) {
+    return name.startsWith('@_') ? name.slice(2).toLowerCase() : name.toLowerCase();
+}
+function decodeEntities(value) {
+    return value
+        .replace(/&#x([0-9a-f]+);?/gi, (_, h) => String.fromCodePoint(parseInt(h, 16)))
+        .replace(/&#(\d+);?/g, (_, d) => String.fromCodePoint(parseInt(d, 10)))
+        .replace(/&lt;/gi, '<').replace(/&gt;/gi, '>').replace(/&quot;/gi, '"')
+        .replace(/&apos;/gi, "'").replace(/&amp;/gi, '&');
+}
+function isUnsafeAttribute(name, value) {
+    const normalizedName = normalizeName(name);
+    if (normalizedName.startsWith('on'))
+        return true;
+    if (normalizedName.startsWith('data-'))
+        return true;
+    if (normalizedName === 'style')
+        return true;
+    if (typeof value !== 'string')
+        return false;
+    const normalizedValue = decodeEntities(value).replace(/\s+/g, '').toLowerCase();
+    if (normalizedValue.includes('javascript:'))
+        return true;
+    if (normalizedValue.includes('vbscript:'))
+        return true;
+    if (urlAttributes.has(normalizedName) && normalizedValue.startsWith('data:'))
+        return true;
+    return false;
+}
+function sanitizeNode(value) {
+    if (Array.isArray(value)) {
+        return value.map(sanitizeNode).filter((item) => item !== undefined);
+    }
+    if (!isRecord(value)) {
+        return value;
+    }
+    const sanitized = {};
+    for (const [key, child] of Object.entries(value)) {
+        if (key.startsWith('@_')) {
+            if (!isUnsafeAttribute(key, child))
+                sanitized[key] = child;
+            continue;
+        }
+        if (key === '#text') {
+            sanitized[key] = child;
+            continue;
+        }
+        if (!allowedTags.has(normalizeName(key)))
+            continue;
+        const sanitizedChild = sanitizeNode(child);
+        if (sanitizedChild !== undefined) {
+            sanitized[key] = sanitizedChild;
+        }
+    }
+    return sanitized;
+}
+export function sanitizeSvg(svg) {
+    if (XMLValidator.validate(svg) !== true) {
+        return '';
+    }
+    const parsed = parser.parse(svg);
+    if (!isRecord(parsed) || !isRecord(parsed.svg)) {
+        return '';
+    }
+    const sanitized = sanitizeNode({ svg: parsed.svg });
+    if (!isRecord(sanitized)) {
+        return '';
+    }
+    return builder
+        .build(sanitized)
+        .replace(/\s+on[a-z]+\s*=\s*("[^"]*"|'[^']*'|[^\s>]+)/gi, '')
+        .replace(/\s+(href|xlink:href|src)\s*=\s*("|')\s*javascript:[\s\S]*?\2/gi, '')
+        .replace(/\s+(href|xlink:href|src)\s*=\s*("|')\s*data:[\s\S]*?\2/gi, '');
+}
+export function sanitizeSvgBytes(bytes) {
+    return Buffer.from(sanitizeSvg(Buffer.from(bytes).toString('utf8')), 'utf8');
+}

package/build/lib/webhook-events.d.ts

@@ -1,4 +1,4 @@
-export type WebhookEvent = 'campaign.activated' | 'campaign.completed' | 'campaign.paused' | 'email.delivered' | 'email.bounced' | 'email.complained' | 'bounce_rate.warning' | 'domain.dns_lost' | 'approval.requested' | 'approval.decided' | 'social.post.created' | 'social.post.updated' | 'social.post.scheduled' | 'social.post.published' | 'social.post.failed' | 'social.post.archived';
+export type WebhookEvent = 'campaign.activated' | 'campaign.completed' | 'campaign.paused' | 'email.delivered' | 'email.bounced' | 'email.complained' | 'bounce_rate.warning' | 'domain.dns_lost' | 'approval.requested' | 'approval.decided' | 'social.post.created' | 'social.post.updated' | 'social.post.scheduled' | 'social.post.published' | 'social.post.failed' | 'social.post.archived' | 'asset_link.viewed';
 /**
  * Fire a webhook event to all active subscriptions matching the event type.
  * Non-blocking — failures are logged to webhook_deliveries for retry.

package/build/scoped-token.d.ts

@@ -0,0 +1,11 @@
+export declare const SCOPED_TOKEN_SCOPES: readonly ["data", "service:provision"];
+export type ScopedTokenScope = (typeof SCOPED_TOKEN_SCOPES)[number];
+export type ScopedTokenClaims = {
+    userId: string;
+    projectId: string | null;
+    workspaceId: string | null;
+    scope: ScopedTokenScope;
+};
+export declare function scopedJwtVerificationEnabled(): boolean;
+export declare function looksLikeScopedJwt(token: string): boolean;
+export declare function verifyScopedToken(token: string): Promise<ScopedTokenClaims>;

package/build/scoped-token.js

@@ -0,0 +1,59 @@
+import { createRemoteJWKSet, jwtVerify } from 'jose';
+const ISSUER = 'synchronex';
+const AUDIENCE = 'sendinel';
+const ALGORITHM = 'RS256';
+const MAX_TOKEN_AGE = '5m';
+export const SCOPED_TOKEN_SCOPES = ['data', 'service:provision'];
+let jwks = null;
+export function scopedJwtVerificationEnabled() {
+    return Boolean(process.env.SYNCHRONEX_JWKS_URL);
+}
+export function looksLikeScopedJwt(token) {
+    return !token.startsWith('snk_') && token.split('.').length === 3;
+}
+function getJwks() {
+    if (!jwks) {
+        const url = process.env.SYNCHRONEX_JWKS_URL;
+        if (!url)
+            throw new Error('SYNCHRONEX_JWKS_URL is not configured');
+        jwks = createRemoteJWKSet(new URL(url));
+    }
+    return jwks;
+}
+export async function verifyScopedToken(token) {
+    const { payload } = await jwtVerify(token, getJwks(), {
+        issuer: ISSUER,
+        audience: AUDIENCE,
+        algorithms: [ALGORITHM],
+        requiredClaims: ['sub', 'scope', 'sendinel_project_id', 'iat', 'exp'],
+        maxTokenAge: MAX_TOKEN_AGE,
+    });
+    const userId = typeof payload.sub === 'string' ? payload.sub.trim() : '';
+    const scope = typeof payload.scope === 'string' ? payload.scope : '';
+    const projectId = typeof payload.sendinel_project_id === 'string'
+        ? payload.sendinel_project_id.trim()
+        : null;
+    const workspaceId = typeof payload.workspace_id === 'string'
+        ? payload.workspace_id.trim()
+        : null;
+    if (!userId)
+        throw new Error('Scoped token subject is required');
+    if (!SCOPED_TOKEN_SCOPES.includes(scope)) {
+        throw new Error('Scoped token scope is invalid');
+    }
+    if (scope === 'data' && !projectId) {
+        throw new Error('Data-scoped token project is required');
+    }
+    if (payload.sendinel_project_id !== null && typeof payload.sendinel_project_id !== 'string') {
+        throw new Error('Scoped token project claim is invalid');
+    }
+    if (payload.workspace_id !== null && payload.workspace_id !== undefined && typeof payload.workspace_id !== 'string') {
+        throw new Error('Scoped token workspace claim is invalid');
+    }
+    return {
+        userId,
+        projectId,
+        workspaceId,
+        scope: scope,
+    };
+}

package/build/server.js

@@ -1,3 +1,4 @@
+import { runWithToolContext } from './db.js';
 import { registerAnalyticsTools } from './tools/analytics.js';
 import { registerCampaignTools } from './tools/campaigns.js';
 import { registerContactTools } from './tools/contacts.js';
@@ -21,6 +22,11 @@ import { registerOrgTools } from './tools/org.js';
 import { registerSmsTools } from './tools/sms.js';
 import { registerSocialPostTools } from './tools/social-posts.js';
 import { registerDataProposalTools } from './tools/data-proposals.js';
+import { registerSurveyTools } from './tools/surveys.js';
+import { registerShortLinkTools } from './tools/short-links.js';
+import { registerAiWorkTools } from './tools/ai-work.js';
+import { registerBrandKitTools } from './tools/brand-kit.js';
+import { registerNewsletterTools } from './tools/newsletters.js';
 const GROUP_REGISTRY = {
     analytics: registerAnalyticsTools,
     campaigns: registerCampaignTools,
@@ -45,6 +51,11 @@ const GROUP_REGISTRY = {
     sms: registerSmsTools,
     'social-posts': registerSocialPostTools,
     'data-proposals': registerDataProposalTools,
+    surveys: registerSurveyTools,
+    'short-links': registerShortLinkTools,
+    'ai-work': registerAiWorkTools,
+    brand_kit: registerBrandKitTools,
+    newsletters: registerNewsletterTools,
 };
 export const ALL_TOOL_GROUPS = Object.keys(GROUP_REGISTRY);
 // ── Scope enforcement ─────────────────────────────────────────────────────
@@ -53,8 +64,9 @@ const WRITE_TOOLS = new Set([
     'add_subscriber', 'import_subscribers', 'update_subscriber',
     'enrich_subscriber',
     'create_campaign', 'update_campaign', 'delete_campaign', 'add_campaign_step', 'update_campaign_status',
+    'review_campaign_portfolio',
     'list_campaign_steps', 'update_campaign_step', 'delete_campaign_step',
-    'enroll_contact', 'enroll_segment', 'get_enrollment_status', 'clone_campaign', 'generate_email',
+    'enroll_contact', 'enroll_segment', 'broadcast_to_segment', 'get_enrollment_status', 'clone_campaign', 'generate_email',
     'create_social_campaign', 'schedule_social_post',
     'create_social_post', 'update_social_post', 'delete_social_post',
     'create_draft', 'approve_draft', 'reject_draft',
@@ -67,13 +79,17 @@ const WRITE_TOOLS = new Set([
     'send_test_email', 'send_transactional', 'subscribe_webhook', 'update_webhook_subscription',
     'create_ab_test', 'promote_ab_winner', 'optimize_subject_lines',
     'unsubscribe_subscriber', 'add_suppression', 'remove_suppression',
-    'trigger_automation', 'enroll_automation',
+    'trigger_automation', 'enroll_automation', 'create_escalation_ladder', 'enroll_in_escalation_ladder',
     'update_scoring_rules', 'register_domain',
     'update_warmup_schedule', 'pause_warmup', 'resume_warmup',
     'create_form', 'invite_team_member',
+    'start_provider_switch', 'get_provider_switch_status', 'rollback_provider_switch',
     'create_api_key', 'revoke_api_key', 'mark_notifications_read',
     'migrate_campaigns_from', 'start_platform_migration',
     'create_content_block', 'delete_content_block', 'trigger_content_pipeline',
+    'create_asset_link',
+    'set_white_label_settings', 'add_white_label_domain',
+    'create_blog_post',
     'run_list_hygiene', 'run_portfolio_analysis',
     'abuse_monitor_override',
     'send_sms', 'send_sms_campaign', 'set_contact_sms_consent',
@@ -81,6 +97,12 @@ const WRITE_TOOLS = new Set([
     'connect_platform', 'disconnect_platform', 'configure_platform_trigger',
     'update_brand_voice', 'promote_draft_to_campaign',
     'propose_campaign_from_data', 'approve_data_proposal',
+    'create_survey', 'update_survey', 'create_short_link', 'generate_qr_code',
+    'mark_ai_work_item_seen', 'snooze_ai_work_item', 'dismiss_ai_work_item',
+    'submit_ai_context_event',
+    'import_brand_kit_text', 'ingest_brand_assets_by_url', 'upload_brand_asset',
+    'create_newsletter', 'update_newsletter', 'create_newsletter_issue', 'schedule_newsletter_issue',
+    'send_newsletter_issue', 'subscribe_to_newsletter', 'unsubscribe_from_newsletter',
 ]);
 const ADMIN_TOOLS = new Set([
     'delete_subscriber_data', 'list_deletion_log',
@@ -93,6 +115,7 @@ const ADMIN_TOOLS = new Set([
     'tenant_export_full',
     'identify_inactive', 'delete_segment',
     'merge_subscribers', 'delete_webhook_subscription',
+    'set_white_label_settings', 'add_white_label_domain',
 ]);
 const SCOPE_HIERARCHY = { read: 1, write: 2, admin: 3 };
 export function getRequiredScope(name) {
@@ -122,12 +145,12 @@ export function getRegisteredToolGroups(options) {
             toolGroups[name] = currentGroup;
         },
     };
-    const effectiveServer = createScopeProxy(collector, options?.scopes?.length ? options.scopes : null);
     for (const group of groups) {
         const register = GROUP_REGISTRY[group];
         if (!register)
             continue;
         currentGroup = group;
+        const effectiveServer = createScopeProxy(collector, options?.scopes?.length ? options.scopes : null, group);
         register(effectiveServer);
     }
     return toolGroups;
@@ -183,7 +206,7 @@ function scanToolDefinition(name, config) {
  * and wraps handlers with scope enforcement.
  */
 // scopes=null means no scope restriction (all tools allowed) but scan still runs.
-function createScopeProxy(server, scopes) {
+function createScopeProxy(server, scopes, toolGroup) {
     return new Proxy(server, {
         get(target, prop, receiver) {
             if (prop === 'registerTool') {
@@ -210,11 +233,11 @@ function createScopeProxy(server, scopes) {
                             if (!scopeAllows(scopes, required)) {
                                 return { content: [{ type: 'text', text: `Forbidden: this action requires "${required}" scope.` }] };
                             }
-                            return handler(...args);
+                            return runWithToolContext(toolGroup, name, () => handler(...args));
                         };
                         return target.registerTool(name, config, guardedHandler);
                     }
-                    return target.registerTool(name, config, handler);
+                    return target.registerTool(name, config, (...args) => runWithToolContext(toolGroup, name, () => handler(...args)));
                 };
             }
             return Reflect.get(target, prop, receiver);
@@ -225,11 +248,9 @@ export function registerAllTools(server, options) {
     const groups = options?.toolGroups === undefined
         ? ALL_TOOL_GROUPS
         : options.toolGroups;
-    // Always wrap — scanner runs for every caller, scope enforcement only when scopes provided
-    const effectiveServer = createScopeProxy(server, options?.scopes?.length ? options.scopes : null);
     for (const group of groups) {
         const register = GROUP_REGISTRY[group];
         if (register)
-            register(effectiveServer);
+            register(createScopeProxy(server, options?.scopes?.length ? options.scopes : null, group));
     }
 }

package/build/tools/ab-testing.js

@@ -5,6 +5,13 @@ const txt = (text) => ({ content: [{ type: 'text', text }] });
 const j = (data) => txt(JSON.stringify(data, null, 2));
 export function registerAbTestingTools(server) {
     server.registerTool('create_ab_test', {
+        title: 'Create A/B Test',
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: false,
+            openWorldHint: false,
+        },
         description: 'Create an A/B test for a campaign step. Requires at least 2 variant steps (add via add_campaign_step with variant_label). Returns the test config for review.',
         inputSchema: {
             campaign_id: z.string().uuid(),
@@ -72,6 +79,13 @@ export function registerAbTestingTools(server) {
         });
     });
     server.registerTool('list_ab_tests', {
+        title: 'List A/B Tests',
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
         description: 'List A/B tests, optionally filtered by campaign or status',
         inputSchema: {
             campaign_id: z.string().uuid().optional(),
@@ -95,6 +109,13 @@ export function registerAbTestingTools(server) {
         return j(data);
     });
     server.registerTool('check_ab_significance', {
+        title: 'Check A/B Significance',
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
         description: 'Check statistical significance of an A/B test. Uses a two-proportion z-test. Returns per-variant rates, z-score, p-value, and whether the result is significant at the configured confidence level.',
         inputSchema: {
             test_id: z.string().uuid(),
@@ -131,6 +152,13 @@ export function registerAbTestingTools(server) {
         return j(data);
     });
     server.registerTool('promote_ab_winner', {
+        title: 'Promote A/B Winner',
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: true,
+            idempotentHint: false,
+            openWorldHint: false,
+        },
         description: 'End an A/B test and keep only the winning variant. Requires confirmation (two-call pattern). Deletes the losing variant step(s) from campaign_steps.',
         inputSchema: {
             test_id: z.string().uuid(),

package/build/tools/advisor.js

@@ -4,6 +4,7 @@ import { db } from '../db.js';
 import { getProjectId } from '../project.js';
 import { buildVoicePrompt } from '../lib/voice.js';
 import { getAnthropicModelId } from '../anthropic-model.js';
+import { dkimRemediationText } from '../lib/email-provider.js';
 const txt = (text) => ({ content: [{ type: 'text', text }] });
 const j = (data) => txt(JSON.stringify(data, null, 2));
 const DAY_NAMES = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'];
@@ -58,6 +59,13 @@ export function buildTimeBuckets(rows, groupBy, metric) {
 // ── Registration ──────────────────────────────────────────────────────
 export function registerAdvisorTools(server) {
     server.registerTool('run_portfolio_analysis', {
+        title: 'Run Portfolio Analysis',
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
         description: 'Run a grounded portfolio health analysis across active campaigns.',
         inputSchema: { force_run: z.boolean().optional().default(false) },
     }, async ({ force_run = false }) => {
@@ -98,6 +106,13 @@ export function registerAdvisorTools(server) {
     });
     // ── 1. campaign_advisor ────────────────────────────────────────────
     server.registerTool('campaign_advisor', {
+        title: 'Campaign Advisor',
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: true,
+        },
         description: 'Analyze campaign performance and get actionable recommendations. Returns period-over-period metrics, domain health issues, engagement distribution, and prioritized recommendations with severity levels.',
         inputSchema: {
             site_id: z.string().uuid().optional().describe('Filter to a specific site'),
@@ -278,6 +293,13 @@ export function registerAdvisorTools(server) {
     });
     // ── 2. optimize_subject_lines ──────────────────────────────────────
     server.registerTool('optimize_subject_lines', {
+        title: 'Optimize Subject Lines',
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: true,
+        },
         description: 'Generate optimized subject line variants using AI, informed by historical top performers and brand voice. Optionally creates campaign step variants for A/B testing.',
         inputSchema: {
             campaign_id: z.string().uuid(),
@@ -402,6 +424,13 @@ Each subject should be distinct in approach (urgency, curiosity, benefit, social
     });
     // ── 3. suggest_content_topics ────────────────────────────────────
     server.registerTool('suggest_content_topics', {
+        title: 'Suggest Content Topics',
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: true,
+        },
         description: 'Analyze past email performance and recommend content topics for future emails. Uses AI to identify patterns in high- and low-performing content, then suggests specific topics with expected engagement levels.',
         inputSchema: {
             site_id: z.string().uuid().describe('Site UUID to analyze'),
@@ -515,6 +544,13 @@ Return ONLY valid JSON (no markdown fences): { "topics": [{ "title": "...", "rat
     });
     // ── 4. suggest_send_time ───────────────────────────────────────────
     server.registerTool('suggest_send_time', {
+        title: 'Suggest Send Time',
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
         description: 'Analyze historical engagement patterns to recommend optimal send times. Groups by hour-of-day and day-of-week to identify when your audience is most responsive.',
         inputSchema: {
             site_id: z.string().uuid(),
@@ -583,6 +619,13 @@ Return ONLY valid JSON (no markdown fences): { "topics": [{ "title": "...", "rat
     });
     // ── 5. recovery_plan ───────────────────────────────────────────────
     server.registerTool('recovery_plan', {
+        title: 'Recovery Plan',
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
         description: 'Analyze deliverability issues for a site and generate a structured recovery plan. Examines domain health (SPF/DKIM/DMARC), bounce/complaint rates, recent send stats, and new suppressions to produce prioritized immediate, short-term, and monitoring steps. Deterministic — no AI call, pure rule-based analysis.',
         inputSchema: {
             site_id: z.string().uuid().describe('Site UUID with deliverability issues'),
@@ -670,8 +713,15 @@ Return ONLY valid JSON (no markdown fences): { "topics": [{ "title": "...", "rat
         // DNS fixes
         if (!spfValid)
             immediate.push('Add SPF record for sending domain');
-        if (!dkimValid)
-            immediate.push('Configure DKIM record (CNAME for resend._domainkey)');
+        if (!dkimValid) {
+            const { data: dkimSite } = await db()
+                .from('sites')
+                .select('provider')
+                .eq('project_id', projectId)
+                .eq('id', site_id)
+                .maybeSingle();
+            immediate.push(dkimRemediationText(dkimSite?.provider));
+        }
         if (!dmarcValid)
             shortTerm.push('Add DMARC record (start with p=none for monitoring)');
         // List hygiene

package/build/tools/ai-work.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerAiWorkTools(server: McpServer): void;