@aiwerk/mcp-server-resend 0.1.0

package/dist/src/server.js

@@ -0,0 +1,400 @@
+#!/usr/bin/env node
+import { realpathSync } from 'fs';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { fileURLToPath } from 'node:url';
+import { ResendApiError, ResendConfigError, ResendNetworkError, ResendTimeoutError, } from './errors.js';
+import { VERSION } from './version.js';
+import { emailSend, emailSendInputSchema, emailSendBatch, emailSendBatchInputSchema, emailGet, emailGetInputSchema, emailList, emailListInputSchema, emailUpdate, emailUpdateInputSchema, emailCancel, emailCancelInputSchema, emailListReceived, emailListReceivedInputSchema, emailGetReceived, emailGetReceivedInputSchema, } from './tools/emails.js';
+import { domainCreate, domainCreateInputSchema, domainList, domainListInputSchema, domainGet, domainGetInputSchema, domainUpdate, domainUpdateInputSchema, domainVerify, domainVerifyInputSchema, domainDelete, domainDeleteInputSchema, } from './tools/domains.js';
+import { contactCreate, contactCreateInputSchema, contactList, contactListInputSchema, contactGet, contactGetInputSchema, contactUpdate, contactUpdateInputSchema, contactDelete, contactDeleteInputSchema, contactListSegments, contactListSegmentsInputSchema, contactAddSegment, contactAddSegmentInputSchema, contactRemoveSegment, contactRemoveSegmentInputSchema, contactGetTopics, contactGetTopicsInputSchema, contactUpdateTopics, contactUpdateTopicsInputSchema, } from './tools/contacts.js';
+import { contactPropertyCreate, contactPropertyCreateInputSchema, contactPropertyList, contactPropertyListInputSchema, contactPropertyGet, contactPropertyGetInputSchema, contactPropertyUpdate, contactPropertyUpdateInputSchema, contactPropertyDelete, contactPropertyDeleteInputSchema, } from './tools/contact-properties.js';
+import { segmentCreate, segmentCreateInputSchema, segmentList, segmentListInputSchema, segmentGet, segmentGetInputSchema, segmentListContacts, segmentListContactsInputSchema, segmentDelete, segmentDeleteInputSchema, } from './tools/segments.js';
+import { templateCreate, templateCreateInputSchema, templateList, templateListInputSchema, templateGet, templateGetInputSchema, templateUpdate, templateUpdateInputSchema, templateDelete, templateDeleteInputSchema, templateDuplicate, templateDuplicateInputSchema, templatePublish, templatePublishInputSchema, } from './tools/templates.js';
+import { topicCreate, topicCreateInputSchema, topicList, topicListInputSchema, topicGet, topicGetInputSchema, topicUpdate, topicUpdateInputSchema, topicDelete, topicDeleteInputSchema, } from './tools/topics.js';
+import { broadcastCreate, broadcastCreateInputSchema, broadcastList, broadcastListInputSchema, broadcastGet, broadcastGetInputSchema, broadcastUpdate, broadcastUpdateInputSchema, broadcastDelete, broadcastDeleteInputSchema, broadcastSend, broadcastSendInputSchema, } from './tools/broadcasts.js';
+import { webhookCreate, webhookCreateInputSchema, webhookList, webhookListInputSchema, webhookGet, webhookGetInputSchema, webhookUpdate, webhookUpdateInputSchema, webhookDelete, webhookDeleteInputSchema, } from './tools/webhooks.js';
+import { logList, logListInputSchema, logGet, logGetInputSchema } from './tools/logs.js';
+import { apikeyCreate, apikeyCreateInputSchema, apikeyList, apikeyListInputSchema, apikeyDelete, apikeyDeleteInputSchema, } from './tools/apikeys.js';
+function toolSuccess(data) {
+    return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+}
+export function toolError(error) {
+    let message;
+    if (error instanceof ResendTimeoutError) {
+        message = `Timeout: ${error.message}. Raise RESEND_API_TIMEOUT_MS or retry.`;
+    }
+    else if (error instanceof ResendNetworkError) {
+        message = `Network error: ${error.message}. Check connectivity.`;
+    }
+    else if (error instanceof ResendConfigError) {
+        message = `Configuration error: ${error.message}`;
+    }
+    else if (error instanceof ResendApiError) {
+        // error.message is the compact "{status} on {endpoint} — {hint}" from compactError().
+        // Do NOT append raw body — that risks PII leakage (Decision #9).
+        message = error.message;
+    }
+    else if (error instanceof Error) {
+        message = error.message;
+    }
+    else {
+        message = String(error);
+    }
+    return { isError: true, content: [{ type: 'text', text: message }] };
+}
+function wrap(fn) {
+    return async (args) => {
+        try {
+            return toolSuccess(await fn(args));
+        }
+        catch (err) {
+            return toolError(err);
+        }
+    };
+}
+export function createServer() {
+    const server = new McpServer({ name: '@aiwerk/mcp-server-resend', version: VERSION });
+    // ---- Emails ----
+    server.registerTool('resend_email_send', {
+        description: 'Send a transactional email via Resend. α-gated: first call returns a confirm_token; second call with that token actually sends. Provide from, to, subject, and html/text. For testing without a verified domain, use onboarding@resend.dev as sender and delivered@resend.dev as recipient.',
+        inputSchema: emailSendInputSchema,
+        annotations: { title: 'Send Email', readOnlyHint: false, openWorldHint: true },
+    }, wrap(emailSend));
+    server.registerTool('resend_email_send_batch', {
+        description: 'Send up to 100 emails in a single batch call. α-gated: first call returns a confirm_token; second call actually sends. Each email in the array has the same fields as resend_email_send.',
+        inputSchema: emailSendBatchInputSchema,
+        annotations: { title: 'Send Batch Emails', readOnlyHint: false, openWorldHint: true },
+    }, wrap(emailSendBatch));
+    server.registerTool('resend_email_get', {
+        description: 'Get the status and details of a sent email by ID (delivery status, timestamps, recipients).',
+        inputSchema: emailGetInputSchema,
+        annotations: { title: 'Get Email', readOnlyHint: true, openWorldHint: true },
+    }, wrap(emailGet));
+    server.registerTool('resend_email_list', {
+        description: 'List sent emails with optional pagination.',
+        inputSchema: emailListInputSchema,
+        annotations: { title: 'List Emails', readOnlyHint: true, openWorldHint: true },
+    }, wrap(emailList));
+    server.registerTool('resend_email_update', {
+        description: 'Reschedule a scheduled email. Only works before the email is sent.',
+        inputSchema: emailUpdateInputSchema,
+        annotations: { title: 'Update Email', readOnlyHint: false, openWorldHint: true },
+    }, wrap(emailUpdate));
+    server.registerTool('resend_email_cancel', {
+        description: 'Cancel a scheduled email before it is sent. This is a safety action and is NOT α-gated.',
+        inputSchema: emailCancelInputSchema,
+        annotations: { title: 'Cancel Email', readOnlyHint: false, openWorldHint: true },
+    }, wrap(emailCancel));
+    server.registerTool('resend_email_list_received', {
+        description: 'List inbound emails received via Resend. Requires inbound email routing to be configured. May be plan-gated on free tier.',
+        inputSchema: emailListReceivedInputSchema,
+        annotations: { title: 'List Received Emails', readOnlyHint: true, openWorldHint: true },
+    }, wrap(emailListReceived));
+    server.registerTool('resend_email_get_received', {
+        description: 'Get a specific inbound/received email by ID.',
+        inputSchema: emailGetReceivedInputSchema,
+        annotations: { title: 'Get Received Email', readOnlyHint: true, openWorldHint: true },
+    }, wrap(emailGetReceived));
+    // ---- Domains ----
+    server.registerTool('resend_domain_create', {
+        description: 'Add a new sending domain to Resend. After creation, add the returned DNS records to your DNS provider, then call resend_domain_verify.',
+        inputSchema: domainCreateInputSchema,
+        annotations: { title: 'Create Domain', readOnlyHint: false, openWorldHint: true },
+    }, wrap(domainCreate));
+    server.registerTool('resend_domain_list', {
+        description: 'List all sending domains configured on the account.',
+        inputSchema: domainListInputSchema,
+        annotations: { title: 'List Domains', readOnlyHint: true, openWorldHint: true },
+    }, wrap(domainList));
+    server.registerTool('resend_domain_get', {
+        description: 'Get details and DNS record status for a specific domain by ID.',
+        inputSchema: domainGetInputSchema,
+        annotations: { title: 'Get Domain', readOnlyHint: true, openWorldHint: true },
+    }, wrap(domainGet));
+    server.registerTool('resend_domain_update', {
+        description: 'Update domain tracking settings (open tracking, click tracking, TLS mode).',
+        inputSchema: domainUpdateInputSchema,
+        annotations: { title: 'Update Domain', readOnlyHint: false, openWorldHint: true },
+    }, wrap(domainUpdate));
+    server.registerTool('resend_domain_verify', {
+        description: 'Trigger DNS verification for a domain. Call after adding the DNS records returned by resend_domain_create.',
+        inputSchema: domainVerifyInputSchema,
+        annotations: { title: 'Verify Domain', readOnlyHint: false, openWorldHint: true },
+    }, wrap(domainVerify));
+    server.registerTool('resend_domain_delete', {
+        description: 'Delete one or more sending domains. α-gated: first call returns a confirm_token; second call executes. Supports bulk deletion via domain_ids[].',
+        inputSchema: domainDeleteInputSchema,
+        annotations: { title: 'Delete Domain', readOnlyHint: false, openWorldHint: true },
+    }, wrap(domainDelete));
+    // ---- Contacts ----
+    server.registerTool('resend_contact_create', {
+        description: 'Create a new contact. Can add to segments and set topic subscriptions at creation time.',
+        inputSchema: contactCreateInputSchema,
+        annotations: { title: 'Create Contact', readOnlyHint: false, openWorldHint: true },
+    }, wrap(contactCreate));
+    server.registerTool('resend_contact_list', {
+        description: 'List contacts with optional segment filter and cursor pagination.',
+        inputSchema: contactListInputSchema,
+        annotations: { title: 'List Contacts', readOnlyHint: true, openWorldHint: true },
+    }, wrap(contactList));
+    server.registerTool('resend_contact_get', {
+        description: 'Get a contact by ID or email address.',
+        inputSchema: contactGetInputSchema,
+        annotations: { title: 'Get Contact', readOnlyHint: true, openWorldHint: true },
+    }, wrap(contactGet));
+    server.registerTool('resend_contact_update', {
+        description: 'Update a contact\'s details (name, email, custom properties, unsubscribe status).',
+        inputSchema: contactUpdateInputSchema,
+        annotations: { title: 'Update Contact', readOnlyHint: false, openWorldHint: true },
+    }, wrap(contactUpdate));
+    server.registerTool('resend_contact_delete', {
+        description: 'Delete one or more contacts. α-gated. Supports bulk via ids[].',
+        inputSchema: contactDeleteInputSchema,
+        annotations: { title: 'Delete Contact', readOnlyHint: false, openWorldHint: true },
+    }, wrap(contactDelete));
+    server.registerTool('resend_contact_list_segments', {
+        description: 'List segments a contact belongs to.',
+        inputSchema: contactListSegmentsInputSchema,
+        annotations: { title: 'List Contact Segments', readOnlyHint: true, openWorldHint: true },
+    }, wrap(contactListSegments));
+    server.registerTool('resend_contact_add_segment', {
+        description: 'Add a contact to a segment.',
+        inputSchema: contactAddSegmentInputSchema,
+        annotations: { title: 'Add Contact to Segment', readOnlyHint: false, openWorldHint: true },
+    }, wrap(contactAddSegment));
+    server.registerTool('resend_contact_remove_segment', {
+        description: 'Remove a contact from a segment. NOT α-gated (recoverable).',
+        inputSchema: contactRemoveSegmentInputSchema,
+        annotations: { title: 'Remove Contact from Segment', readOnlyHint: false, openWorldHint: true },
+    }, wrap(contactRemoveSegment));
+    server.registerTool('resend_contact_get_topics', {
+        description: 'Get topic subscription statuses for a contact.',
+        inputSchema: contactGetTopicsInputSchema,
+        annotations: { title: 'Get Contact Topics', readOnlyHint: true, openWorldHint: true },
+    }, wrap(contactGetTopics));
+    server.registerTool('resend_contact_update_topics', {
+        description: 'Update a contact\'s topic subscriptions (opt_in or opt_out per topic).',
+        inputSchema: contactUpdateTopicsInputSchema,
+        annotations: { title: 'Update Contact Topics', readOnlyHint: false, openWorldHint: true },
+    }, wrap(contactUpdateTopics));
+    // ---- Contact Properties ----
+    server.registerTool('resend_contactproperty_create', {
+        description: 'Create a custom contact property (key, type, optional fallback value).',
+        inputSchema: contactPropertyCreateInputSchema,
+        annotations: { title: 'Create Contact Property', readOnlyHint: false, openWorldHint: true },
+    }, wrap(contactPropertyCreate));
+    server.registerTool('resend_contactproperty_list', {
+        description: 'List all contact properties defined on the account.',
+        inputSchema: contactPropertyListInputSchema,
+        annotations: { title: 'List Contact Properties', readOnlyHint: true, openWorldHint: true },
+    }, wrap(contactPropertyList));
+    server.registerTool('resend_contactproperty_get', {
+        description: 'Get a contact property by ID.',
+        inputSchema: contactPropertyGetInputSchema,
+        annotations: { title: 'Get Contact Property', readOnlyHint: true, openWorldHint: true },
+    }, wrap(contactPropertyGet));
+    server.registerTool('resend_contactproperty_update', {
+        description: 'Update a contact property\'s fallback value.',
+        inputSchema: contactPropertyUpdateInputSchema,
+        annotations: { title: 'Update Contact Property', readOnlyHint: false, openWorldHint: true },
+    }, wrap(contactPropertyUpdate));
+    server.registerTool('resend_contactproperty_delete', {
+        description: 'Delete one or more contact properties. α-gated. Supports bulk via ids[].',
+        inputSchema: contactPropertyDeleteInputSchema,
+        annotations: { title: 'Delete Contact Property', readOnlyHint: false, openWorldHint: true },
+    }, wrap(contactPropertyDelete));
+    // ---- Segments ----
+    server.registerTool('resend_segment_create', {
+        description: 'Create a new audience segment with optional filter conditions.',
+        inputSchema: segmentCreateInputSchema,
+        annotations: { title: 'Create Segment', readOnlyHint: false, openWorldHint: true },
+    }, wrap(segmentCreate));
+    server.registerTool('resend_segment_list', {
+        description: 'List all segments.',
+        inputSchema: segmentListInputSchema,
+        annotations: { title: 'List Segments', readOnlyHint: true, openWorldHint: true },
+    }, wrap(segmentList));
+    server.registerTool('resend_segment_get', {
+        description: 'Get a segment by ID.',
+        inputSchema: segmentGetInputSchema,
+        annotations: { title: 'Get Segment', readOnlyHint: true, openWorldHint: true },
+    }, wrap(segmentGet));
+    server.registerTool('resend_segment_list_contacts', {
+        description: 'List contacts in a segment (uses GET /contacts?segment_id).',
+        inputSchema: segmentListContactsInputSchema,
+        annotations: { title: 'List Segment Contacts', readOnlyHint: true, openWorldHint: true },
+    }, wrap(segmentListContacts));
+    server.registerTool('resend_segment_delete', {
+        description: 'Delete one or more segments. α-gated. Supports bulk via ids[].',
+        inputSchema: segmentDeleteInputSchema,
+        annotations: { title: 'Delete Segment', readOnlyHint: false, openWorldHint: true },
+    }, wrap(segmentDelete));
+    // ---- Templates ----
+    server.registerTool('resend_template_create', {
+        description: 'Create a new email template with HTML content and optional default fields.',
+        inputSchema: templateCreateInputSchema,
+        annotations: { title: 'Create Template', readOnlyHint: false, openWorldHint: true },
+    }, wrap(templateCreate));
+    server.registerTool('resend_template_list', {
+        description: 'List all email templates.',
+        inputSchema: templateListInputSchema,
+        annotations: { title: 'List Templates', readOnlyHint: true, openWorldHint: true },
+    }, wrap(templateList));
+    server.registerTool('resend_template_get', {
+        description: 'Get a template by ID.',
+        inputSchema: templateGetInputSchema,
+        annotations: { title: 'Get Template', readOnlyHint: true, openWorldHint: true },
+    }, wrap(templateGet));
+    server.registerTool('resend_template_update', {
+        description: 'Update a template\'s content or settings.',
+        inputSchema: templateUpdateInputSchema,
+        annotations: { title: 'Update Template', readOnlyHint: false, openWorldHint: true },
+    }, wrap(templateUpdate));
+    server.registerTool('resend_template_delete', {
+        description: 'Delete one or more templates. α-gated. Supports bulk via ids[].',
+        inputSchema: templateDeleteInputSchema,
+        annotations: { title: 'Delete Template', readOnlyHint: false, openWorldHint: true },
+    }, wrap(templateDelete));
+    server.registerTool('resend_template_duplicate', {
+        description: 'Create a copy of an existing template.',
+        inputSchema: templateDuplicateInputSchema,
+        annotations: { title: 'Duplicate Template', readOnlyHint: false, openWorldHint: true },
+    }, wrap(templateDuplicate));
+    server.registerTool('resend_template_publish', {
+        description: 'Publish a template draft so it can be used in resend_email_send via its alias.',
+        inputSchema: templatePublishInputSchema,
+        annotations: { title: 'Publish Template', readOnlyHint: false, openWorldHint: true },
+    }, wrap(templatePublish));
+    // ---- Topics ----
+    server.registerTool('resend_topic_create', {
+        description: 'Create a new topic for managing contact subscriptions (e.g. "Weekly Newsletter").',
+        inputSchema: topicCreateInputSchema,
+        annotations: { title: 'Create Topic', readOnlyHint: false, openWorldHint: true },
+    }, wrap(topicCreate));
+    server.registerTool('resend_topic_list', {
+        description: 'List all topics.',
+        inputSchema: topicListInputSchema,
+        annotations: { title: 'List Topics', readOnlyHint: true, openWorldHint: true },
+    }, wrap(topicList));
+    server.registerTool('resend_topic_get', {
+        description: 'Get a topic by ID.',
+        inputSchema: topicGetInputSchema,
+        annotations: { title: 'Get Topic', readOnlyHint: true, openWorldHint: true },
+    }, wrap(topicGet));
+    server.registerTool('resend_topic_update', {
+        description: 'Update a topic\'s name, description, or visibility.',
+        inputSchema: topicUpdateInputSchema,
+        annotations: { title: 'Update Topic', readOnlyHint: false, openWorldHint: true },
+    }, wrap(topicUpdate));
+    server.registerTool('resend_topic_delete', {
+        description: 'Delete one or more topics. α-gated. Supports bulk via ids[].',
+        inputSchema: topicDeleteInputSchema,
+        annotations: { title: 'Delete Topic', readOnlyHint: false, openWorldHint: true },
+    }, wrap(topicDelete));
+    // ---- Broadcasts ----
+    server.registerTool('resend_broadcast_create', {
+        description: 'Create a broadcast email to a segment. Always creates a DRAFT (send:false enforced). Use resend_broadcast_send to send.',
+        inputSchema: broadcastCreateInputSchema,
+        annotations: { title: 'Create Broadcast', readOnlyHint: false, openWorldHint: true },
+    }, wrap(broadcastCreate));
+    server.registerTool('resend_broadcast_list', {
+        description: 'List all broadcasts.',
+        inputSchema: broadcastListInputSchema,
+        annotations: { title: 'List Broadcasts', readOnlyHint: true, openWorldHint: true },
+    }, wrap(broadcastList));
+    server.registerTool('resend_broadcast_get', {
+        description: 'Get a broadcast by ID (includes status, stats if sent).',
+        inputSchema: broadcastGetInputSchema,
+        annotations: { title: 'Get Broadcast', readOnlyHint: true, openWorldHint: true },
+    }, wrap(broadcastGet));
+    server.registerTool('resend_broadcast_update', {
+        description: 'Update a draft broadcast\'s content or targeting.',
+        inputSchema: broadcastUpdateInputSchema,
+        annotations: { title: 'Update Broadcast', readOnlyHint: false, openWorldHint: true },
+    }, wrap(broadcastUpdate));
+    server.registerTool('resend_broadcast_delete', {
+        description: 'Delete one or more draft broadcasts. α-gated. Supports bulk via ids[].',
+        inputSchema: broadcastDeleteInputSchema,
+        annotations: { title: 'Delete Broadcast', readOnlyHint: false, openWorldHint: true },
+    }, wrap(broadcastDelete));
+    server.registerTool('resend_broadcast_send', {
+        description: 'Send or schedule a broadcast. α-gated — high blast radius (sends to entire segment). First call returns confirm_token; second call executes.',
+        inputSchema: broadcastSendInputSchema,
+        annotations: { title: 'Send Broadcast', readOnlyHint: false, openWorldHint: true },
+    }, wrap(broadcastSend));
+    // ---- Webhooks ----
+    server.registerTool('resend_webhook_create', {
+        description: 'Create a webhook endpoint to receive real-time email event notifications.',
+        inputSchema: webhookCreateInputSchema,
+        annotations: { title: 'Create Webhook', readOnlyHint: false, openWorldHint: true },
+    }, wrap(webhookCreate));
+    server.registerTool('resend_webhook_list', {
+        description: 'List all webhook endpoints.',
+        inputSchema: webhookListInputSchema,
+        annotations: { title: 'List Webhooks', readOnlyHint: true, openWorldHint: true },
+    }, wrap(webhookList));
+    server.registerTool('resend_webhook_get', {
+        description: 'Get a webhook by ID.',
+        inputSchema: webhookGetInputSchema,
+        annotations: { title: 'Get Webhook', readOnlyHint: true, openWorldHint: true },
+    }, wrap(webhookGet));
+    server.registerTool('resend_webhook_update', {
+        description: 'Update a webhook\'s endpoint, subscribed events, or enable/disable it.',
+        inputSchema: webhookUpdateInputSchema,
+        annotations: { title: 'Update Webhook', readOnlyHint: false, openWorldHint: true },
+    }, wrap(webhookUpdate));
+    server.registerTool('resend_webhook_delete', {
+        description: 'Delete one or more webhook endpoints. α-gated. Supports bulk via webhook_ids[].',
+        inputSchema: webhookDeleteInputSchema,
+        annotations: { title: 'Delete Webhook', readOnlyHint: false, openWorldHint: true },
+    }, wrap(webhookDelete));
+    // ---- Logs ----
+    server.registerTool('resend_log_list', {
+        description: 'List API request logs. Availability may be plan-gated on free tier.',
+        inputSchema: logListInputSchema,
+        annotations: { title: 'List Logs', readOnlyHint: true, openWorldHint: true },
+    }, wrap(logList));
+    server.registerTool('resend_log_get', {
+        description: 'Get a specific API log entry by ID.',
+        inputSchema: logGetInputSchema,
+        annotations: { title: 'Get Log', readOnlyHint: true, openWorldHint: true },
+    }, wrap(logGet));
+    // ---- API Keys ----
+    server.registerTool('resend_apikey_create', {
+        description: 'Create a new API key. The returned token (re_...) is shown ONLY ONCE — store it immediately. NOT α-gated (creating a key is not destructive), but the response includes a clear warning.',
+        inputSchema: apikeyCreateInputSchema,
+        annotations: { title: 'Create API Key', readOnlyHint: false, openWorldHint: true },
+    }, wrap(apikeyCreate));
+    server.registerTool('resend_apikey_list', {
+        description: 'List all API keys (IDs and names only — tokens are never returned after creation).',
+        inputSchema: apikeyListInputSchema,
+        annotations: { title: 'List API Keys', readOnlyHint: true, openWorldHint: true },
+    }, wrap(apikeyList));
+    server.registerTool('resend_apikey_delete', {
+        description: 'Revoke one or more API keys. α-gated. Irreversible — integrations using the key break immediately.',
+        inputSchema: apikeyDeleteInputSchema,
+        annotations: { title: 'Delete API Key', readOnlyHint: false, openWorldHint: true },
+    }, wrap(apikeyDelete));
+    return server;
+}
+async function main() {
+    const server = createServer();
+    await server.connect(new StdioServerTransport());
+}
+export function isCliEntry(moduleUrl = import.meta.url, argv1 = process.argv[1]) {
+    if (!argv1)
+        return false;
+    try {
+        return realpathSync(fileURLToPath(moduleUrl)) === realpathSync(argv1);
+    }
+    catch {
+        return false;
+    }
+}
+if (isCliEntry()) {
+    main().catch((err) => {
+        console.error('[mcp-server-resend] fatal:', err);
+        process.exit(1);
+    });
+}

