@sendinel/mcp-server 1.0.121 → 1.0.123

package/build/lib/action-approvals.js

@@ -298,6 +298,17 @@ export async function requestApproval(action, params, apiKeyId, channelContext,
         resource_id: params.resource_id ?? params.campaign_id ?? params.contact_id ?? null,
         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. */ }
     return elicitApproval({
         requires_approval: true,
         ...(await offerApprovalApp({ id: data.id, action, params: frozenParams, summary, tier, expires_at: expiresAt,
@@ -309,9 +320,9 @@ export async function requestApproval(action, params, apiKeyId, channelContext,
         expires_at: expiresAt,
         approve_via: 'Open approve_url (works on a phone) or Dashboard → Settings → Pending Approvals',
         approve_url: approvalPageUrl(data.id),
-        preview_text: buildApprovalPreview({ action, params: frozenParams, summary }).plain_summary,
+        preview_text: buildApprovalPreview({ action, params: frozenParams, summary, projectName }).plain_summary,
         message: `This action requires human approval. A notification has been sent to your dashboard. Approval ID: ${data.id}. Check status with: poll this approval_id, or wait for the webhook callback (event: approval.decided). Token expires in 24 hours.`,
-    }, { action, params: frozenParams, summary }, getProjectId());
+    }, { action, params: frozenParams, summary, projectName }, getProjectId());
 }
 const registeredApproval = new AsyncLocalStorage();
 /** Read by the hosted bridge only; no scope or token is changed. */
@@ -334,7 +345,7 @@ export async function checkApproval(approvalId, options = {}) {
     }
     const { data, error } = await approvalStore()
         .from('action_approvals')
-        .select('action, status, decided_by, decided_via, expires_at, used_at, params, payload_hash, requested_at')
+        .select('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();

package/build/lib/approval-elicitation-relay.js

@@ -1,3 +1,4 @@
+import { ELICITATION_HOLD_MS } from './approval-elicitation.js';
 import { randomUUID } from 'node:crypto';
 import { approvalStore } from './tester-requests-store.js';
 import { humanApprovalEligible } from './approval-human-eligibility.js';
@@ -20,9 +21,10 @@ export async function recordElicitationResponse(body, identity) {
         (typeof message.id !== 'string' && typeof message.id !== 'number') ||
         ('error' in message) || !identity.oauthTokenId || !identity.actorId)
         return;
-    const result = object(message.result), content = object(result?.content);
-    if (result?.action !== 'accept' || (content?.decision !== 'approve' && content?.decision !== 'reject'))
+    const result = object(message.result);
+    if (result?.action !== 'accept' && result?.action !== 'decline')
         return;
+    const decision = result.action === 'accept' ? 'approve' : 'reject';
     try {
         const client = email(), now = new Date().toISOString();
         const { data: prompt, error } = await client.from(TABLE).select('*')
@@ -48,7 +50,7 @@ export async function recordElicitationResponse(body, identity) {
             return;
         const { data, error: rpcError } = await client.rpc('record_elicitation_decision', {
             p_prompt_id: prompt.id, p_oauth_token_id: identity.oauthTokenId, p_user_id: identity.actorId,
-            p_decision: content.decision, p_project_id: prompt.project_id, p_action: approval.action,
+            p_decision: decision, p_project_id: prompt.project_id, p_action: approval.action,
         });
         if (rpcError || data !== true)
             return;
@@ -63,53 +65,70 @@ export async function recordElicitationResponse(body, identity) {
  */
 export async function relayElicitation(options) {
     const pending = 'decision_pending';
+    const exit = (reason) => {
+        console.warn('[approval_wait]', { stage: 'relay', reason });
+        return pending;
+    };
     const { identity, signal } = options;
-    if (signal.aborted || !identity.projectId || !identity.oauthTokenId || !identity.actorId ||
+    if (signal.aborted)
+        return exit('request_aborted');
+    if (!identity.projectId || !identity.oauthTokenId || !identity.actorId ||
         !await humanApprovalEligible(options.action, identity.projectId, identity))
-        return pending;
-    const client = email(), now = Date.now(), requestId = randomUUID();
+        return exit('eligibility_refused');
+    const now = Date.now(), requestId = randomUUID();
     const promptId = randomUUID();
     try {
+        const client = email();
         const { error: expireError } = await client.from(TABLE).update({ status: 'expired' })
             .eq('oauth_token_id', identity.oauthTokenId).eq('status', 'pending').lt('expires_at', new Date(now).toISOString());
         if (expireError)
-            return pending;
+            return exit('expiry_update_failed');
         // Bounded per-token purge; an old backlog is drained in chunks, never one unbounded delete.
         const { data: old, error: oldError } = await client.from(TABLE).select('id')
             .eq('oauth_token_id', identity.oauthTokenId).lt('created_at', new Date(now - 3_600_000).toISOString()).limit(100);
         if (oldError)
-            return pending;
+            return exit('cleanup_read_failed');
         if (old?.length) {
             const { error: deleteError } = await client.from(TABLE).delete().eq('oauth_token_id', identity.oauthTokenId)
                 .in('id', old.map((row) => row.id));
             if (deleteError)
-                return pending;
+                return exit('cleanup_delete_failed');
         }
         const { data: approval, error: approvalError } = await client.from('action_approvals')
             .select('id, expires_at').eq('id', options.approvalId).eq('project_id', identity.projectId)
             .eq('oauth_token_id', identity.oauthTokenId).eq('action', options.action)
             .eq('tier', 'gated').eq('status', 'pending').is('used_at', null).gt('expires_at', new Date(now).toISOString()).maybeSingle();
-        if (approvalError || !approval || !(Date.parse(approval.expires_at) > Date.now()) || signal.aborted)
-            return pending;
+        if (signal.aborted)
+            return exit('request_aborted');
+        if (approvalError || !approval)
+            return exit(approvalError ? 'approval_lookup_failed' : 'row_not_found');
+        if (!(Date.parse(approval.expires_at) > Date.now()))
+            return exit('approval_expired');
         const { error } = await client.from(TABLE).insert({ id: promptId, approval_id: options.approvalId,
             project_id: identity.projectId, oauth_token_id: identity.oauthTokenId, user_id: identity.actorId,
             jsonrpc_request_id: requestId, channel: 'mcp_elicitation', status: 'pending',
             created_at: new Date(now).toISOString(), expires_at: new Date(Math.min(now + 120_000, Date.parse(approval.expires_at))).toISOString() });
-        if (error || signal.aborted)
-            return pending;
+        if (signal.aborted)
+            return exit('request_aborted');
+        if (error)
+            return exit('prompt_insert_failed');
         // The id is created here and passed unchanged both to the row and the actual transport.
         await options.send({ jsonrpc: '2.0', id: requestId, method: 'elicitation/create', params: options.params });
-        while (!signal.aborted && Date.now() < now + 60_000) {
+        while (!signal.aborted && Date.now() < now + ELICITATION_HOLD_MS) {
             const { data: prompt, error: readError } = await client.from(TABLE).select('status, answer, expires_at')
                 .eq('id', promptId).eq('oauth_token_id', identity.oauthTokenId).eq('user_id', identity.actorId).maybeSingle();
-            if (signal.aborted || readError || !prompt || !(Date.parse(prompt.expires_at) > Date.now()))
-                return pending;
+            if (signal.aborted)
+                return exit('request_aborted');
+            if (readError || !prompt)
+                return exit(readError ? 'prompt_lookup_failed' : 'row_not_found');
+            if (!(Date.parse(prompt.expires_at) > Date.now()))
+                return exit('prompt_expired');
             if (prompt.status === 'answered')
-                return prompt.answer === 'approve' ? 'approved' : prompt.answer === 'reject' ? 'rejected' : pending;
+                return prompt.answer === 'approve' ? 'approved' : prompt.answer === 'reject' ? 'rejected' : exit('invalid_answer');
             if (prompt.status !== 'pending')
-                return pending;
+                return exit('prompt_not_pending');
             await new Promise(resolve => {
-                const timer = setTimeout(done, 750);
+                const timer = setTimeout(done, Math.min(750, Math.max(0, now + ELICITATION_HOLD_MS - Date.now())));
                 function done() { clearTimeout(timer); signal.removeEventListener('abort', done); resolve(); }
                 signal.addEventListener('abort', done, { once: true });
                 if (signal.aborted)
@@ -119,6 +138,7 @@ export async function relayElicitation(options) {
     }
     catch {
         // Refused inserts/updates, missing migrations and disconnected streams keep approve_url.
+        return exit(signal.aborted ? 'request_aborted' : 'relay_failed');
     }
-    return pending;
+    return exit(signal.aborted ? 'request_aborted' : 'hold_elapsed');
 }

package/build/lib/approval-elicitation.d.ts

@@ -34,7 +34,11 @@ export type TransportBinding = {
 type RequestExtra = {
     requestId?: RequestId;
     signal?: AbortSignal;
+    _meta?: {
+        progressToken?: string | number;
+    };
 };
+export declare const ELICITATION_HOLD_MS = 30000;
 export declare function installApprovalElicitation(server: Pick<McpServer, 'server'>, binding: TransportBinding): void;
 /** Called by the registry wrapper with SDK-owned extra, outside parsed model arguments. */
 export declare function runWithApprovalElicitation<T>(server: Pick<McpServer, 'server'>, extra: RequestExtra | undefined, run: () => T): T;
@@ -50,6 +54,7 @@ export declare function elicitApproval<T extends ApprovalFallback>(result: T, fr
     action: string;
     params: unknown;
     summary: string;
+    projectName?: string;
 }, projectId: string): Promise<T & {
     decision_status: ElicitationDecision;
 }>;

package/build/lib/approval-elicitation.js

@@ -2,14 +2,15 @@ import { isHumanRequestableAdminTool } from './admin-tools.js';
 import { humanApprovalEligible } from './approval-human-eligibility.js';
 import { AsyncLocalStorage } from 'node:async_hooks';
 import { randomUUID } from 'node:crypto';
-import { buildApprovalPreview, isHumanApprovalChannel } from '@sendinel/domain';
+import { approvalDisplayFact, buildApprovalPreview, isEmailApprovalAction, isHumanApprovalChannel } from '@sendinel/domain';
 import { approvalStore } from './tester-requests-store.js';
 import { approvalAppClientAllowed, approvalClientName, approval_channel_available, probeApprovalCapabilities } from './approval-capabilities.js';
 // Keyed by the SDK Server, not the McpServer wrapper: other installers (the Apps tier) wrap
 // McpServer in a Proxy, which changes the wrapper's identity but never the connection's Server.
 const sessions = new WeakMap();
 const requests = new AsyncLocalStorage();
-const TIMEOUT_MS = 60_000;
+export const ELICITATION_HOLD_MS = 30_000;
+const PROGRESS_INTERVAL_MS = 5_000;
 export function installApprovalElicitation(server, binding) {
     sessions.set(server.server, { ...binding, connectionId: randomUUID() });
 }
@@ -25,75 +26,99 @@ export function runWithApprovalElicitation(server, extra, run) {
 /** All outcomes retain the ordinary approval link/text. Approval never applies the action. */
 export async function elicitApproval(result, frozen, projectId) {
     const pending = { ...result, decision_status: 'decision_pending' };
+    const warn = (reason) => console.warn('[approval_wait]', { stage: 'elicitation', reason });
+    const exit = (reason) => { warn(reason); return pending; };
     const context = requests.getStore();
-    if (!context || context.projectId !== projectId || result.tier !== 'gated')
-        return pending;
+    if (!context)
+        return exit('no_transport_context');
+    if (context.projectId !== projectId)
+        return exit('project_mismatch');
+    if (result.tier !== 'gated')
+        return exit('tier_ineligible');
     // #4285: with the Apps tier off for this client (default), a declared lower tier still applies.
     let channel = approval_channel_available(context.server.server, { appsAllowed: approvalAppClientAllowed(approvalClientName(context.server.server)) });
     if (channel === 'mcp_elicitation_form' && !context.userId &&
         probeApprovalCapabilities(context.server.server.getClientCapabilities()).elicitation_url)
         channel = 'mcp_elicitation_url';
     if (channel !== 'mcp_elicitation_form' && channel !== 'mcp_elicitation_url')
-        return pending;
+        return exit('channel_unavailable');
     if (channel === 'mcp_elicitation_form' && (!context.userId ||
         !await humanApprovalEligible(frozen.action, projectId, context.identity)))
-        return pending;
+        return exit('eligibility_refused');
     if (channel === 'mcp_elicitation_url' && isHumanRequestableAdminTool(frozen.action) &&
         !await humanApprovalEligible(frozen.action, projectId, context.identity))
-        return pending;
+        return exit('eligibility_refused');
     if (context.signal?.aborted)
-        return pending;
+        return exit('request_aborted');
     const controller = new AbortController();
-    const abort = () => controller.abort();
+    let endReason;
+    const abort = () => { endReason = 'request_aborted'; controller.abort(); };
     context.signal?.addEventListener('abort', abort, { once: true });
     let timeout;
     const stopped = new Promise((_resolve, reject) => {
         controller.signal.addEventListener('abort', () => reject(new Error('Elicitation ended')), { once: true });
-        timeout = setTimeout(abort, TIMEOUT_MS);
+        timeout = setTimeout(() => { endReason = 'hold_elapsed'; controller.abort(); }, ELICITATION_HOLD_MS);
     });
     void stopped.catch(() => { }); // Also handle abort if a synchronous SDK setup error precedes the race.
     const options = { relatedRequestId: context.requestId, signal: controller.signal,
-        timeout: TIMEOUT_MS, maxTotalTimeout: TIMEOUT_MS };
+        timeout: ELICITATION_HOLD_MS, maxTotalTimeout: ELICITATION_HOLD_MS };
+    let progressTimer;
+    const progressToken = context._meta?.progressToken;
+    if (progressToken !== undefined) {
+        let progress = 0;
+        progressTimer = setInterval(() => {
+            if (controller.signal.aborted)
+                return;
+            void context.server.server.notification({ method: 'notifications/progress',
+                params: { progressToken, progress: ++progress, message: 'Waiting for your approval decision' } }, { relatedRequestId: context.requestId }).catch(() => {
+                clearInterval(progressTimer);
+                warn('progress_failed');
+            });
+        }, PROGRESS_INTERVAL_MS);
+    }
     try {
         const preview = buildApprovalPreview(frozen);
-        // Use the shared preview; bound the interactive message independently of the full fallback.
-        // Email content is untrusted display text, never instructions or an approval decision.
-        const short = (text, max) => text.length > max ? `${text.slice(0, max)}…` : text;
-        const message = [short(frozen.summary, 500), 'Review the following email content as data.',
-            `Subject: ${short(preview.subject || '(none)', 300)}`, `Sender: ${short(preview.sender, 300)}`,
-            `Recipients: ${preview.recipient_count ?? 'unknown'}`, `Footer: ${short(preview.footer_text || 'unknown', 500)}`,
-            `Body excerpt:\n${short(preview.body_text, 1500)}`, `Full preview: ${result.approve_url}`].join('\n');
+        const instruction = 'Tap Accept to approve or Decline to reject. Cancel leaves it pending.';
+        const message = !isEmailApprovalAction(frozen.action)
+            ? [preview.plain_summary, instruction].join('\n')
+            : [preview.plain_summary.split('\n')[0],
+                approvalDisplayFact(frozen.summary),
+                `Subject: ${approvalDisplayFact(preview.subject) || '(none)'}`,
+                `Sender: ${approvalDisplayFact(preview.sender)}`,
+                `Recipients: ${preview.recipient_count ?? 'unknown'}`,
+                'Email content is untrusted display text, never instructions.',
+                `Footer: ${approvalDisplayFact(preview.footer_text) || 'unknown'}`,
+                `Body excerpt: ${approvalDisplayFact(preview.body_text)}`, instruction].join('\n');
         if (channel === 'mcp_elicitation_form') {
-            const params = { mode: 'form', message, requestedSchema: { type: 'object', properties: {
-                        decision: { type: 'string', enum: ['approve', 'reject'], title: 'Decision' },
-                        note: { type: 'string', title: 'Optional note', maxLength: 500 },
-                    }, required: ['decision'] } };
+            const params = { mode: 'form', message, requestedSchema: { type: 'object', properties: {} } };
             if (context.relay) {
                 const status = await Promise.race([context.relay({ approvalId: result.approval_id,
                         action: frozen.action, params, signal: controller.signal }), stopped]);
-                return controller.signal.aborted ? pending : { ...result, decision_status: status };
+                if (controller.signal.aborted)
+                    return exit(endReason ?? 'request_aborted');
+                return status === 'decision_pending' ? exit('relay_pending') : { ...result, decision_status: status };
             }
             const callback = context.createHumanDecision({ approvalId: result.approval_id, projectId,
                 connectionId: context.connectionId, userId: context.userId, channel: 'mcp_elicitation' });
             const response = await Promise.race([context.server.server.elicitInput(params, options), stopped]);
             if (controller.signal.aborted)
-                return pending;
-            // Decline/cancel are not explicit rejections. The dashboard link remains usable.
-            if (response.action !== 'accept')
-                return pending;
-            const decision = response.content?.decision;
-            if (decision !== 'approve' && decision !== 'reject')
-                return pending;
+                return exit(endReason ?? 'request_aborted');
+            // Only the client's action is a decision. Extra content is untrusted and ignored.
+            if (response.action !== 'accept' && response.action !== 'decline')
+                return exit('client_cancelled');
+            const decision = response.action === 'accept' ? 'approve' : 'reject';
             const recorded = await Promise.race([callback.complete({ interactionId: callback.interactionId,
                     connectionId: context.connectionId, decision }), stopped]);
-            return recorded ? { ...result, decision_status: decision === 'approve' ? 'approved' : 'rejected' } : pending;
+            return recorded ? { ...result, decision_status: decision === 'approve' ? 'approved' : 'rejected' } : exit('decision_refused');
         }
         const elicitationId = randomUUID();
         const notify = context.server.server.createElicitationCompletionNotifier(elicitationId, { relatedRequestId: context.requestId });
         const response = await Promise.race([context.server.server.elicitInput({ mode: 'url', message,
                 url: result.approve_url, elicitationId }, options), stopped]);
-        if (response.action !== 'accept' || controller.signal.aborted)
-            return pending;
+        if (controller.signal.aborted)
+            return exit(endReason ?? 'request_aborted');
+        if (response.action !== 'accept')
+            return exit('url_not_accepted');
         // URL accept only means the page may open. Only its authenticated decision counts.
         // Observe while this request is alive; do not retain a background poller after timeout.
         while (!controller.signal.aborted) {
@@ -102,7 +127,7 @@ export async function elicitApproval(result, frozen, projectId) {
             const { data, error } = await Promise.race([client.from('action_approvals')
                     .select('status, decided_via').eq('id', result.approval_id).eq('project_id', projectId).maybeSingle(), stopped]);
             if (error || !data)
-                return pending;
+                return exit(error ? 'lookup_failed' : 'row_not_found');
             if ((data.status === 'approved' || data.status === 'rejected') && isHumanApprovalChannel(data.decided_via)) {
                 await Promise.race([notify(), stopped]);
                 return { ...result, decision_status: data.status };
@@ -113,13 +138,16 @@ export async function elicitApproval(result, frozen, projectId) {
                     controller.signal.addEventListener('abort', done, { once: true });
                 }), stopped]);
         }
+        warn(endReason ?? 'request_aborted');
     }
     catch {
+        warn(endReason ?? 'wait_failed');
         // Unsupported SDK modes, disconnections, timeouts and refused DB writes fail to the link.
-        // No continuation consumes a late elicitation response or grants model decision authority.
+        // The hosted relay row remains valid for late authenticated answer POSTs.
     }
     finally {
         clearTimeout(timeout);
+        clearInterval(progressTimer);
         context.signal?.removeEventListener('abort', abort);
         controller.abort();
     }

package/package.json

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