@sendinel/mcp-server 1.0.23 → 1.0.25

package/README.md

@@ -12,14 +12,14 @@ AI-controlled email operations control plane for campaigns, contacts, segments,
 
 ## Tool groups
 
-Sendinel currently exposes 34 tool groups and 314 tools (gateway mode adds 3 meta-tools). These counts are checked against the tool registry in CI, so this table matches what ships.
+Sendinel currently exposes 34 tool groups and 315 tools (gateway mode adds 3 meta-tools). These counts are checked against the tool registry in CI, so this table matches what ships.
 
 | Group | Count | Purpose |
 |-------|-------|---------|
 | `ab-testing` | 4 | A/B test creation, listing, significance checks, winner promotion |
 | `advisor` | 6 | Campaign advisor: recommendations, benchmarks, subject/content/send-time guidance |
 | `ai-work` | 9 | AI work items, recommended segments, context events, agent proposals |
-| `analytics` | 17 | Stats, portfolio analytics, domain health, engagement, deliverability, revenue analytics |
+| `analytics` | 18 | Stats, portfolio analytics, project switching, domain health, engagement, deliverability, revenue analytics |
 | `approvals` | 2 | Poll and list risk-tiered action approvals |
 | `automations` | 7 | Automation triggers, previews, and response-gated escalation ladders |
 | `brand_kit` | 5 | Brand Core text import, media library upload/URL ingest, asset-context reads |

package/build/db.d.ts

@@ -37,6 +37,7 @@ export declare function runWithClient<T>(client: any, fn: () => Promise<T>, requ
     channelVerified?: boolean;
     actorType?: string;
     actorId?: string | null;
+    oauthTokenId?: string | null;
     workspaceId?: string | null;
     v1Caller?: V1Caller;
 }): Promise<T>;
@@ -52,6 +53,7 @@ export declare function requestContext(): {
     channelVerified?: boolean;
     actorType?: string;
     actorId?: string | null;
+    oauthTokenId?: string | null;
     workspaceId?: string | null;
     v1Caller?: V1Caller;
 } | undefined;

package/build/db.js

@@ -68,6 +68,7 @@ export function requestContext() {
             channelVerified: ctx.channelVerified,
             actorType: ctx.actorType,
             actorId: ctx.actorId,
+            oauthTokenId: ctx.oauthTokenId,
             workspaceId: ctx.workspaceId,
             v1Caller: ctx.v1Caller,
         }

package/build/server.js