package/dist/src/tools/apikeys.d.ts

@@ -0,0 +1,37 @@
+import { z } from 'zod';
+import { type ConfirmationRequired } from '../lib/destructive-gate.js';
+export declare const apikeyCreateInputSchema: {
+    name: z.ZodString;
+    permission: z.ZodOptional<z.ZodEnum<["full_access", "sending_access"]>>;
+    domain_id: z.ZodOptional<z.ZodString>;
+};
+export declare function apikeyCreate(args: {
+    name: string;
+    permission?: 'full_access' | 'sending_access';
+    domain_id?: string;
+}): Promise<{
+    id: string;
+    token: string;
+    _warning: string;
+}>;
+export declare const apikeyListInputSchema: {
+    limit: z.ZodOptional<z.ZodNumber>;
+    after: z.ZodOptional<z.ZodString>;
+    before: z.ZodOptional<z.ZodString>;
+};
+export declare function apikeyList(args: {
+    limit?: number;
+    after?: string;
+    before?: string;
+}): Promise<unknown>;
+export declare const apikeyDeleteInputSchema: {
+    api_key_id: z.ZodOptional<z.ZodString>;
+    api_key_ids: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    confirm_token: z.ZodOptional<z.ZodString>;
+};
+export declare function apikeyDelete(args: {
+    api_key_id?: string;
+    api_key_ids?: string[];
+    confirm_token?: string;
+}): Promise<unknown | ConfirmationRequired>;
+//# sourceMappingURL=apikeys.d.ts.map

