@sendinel/mcp-server 1.0.125 → 1.0.127

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

@@ -70,6 +70,7 @@ type AdminApprovalAuthority = {
     projectId: string;
     phase: 'preview' | 'approved';
     decidedBy?: string;
+    decisionChannel?: 'sandbox';
 };
 /** Read by the hosted bridge only; no scope or token is changed. */
 export declare function currentAdminApprovalAuthority(): Readonly<AdminApprovalAuthority> | undefined;
@@ -85,6 +86,7 @@ export declare function checkApproval(approvalId: string, options?: {
     approved: boolean;
     status: string;
     decided_by?: string;
+    decision_channel?: 'sandbox';
 }>;
 type ToolResult = {
     content: Array<{

package/build/lib/action-approvals.js

@@ -1,3 +1,4 @@
+import { sandboxApprovalEligible, trySandboxApproval } from './sandbox-approvals.js';
 import { humanApprovalEligible } from './approval-human-eligibility.js';
 import { AsyncLocalStorage } from 'node:async_hooks';
 import { GATED_ACTIONS, PROTECTED_ACTIONS } from './approval-actions.js';
@@ -290,6 +291,9 @@ export async function requestApproval(action, params, apiKeyId, channelContext,
         .single();
     if (error)
         throw new Error(`Failed to create approval request: ${error.message}`);
+    let projectName;
+    let sandboxDisplayRead = false;
+    const sandboxApproved = tier === 'gated' && await trySandboxApproval(data.id, getProjectId(), action, approvalPayloadHash(action, frozenParams), name => { projectName = name; sandboxDisplayRead = true; });
     if (isTesterRequest(action))
         await logTesterRequestAudit('tester_request', action, data.id, null);
     fireWebhookEvent('approval.requested', {
@@ -299,18 +303,23 @@ export async function requestApproval(action, params, apiKeyId, channelContext,
         requested_by: apiKeyId ?? null,
     }, getProjectId()).catch(() => { });
     // Display-only lookup: never add mutable project names to the frozen params/hash.
-    let projectName;
-    try {
-        const source = approvalStore();
-        const client = typeof source.schema === 'function' ? source.schema('email') : source;
-        const { data: project, error: projectError } = await client.from('projects').select('name')
-            .eq('id', getProjectId()).maybeSingle();
-        if (!projectError && typeof project?.name === 'string')
-            projectName = project.name;
-    }
-    catch { /* Missing display data omits the project line. */ }
+    if (!sandboxDisplayRead)
+        try {
+            const source = approvalStore();
+            const client = typeof source.schema === 'function' ? source.schema('email') : source;
+            const { data: project, error: projectError } = await client.from('projects').select('name')
+                .eq('id', getProjectId()).maybeSingle();
+            if (!projectError && typeof project?.name === 'string')
+                projectName = project.name;
+        }
+        catch { /* Missing display data omits the project line. */ }
     const approveUrl = approvalPageUrl(data.id);
     const previewText = buildApprovalPreview({ action, params: frozenParams, summary, projectName }).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.' };
+    }
     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.`
         : '';
@@ -352,11 +361,11 @@ function captureSnapshot(action, params) {
 export async function checkApproval(approvalId, options = {}) {
     const applied = registeredApproval.getStore();
     if (options.consume && applied?.phase === 'approved' && applied.id === approvalId && applied.action === options.action && applied.projectId === getProjectId()) {
-        return { approved: true, status: 'approved', decided_by: applied.decidedBy };
+        return { approved: true, status: 'approved', decided_by: applied.decidedBy, ...(applied.decisionChannel ? { decision_channel: applied.decisionChannel } : {}) };
     }
     const { data, error } = await approvalStore()
         .from('action_approvals')
-        .select('action, status, decided_by, decided_via, oauth_token_id, expires_at, used_at, params, payload_hash, requested_at')
+        .select('project_id, tier, action, status, decided_by, decided_via, oauth_token_id, expires_at, used_at, params, payload_hash, requested_at')
         .eq('id', approvalId)
         .eq('project_id', getProjectId())
         .maybeSingle();
@@ -391,7 +400,12 @@ export async function checkApproval(approvalId, options = {}) {
             !await humanApprovalEligible(data.action, getProjectId(), requestContext(), true))) {
         return { approved: false, status: 'human_decision_required' };
     }
-    if (data.status === 'approved' && (!isHumanApprovalChannel(data.decided_via) ||
+    const sandboxDecision = data.decided_via === 'sandbox';
+    if (sandboxDecision && (data.project_id !== getProjectId() || data.tier !== 'gated' || PROTECTED_ACTIONS.has(data.action) ||
+        !await sandboxApprovalEligible(getProjectId(), data.action))) {
+        return { approved: false, status: 'sandbox_decision_no_longer_eligible' };
+    }
+    if (data.status === 'approved' && !sandboxDecision && (!isHumanApprovalChannel(data.decided_via) ||
         (isHumanRequestableAdminTool(data.action) && data.decided_via !== 'dashboard' &&
             (!['mcp_app', 'mcp_elicitation', 'chat_confirm'].includes(data.decided_via) ||
                 !await humanApprovalEligible(data.action, getProjectId(), { projectId: getProjectId(),
@@ -405,6 +419,7 @@ export async function checkApproval(approvalId, options = {}) {
             approved: data.status === 'approved',
             status: data.status,
             decided_by: data.decided_by,
+            ...(sandboxDecision ? { decision_channel: 'sandbox' } : {}),
         };
     }
     if (data.params?.__approval_snapshot) {
@@ -443,6 +458,7 @@ export async function checkApproval(approvalId, options = {}) {
         approved: true,
         status: 'approved',
         decided_by: claimed.decided_by,
+        ...(sandboxDecision ? { decision_channel: 'sandbox' } : {}),
     };
 }
 function toolText(value) {
@@ -464,6 +480,7 @@ export function withApproval(action, handler, options = {}) {
         if (!decision.allowed)
             return toolText(decision.reason ?? 'This channel cannot request this action.');
         let decidedBy;
+        let decisionChannel;
         if (options.registeredRequestOnly || decision.tier !== 'autonomous') {
             if (!approval_id) {
                 const display = options.display ? await options.display(params) : undefined;
@@ -471,12 +488,13 @@ export function withApproval(action, handler, options = {}) {
             }
             const check = await checkApproval(approval_id, { consume: true, action, params });
             decidedBy = check.decided_by;
+            decisionChannel = check.decision_channel;
             if (!check.approved) {
                 return toolText(`Approval ${approval_id} is ${check.status}. ${check.status === 'pending' ? 'Waiting for human approval via dashboard.' : 'Request a new approval.'}`);
             }
         }
         if (options.registeredRequestOnly) {
-            return registeredApproval.run({ id: approval_id, action, projectId: getProjectId(), phase: 'approved', decidedBy }, () => handler(args, extra));
+            return registeredApproval.run({ id: approval_id, action, projectId: getProjectId(), phase: 'approved', decidedBy, decisionChannel }, () => handler(args, extra));
         }
         return handler(params, extra);
     };

package/build/lib/approval-chat-confirm.js

@@ -45,9 +45,9 @@ export async function confirmApproval(input) {
         const now = Date.now();
         const requested = Date.parse(approval.requested_at);
         if (!(Date.parse(approval.expires_at) > now))
-            return refuse('chat_confirm_expired', 'Approval has expired. Request a new approval.');
+            return refuse('chat_confirm_expired', 'Approval has expired. Request a new approval, or tap the approve_url.');
         if (!Number.isFinite(requested) || requested > now || requested < now - 600_000) {
-            return refuse('chat_confirm_too_old', 'Chat confirm requires an approval requested within the last 10 minutes. Request a new approval.');
+            return refuse('chat_confirm_too_old', 'Chat confirm requires an approval requested within the last 10 minutes. Request a new approval, or tap the approve_url.');
         }
         if (input.action !== approval.action)
             return refuse('chat_confirm_action_mismatch', 'Action does not match the approval.');

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

@@ -0,0 +1,31 @@
+/** Conservative classification: shared org credentials and grants require an all-sandbox org. */
+export declare const SANDBOX_ADMIN_SCOPE: {
+    readonly action_ccpa_request: 'project';
+    readonly create_agent_mailbox: 'project';
+    readonly create_api_key: 'org';
+    readonly delete_provider_credential: 'org';
+    readonly delete_segment: 'project';
+    readonly delete_signature: 'project';
+    readonly delete_subscriber_data: 'project';
+    readonly delete_template: 'project';
+    readonly delete_webhook_subscription: 'project';
+    readonly disconnect_platform: 'org';
+    readonly identify_inactive: 'project';
+    readonly install_connector_schema: 'project';
+    readonly install_connector_view: 'project';
+    readonly invite_team_member: 'org';
+    readonly merge_subscribers: 'project';
+    readonly remove_suppression: 'project';
+    readonly remove_team_member: 'org';
+    readonly resync_connector: 'project';
+    readonly revoke_api_key: 'org';
+    readonly revoke_invitation: 'org';
+    readonly rotate_custom_webhook_secret: 'project';
+    readonly set_connector_mapping: 'project';
+    readonly set_member_project_access: 'org';
+    readonly set_team_member_role: 'org';
+    readonly tenant_export_full: 'project';
+};
+/** Never consult token claims, BYOD clients or cached display data for this authority. */
+export declare function sandboxApprovalEligible(projectId: string, action: string, onProjectRead?: (name: string | undefined) => void): Promise<boolean>;
+export declare function trySandboxApproval(id: string, projectId: string, action: string, payloadHash: string, onProjectRead?: (name: string | undefined) => void): Promise<boolean>;

package/build/lib/sandbox-approvals.js

@@ -0,0 +1,55 @@
+import { adminDb } from '../db.js';
+import { PROTECTED_ACTIONS } from './approval-actions.js';
+import { isHumanRequestableAdminTool } from './admin-tools.js';
+/** Conservative classification: shared org credentials and grants require an all-sandbox org. */
+export const SANDBOX_ADMIN_SCOPE = {
+    action_ccpa_request: 'project', create_agent_mailbox: 'project', create_api_key: 'org',
+    delete_provider_credential: 'org', delete_segment: 'project', delete_signature: 'project',
+    delete_subscriber_data: 'project', delete_template: 'project', delete_webhook_subscription: 'project',
+    disconnect_platform: 'org', identify_inactive: 'project', install_connector_schema: 'project',
+    install_connector_view: 'project', invite_team_member: 'org', merge_subscribers: 'project',
+    remove_suppression: 'project', remove_team_member: 'org', resync_connector: 'project',
+    revoke_api_key: 'org', revoke_invitation: 'org', rotate_custom_webhook_secret: 'project',
+    set_connector_mapping: 'project', set_member_project_access: 'org', set_team_member_role: 'org',
+    tenant_export_full: 'project',
+};
+/** Never consult token claims, BYOD clients or cached display data for this authority. */
+export async function sandboxApprovalEligible(projectId, action, onProjectRead) {
+    if (PROTECTED_ACTIONS.has(action))
+        return false;
+    try {
+        const source = adminDb().schema('email');
+        const { data, error } = await source.from('projects').select('id, org_id, sandbox_mode, name')
+            .eq('id', projectId).maybeSingle();
+        onProjectRead?.(!error && typeof data?.name === 'string' ? data.name : undefined);
+        if (error || data?.id !== projectId || data.sandbox_mode !== true)
+            return false;
+        if (!isHumanRequestableAdminTool(action))
+            return true;
+        const scope = SANDBOX_ADMIN_SCOPE[action];
+        if (scope === 'project')
+            return true;
+        if (scope !== 'org' || typeof data.org_id !== 'string')
+            return false;
+        const others = await source.from('projects').select('id').eq('org_id', data.org_id)
+            .eq('sandbox_mode', false).limit(1);
+        return !others.error && Array.isArray(others.data) && others.data.length === 0;
+    }
+    catch {
+        return false;
+    }
+}
+export async function trySandboxApproval(id, projectId, action, payloadHash, onProjectRead) {
+    if (!await sandboxApprovalEligible(projectId, action, onProjectRead))
+        return false;
+    try {
+        // The RPC performs one conditional UPDATE + audit INSERT in one transaction.
+        const { data, error } = await adminDb().schema('email').rpc('approve_sandbox_action', {
+            p_approval_id: id, p_project_id: projectId, p_action: action, p_payload_hash: payloadHash,
+        });
+        return !error && data === true;
+    }
+    catch {
+        return false;
+    }
+}

package/build/tools/analytics.js

@@ -292,10 +292,10 @@ export function registerAnalyticsTools(server) {
             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)
+                    ? adminDb().from('projects').select('id, name, org_id, sandbox_mode, sandbox_allowed_domains').in('id', directProjectIds)
                     : Promise.resolve({ data: [], error: null }),
                 ownedOrgIds.length
-                    ? adminDb().from('projects').select('id, name, org_id').in('org_id', ownedOrgIds)
+                    ? adminDb().from('projects').select('id, name, org_id, sandbox_mode, sandbox_allowed_domains').in('org_id', ownedOrgIds)
                     : Promise.resolve({ data: [], error: null }),
             ]);
             if (directProjectsError)
@@ -323,6 +323,8 @@ export function registerAnalyticsTools(server) {
                     name: project.name,
                     org_id: project.org_id,
                     org_name: project.org_id ? orgNames.get(project.org_id) ?? null : null,
+                    sandbox_mode: project.sandbox_mode,
+                    sandbox_allowed_domains: project.sandbox_allowed_domains,
                     active: project.id === ctx.projectId,
                 })),
             });
@@ -332,19 +334,19 @@ export function registerAnalyticsTools(server) {
         // Look up the org for this project, then list all projects in that org.
         const { data: project, error: projErr } = await adminDb()
             .from('projects')
-            .select('id, name, org_id')
+            .select('id, name, org_id, sandbox_mode, sandbox_allowed_domains')
             .eq('id', projectId)
             .maybeSingle();
         if (projErr || !project)
             return txt(`Error: could not find project ${projectId}`);
         if (!project.org_id) {
             // No org — return just this project
-            return j({ projects: [{ id: project.id, name: project.name, current: true }] });
+            return j({ projects: [{ id: project.id, name: project.name, sandbox_mode: project.sandbox_mode, sandbox_allowed_domains: project.sandbox_allowed_domains, current: true }] });
         }
         // List all projects in the same organization
         const { data: projects, error: listErr } = await adminDb()
             .from('projects')
-            .select('id, name')
+            .select('id, name, sandbox_mode, sandbox_allowed_domains')
             .eq('org_id', project.org_id)
             .order('name');
         if (listErr)
@@ -360,6 +362,8 @@ export function registerAnalyticsTools(server) {
             projects: (projects ?? []).map((p) => ({
                 id: p.id,
                 name: p.name,
+                sandbox_mode: p.sandbox_mode,
+                sandbox_allowed_domains: p.sandbox_allowed_domains,
                 current: p.id === projectId,
             })),
         });

package/build/tools/sms.js

@@ -1,8 +1,9 @@
+import { assertProjectAllowsSms } from "@sendinel/domain";
 import { randomUUID } from 'crypto';
 import { withApproval } from '../lib/action-approvals.js';
 import { z } from 'zod';
 import { decrypt } from '../crypto.js';
-import { db } from '../db.js';
+import { adminDb, db } from '../db.js';
 import { getProjectId } from '../project.js';
 const txt = (text) => ({ content: [{ type: 'text', text }] });
 const j = (data) => txt(JSON.stringify(data, null, 2));
@@ -91,6 +92,7 @@ async function readJsonSafe(res) {
     return res.json().catch(() => ({}));
 }
 async function sendViaProvider(provider, credentialsEnc, fromNumber, toNumber, body, webhookUrl, trackingToken) {
+    await assertProjectAllowsSms(adminDb(), getProjectId());
     const credentials = parseCredentials(credentialsEnc);
     const meta = countSmsSegments(body);
     if (provider === 'twilio') {

package/package.json

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