@sendinel/mcp-server 1.0.66 → 1.0.68

package/README.md

@@ -12,7 +12,7 @@ AI-controlled email operations control plane for campaigns, contacts, segments,
 
 ## Tool groups
 
-Sendinel currently exposes 34 tool groups and 328 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 329 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 |
 |-------|-------|---------|
@@ -38,7 +38,7 @@ Sendinel currently exposes 34 tool groups and 328 tools (gateway mode adds 3 met
 | `landing-pages` | 5 | Landing page CRUD |
 | `lists` | 7 | Static contact lists and membership management |
 | `newsletters` | 12 | Newsletter publications, issues, subscribers, scheduling, sending, stats |
-| `org` | 23 | Team members, plan usage/limits, audit log, model registry, white-label, support tickets, provider switching |
+| `org` | 24 | Team members, plan usage/limits, audit log, model registry, white-label, support tickets, outbound digest, provider switching |
 | `segments` | 6 | Audience builder: create, edit, natural-language generation, preview |
 | `short-links` | 3 | Short links, click stats, QR codes |
 | `signatures` | 4 | Sending signature blocks |

package/build/db.d.ts

@@ -40,6 +40,7 @@ export declare function runWithClient<T>(client: any, fn: () => Promise<T>, requ
     oauthTokenId?: string | null;
     authKind?: string | null;
     oauthClientId?: string | null;
+    agentLabel?: string | null;
     keyId?: string | null;
     workspaceId?: string | null;
     v1Caller?: V1Caller;
@@ -59,6 +60,7 @@ export declare function requestContext(): {
     oauthTokenId?: string | null;
     authKind?: string | null;
     oauthClientId?: string | null;
+    agentLabel?: string | null;
     keyId?: string | null;
     workspaceId?: string | null;
     v1Caller?: V1Caller;

package/build/db.js

@@ -71,6 +71,7 @@ export function requestContext() {
             oauthTokenId: ctx.oauthTokenId,
             authKind: ctx.authKind,
             oauthClientId: ctx.oauthClientId,
+            agentLabel: ctx.agentLabel,
             keyId: ctx.keyId,
             workspaceId: ctx.workspaceId,
             v1Caller: ctx.v1Caller,

package/build/lib/action-approvals.d.ts

@@ -48,6 +48,7 @@ export interface ApprovalResult {
     approve_url: string;
     message: string;
 }
+export declare function approvalPageUrl(approvalId: string): string;
 /**
  * Request human approval for an action. Creates a pending approval token
  * and returns instructions for the agent to wait.

package/build/lib/action-approvals.js

@@ -282,7 +282,7 @@ export function buildApprovalSummary(action, params, display = {}) {
     const payload = JSON.stringify(normalizeApprovalParams(params));
     return `Execute ${action} with: ${payload.length > 400 ? `${payload.slice(0, 399)}…` : payload}`;
 }
-function approvalPageUrl(approvalId) {
+export function approvalPageUrl(approvalId) {
     const base = (process.env.NEXT_PUBLIC_APP_URL ?? process.env.SENDINEL_APP_URL ?? process.env.APP_URL ?? 'https://sendinel.ai').replace(/\/$/, '');
     return `${base}/dashboard/approvals/${approvalId}`;
 }
@@ -310,11 +310,14 @@ export async function requestApproval(action, params, apiKeyId, channelContext,
     const summary = buildApprovalSummary(action, params, display);
     const expiresAt = new Date(Date.now() + 30 * 60 * 1000).toISOString();
     const { channel, verified } = channelContext ?? currentChannelContext();
+    const actor = requestContext();
     const { data, error } = await db()
         .from('action_approvals')
         .insert({
         project_id: getProjectId(),
-        api_key_id: apiKeyId ?? null,
+        api_key_id: apiKeyId ?? actor?.keyId ?? null,
+        oauth_token_id: actor?.oauthTokenId ?? null,
+        agent_label: actor?.agentLabel ?? null,
         action,
         tier,
         params,

package/build/lib/outbound-digest.d.ts

@@ -0,0 +1,57 @@
+type AgentKind = 'worker' | 'connected_agent' | 'user' | 'system';
+export declare function digestAgent(label: string | null): {
+    agent_kind: AgentKind | null;
+    agent_id: string | null;
+    agent_label: string | null;
+};
+type Counts = {
+    sent: number;
+    delivered: number;
+    bounced: number;
+    complained: number;
+    opened: number;
+};
+export type OutboundItem = ReturnType<typeof digestAgent> & {
+    project_id: string;
+    item: {
+        type: 'email' | 'broadcast';
+        id: string;
+        summary: string;
+        platform: null;
+        preview_url: string | null;
+    };
+    audience_count: number | null;
+    counts: Counts | null;
+    is_test: boolean;
+    approval_id: string | null;
+    approve_url: string | null;
+    outcome: 'pending_approval' | 'approved' | 'declined' | 'expired' | 'scheduled' | 'sent' | 'failed';
+    approved_by: string | null;
+    approved_at: string | null;
+    occurred_at: string;
+    provider_ref: string | null;
+};
+type DigestDb = {
+    schema(name: 'email'): {
+        rpc(name: string, args: {
+            p_from: string;
+            p_to: string;
+            p_project_id: string | null;
+        }): PromiseLike<{
+            data: unknown;
+            error: unknown;
+        }>;
+    };
+};
+/** Sources return scalar JSON arrays: no recipient reads and no PostgREST row cap. */
+export declare function getOutboundDigest(sb: DigestDb, from: string, to: string, projectId?: string): Promise<{
+    product: 'sendinel';
+    range: {
+        from: string;
+        to: string;
+    };
+    status: string;
+    unknown_sources: string[];
+    items: OutboundItem[];
+}>;
+export {};

package/build/lib/outbound-digest.js

@@ -0,0 +1,75 @@
+import { approvalPageUrl } from './action-approvals.js';
+export function digestAgent(label) {
+    const match = label?.match(/^(worker|connected_agent|user|system):([^\s:]+)$/);
+    return {
+        agent_kind: match ? match[1] : null,
+        agent_id: match ? match[2] : null,
+        agent_label: label,
+    };
+}
+function approvalFields(approval) {
+    const url = approval ? approvalPageUrl(approval.id) : null;
+    return {
+        ...digestAgent(approval?.agent_label ?? null),
+        approval_id: approval?.id ?? null, approve_url: url,
+        approved_by: approval?.decided_by ?? null, approved_at: approval?.decided_at ?? null,
+    };
+}
+/** Sources return scalar JSON arrays: no recipient reads and no PostgREST row cap. */
+export async function getOutboundDigest(sb, from, to, projectId) {
+    const unknownSources = [];
+    const args = { p_from: from, p_to: to, p_project_id: projectId ?? null };
+    async function source(name, rpc) {
+        try {
+            const result = await sb.schema('email').rpc(rpc, args);
+            if (result.error || !Array.isArray(result.data))
+                throw new Error('Source unavailable');
+            return result.data;
+        }
+        catch {
+            unknownSources.push(name);
+            return [];
+        }
+    }
+    // Separate reads preserve the readable source if the other fails, including during rollout.
+    const approvals = await source('action_approvals', 'outbound_digest_approvals');
+    const sends = await source('email_log', 'outbound_digest_sends');
+    const items = sends.map(send => {
+        const fields = approvalFields(send.approval);
+        const broadcast = send.campaign_type === 'broadcast';
+        return {
+            project_id: send.project_id, ...fields,
+            item: {
+                type: broadcast ? 'broadcast' : 'email',
+                // Standalone logs without a campaign/step are one unknown group per category, never per recipient.
+                id: (broadcast ? send.campaign_id : send.step_id) ?? 'unknown',
+                summary: send.subject ?? send.campaign_name ?? 'unknown', platform: null, preview_url: fields.approve_url,
+            },
+            audience_count: send.audience_count, counts: send.counts, is_test: send.category === 'test',
+            outcome: send.failed ? 'failed' : 'sent', occurred_at: send.occurred_at, provider_ref: send.provider_ref,
+        };
+    });
+    const sentApprovals = new Set(sends.flatMap(send => send.approval ? [send.approval.id] : []));
+    for (const approval of approvals) {
+        if (sentApprovals.has(approval.id))
+            continue;
+        const fields = approvalFields(approval);
+        const outcome = approval.status === 'pending'
+            ? (Date.parse(approval.expires_at) <= Date.parse(to) ? 'expired' : 'pending_approval')
+            : approval.status === 'rejected' ? 'declined'
+                : approval.status === 'expired' ? 'expired' : 'approved';
+        items.push({
+            project_id: approval.project_id, ...fields,
+            item: { type: approval.action.includes('broadcast') ? 'broadcast' : 'email', id: approval.id,
+                summary: approval.summary, platform: null, preview_url: fields.approve_url },
+            audience_count: null, counts: null, is_test: approval.action === 'send_test_email',
+            outcome, occurred_at: approval.occurred_at, provider_ref: null,
+        });
+    }
+    items.sort((a, b) => a.occurred_at.localeCompare(b.occurred_at) || a.project_id.localeCompare(b.project_id) || a.item.id.localeCompare(b.item.id));
+    return {
+        product: 'sendinel', range: { from, to },
+        status: unknownSources.length === 0 ? 'complete' : unknownSources.length === 2 ? 'unknown' : 'partial',
+        unknown_sources: unknownSources, items,
+    };
+}

package/build/lib/ssrf-pinned-fetch.js

@@ -5,16 +5,23 @@
 // than a cross-package import — keep both in sync if the SSRF guard changes.
 import dns from 'node:dns/promises';
 import net from 'node:net';
-import { Agent } from 'undici';
+// #4049: fetch must come from the same undici as Agent. Node's global fetch bundles its own undici and
+// rejects a foreign dispatcher (UND_ERR_INVALID_ARG) before any request, so every pinned fetch failed.
+import { Agent, fetch as undiciFetch } from 'undici';
 export function createPinnedIpDispatcher(hostname, resolved) {
     const expectedHost = hostname.toLowerCase();
     return new Agent({
         connect: {
-            lookup(requestedHost, _options, callback) {
+            lookup(requestedHost, options, callback) {
                 if (String(requestedHost).toLowerCase() !== expectedHost) {
                     callback(new Error('Pinned fetch attempted to resolve an unexpected host'), []);
                     return;
                 }
+                // Node's connect asks for every address when options.all is set; answer in the shape it asked for.
+                if (options?.all) {
+                    callback(null, [{ address: resolved.address, family: resolved.family }]);
+                    return;
+                }
                 callback(null, resolved.address, resolved.family);
             },
         },
@@ -23,7 +30,7 @@ export function createPinnedIpDispatcher(hostname, resolved) {
 }
 export function fetchPinnedToResolvedIp(url, resolved, init = {}) {
     const dispatcher = createPinnedIpDispatcher(url.hostname, resolved);
-    return fetch(url, { ...init, dispatcher });
+    return undiciFetch(url, { ...init, dispatcher });
 }
 function isPrivateIp(address) {
     if (net.isIPv4(address)) {

package/build/tools/org.js

@@ -902,6 +902,23 @@ export function registerOrgTools(server) {
         });
         return result.ok ? j(result.data) : j({ error: result.error });
     });
+    server.registerTool('get_outbound_digest', {
+        title: 'Get Outbound Digest',
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+        description: 'Daily fleet outbound digest of approvals and SQL-aggregated sends, including separate test sends. Platform-admin only; tenant credentials receive Not available. Unknown attribution stays null; failed sources are explicit.',
+        inputSchema: {
+            since: z.iso.datetime({ offset: true }).optional().describe('Start of the window; defaults to 24 hours ago.'),
+            project_id: z.string().uuid().optional(),
+        },
+    }, async ({ since, project_id }) => {
+        const query = {};
+        if (since)
+            query.since = since;
+        if (project_id)
+            query.project_id = project_id;
+        const result = await callSendinelV1('/api/v1/outbound-digest', { method: 'GET', query });
+        return result.ok ? j(result.data) : j({ error: result.error });
+    });
     server.registerTool('start_provider_switch', {
         title: 'Start Provider Switch',
         annotations: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sendinel/mcp-server",
-  "version": "1.0.66",
+  "version": "1.0.68",
   "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",