package/dist/src/tools/apikeys.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"apikeys.d.ts","sourceRoot":"","sources":["../../../src/tools/apikeys.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAA2C,KAAK,oBAAoB,EAAE,MAAM,4BAA4B,CAAC;AAMhH,eAAO,MAAM,uBAAuB;;;;CAMnC,CAAC;AAOF,wBAAsB,YAAY,CAAC,IAAI,EAAE;IACvC,IAAI,EAAE,MAAM,CAAC;IAAC,UAAU,CAAC,EAAE,aAAa,GAAG,gBAAgB,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAC;CACjF;;;;GASA;AAID,eAAO,MAAM,qBAAqB;;;;CAIjC,CAAC;AAEF,wBAAsB,UAAU,CAAC,IAAI,EAAE;IAAE,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,oBAEzF;AAID,eAAO,MAAM,uBAAuB;;;;CAInC,CAAC;AAEF,wBAAsB,YAAY,CAAC,IAAI,EAAE;IACvC,UAAU,CAAC,EAAE,MAAM,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;IAAC,aAAa,CAAC,EAAE,MAAM,CAAC;CACrE,GAAG,OAAO,CAAC,OAAO,GAAG,oBAAoB,CAAC,CAoC1C"}

package/dist/src/tools/apikeys.js