@@ -103,6 +103,7 @@ const WRITE_TOOLS = new Set([
     'update_warmup_schedule', 'pause_warmup', 'resume_warmup',
     'create_form', 'invite_team_member',
     'remove_team_member', 'set_team_member_role', 'set_member_project_access',
+    'set_active_project',
     'resend_invitation', 'revoke_invitation',
     'create_landing_page', 'update_landing_page', 'delete_landing_page',
     'start_provider_switch', 'get_provider_switch_status', 'rollback_provider_switch',

package/build/tools/analytics.js

@@ -1,8 +1,10 @@
+import { fetchAllRows } from '@sendinel/domain';
 import { z } from 'zod';
-import { db, adminDb } from '../db.js';
+import { db, adminDb, requestContext } from '../db.js';
 import { getProjectId } from '../project.js';
 import { resolveProjectClient } from '../byod-client.js';
 import { decrypt } from '../crypto.js';
+import { logAudit } from '../audit.js';
 const txt = (text) => ({ content: [{ type: 'text', text }] });
 const j = (data) => txt(JSON.stringify(data, null, 2));
 const percent = (rate) => `${(rate * 100).toFixed(1)}%`;
@@ -347,9 +349,63 @@ export function registerAnalyticsTools(server) {
         description: 'List all projects accessible to this API key. Returns project ID, name, plan, and associated organization. Useful for orchestrators managing multiple products through a single Sendinel account.',
         inputSchema: {},
     }, async () => {
+        const projectId = getProjectId();
+        const ctx = requestContext();
+        if (ctx?.channel === 'mcp_oauth_session' && ctx.actorId) {
+            const [{ data: directAccess, error: directError }, { data: ownedOrgs, error: ownerError }] = await Promise.all([
+                adminDb()
+                    .from('user_project_access')
+                    .select('project_id')
+                    .eq('user_id', ctx.actorId),
+                adminDb()
+                    .from('org_members')
+                    .select('org_id')
+                    .eq('user_id', ctx.actorId)
+                    .eq('role', 'owner'),
+            ]);
+            if (directError)
+                return txt(`Error: ${directError.message}`);
+            if (ownerError)
+                return txt(`Error: ${ownerError.message}`);
+            const directProjectIds = Array.from(new Set((directAccess ?? []).map((row) => row.project_id).filter(Boolean)));
+            const ownedOrgIds = Array.from(new Set((ownedOrgs ?? []).map((row) => row.org_id).filter(Boolean)));
+            const [{ data: directProjects, error: directProjectsError }, { data: ownedProjects, error: ownedProjectsError }] = await Promise.all([
+                directProjectIds.length
+                    ? adminDb().from('projects').select('id, name, org_id').in('id', directProjectIds)
+                    : Promise.resolve({ data: [], error: null }),
+                ownedOrgIds.length
+                    ? adminDb().from('projects').select('id, name, org_id').in('org_id', ownedOrgIds)
+                    : Promise.resolve({ data: [], error: null }),
+            ]);
+            if (directProjectsError)
+                return txt(`Error: ${directProjectsError.message}`);
+            if (ownedProjectsError)
+                return txt(`Error: ${ownedProjectsError.message}`);
+            const byId = new Map();
+            for (const project of [...(directProjects ?? []), ...(ownedProjects ?? [])]) {
+                byId.set(project.id, project);
+            }
+            const orgIds = Array.from(new Set(Array.from(byId.values()).map((project) => project.org_id).filter((id) => Boolean(id))));
+            const { data: organizations, error: organizationsError } = orgIds.length
+                ? await adminDb().from('organizations').select('id, name').in('id', orgIds)
+                : { data: [], error: null };
+            if (organizationsError)
+                return txt(`Error: ${organizationsError.message}`);
+            const orgNames = new Map((organizations ?? []).map((org) => [org.id, org.name]));
+            return j({
+                projects: Array.from(byId.values())
+                    .sort((a, b) => a.name.localeCompare(b.name) || a.id.localeCompare(b.id))
+                    .map((project) => ({
+                    id: project.id,
+                    name: project.name,
+                    org_id: project.org_id,
+                    org_name: project.org_id ? orgNames.get(project.org_id) ?? null : null,
+                    active: project.id === projectId,
+                })),
+            });
+        }
         // API keys are scoped to a single project, but an organization can have multiple projects.
         // Look up the org for this project, then list all projects in that org.
-        const projectId = getProjectId();
         const { data: project, error: projErr } = await adminDb()
             .from('projects')
             .select('id, name, org_id')
@@ -384,6 +440,59 @@ export function registerAnalyticsTools(server) {
             })),
         });
     });
