@sendinel/mcp-server 1.0.9 → 1.0.11

package/build/tools/data.js

@@ -1,8 +1,10 @@
+import { encodeSavedCredentialId, extractSavedCredentialValue, parseSavedCredentialId, savedCredentialProviderLabel, } from '@sendinel/domain';
 import { createHash, randomBytes } from 'crypto';
 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 } from '../lib/action-approvals.js';
 import { getProjectId } from '../project.js';
 import { logAudit } from '../audit.js';
 const j = (data) => ({ content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] });
@@ -14,6 +16,15 @@ function generateApiKey() {
         prefix: secret.slice(0, 8),
     };
 }
+function generateCustomWebhookSecret() {
+    return randomBytes(32).toString('hex');
+}
+function appBaseUrl() {
+    return (process.env.NEXT_PUBLIC_APP_URL ?? process.env.SENDINEL_APP_URL ?? process.env.APP_URL ?? 'https://sendinel.ai').replace(/\/$/, '');
+}
+function customWebhookEndpointUrl(connectionId) {
+    return `${appBaseUrl()}/api/v1/webhooks/custom/${connectionId}`;
+}
 function sanitizeSuppression(row) {
     return {
         ...row,
@@ -262,6 +273,219 @@ export function registerDataTools(server) {
             return j({ error: error instanceof Error ? error.message : 'Failed to list connected platforms' });
         }
     });