@@ -0,0 +1,72 @@
+import { z } from 'zod';
+import { resendPost, resendGet, resendDelete } from '../lib/resend-client.js';
+import { requireConfirmation, validateAndConsume } from '../lib/destructive-gate.js';
+// --- resend_apikey_create ---
+// The response contains a secret token (re_...) shown ONLY ONCE.
+// We include a prominent warning in the return value.
+export const apikeyCreateInputSchema = {
+    name: z.string().describe('Human-readable name for the API key.'),
+    permission: z.enum(['full_access', 'sending_access']).optional()
+        .describe('Key permission level. full_access: all operations. sending_access: send emails only (default: full_access).'),
+    domain_id: z.string().optional()
+        .describe('Restrict the key to a specific sending domain. Only used with sending_access permission.'),
+};
+export async function apikeyCreate(args) {
+    const result = await resendPost('/api-keys', args);
+    // Return with a prominent warning — the token is shown only once.
+    // Never log the token (it starts with re_).
+    return {
+        id: result.id,
+        token: result.token,
+        _warning: 'STORE THIS TOKEN NOW — it will NOT be shown again. It starts with re_ and grants API access.',
+    };
+}
+// --- resend_apikey_list ---
+export const apikeyListInputSchema = {
+    limit: z.number().int().min(1).max(100).optional().describe('Max items to return (max 100).'),
+    after: z.string().optional().describe('Cursor — return items after this value.'),
+    before: z.string().optional().describe('Cursor — return items before this value.'),
+};
+export async function apikeyList(args) {
+    return resendGet('/api-keys', args);
+}
+// --- resend_apikey_delete (α-gated, bulk) ---
+export const apikeyDeleteInputSchema = {
+    api_key_id: z.string().optional().describe('API key ID to revoke. Provide api_key_id or api_key_ids.'),
+    api_key_ids: z.array(z.string()).optional().describe('Multiple API key IDs to revoke.'),
+    confirm_token: z.string().optional().describe('Confirmation token from a previous call.'),
+};
+export async function apikeyDelete(args) {
+    const { confirm_token, ...rest } = args;
+    const tool = 'resend_apikey_delete';
+    if (!rest.api_key_id && (!rest.api_key_ids || rest.api_key_ids.length === 0)) {
+        throw new Error('Provide api_key_id (single) or api_key_ids (bulk).');
+    }
+    const isBulk = !!rest.api_key_ids;
+    const ids = isBulk ? rest.api_key_ids : undefined;
+    const id = !isBulk ? rest.api_key_id : undefined;
+    if (!confirm_token) {
+        const count = isBulk ? ids.length : 1;
+        const preview = isBulk ? ids.slice(0, 3).join(', ') : rest.api_key_id;
+        return requireConfirmation({
+            tool, id, ids, payload: rest,
+            summary: `Revoke ${count} API key(s): ${preview}. This permanently revokes API access — any integrations using this key will break immediately.`,
+        });
+    }
+    const result = validateAndConsume({ confirm_token, tool, id, ids, payload: rest });
+    if (!result.valid)
+        throw new Error(result.reason);
+    if (isBulk) {
+        const results = await Promise.allSettled(ids.map(kid => resendDelete(`/api-keys/${kid}`)));
+        const succeeded = [];
+        const failed = [];
+        results.forEach((r, idx) => {
+            if (r.status === 'fulfilled')
+                succeeded.push(ids[idx]);
+            else
+                failed.push({ id: ids[idx], error: String(r.reason) });
+        });
+        return { succeeded, failed, summary: `${succeeded.length}/${ids.length} succeeded` };
+    }
+    return resendDelete(`/api-keys/${rest.api_key_id}`);
+}

