@sendinel/mcp-server 1.0.142 → 1.0.143

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

@@ -50,6 +50,8 @@ export interface ApprovalResult {
     summary: string;
     expires_at: string;
     approve_via: string;
+    decided_via?: 'sandbox';
+    decided_by?: null;
     /** One-tap approval page; works on a phone and needs no project switching (#3661). */
     approve_url: string;
     preview_text: string;

package/build/lib/action-approvals.js

@@ -137,7 +137,7 @@ export function approvalExcerpt(html, max = 200) {
 function broadcastSummary(d) {
     if (!d.subject)
         return null;
-    const count = typeof d.recipient_count === 'number' ? `${d.recipient_count.toLocaleString('en-US')} recipient${d.recipient_count === 1 ? '' : 's'}` : null;
+    const count = typeof d.recipient_count === 'number' ? `${d.recipient_count.toLocaleString('en-US')} recipient${d.recipient_count === 1 ? '' : 's'}` : d.recipient_count === null ? 'unknown recipients' : null;
     const audience = d.segment_name ? `segment "${d.segment_name}"` : (d.audience_label ? String(d.audience_label) : 'the chosen audience');
     const when = d.send_at ? ` at ${d.send_at}` : '';
     const excerpt = d.body_excerpt ? ` — "${d.body_excerpt}"` : '';
@@ -323,11 +323,13 @@ export async function requestApproval(action, params, apiKeyId, channelContext,
         }
         catch { /* Missing display data omits the project line. */ }
     const approveUrl = approvalPageUrl(data.id);
-    const previewText = buildApprovalPreview({ action, params: frozenParams, summary, projectName }).plain_summary;
+    const previewText = buildApprovalPreview({ action, params: frozenParams, summary, projectName, ...(display && 'recipient_count' in display ? { recipientCount: display.recipient_count } : {}) }).plain_summary;
     if (sandboxApproved) {
         return { requires_approval: true, approval_id: data.id, tier, action, summary, expires_at: expiresAt,
-            approve_via: 'sandbox', approve_url: approveUrl, preview_text: previewText, decision_status: 'approved',
-            message: 'Sandbox project: approved automatically\nCall this tool again with the same arguments plus approval_id to run it.' };
+            approve_via: 'sandbox', decided_via: 'sandbox', decided_by: null, approve_url: approveUrl, preview_text: previewText, decision_status: 'approved',
+            message: action === 'send_broadcast'
+                ? 'Sandbox project: approved automatically (no person decided it). Call send_broadcast again with only approval_id to send.'
+                : 'Sandbox project: approved automatically\nCall this tool again with the same arguments plus approval_id to run it.' };
     }
     const chatGuidance = tier === 'gated' && await humanApprovalEligible(action, getProjectId(), actor, true)
         ? `\nAsk the user in plain chat: "${previewText.split('\n')[0].trim()}". Only after they say yes, call confirm_approval with approval_id, action, echo (the first line of preview_text) and user_reply (their exact words), then call the original tool again with approval_id.`

package/build/lib/sandbox-audience.d.ts

@@ -0,0 +1,30 @@
+/** Display only: never narrow or otherwise change the frozen enrollment payload. */
+export declare function sandboxAudience(projectId: string, contactIds: string[]): Promise<{
+    recipient_count: number;
+    audience_matched_count?: undefined;
+    sandbox?: undefined;
+} | {
+    recipient_count: number;
+    audience_matched_count: number;
+    sandbox: {
+        active: true;
+        allowed_domains: string[] | null;
+        filtered_out: number;
+        count_unknown?: undefined;
+    };
+} | {
+    recipient_count: null;
+    audience_matched_count: number;
+    sandbox: {
+        active: boolean | null;
+        allowed_domains: string[] | null;
+        filtered_out: null;
+        count_unknown: boolean;
+    };
+}>;
+export declare function broadcastApprovalNext(approval: {
+    approve_via?: string;
+    decision_status?: string;
+}, sandbox?: {
+    allowed_domains: string[] | null;
+}): string;

package/build/lib/sandbox-audience.js

@@ -0,0 +1,48 @@
+import { chunkIds, isSandboxDomain, matchSandboxDomains, readAllRows } from '@sendinel/domain';
+import { adminDb, db } from '../db.js';
+/** Display only: never narrow or otherwise change the frozen enrollment payload. */
+export async function sandboxAudience(projectId, contactIds) {
+    let active = null;
+    let allowedDomains = null;
+    try {
+        const { data, error } = await adminDb().schema('email').from('projects')
+            .select('sandbox_mode, sandbox_allowed_domains').eq('id', projectId).maybeSingle();
+        if (error || !data || typeof data.sandbox_mode !== 'boolean')
+            throw new Error('Sandbox policy unavailable');
+        active = data.sandbox_mode;
+        if (!active)
+            return { recipient_count: contactIds.length };
+        if (!Array.isArray(data.sandbox_allowed_domains) || !data.sandbox_allowed_domains.every(isSandboxDomain)) {
+            throw new Error('Sandbox domains unavailable');
+        }
+        allowedDomains = data.sandbox_allowed_domains;
+        const emails = new Map();
+        for (const chunk of chunkIds(contactIds)) {
+            const rows = await readAllRows(db().schema('email').from('subscribers').select('id, email').eq('project_id', projectId).in('id', chunk));
+            for (const row of rows) {
+                if (typeof row.email !== 'string')
+                    throw new Error('Contact email unavailable');
+                emails.set(row.id, row.email);
+            }
+        }
+        if (contactIds.some(id => !emails.has(id)))
+            throw new Error('Contact lookup incomplete');
+        const count = contactIds.filter(id => !matchSandboxDomains(allowedDomains, { to: emails.get(id) })).length;
+        return { recipient_count: count, audience_matched_count: contactIds.length,
+            sandbox: { active, allowed_domains: allowedDomains, filtered_out: contactIds.length - count } };
+    }
+    catch {
+        return { recipient_count: null, audience_matched_count: contactIds.length,
+            sandbox: { active, allowed_domains: allowedDomains, filtered_out: null, count_unknown: true } };
+    }
+}
+export function broadcastApprovalNext(approval, sandbox) {
+    if (approval.approve_via === 'sandbox' && approval.decision_status === 'approved') {
+        const domains = sandbox?.allowed_domains;
+        return 'Sandbox project: this was approved automatically (no person decided it). Call send_broadcast again with only approval_id to send. ' +
+            (domains ? domains.length ? `Only recipients on ${domains.join(', ')} can be delivered, subject to send-time policy checks.` : 'No sandbox domains are allowed; no recipients can be delivered.'
+                : 'Sandbox domains could not be loaded; the deliverable recipient count is unknown.') +
+            ' Do not say it was sent before that call succeeds.';
+    }
+    return 'Show the user the subject, recipient count and approve_url. After a person approves, call send_broadcast with only approval_id. Do not say it was sent before that call succeeds.';
+}

package/build/tools/approvals.js

@@ -48,7 +48,7 @@ export function registerApprovalTools(server, options) {
     }, async () => {
         const { data, error } = await db()
             .from('action_approvals')
-            .select('id, action, tier, channel, summary, status, requested_at, expires_at')
+            .select('id, action, tier, channel, summary, status, requested_at, expires_at, decided_via, decided_by')
             .eq('project_id', getProjectId())
             .eq('status', 'pending')
             .gt('expires_at', new Date().toISOString())
@@ -56,6 +56,6 @@ export function registerApprovalTools(server, options) {
             .limit(25);
         if (error)
             return toolError(dbToolError(error));
-        return j({ pending: data ?? [], count: data?.length ?? 0 });
+        return j({ pending: (data ?? []).map((row) => ({ ...row, ...(row.decided_via === 'sandbox' ? { decision_channel: 'sandbox' } : {}) })), count: data?.length ?? 0 });
     });
 }

package/build/tools/campaigns.js

@@ -18,6 +18,7 @@ import { checkPlanLimit } from '../plan-limits.js';
 import { buildVoicePrompt, buildEmailSystemPrompt, deriveTemplateVariables, validateTemplate } from '../lib/voice.js';
 import { fireWebhookEvent } from '../lib/webhook-events.js';
 import { approvalExcerpt, assertChannelCanExecute, currentChannelContext, requestApproval, checkApproval, withApproval } from '../lib/action-approvals.js';
+import { sandboxAudience, broadcastApprovalNext } from '../lib/sandbox-audience.js';
 import { resolveSegmentContactIds, resolveSendAudience } from '../lib/send-audience.js';
 import { generateEmailFromBrief, parseAudienceRules } from '../lib/email-generation.js';
 import { getAnthropicModelId } from '../anthropic-model.js';
@@ -1578,6 +1579,7 @@ export function registerCampaignTools(server) {
         else {
             content = { subject: subject, body_html: html, body_text: body_text ?? approvalExcerpt(html, 100000), blocks: null };
         }
+        const delivery = await sandboxAudience(projectId, resolved.contactIds);
         const campaignName = name ?? `Broadcast - ${content.subject.slice(0, 120)}`;
         const payload = {
             site_id: site.id,
@@ -1603,18 +1605,18 @@ export function registerCampaignTools(server) {
             subject: content.subject,
             segment_name: segment_id ? segmentName : null,
             audience_label: segment_id ? null : `"${segmentName}"`,
-            recipient_count: resolved.contactIds.length,
+            recipient_count: delivery.recipient_count,
             body_excerpt: approvalExcerpt(content.body_html),
             send_at: sendAt,
         });
         return j({
             ...approval,
             rendered: { subject: content.subject, body_html: stripActiveEmailContent(content.body_html).html, body_text: content.body_text },
-            recipient_count: resolved.contactIds.length,
+            ...delivery,
             audience: { label: segmentName, segment_id: segment_id ?? null, ...heldBackLines(resolved) },
             site: { id: site.id, name: site.name, from_email: site.from_email },
             send_at: sendAt ?? 'right after approval',
-            next: 'Show the user the subject, recipient count and approve_url. After a person approves, call send_broadcast with only approval_id. Do not say it was sent before that call succeeds.',
+            next: broadcastApprovalNext(approval, delivery.sandbox),
         });
     });
     server.registerTool('clone_campaign', {

package/package.json

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