+    server.registerTool('list_provider_credentials', {
+        title: 'List Provider Credentials',
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+        description: 'List saved provider credential metadata for the current project organization across platform connections and migration imports. Never returns decrypted secrets, masked fragments, or suffixes.',
+        inputSchema: {
+            org_id: z.string().uuid().optional(),
+            include_inactive: z.boolean().optional().default(false),
+        },
+    }, async ({ org_id, include_inactive = false }) => {
+        try {
+            const client = adminDb();
+            const context = await getPlatformProjectContext(client, org_id);
+            let platformQuery = client
+                .schema('email')
+                .from('platform_connections')
+                .select('id, platform, display_name, credentials_enc, status, is_active, created_at, updated_at, last_synced_at')
+                .eq('org_id', context.orgId)
+                .eq('project_id', context.projectId)
+                .order('updated_at', { ascending: false });
+            if (!include_inactive)
+                platformQuery = platformQuery.eq('is_active', true);
+            const importQuery = client
+                .schema('email')
+                .from('import_jobs')
+                .select('id, provider, credentials_enc, status, created_at, completed_at')
+                .eq('org_id', context.orgId)
+                .eq('project_id', context.projectId)
+                .order('created_at', { ascending: false })
+                .limit(50);
+            const [platformResult, importResult] = await Promise.all([platformQuery, importQuery]);
+            if (platformResult.error)
+                return j({ error: platformResult.error.message });
+            if (importResult.error)
+                return j({ error: importResult.error.message });
+            const mapRow = (row, source) => {
+                let credential;
+                try {
+                    credential = extractSavedCredentialValue(decrypt(row.credentials_enc));
+                }
+                catch {
+                    return null;
+                }
+                if (!credential)
+                    return null;
+                const provider = source === 'platform' ? String(row.platform ?? '') : String(row.provider ?? '');
+                return {
+                    id: encodeSavedCredentialId(source, row.id),
+                    source,
+                    provider,
+                    provider_label: savedCredentialProviderLabel(provider),
+                    display_name: row.display_name ?? null,
+                    credential_key: credential.key,
+                    status: row.status ?? null,
+                    is_active: source === 'platform' ? (row.is_active ?? null) : null,
+                    created_at: row.created_at ?? null,
+                    last_used_at: source === 'platform' ? (row.last_synced_at ?? null) : (row.completed_at ?? null),
+                };
+            };
+            const platformCredentials = (platformResult.data ?? [])
+                .map((row) => mapRow(row, 'platform'))
+                .filter(Boolean);
+            const seenImportProviders = new Set();
+            const importCredentials = [];
+            for (const row of importResult.data ?? []) {
+                const credential = mapRow(row, 'import');
+                if (!credential || seenImportProviders.has(credential.provider))
+                    continue;
+                seenImportProviders.add(credential.provider);
+                importCredentials.push(credential);
+            }
+            return j({ credentials: [...platformCredentials, ...importCredentials] });
+        }
+        catch (error) {
+            return j({ error: error instanceof Error ? error.message : 'Failed to list provider credentials' });
+        }
+    });
+    server.registerTool('delete_provider_credential', {
+        title: 'Delete Provider Credential',
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: true,
+            idempotentHint: false,
+            openWorldHint: false,
+        },
+        description: 'Remove a saved provider credential after a metadata-only preview and approval. Platform connections are deleted outright; migration-import secrets are revoked in place while retaining the import-job row. No secret value is returned.',
+        inputSchema: {
+            org_id: z.string().uuid().optional(),
+            credential_id: z.string().min(1),
+            confirmed: z.boolean().optional().default(false).describe('Two-call confirmation. First call previews exactly what is removed; second call with confirmed=true proceeds to approval.'),
+            approval_id: z.string().uuid().optional().describe('Approval token from a previous confirmed call without approval_id. Required when the action is not autonomous.'),
+        },
+    }, async ({ org_id, credential_id, confirmed, approval_id }) => {
+        try {
+            const parsed = parseSavedCredentialId(credential_id);
+            if (!parsed)
+                return j({ error: 'Invalid credential_id' });
+            const client = adminDb();
+            const context = await getPlatformProjectContext(client, org_id);
+            const table = parsed.source === 'platform' ? 'platform_connections' : 'import_jobs';
+            const columns = parsed.source === 'platform'
+                ? 'id, platform, display_name, status, is_active, created_at'
+                : 'id, provider, status, created_at, completed_at';
+            const { data: credential, error: credentialErr } = await client
+                .schema('email')
+                .from(table)
+                .select(columns)
+                .eq('id', parsed.rowId)
+                .eq('org_id', context.orgId)
+                .eq('project_id', context.projectId)
+                .maybeSingle();
+            if (credentialErr)
+                return j({ error: credentialErr.message });
+            if (!credential)
+                return j({ error: 'Credential not found' });
+            const provider = parsed.source === 'platform' ? credential.platform : credential.provider;
+            const approvalParams = {
+                credential_id,
+                source: parsed.source,
+                provider,
+                org_id: context.orgId,
+                project_id: context.projectId,
+            };
+            if (!confirmed) {
+                return j({
+                    confirmation_required: true,
+                    tool: 'delete_provider_credential',
+                    credential: {
+                        id: credential_id,
+                        source: parsed.source,
+                        provider,
+                        provider_label: savedCredentialProviderLabel(String(provider ?? '')),
+                        display_name: credential.display_name ?? null,
+                        status: credential.status ?? null,
+                        created_at: credential.created_at ?? null,
+                    },
+                    will_delete: parsed.source === 'platform'
+                        ? 'The platform connection row and its encrypted credential will be permanently deleted.'
+                        : 'The stored migration-import secret will be overwritten with a revocation marker; the import-job row will be retained.',
+                    message: 'Call again with confirmed=true to proceed to the approval step.',
+                });
+            }
+            const channelContext = currentChannelContext();
+            const decision = assertChannelCanExecute('delete_provider_credential', approvalParams, channelContext);
+            if (!decision.allowed)
+                return j({ error: decision.reason ?? 'This channel cannot request this action.' });
+            if (decision.tier !== 'autonomous') {
+                if (!approval_id)
+                    return j(await requestApproval('delete_provider_credential', approvalParams, undefined, channelContext));
+                const check = await checkApproval(approval_id, {
+                    consume: true,
+                    action: 'delete_provider_credential',
+                    params: approvalParams,
+                });
+                if (!check.approved) {
+                    return j({
+                        error: `Approval ${approval_id} is ${check.status}. ${check.status === 'pending' ? 'Waiting for human approval via dashboard.' : 'Request a new approval.'}`,
+                        code: `APPROVAL_${check.status.toUpperCase()}`,
+                    });
+                }
+            }
+            if (parsed.source === 'platform') {
+                const { data, error } = await client
+                    .schema('email')
+                    .from('platform_connections')
+                    .delete()
+                    .eq('id', parsed.rowId)
+                    .eq('org_id', context.orgId)
+                    .eq('project_id', context.projectId)
+                    .select('id, platform')
+                    .maybeSingle();
+                if (error)
+                    return j({ error: error.message });
+                if (!data)
+                    return j({ error: 'Credential not found' });
+                await logAudit({
+                    action: 'credential.deleted',
+                    resourceType: 'platform_connection',
+                    resourceId: parsed.rowId,
+                    details: { platform: data.platform },
+                });
+                return j({ deleted: true, id: credential_id, source: 'platform', provider: data.platform });
+            }
+            const revokedAt = new Date().toISOString();
+            const { data, error } = await client
+                .schema('email')
+                .from('import_jobs')
+                .update({ credentials_enc: encrypt(JSON.stringify({ revoked: true, revoked_at: revokedAt })) })
+                .eq('id', parsed.rowId)
+                .eq('org_id', context.orgId)
+                .eq('project_id', context.projectId)
+                .select('id, provider')
+                .maybeSingle();
+            if (error)
+                return j({ error: error.message });
+            if (!data)
+                return j({ error: 'Credential not found' });
+            await logAudit({
+                action: 'credential.revoked',
+                resourceType: 'import_job',
+                resourceId: parsed.rowId,
+                details: { provider: data.provider },
+            });
+            return j({ deleted: true, id: credential_id, source: 'import', provider: data.provider });
+        }
+        catch (error) {
+            return j({ error: error instanceof Error ? error.message : 'Failed to delete provider credential' });
+        }
+    });
     server.registerTool('connect_platform', {
         title: 'Connect Platform',
         annotations: {
@@ -480,6 +704,223 @@ export function registerDataTools(server) {
             return j({ error: error instanceof Error ? error.message : 'Failed to configure platform trigger' });
         }
     });
+    server.registerTool('list_custom_webhooks', {
+        title: 'List Custom Webhooks',
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+        description: 'List custom inbound webhook connections for the current project. These are Sendinel-hosted receiving endpoints your own systems POST contact events to — separate from subscribe_webhook, which registers an outbound URL that Sendinel pushes its own events to. Stored secrets are never returned.',
+        inputSchema: {
+            org_id: z.string().uuid().optional(),
+            include_inactive: z.boolean().optional().default(false),
+        },
+    }, async ({ org_id, include_inactive = false }) => {
+        try {
+            const client = adminDb();
+            const context = await getPlatformProjectContext(client, org_id);
+            let query = client
+                .schema('email')
+                .from('platform_connections')
+                .select('id, display_name, status, is_active, created_at, updated_at')
+                .eq('org_id', context.orgId)
+                .eq('project_id', context.projectId)
+                .eq('platform', 'custom')
+                .order('created_at', { ascending: false });
+            if (!include_inactive)
+                query = query.eq('is_active', true);
+            const { data, error } = await query;
+            if (error)
+                return j({ error: error.message });
+            return j({
+                connections: (data ?? []).map((connection) => ({
+                    id: connection.id,
+                    display_name: connection.display_name,
+                    status: connection.status,
+                    is_active: connection.is_active,
+                    endpoint_url: customWebhookEndpointUrl(connection.id),
+                    has_secret: true,
+                    created_at: connection.created_at,
+                    updated_at: connection.updated_at,
+                })),
+            });
+        }
+        catch (error) {
+            return j({ error: error instanceof Error ? error.message : 'Failed to list custom webhooks' });
+        }
+    });
+    server.registerTool('create_custom_webhook', {
+        title: 'Create Custom Webhook',
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: false,
+            openWorldHint: false,
+        },
+        description: 'Create a Sendinel-hosted inbound webhook endpoint and return the secret once. Your own system can POST contact events to the returned endpoint_url, signed with the returned secret (HMAC-SHA256, header x-sendinel-signature: sha256=<hex>). Store the secret now because no tool can reveal the stored secret later. This is separate from subscribe_webhook: that tool registers a URL Sendinel pushes events to; this tool creates a URL that receives events from you.',
+        inputSchema: {
+            org_id: z.string().uuid().optional(),
+            label: z.string().min(1).max(200).optional(),
+        },
+    }, async ({ org_id, label }) => {
+        try {
+            const client = adminDb();
+            const context = await getPlatformProjectContext(client, org_id);
+            const displayName = label?.trim() || 'Custom webhook';
+            const secret = generateCustomWebhookSecret();
+            const config = {
+                label: displayName,
+                credential_keys: ['webhook_secret'],
+                signature_header: 'x-sendinel-signature',
+                signature_format: 'sha256=<hex>',
+            };
+            const { data, error } = await client
+                .schema('email')
+                .from('platform_connections')
+                .upsert({
+                user_id: context.userId,
+                org_id: context.orgId,
+                project_id: context.projectId,
+                platform: 'custom',
+                connection_mode: 'migrate',
+                display_name: displayName,
+                credentials_enc: encrypt(JSON.stringify({ webhook_secret: secret })),
+                config,
+                meta: config,
+                status: 'connected',
+                is_active: true,
+                last_error: null,
+                updated_at: new Date().toISOString(),
+            }, { onConflict: 'user_id,org_id,project_id,platform,connection_mode' })
+                .select('id')
+                .single();
+            if (error || !data)
+                return j({ error: error?.message ?? 'Failed to create custom webhook' });
+            const endpointUrl = customWebhookEndpointUrl(data.id);
+            await client
+                .schema('email')
+                .from('platform_connections')
+                .update({ config: { ...config, webhook_url: endpointUrl }, meta: { ...config, webhook_url: endpointUrl } })
+                .eq('id', data.id);
+            await logAudit({
+                action: 'platform_connection.custom_webhook_created',
+                resourceType: 'platform_connection',
+                resourceId: data.id,
+            });
+            return j({
+                connection_id: data.id,
+                endpoint_url: endpointUrl,
+                secret,
+                message: `Custom webhook created. Store the secret now — it will not be shown again. POST events to ${endpointUrl} with an x-sendinel-signature: sha256=<hmac-sha256-hex> header.`,
+            });
+        }
+        catch (error) {
+            return j({ error: error instanceof Error ? error.message : 'Failed to create custom webhook' });
+        }
+    });
+    server.registerTool('rotate_custom_webhook_secret', {
+        title: 'Rotate Custom Webhook Secret',
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: true,
+            idempotentHint: false,
+            openWorldHint: false,
+        },
+        description: 'Rotate the signing secret for a custom inbound webhook connection and return the secret once. Uses two-call confirmation plus approval before immediately invalidating the previous secret. Any system still signing requests with the old secret will get a 400 (invalid signature) on every call until it is updated with the new secret returned here. There is no grace period.',
+        inputSchema: {
+            connection_id: z.string().uuid(),
+            confirmed: z.boolean().optional().default(false).describe('Two-call confirmation. First call previews, second call with confirmed=true proceeds to approval.'),
+            approval_id: z.string().uuid().optional().describe('Approval token from a previous confirmed call without approval_id. Required when the action is not autonomous.'),
+        },
+    }, async ({ connection_id, confirmed, approval_id }) => {
+        try {
+            const client = adminDb();
+            const projectId = getProjectId();
+            const { data: connection, error: lookupError } = await client
+                .schema('email')
+                .from('platform_connections')
+                .select('id, project_id, display_name, config')
+                .eq('id', connection_id)
+                .eq('project_id', projectId)
+                .eq('platform', 'custom')
+                .eq('is_active', true)
+                .maybeSingle();
+            if (lookupError)
+                return j({ error: lookupError.message });
+            if (!connection)
+                return j({ error: 'Custom webhook not found' });
+            if (!confirmed) {
+                return j({
+                    confirmation_required: true,
+                    tool: 'rotate_custom_webhook_secret',
+                    connection: {
+                        id: connection.id,
+                        display_name: connection.display_name,
+                        endpoint_url: customWebhookEndpointUrl(connection.id),
+                    },
+                    warning: 'Rotation immediately invalidates the previous secret. Requests signed with it will be rejected (400) until the sender is updated. There is no grace period.',
+                    message: 'Call again with confirmed=true to proceed to approval.',
+                });
+            }
+            const approvalParams = { connection_id };
+            const channelContext = currentChannelContext();
+            const decision = assertChannelCanExecute('rotate_custom_webhook_secret', approvalParams, channelContext);
+            if (!decision.allowed)
+                return j({ error: decision.reason ?? 'This channel cannot request this action.' });
+            if (decision.tier !== 'autonomous') {
+                if (!approval_id) {
+                    const approval = await requestApproval('rotate_custom_webhook_secret', approvalParams, undefined, channelContext);
+                    return j(approval);
+                }
+                const check = await checkApproval(approval_id, { consume: true, action: 'rotate_custom_webhook_secret', params: approvalParams });
+                if (!check.approved) {
+                    return j({
+                        error: `Approval ${approval_id} is ${check.status}. ${check.status === 'pending' ? 'Waiting for human approval via dashboard.' : 'Request a new approval.'}`,
+                    });
+                }
+            }
+            const secret = generateCustomWebhookSecret();
+            const updatedAt = new Date().toISOString();
+            const config = { ...(connection.config ?? {}), rotated_at: updatedAt };
+            const { data: updated, error } = await client
+                .schema('email')
+                .from('platform_connections')
+                .update({
+                credentials_enc: encrypt(JSON.stringify({ webhook_secret: secret })),
+                config,
+                meta: config,
+                updated_at: updatedAt,
+                status: 'connected',
+                last_error: null,
+            })
+                .eq('id', connection.id)
+                .eq('project_id', projectId)
+                .eq('platform', 'custom')
+                .eq('is_active', true)
+                .select('id')
+                .maybeSingle();
+            if (error)
+                return j({ error: error.message });
+            if (!updated)
+                return j({ error: 'Custom webhook is no longer active' });
+            await logAudit({
+                action: 'platform_connection.custom_webhook_rotated',
+                resourceType: 'platform_connection',
+                resourceId: connection.id,
+            });
+            return j({
+                connection_id: connection.id,
+                endpoint_url: customWebhookEndpointUrl(connection.id),
+                secret,
+                warning: 'The previous secret is now invalid. Requests signed with it will be rejected (400) until the sender is updated with this new secret. The new secret will not be shown again.',
+            });
+        }
+        catch (error) {
+            return j({ error: error instanceof Error ? error.message : 'Failed to rotate custom webhook secret' });
+        }
+    });
     server.registerTool('list_import_history', {
         title: 'List Import History',
         annotations: {