package/dist/src/tools/broadcasts.d.ts

@@ -0,0 +1,85 @@
+import { z } from 'zod';
+import { type ConfirmationRequired } from '../lib/destructive-gate.js';
+export declare const broadcastCreateInputSchema: {
+    from: z.ZodString;
+    subject: z.ZodString;
+    segment_id: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    reply_to: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    preview_text: z.ZodOptional<z.ZodString>;
+    html: z.ZodOptional<z.ZodString>;
+    text: z.ZodOptional<z.ZodString>;
+    topic_id: z.ZodOptional<z.ZodString>;
+};
+export declare function broadcastCreate(args: {
+    from: string;
+    subject: string;
+    segment_id: string;
+    name?: string;
+    reply_to?: string[];
+    preview_text?: string;
+    html?: string;
+    text?: string;
+    topic_id?: string;
+}): Promise<unknown>;
+export declare const broadcastListInputSchema: {
+    limit: z.ZodOptional<z.ZodNumber>;
+    after: z.ZodOptional<z.ZodString>;
+    before: z.ZodOptional<z.ZodString>;
+};
+export declare function broadcastList(args: {
+    limit?: number;
+    after?: string;
+    before?: string;
+}): Promise<unknown>;
+export declare const broadcastGetInputSchema: {
+    id: z.ZodString;
+};
+export declare function broadcastGet(args: {
+    id: string;
+}): Promise<unknown>;
+export declare const broadcastUpdateInputSchema: {
+    id: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    segment_id: z.ZodOptional<z.ZodString>;
+    from: z.ZodOptional<z.ZodString>;
+    subject: z.ZodOptional<z.ZodString>;
+    reply_to: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    preview_text: z.ZodOptional<z.ZodString>;
+    html: z.ZodOptional<z.ZodString>;
+    text: z.ZodOptional<z.ZodString>;
+    topic_id: z.ZodOptional<z.ZodString>;
+};
+export declare function broadcastUpdate(args: {
+    id: string;
+    name?: string;
+    segment_id?: string;
+    from?: string;
+    subject?: string;
+    reply_to?: string[];
+    preview_text?: string;
+    html?: string;
+    text?: string;
+    topic_id?: string;
+}): Promise<unknown>;
+export declare const broadcastDeleteInputSchema: {
+    id: z.ZodOptional<z.ZodString>;
+    ids: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    confirm_token: z.ZodOptional<z.ZodString>;
+};
+export declare function broadcastDelete(args: {
+    id?: string;
+    ids?: string[];
+    confirm_token?: string;
+}): Promise<unknown | ConfirmationRequired>;
+export declare const broadcastSendInputSchema: {
+    id: z.ZodString;
+    scheduled_at: z.ZodOptional<z.ZodString>;
+    confirm_token: z.ZodOptional<z.ZodString>;
+};
+export declare function broadcastSend(args: {
+    id: string;
+    scheduled_at?: string;
+    confirm_token?: string;
+}): Promise<unknown | ConfirmationRequired>;
+//# sourceMappingURL=broadcasts.d.ts.map