+    server.registerTool('set_active_project', {
+        title: 'Set Active Project',
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+        description: 'Switch this connection to act on a different project you have access to, without reconnecting. Only available on an OAuth-connected session (claude.ai / Claude Code / Cursor); API keys and Synchronex connections stay pinned to their original project.',
+        inputSchema: {
+            project_id: z.string().uuid().describe('Project UUID to switch to. Use list_projects to see what you can access.'),
+        },
+    }, async ({ project_id }) => {
+        const ctx = requestContext();
+        if (ctx?.channel !== 'mcp_oauth_session' || !ctx.oauthTokenId || !ctx.actorId) {
+            return j({
+                error: 'set_active_project is only available on an OAuth-connected session (claude.ai, Claude Code, Cursor). This connection is pinned to a single project.',
+                code: 'SWITCH_NOT_SUPPORTED',
+            });
+        }
+        const { data: hasAccess, error: accessError } = await adminDb().rpc('user_has_project_access', {
+            p_user_id: ctx.actorId,
+            p_project_id: project_id,
+        });
+        if (accessError)
+            return j({ error: accessError.message });
+        if (!hasAccess)
+            return j({ error: 'You do not have access to this project.', code: 'PROJECT_ACCESS_DENIED' });
+        const previousProjectId = getProjectId();
+        const { error: updateError } = await adminDb()
+            .from('mcp_oauth_tokens')
+            .update({ active_project_id: project_id })
+            .eq('id', ctx.oauthTokenId);
+        if (updateError)
+            return j({ error: updateError.message });
+        const { data: project } = await adminDb()
+            .from('projects')
+            .select('id, name, org_id')
+            .eq('id', project_id)
+            .maybeSingle();
+        void logAudit({
+            action: 'mcp.set_active_project',
+            resourceType: 'project',
+            resourceId: project_id,
+            details: { previous_project_id: previousProjectId },
+            channel: 'mcp_oauth_session',
+        }).catch(() => { });
+        return j({
+            ok: true,
+            active_project: project ? { id: project.id, name: project.name, org_id: project.org_id } : { id: project_id },
+            note: 'Applies starting with your next tool call on this connection.',
+        });
+    });
     server.registerTool('get_sites', {
         title: 'Get Sites',
         annotations: {
@@ -431,42 +540,54 @@ export function registerAnalyticsTools(server) {
         if (siteError)
             return { content: [{ type: 'text', text: `Error: ${siteError.message}` }] };
         const trackingEnabled = site?.tracking_enabled ?? false;
-        const { data, error } = await db()
+        const { data, error, pageCount: logPageCount } = await fetchAllRows(async (offset, limit) => db()
             .from('email_log')
             .select('id, provider_message_id, status, sent_at')
             .eq('project_id', projectId)
             .eq('site_id', site_id)
             .gte('sent_at', `${start_date}T00:00:00Z`)
-            .lte('sent_at', `${end}T23:59:59Z`);
+            .lte('sent_at', `${end}T23:59:59Z`)
+            .order('id', { ascending: true })
+            .range(offset, offset + limit - 1));
         if (error)
             return { content: [{ type: 'text', text: `Error: ${error.message}` }] };
         const rows = (data ?? []);
         let eventCounts = { opened: 0, clicked: 0 };
+        let eventRows = [];
+        let eventPageCount = 0;
         if (trackingEnabled) {
-            const { data: events, error: eventsError } = await db()
+            const { data: events, error: eventsError, pageCount } = await fetchAllRows(async (offset, limit) => db()
                 .from('email_events')
                 .select('provider_message_id, event_type')
                 .eq('project_id', projectId)
                 .eq('site_id', site_id)
                 .in('event_type', ['open', 'click'])
                 .gte('occurred_at', `${start_date}T00:00:00Z`)
-                .lte('occurred_at', `${end}T23:59:59Z`);
+                .lte('occurred_at', `${end}T23:59:59Z`)
+                .order('id', { ascending: true })
+                .range(offset, offset + limit - 1));
             if (eventsError)
                 return { content: [{ type: 'text', text: `Error: ${eventsError.message}` }] };
+            eventRows = events ?? [];
+            eventPageCount = pageCount;
             const messageIds = new Set(rows.map(row => row.provider_message_id).filter((id) => Boolean(id)));
             eventCounts = {
-                opened: distinctEventCount(events ?? [], 'open', messageIds),
-                clicked: distinctEventCount(events ?? [], 'click', messageIds),
+                opened: distinctEventCount(eventRows, 'open', messageIds),
+                clicked: distinctEventCount(eventRows, 'click', messageIds),
             };
         }
         const metrics = computeAnalyticsMetrics(rows, trackingEnabled ? eventCounts : undefined);
         const periodDays = daysBetween(start_date, end);
         const priorStart = dateOnly(addDays(new Date(`${start_date}T00:00:00Z`), -periodDays));
         const priorEnd = dateOnly(addDays(new Date(`${start_date}T00:00:00Z`), -1));
-        const { data: subscribers } = await db()
+        const { data: subscribers, error: subscribersError, pageCount: subscriberPageCount } = await fetchAllRows(async (offset, limit) => db()
             .from('subscribers')
             .select('created_at, last_engaged_at, last_opened_at, last_clicked_at')
-            .eq('project_id', projectId);
+            .eq('project_id', projectId)
+            .order('id', { ascending: true })
+            .range(offset, offset + limit - 1));
+        if (subscribersError)
+            return { content: [{ type: 'text', text: `Error: ${subscribersError.message}` }] };
         const subscriberRows = (subscribers ?? []);
         const currentNew = subscriberRows.filter(s => s.created_at && s.created_at >= `${start_date}T00:00:00Z` && s.created_at <= `${end}T23:59:59Z`).length;
         const priorNew = subscriberRows.filter(s => s.created_at && s.created_at >= `${priorStart}T00:00:00Z` && s.created_at <= `${priorEnd}T23:59:59Z`).length;
@@ -488,6 +609,15 @@ export function registerAnalyticsTools(server) {
             list_growth_rate: subscriberRows.length > 0 ? pctNumber(currentNew / subscriberRows.length) : 0,
             inactive_pct: subscriberRows.length > 0 ? pctNumber(inactive / subscriberRows.length) : 0,
             sender_health_score: computeSenderHealthScore(metrics, trackingEnabled),
+            coverage: {
+                log_rows_scanned: rows.length,
+                log_page_count: logPageCount,
+                event_rows_scanned: trackingEnabled ? eventRows.length : null,
+                event_page_count: trackingEnabled ? eventPageCount : null,
+                subscriber_rows_scanned: subscriberRows.length,
+                subscriber_page_count: subscriberPageCount,
+                complete: true,
+            },
         };
         if (trackingEnabled) {
             response.open_rate = metrics.sent > 0 ? percent(metrics.open_rate) : 'N/A';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sendinel/mcp-server",
-  "version": "1.0.23",
+  "version": "1.0.25",
   "description": "AI-controlled email operations control plane for campaigns, contacts, segments, analytics, and multi-provider sending via MCP.",
   "mcpName": "ai.sendinel/mcp-server",
   "type": "module",