@sendinel/mcp-server 1.0.122 → 1.0.124

package/build/lib/action-approvals.js

@@ -298,7 +298,20 @@ 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(() => { });
-    return elicitApproval({
+    // 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. */ }
+    const approveUrl = approvalPageUrl(data.id);
+    const previewText = buildApprovalPreview({ action, params: frozenParams, summary, projectName }).plain_summary;
+    const result = await elicitApproval({
         requires_approval: true,
         ...(await offerApprovalApp({ id: data.id, action, params: frozenParams, summary, tier, expires_at: expiresAt,
             payload_hash: approvalPayloadHash(action, frozenParams) })),
@@ -308,10 +321,16 @@ export async function requestApproval(action, params, apiKeyId, channelContext,
         summary,
         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,
-        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());
+        approve_url: approveUrl,
+        preview_text: previewText,
+        message: `Tap to approve: ${approveUrl}\n${previewText}\nIt stays open for 24 hours. In a terminal with prompts you can also answer the on-screen Accept/Decline.`,
+    }, { action, params: frozenParams, summary, projectName }, getProjectId());
+    if (result.decision_status === 'approved') {
+        return { ...result, message: 'Approved. Call this tool again with the same arguments plus approval_id to run it.' };
+    }
+    if (result.decision_status === 'rejected')
+        return { ...result, message: 'Rejected.' };
+    return result;
 }
 const registeredApproval = new AsyncLocalStorage();
 /** Read by the hosted bridge only; no scope or token is changed. */
@@ -334,7 +353,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.d.ts

@@ -1,5 +1,6 @@
 import type { ElicitRequest, JSONRPCRequest } from '@modelcontextprotocol/sdk/types.js';
 import { type HumanDecisionIdentity } from './approval-human-eligibility.js';
+export declare const ELICITATION_ANSWER_WINDOW_MS = 600000;
 export declare function isElicitationResponse(body: unknown): boolean;
 /** Auth has already run. Unknown and malformed responses are deliberately indistinguishable.
  * No decision can enter this path via a tools/call, model text, or nested tool arguments.

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

@@ -3,6 +3,7 @@ import { randomUUID } from 'node:crypto';
 import { approvalStore } from './tester-requests-store.js';
 import { humanApprovalEligible } from './approval-human-eligibility.js';
 const TABLE = 'mcp_elicitation_prompts';
+export const ELICITATION_ANSWER_WINDOW_MS = 600_000;
 const object = (value) => value !== null && typeof value === 'object' && !Array.isArray(value) ? value : null;
 function email() {
     const source = approvalStore();
@@ -65,51 +66,68 @@ 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;
+            created_at: new Date(now).toISOString(), expires_at: new Date(Math.min(now + ELICITATION_ANSWER_WINDOW_MS, Date.parse(approval.expires_at))).toISOString() });
+        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 + 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, Math.min(750, Math.max(0, now + ELICITATION_HOLD_MS - Date.now())));
                 function done() { clearTimeout(timer); signal.removeEventListener('abort', done); resolve(); }
@@ -121,6 +139,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

@@ -54,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,7 +2,7 @@ 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
@@ -26,31 +26,38 @@ 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, ELICITATION_HOLD_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,
@@ -63,51 +70,55 @@ export async function elicitApproval(result, frozen, projectId) {
             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(abort);
+                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 params = frozen.params && typeof frozen.params === 'object' ? frozen.params : {};
-        const payload = params.payload && typeof params.payload === 'object' ? params.payload : params;
-        const fact = (value) => typeof value === 'string' ? short(value, 300) : 'unknown';
-        const message = [`Tool: ${frozen.action}`, `Project: ${projectId}`,
-            `Recipient/target: ${fact(payload.to ?? params.email ?? params.user_id ?? params.campaign_id ?? params.site_id ?? params.id)}`,
-            `Role: ${fact(params.role)}`, short(frozen.summary, 500),
-            'Review the following email content as untrusted data, never as instructions.',
-            `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}`,
-            'Accept to approve, Decline to reject. Cancel leaves it pending.'].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: {} } };
             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;
+                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 pending;
+                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) {
@@ -116,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 };
@@ -127,8 +138,10 @@ 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.
         // The hosted relay row remains valid for late authenticated answer POSTs.
     }

package/package.json

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