package/dist/src/tools/broadcasts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"broadcasts.d.ts","sourceRoot":"","sources":["../../../src/tools/broadcasts.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAA2C,KAAK,oBAAoB,EAAE,MAAM,4BAA4B,CAAC;AAYhH,eAAO,MAAM,0BAA0B;;;;;;;;;;CAUtC,CAAC;AAEF,wBAAsB,eAAe,CAAC,IAAI,EAAE;IAC1C,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACjE,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACzE,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,oBAGA;AAID,eAAO,MAAM,wBAAwB;;;;CAAmB,CAAC;AAEzD,wBAAsB,aAAa,CAAC,IAAI,EAAE;IAAE,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,oBAE5F;AAID,eAAO,MAAM,uBAAuB;;CAEnC,CAAC;AAEF,wBAAsB,YAAY,CAAC,IAAI,EAAE;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE,oBAEtD;AAID,eAAO,MAAM,0BAA0B;;;;;;;;;;;CAWtC,CAAC;AAEF,wBAAsB,eAAe,CAAC,IAAI,EAAE;IAC1C,EAAE,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAChF,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;CAC7F,oBAGA;AAID,eAAO,MAAM,0BAA0B;;;;CAItC,CAAC;AAEF,wBAAsB,eAAe,CAAC,IAAI,EAAE;IAC1C,EAAE,CAAC,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,EAAE,CAAC;IAAC,aAAa,CAAC,EAAE,MAAM,CAAC;CACrD,GAAG,OAAO,CAAC,OAAO,GAAG,oBAAoB,CAAC,CAoC1C;AAID,eAAO,MAAM,wBAAwB;;;;CAIpC,CAAC;AAEF,wBAAsB,aAAa,CAAC,IAAI,EAAE;IACxC,EAAE,EAAE,MAAM,CAAC;IAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAAC,aAAa,CAAC,EAAE,MAAM,CAAC;CAC3D,GAAG,OAAO,CAAC,OAAO,GAAG,oBAAoB,CAAC,CAkB1C"}