@sendinel/mcp-server 1.0.196 → 1.0.197

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

@@ -132,6 +132,7 @@ export declare function withPreviewApproval<A extends object, R extends ToolResu
 export declare function markNotExecuted<R extends object>(result: R): R;
 /** HTTP statuses that mean the request was refused before it changed anything. */
 export declare function isPreExecutionStatus(status: number | undefined): boolean;
+export declare function currentExecutingApprovalId(): string | undefined;
 export declare function withApproval<A extends object, R extends ToolResult>(action: string, handler: (args: A, extra?: unknown) => Promise<R> | R, options?: {
     display?: (args: A) => Promise<ApprovalDisplay> | ApprovalDisplay;
     registeredRequestOnly?: boolean;

package/build/lib/action-approvals.js

@@ -668,6 +668,12 @@ export function markNotExecuted(result) {
 export function isPreExecutionStatus(status) {
     return status !== undefined && [0, 400, 401, 403, 404, 422, 429, 501].includes(status);
 }
+// Server-owned context: the approval id a legacy withApproval handler is executing under.
+// Never read from tool arguments.
+const executingApproval = new AsyncLocalStorage();
+export function currentExecutingApprovalId() {
+    return executingApproval.getStore()?.id;
+}
 export function withApproval(action, handler, options = {}) {
     return async (args, extra) => {
         const { approval_id, ...params } = args;
@@ -709,7 +715,7 @@ export function withApproval(action, handler, options = {}) {
             return registeredApproval.run({ id: approval_id, action, projectId: getProjectId(), phase: decision.tier === 'autonomous' ? 'level' : 'approved',
                 ...(decision.tier === 'autonomous' ? { levelUserId: requestContext()?.actorId ?? undefined } : {}), decidedBy, decisionChannel }, () => handler(args, extra));
         }
-        const result = await handler(params, extra);
+        const result = await executingApproval.run({ id: approval_id }, () => handler(params, extra));
         // Keep the atomic claim across the outbound hop. Only a definitive pre-acceptance
         // failure may release it; transport errors and unknown outcomes can already have sent.
         const releasable = action === 'send_test_email' ? testSendNotAccepted(result) : notExecutedResults.has(result);

package/build/tools/data.js

@@ -4,7 +4,7 @@ import { z } from 'zod';
 import { adminDb, db } from '../db.js';
 import { decrypt, encrypt } from '../crypto.js';
 import { normalizeActiveCampaignAccountUrl } from '../lib/url-validation.js';
-import { assertChannelCanExecute, checkApproval, currentChannelContext, requestApproval, withApproval } from '../lib/action-approvals.js';
+import { approvalPageUrl, assertChannelCanExecute, checkApproval, currentChannelContext, currentExecutingApprovalId, requestApproval, withApproval } from '../lib/action-approvals.js';
 import { getProjectId } from '../project.js';
 import { logAudit } from '../audit.js';
 import { dbToolError, deleteBlockedToolResult } from '../lib/db-error.js';
@@ -17,6 +17,35 @@ function generateApiKey() {
         prefix: secret.slice(0, 8),
     };
 }
+const MAX_ACTIVE_API_KEYS = 10;
+const API_KEY_CLAIM_TTL_MS = 30 * 60 * 1000;
+const API_KEY_ALLOWED_SCOPES = new Set(['read', 'write']);
+/** Returns a plain error message, or null when the key request is valid. Never echoes secrets. */
+async function validateCreateApiKeyInput(scopes, toolGroups) {
+    if (scopes.includes('admin')) {
+        return 'Admin-scope API keys must be created in the dashboard by an org owner or admin.';
+    }
+    const badScope = scopes.find((scope) => !API_KEY_ALLOWED_SCOPES.has(scope));
+    if (badScope !== undefined)
+        return `Invalid scope "${badScope}". Only "read" and "write" are allowed here.`;
+    if (toolGroups.length === 0)
+        return null;
+    // Lazy: a static import of server.js is an import cycle (server imports every tool module).
+    const { ALL_TOOL_GROUPS } = await import('../server.js');
+    const badGroup = toolGroups.find((group) => !ALL_TOOL_GROUPS.includes(group));
+    if (badGroup !== undefined)
+        return `Unknown tool group "${badGroup}". Valid groups: ${ALL_TOOL_GROUPS.join(', ')}.`;
+    return null;
+}
+// Bad scopes or groups fail before a person is asked to approve anything.
+function createApiKeyWithEarlyValidation(gated) {
+    return async (args, extra) => {
+        const invalid = await validateCreateApiKeyInput(args.scopes ?? ['read'], args.tool_groups ?? []);
+        if (invalid)
+            return j({ error: invalid });
+        return gated(args, extra);
+    };
+}
 function generateCustomWebhookSecret() {
     return randomBytes(32).toString('hex');
 }
@@ -981,29 +1010,80 @@ export function registerDataTools(server) {
             idempotentHint: false,
             openWorldHint: false,
         },
-        description: 'Create an API key and return the secret once.',
+        description: 'Create an API key (read or write scope, optionally limited to tool_groups). The secret is NEVER returned here: it is shown once to a person on the claim_url page (open for 30 minutes). Ask the person to open claim_url and hand the key to the agent runtime.',
         inputSchema: {
             approval_id: z.string().uuid().optional().describe('Get this by calling once without it, then have a human approve the returned approve_url. Re-call with only approval_id to run the action.'),
             name: z.string().min(1),
             slug: z.string().optional(),
             scopes: z.array(z.string()).optional().default(['read']),
+            tool_groups: z.array(z.string()).optional().default([]).describe('Tool groups this key may use. Empty means all groups.'),
         },
-    }, withApproval('create_api_key', async ({ name, slug, scopes = ['read'] }) => {
-        // MCP API-key sessions can be unbound to a user, so they cannot prove an
-        // acting org role. Admin keys must be created through the dashboard.
-        if (scopes.includes('admin')) {
-            return j({ error: 'Admin-scope API keys must be created in the dashboard by an org owner or admin.' });
-        }
+    }, createApiKeyWithEarlyValidation(withApproval('create_api_key', async ({ name, slug, scopes = ['read'], tool_groups = [] }) => {
+        const invalid = await validateCreateApiKeyInput(scopes, tool_groups);
+        if (invalid)
+            return j({ error: invalid });
         const { secret, hash, prefix } = generateApiKey();
         const cleanSlug = slug?.trim().toLowerCase().replace(/[^a-z0-9-]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 50) || null;
+        const approvalId = currentExecutingApprovalId();
+        if (!approvalId)
+            return j({ error: 'This key needs an approved request so a person can claim it. Call without approval_id first.' });
+        const projectId = getProjectId();
+        const { count, error: countError } = await db().from('api_keys')
+            .select('id', { count: 'exact', head: true })
+            .eq('project_id', projectId)
+            .is('revoked_at', null);
+        if (countError)
+            return j(dbToolError(countError));
+        if ((count ?? 0) >= MAX_ACTIVE_API_KEYS) {
+            return j({ error: `Workspace API key limit reached (${MAX_ACTIVE_API_KEYS} active keys). Revoke one first.` });
+        }
         const { data, error } = await db().from('api_keys')
-            .insert({ project_id: getProjectId(), name, slug: cleanSlug, key_hash: hash, key_prefix: prefix, scopes })
+            .insert({ project_id: projectId, name, slug: cleanSlug, key_hash: hash, key_prefix: prefix, scopes, tool_groups })
             .select('id, name, slug')
             .single();
         if (error)
             return j(dbToolError(error));
-        return j({ key_id: data.id, name: data.name, slug: data.slug, secret });
-    }));
+        const { data: project } = await adminDb().schema('email').from('projects').select('org_id').eq('id', projectId).maybeSingle();
+        const expiresAt = new Date(Date.now() + API_KEY_CLAIM_TTL_MS).toISOString();
+        let stored = false;
+        try {
+            const { error: claimError } = await adminDb().schema('email').from('api_key_claims').insert({
+                project_id: projectId,
+                org_id: project?.org_id ?? null,
+                key_id: data.id,
+                approval_id: approvalId,
+                secret_enc: encrypt(secret),
+                expires_at: expiresAt,
+            });
+            stored = !claimError;
+        }
+        catch {
+            stored = false;
+        }
+        if (!stored) {
+            // Nobody can ever see this secret, so the key must not stay live.
+            await db().from('api_keys').update({ revoked_at: new Date().toISOString() }).eq('project_id', projectId).eq('id', data.id);
+            return j({ error: 'The key could not be prepared for a person to claim, so it was revoked. Ask for a new one.' });
+        }
+        return j({
+            key_id: data.id,
+            name: data.name,
+            slug: data.slug,
+            key_prefix: prefix,
+            scopes,
+            tool_groups,
+            claim_url: approvalPageUrl(approvalId),
+            expires_at: expiresAt,
+            message: 'Ask the person to open claim_url. The secret is shown there once and is never in this reply.',
+        });
+    }, {
+        display: ({ name, scopes = ['read'], tool_groups = [] }) => ({
+            key_name: name,
+            access: scopes.includes('write') ? 'Read & write' : 'Read only',
+            tool_groups: tool_groups.length ? tool_groups.join(', ') : 'all tools',
+            note: 'The key will be shown once, to you, on this page.',
+        }),
+    })));
     server.registerTool('revoke_api_key', {
         title: 'Revoke API Key',
         annotations: {

package/package.json

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