@luckydraw/cumulus 0.27.41 → 0.28.0

package/dist/gateway/gateway-agents-mcp.js

@@ -25,6 +25,68 @@ import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprot
 const API_URL = process.env.GATEWAY_API_URL || 'http://127.0.0.1:8090';
 const API_KEY = process.env.GATEWAY_API_KEY || '';
 const AGENT_NAME = process.env.GATEWAY_AGENT_NAME || 'unknown';
+const RESEND_API_KEY = process.env.RESEND_API_KEY || '';
+const RESEND_DEFAULT_FROM = process.env.RESEND_DEFAULT_FROM || '';
+const RESEND_REPLY_TO = process.env.RESEND_REPLY_TO || '';
+const RESEND_RATE_LIMIT = parseInt(process.env.RESEND_RATE_LIMIT || '10', 10);
+// Rate limiting: track emails sent per thread per hour
+const emailRateLimits = new Map();
+function checkRateLimit(threadName) {
+    const now = Date.now();
+    const entry = emailRateLimits.get(threadName);
+    if (!entry || now > entry.resetAt) {
+        emailRateLimits.set(threadName, { count: 1, resetAt: now + 3600_000 });
+        return true;
+    }
+    if (entry.count >= RESEND_RATE_LIMIT) {
+        return false;
+    }
+    entry.count++;
+    return true;
+}
+/**
+ * Make an HTTPS request to the Resend API.
+ */
+async function resendRequest(method, urlPath, body) {
+    const { default: https } = await import('https');
+    return new Promise(resolve => {
+        const options = {
+            hostname: 'api.resend.com',
+            port: 443,
+            path: urlPath,
+            method,
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${RESEND_API_KEY}`,
+            },
+        };
+        const req = https.request(options, res => {
+            let data = '';
+            res.on('data', (chunk) => (data += chunk.toString()));
+            res.on('end', () => {
+                try {
+                    resolve({
+                        status: res.statusCode || 500,
+                        data: JSON.parse(data),
+                    });
+                }
+                catch {
+                    resolve({
+                        status: res.statusCode || 500,
+                        data: { error: 'Invalid JSON response from Resend' },
+                    });
+                }
+            });
+        });
+        req.on('error', (err) => {
+            resolve({ status: 0, data: { error: `Resend API request failed: ${err.message}` } });
+        });
+        if (body) {
+            req.write(JSON.stringify(body));
+        }
+        req.end();
+    });
+}
 /**
  * Make an HTTP request to the gateway API and return the parsed JSON response.
  */
@@ -62,6 +124,42 @@ function apiRequest(method, urlPath, body) {
         req.end();
     });
 }
+/**
+ * Upload a file to the gateway media directory via the upload API.
+ */
+function uploadFile(data, filename) {
+    return new Promise(resolve => {
+        const url = new URL(`/api/media/upload?filename=${encodeURIComponent(filename)}`, API_URL);
+        const options = {
+            hostname: url.hostname,
+            port: url.port,
+            path: url.pathname + url.search,
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/octet-stream',
+                'Content-Length': data.length,
+                'X-API-Key': API_KEY,
+            },
+        };
+        const req = http.request(options, res => {
+            let respData = '';
+            res.on('data', (chunk) => (respData += chunk.toString()));
+            res.on('end', () => {
+                try {
+                    resolve(JSON.parse(respData));
+                }
+                catch {
+                    resolve({ error: 'Invalid JSON response from upload' });
+                }
+            });
+        });
+        req.on('error', (err) => {
+            resolve({ error: `Upload failed: ${err.message}` });
+        });
+        req.write(data);
+        req.end();
+    });
+}
 async function main() {
     const server = new Server({ name: 'gateway-agents', version: '1.0.0' }, { capabilities: { tools: {} } });
     // List available tools
@@ -114,43 +212,209 @@ async function main() {
                     required: ['target', 'message'],
                 },
             },
+            // broadcast tool removed — agents must use send_to_agent with specific targets
             {
-                name: 'broadcast',
-                description: 'Send a message to ALL active agents simultaneously (except yourself). Busy agents will have their messages queued for batch delivery when they finish.',
+                name: 'notify_user',
+                description: "Send a push notification to the user's phone/device. Use this when you need to alert the user about something important — task completion, errors, questions that need human input, or anything worth interrupting them for. The notification appears even if they're not looking at the chat.",
                 inputSchema: {
                     type: 'object',
                     properties: {
                         message: {
                             type: 'string',
-                            description: 'The message to broadcast to all agents.',
+                            description: 'The notification body text. Keep it concise (1-2 sentences). Will be shown as the notification body.',
+                        },
+                        title: {
+                            type: 'string',
+                            description: 'Optional notification title. Defaults to your agent name. Keep short (under 50 chars).',
+                        },
+                        priority: {
+                            type: 'string',
+                            enum: ['low', 'normal', 'high'],
+                            description: 'Notification priority. "high" for urgent alerts, "normal" for regular updates, "low" for FYI. Default: "normal".',
                         },
                     },
                     required: ['message'],
                 },
             },
             {
-                name: 'notify_user',
-                description: "Send a push notification to the user's phone/device. Use this when you need to alert the user about something important — task completion, errors, questions that need human input, or anything worth interrupting them for. The notification appears even if they're not looking at the chat.",
+                name: 'upload_media',
+                description: 'Upload a file to the gateway media directory so it can be served via a public URL. Use this to make locally-generated files (screenshots, diagrams, exports) accessible in blex blocks (image, gallery) or as download links. Returns the public URL path (e.g., /media/filename.png). The file is written to ~/.cumulus/media/ and served at /media/* without authentication.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        source_path: {
+                            type: 'string',
+                            description: 'Absolute path to a local file to upload. The file will be copied to the media directory.',
+                        },
+                        filename: {
+                            type: 'string',
+                            description: "Optional: desired filename (with extension). If omitted, uses the source file's name. A content hash is appended to prevent collisions.",
+                        },
+                    },
+                    required: ['source_path'],
+                },
+            },
+            {
+                name: 'schedule_trigger',
+                description: 'Schedule a future message injection into this thread. Use this for follow-up reminders, drip sequences, periodic check-ins, or any deferred action. The message is injected as a system-level prompt at the scheduled time, triggering a new AI turn.',
                 inputSchema: {
                     type: 'object',
                     properties: {
+                        id: {
+                            type: 'string',
+                            description: 'Unique schedule ID (e.g., "day3-followup", "weekly-check"). Used to cancel or reference the schedule.',
+                        },
+                        trigger: {
+                            type: 'string',
+                            enum: ['once', 'cron'],
+                            description: '"once" fires at a specific datetime then auto-removes. "cron" fires on a recurring schedule.',
+                        },
+                        at: {
+                            type: 'string',
+                            description: 'ISO 8601 datetime for "once" triggers (e.g., "2026-04-06T09:00:00-04:00"). Required for "once", ignored for "cron".',
+                        },
+                        cron: {
+                            type: 'string',
+                            description: 'Cron expression for "cron" triggers (e.g., "0 9 * * MON" for every Monday at 9am). Five fields: minute hour day-of-month month day-of-week.',
+                        },
                         message: {
                             type: 'string',
-                            description: 'The notification body text. Keep it concise (1-2 sentences). Will be shown as the notification body.',
+                            description: 'The message to inject when the trigger fires. Should describe what action to take.',
                         },
-                        title: {
+                    },
+                    required: ['id', 'trigger', 'message'],
+                },
+            },
+            {
+                name: 'cancel_schedule',
+                description: 'Cancel a scheduled trigger by ID. The schedule is removed from the thread config and will no longer fire.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        id: {
                             type: 'string',
-                            description: 'Optional notification title. Defaults to your agent name. Keep short (under 50 chars).',
+                            description: 'The schedule ID to cancel.',
                         },
-                        priority: {
+                    },
+                    required: ['id'],
+                },
+            },
+            {
+                name: 'list_schedules',
+                description: 'List all scheduled triggers for this thread. Returns the schedule ID, trigger type, timing, and message for each.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {},
+                    required: [],
+                },
+            },
+            {
+                name: 'update_pipeline',
+                description: "Update pipeline metadata for this thread or another thread. Use for stage changes, score updates, and tracking next actions. The orchestrator agent uses the threadName parameter to update other threads' pipeline state.",
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        threadName: {
                             type: 'string',
-                            enum: ['low', 'normal', 'high'],
-                            description: 'Notification priority. "high" for urgent alerts, "normal" for regular updates, "low" for FYI. Default: "normal".',
+                            description: 'Thread to update (defaults to current thread). Use for orchestrator cross-thread updates.',
+                        },
+                        stage: {
+                            type: 'string',
+                            enum: [
+                                'prospect',
+                                'outreach',
+                                'warm-engagement',
+                                'proposal',
+                                'onboarding',
+                                'active-client',
+                                'archived',
+                            ],
+                            description: 'Pipeline stage.',
+                        },
+                        score: {
+                            type: 'number',
+                            description: 'Engagement score (0-100).',
+                        },
+                        lastContact: {
+                            type: 'string',
+                            description: 'ISO timestamp of last contact.',
+                        },
+                        nextAction: {
+                            type: 'string',
+                            description: 'Human-readable next action.',
+                        },
+                        nextActionDate: {
+                            type: 'string',
+                            description: 'ISO timestamp when next action should be taken.',
                         },
                     },
-                    required: ['message'],
+                    required: [],
                 },
             },
+            ...(RESEND_API_KEY
+                ? [
+                    {
+                        name: 'send_email',
+                        description: 'Send an email via Resend API. Use this for outreach, follow-ups, and notifications. All sends are logged to the thread history and rate-limited. The default sender is configured in the gateway config.',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                to: {
+                                    type: 'string',
+                                    description: 'Recipient email address.',
+                                },
+                                subject: {
+                                    type: 'string',
+                                    description: 'Email subject line.',
+                                },
+                                body: {
+                                    type: 'string',
+                                    description: 'Email body in plain text. For HTML emails, also provide the html parameter.',
+                                },
+                                from: {
+                                    type: 'string',
+                                    description: `Optional: sender address. Defaults to "${RESEND_DEFAULT_FROM}".`,
+                                },
+                                replyTo: {
+                                    type: 'string',
+                                    description: `Optional: reply-to address. Defaults to "${RESEND_REPLY_TO || RESEND_DEFAULT_FROM}".`,
+                                },
+                                html: {
+                                    type: 'string',
+                                    description: 'Optional: HTML body. If provided, used as the email body with plain text as fallback.',
+                                },
+                                tags: {
+                                    type: 'array',
+                                    items: {
+                                        type: 'object',
+                                        properties: {
+                                            name: { type: 'string' },
+                                            value: { type: 'string' },
+                                        },
+                                        required: ['name', 'value'],
+                                    },
+                                    description: 'Optional: tags for tracking/filtering (e.g., [{"name":"campaign","value":"outreach-q2"}]).',
+                                },
+                            },
+                            required: ['to', 'subject', 'body'],
+                        },
+                    },
+                    {
+                        name: 'list_emails',
+                        description: 'List recently sent emails from the Resend API. Use this to check delivery status, review what was sent, or track engagement.',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                limit: {
+                                    type: 'number',
+                                    description: 'Maximum number of emails to return (default: 10, max: 100).',
+                                },
+                            },
+                            required: [],
+                        },
+                    },
+                ]
+                : []),
         ],
     }));
     // Handle tool calls
@@ -221,56 +485,331 @@ async function main() {
                 isError: !!result.error,
             };
         }
-        if (name === 'broadcast') {
+        // broadcast handler removed — agents must use send_to_agent with specific targets
+        if (name === 'notify_user') {
             const message = args?.message;
+            const title = args?.title || AGENT_NAME;
+            const priority = args?.priority || 'normal';
             if (!message) {
                 return {
                     content: [
                         {
                             type: 'text',
-                            text: JSON.stringify({ delivered: false, error: 'Missing message' }),
+                            text: JSON.stringify({ sent: false, error: 'Missing message' }),
                         },
                     ],
                     isError: true,
                 };
             }
-            const result = await apiRequest('POST', '/api/agents/inject', {
-                targets: '__broadcast__',
-                message,
-                sender: AGENT_NAME,
-                messageType: 'broadcast',
+            const result = await apiRequest('POST', '/api/notify', {
+                title,
+                body: message,
+                threadName: AGENT_NAME,
+                priority,
             });
             return {
                 content: [{ type: 'text', text: JSON.stringify(result) }],
                 isError: !!result.error,
             };
         }
-        if (name === 'notify_user') {
-            const message = args?.message;
-            const title = args?.title || AGENT_NAME;
-            const priority = args?.priority || 'normal';
-            if (!message) {
+        if (name === 'upload_media') {
+            const sourcePath = args?.source_path;
+            const filename = args?.filename;
+            if (!sourcePath) {
                 return {
                     content: [
                         {
                             type: 'text',
-                            text: JSON.stringify({ sent: false, error: 'Missing message' }),
+                            text: JSON.stringify({ error: 'Missing source_path' }),
                         },
                     ],
                     isError: true,
                 };
             }
-            const result = await apiRequest('POST', '/api/notify', {
-                title,
-                body: message,
-                threadName: AGENT_NAME,
-                priority,
-            });
+            const fs = await import('fs');
+            const nodePath = await import('path');
+            let fileData;
+            try {
+                fileData = fs.readFileSync(sourcePath);
+            }
+            catch (err) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({
+                                error: `Cannot read file: ${err instanceof Error ? err.message : String(err)}`,
+                            }),
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+            const uploadFilename = filename || nodePath.basename(sourcePath);
+            const result = await uploadFile(fileData, uploadFilename);
             return {
                 content: [{ type: 'text', text: JSON.stringify(result) }],
                 isError: !!result.error,
             };
         }
+        if (name === 'send_email') {
+            if (!RESEND_API_KEY) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({
+                                error: 'Email not configured — resend.apiKey missing from gateway config',
+                            }),
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+            const to = args?.to;
+            const subject = args?.subject;
+            const body = args?.body;
+            const from = args?.from || RESEND_DEFAULT_FROM;
+            const replyTo = args?.replyTo || RESEND_REPLY_TO || from;
+            const html = args?.html;
+            const tags = args?.tags;
+            if (!to || !subject || !body) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({ error: 'Missing required fields: to, subject, body' }),
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+            // Rate limit check
+            if (!checkRateLimit(AGENT_NAME)) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({
+                                error: `Rate limit exceeded: max ${RESEND_RATE_LIMIT} emails per hour per thread`,
+                            }),
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+            const emailPayload = {
+                from,
+                to: [to],
+                subject,
+                text: body,
+            };
+            if (replyTo)
+                emailPayload.reply_to = replyTo;
+            if (html)
+                emailPayload.html = html;
+            if (tags && tags.length > 0)
+                emailPayload.tags = tags;
+            const result = await resendRequest('POST', '/emails', emailPayload);
+            if (result.status >= 200 && result.status < 300) {
+                // Notify user on first email from this thread
+                const rateEntry = emailRateLimits.get(AGENT_NAME);
+                if (rateEntry && rateEntry.count === 1) {
+                    await apiRequest('POST', '/api/notify', {
+                        title: `${AGENT_NAME}: First email sent`,
+                        body: `Sent to ${to}: "${subject}"`,
+                        threadName: AGENT_NAME,
+                        priority: 'normal',
+                    });
+                }
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({
+                                sent: true,
+                                id: result.data.id,
+                                from,
+                                to,
+                                subject,
+                                sentAt: new Date().toISOString(),
+                            }),
+                        },
+                    ],
+                };
+            }
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            sent: false,
+                            error: result.data.message || result.data.error || `Resend API returned ${result.status}`,
+                        }),
+                    },
+                ],
+                isError: true,
+            };
+        }
+        if (name === 'list_emails') {
+            if (!RESEND_API_KEY) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({
+                                error: 'Email not configured — resend.apiKey missing from gateway config',
+                            }),
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+            const limit = Math.min(Math.max(args?.limit || 10, 1), 100);
+            const result = await resendRequest('GET', `/emails?limit=${limit}`);
+            if (result.status >= 200 && result.status < 300) {
+                return {
+                    content: [{ type: 'text', text: JSON.stringify(result.data) }],
+                };
+            }
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            error: result.data.message || result.data.error || `Resend API returned ${result.status}`,
+                        }),
+                    },
+                ],
+                isError: true,
+            };
+        }
+        if (name === 'schedule_trigger') {
+            const id = args?.id;
+            const trigger = args?.trigger;
+            const at = args?.at;
+            const cron = args?.cron;
+            const message = args?.message;
+            if (!id || !trigger || !message) {
+                return {
+                    content: [
+                        { type: 'text', text: 'Missing required fields: id, trigger, message' },
+                    ],
+                    isError: true,
+                };
+            }
+            if (trigger === 'once' && !at) {
+                return {
+                    content: [{ type: 'text', text: 'Once trigger requires "at" datetime field' }],
+                    isError: true,
+                };
+            }
+            if (trigger === 'cron' && !cron) {
+                return {
+                    content: [
+                        { type: 'text', text: 'Cron trigger requires "cron" expression field' },
+                    ],
+                    isError: true,
+                };
+            }
+            // Save schedule to thread config via REST API
+            const schedule = { id, trigger, ...(at ? { at } : {}), ...(cron ? { cron } : {}), message };
+            const result = await apiRequest('POST', `/api/thread/${encodeURIComponent(AGENT_NAME)}/schedules`, schedule);
+            if (result.error) {
+                return {
+                    content: [{ type: 'text', text: `Failed to create schedule: ${result.error}` }],
+                    isError: true,
+                };
+            }
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            created: true,
+                            id,
+                            trigger,
+                            ...(at ? { at } : {}),
+                            ...(cron ? { cron } : {}),
+                        }),
+                    },
+                ],
+            };
+        }
+        if (name === 'cancel_schedule') {
+            const id = args?.id;
+            if (!id) {
+                return {
+                    content: [{ type: 'text', text: 'Missing required field: id' }],
+                    isError: true,
+                };
+            }
+            const result = await apiRequest('DELETE', `/api/thread/${encodeURIComponent(AGENT_NAME)}/schedules/${encodeURIComponent(id)}`);
+            if (result.error) {
+                return {
+                    content: [{ type: 'text', text: `Failed to cancel schedule: ${result.error}` }],
+                    isError: true,
+                };
+            }
+            return {
+                content: [{ type: 'text', text: JSON.stringify({ cancelled: true, id }) }],
+            };
+        }
+        if (name === 'list_schedules') {
+            const result = await apiRequest('GET', `/api/thread/${encodeURIComponent(AGENT_NAME)}/schedules`);
+            if (result.error) {
+                return {
+                    content: [{ type: 'text', text: `Failed to list schedules: ${result.error}` }],
+                    isError: true,
+                };
+            }
+            return {
+                content: [{ type: 'text', text: JSON.stringify(result.data) }],
+            };
+        }
+        if (name === 'update_pipeline') {
+            const targetThread = args?.threadName || AGENT_NAME;
+            const pipelineFields = {};
+            for (const key of ['stage', 'score', 'lastContact', 'nextAction', 'nextActionDate']) {
+                if (args?.[key] !== undefined)
+                    pipelineFields[key] = args[key];
+            }
+            if (Object.keys(pipelineFields).length === 0) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({ error: 'No pipeline fields provided to update' }),
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+            const result = await apiRequest('PUT', `/api/thread/${encodeURIComponent(targetThread)}/pipeline`, pipelineFields);
+            if (result.error) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({ error: `Failed to update pipeline: ${result.error}` }),
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            updated: true,
+                            thread: targetThread,
+                            pipeline: result.pipeline || pipelineFields,
+                        }),
+                    },
+                ],
+            };
+        }
         return {
             content: [{ type: 'text', text: `Unknown tool: ${name}` }],
             isError: true,