@sendinel/mcp-server 1.0.0

package/build/tools/compound.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerCompoundTools(server: McpServer): void;

package/build/tools/compound.js

@@ -0,0 +1,312 @@
+import { z } from 'zod';
+import Anthropic from '@anthropic-ai/sdk';
+import { db } from '../db.js';
+import { getProjectId } from '../project.js';
+import { buildVoicePrompt } from '../lib/voice.js';
+import { getAnthropicFastModelId } from '../anthropic-model.js';
+const j = (data) => ({ content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] });
+function getAnthropicClient() {
+    const apiKey = process.env.ANTHROPIC_API_KEY;
+    if (!apiKey)
+        throw new Error('ANTHROPIC_API_KEY not configured');
+    return new Anthropic({ apiKey });
+}
+function extractJsonArray(raw) {
+    const match = raw.match(/\[[\s\S]*\]/);
+    if (!match)
+        throw new Error('No JSON array in response');
+    return JSON.parse(match[0]);
+}
+function extractJsonObject(raw) {
+    const match = raw.match(/\{[\s\S]*\}/);
+    if (!match)
+        throw new Error('No JSON object in response');
+    return JSON.parse(match[0]);
+}
+export function registerCompoundTools(server) {
+    server.registerTool('setup_campaign_from_brief', {
+        description: 'Create a complete campaign from a brief: AI-generate steps, create a template, create the campaign, and add all campaign steps.',
+        inputSchema: {
+            site_id: z.string().uuid(),
+            campaign_name: z.string().min(1),
+            brief: z.string().min(10),
+            num_steps: z.number().int().min(1).max(5).default(3),
+            step_delay_hours: z.number().int().min(1).default(72),
+            campaign_type: z.enum(['sequence', 'broadcast', 'triggered']).default('sequence'),
+        },
+    }, async ({ site_id, campaign_name, brief, num_steps, step_delay_hours, campaign_type }) => {
+        const projectId = getProjectId();
+        const sb = db();
+        const { data: site } = await sb.from('sites')
+            .select('name, brand_voice')
+            .eq('id', site_id)
+            .eq('project_id', projectId)
+            .maybeSingle();
+        const voiceContext = buildVoicePrompt(site?.brand_voice);
+        let steps;
+        try {
+            const msg = await getAnthropicClient().messages.create({
+                model: getAnthropicFastModelId(),
+                max_tokens: 4096,
+                messages: [{
+                        role: 'user',
+                        content: `You are writing a ${num_steps}-step email campaign for "${site?.name ?? 'our product'}".
+
+CAMPAIGN BRIEF: ${brief}
+
+BRAND VOICE: ${voiceContext}
+
+Generate exactly ${num_steps} emails. For each email, provide:
+- subject
+- body_html
+- body_text
+- delay_hours_from_previous (0 for the first email, ${step_delay_hours} for subsequent ones)
+
+Respond with a JSON array.`,
+                    }],
+            });
+            const raw = msg.content[0].text;
+            steps = extractJsonArray(raw);
+        }
+        catch (error) {
+            return j({ error: `AI generation failed: ${error instanceof Error ? error.message : String(error)}`, code: 'GENERATION_FAILED' });
+        }
+        const { data: template, error: templateErr } = await sb.from('campaign_templates')
+            .insert({
+            project_id: projectId,
+            name: `${campaign_name} - Template`,
+            brief_template: brief,
+            subject_hint: steps[0]?.subject ?? '',
+            body_html: steps[0]?.body_html ?? null,
+            category: 'campaign',
+            description: `Base template generated for campaign "${campaign_name}"`,
+        })
+            .select('id')
+            .single();
+        if (templateErr)
+            return j({ error: `Template creation failed: ${templateErr.message}` });
+        const { data: campaign, error: campaignErr } = await sb.from('campaigns')
+            .insert({ name: campaign_name, site_id, project_id: projectId, type: campaign_type, status: 'draft' })
+            .select('id, name, status')
+            .single();
+        if (campaignErr)
+            return j({ error: `Campaign creation failed: ${campaignErr.message}` });
+        const createdSteps = [];
+        for (let i = 0; i < steps.length; i++) {
+            const step = steps[i];
+            const { data, error } = await sb.from('campaign_steps')
+                .insert({
+                campaign_id: campaign.id,
+                step_order: i,
+                subject: step.subject,
+                body_html: step.body_html,
+                body_text: step.body_text,
+                delay_days: 0,
+                delay_hours: step.delay_hours_from_previous,
+                template_id: String(template.id),
+            })
+                .select('id, step_order, subject')
+                .single();
+            if (error)
+                return j({ error: `Step ${i + 1} creation failed: ${error.message}`, campaign_id: campaign.id });
+            createdSteps.push(data);
+        }
+        return j({
+            ok: true,
+            campaign,
+            template_id: template.id,
+            steps: createdSteps,
+            summary: `Created campaign "${campaign_name}" with ${createdSteps.length} steps. Campaign is in draft.`,
+        });
+    });
+    server.registerTool('create_template_from_brief', {
+        description: 'AI-generate a polished email template from a brief, using the site brand voice.',
+        inputSchema: {
+            site_id: z.string().uuid(),
+            name: z.string().min(1),
+            brief: z.string().min(10),
+            category: z.string().optional(),
+        },
+    }, async ({ site_id, name, brief, category }) => {
+        const projectId = getProjectId();
+        const { data: site } = await db().from('sites')
+            .select('name, brand_voice')
+            .eq('id', site_id)
+            .eq('project_id', projectId)
+            .maybeSingle();
+        let generated;
+        try {
+            const msg = await getAnthropicClient().messages.create({
+                model: getAnthropicFastModelId(),
+                max_tokens: 2048,
+                messages: [{
+                        role: 'user',
+                        content: `Write an email for "${site?.name ?? 'our product'}".
+BRIEF: ${brief}
+BRAND VOICE: ${buildVoicePrompt(site?.brand_voice)}
+Respond with JSON: { "subject": "...", "body_html": "...", "body_text": "..." }`,
+                    }],
+            });
+            const raw = msg.content[0].text;
+            generated = extractJsonObject(raw);
+        }
+        catch (error) {
+            return j({ error: `Generation failed: ${error instanceof Error ? error.message : String(error)}` });
+        }
+        const { data: template, error } = await db().from('campaign_templates')
+            .insert({
+            project_id: projectId,
+            name,
+            brief_template: brief,
+            subject_hint: generated.subject,
+            body_html: generated.body_html,
+            category: category ?? 'general',
+            description: 'Generated from MCP brief',
+        })
+            .select('id, name, subject_hint, created_at')
+            .single();
+        if (error)
+            return j({ error: error.message });
+        return j({ ok: true, template, preview: generated });
+    });
+    server.registerTool('diagnose_delivery_issue', {
+        description: 'Run a delivery audit across cron health, queue status, send DLQ, and domain health, then summarize likely root causes.',
+        inputSchema: {
+            site_id: z.string().uuid().optional(),
+            symptom: z.string().optional(),
+        },
+    }, async ({ site_id, symptom }) => {
+        const projectId = getProjectId();
+        const sb = db();
+        const since = new Date(Date.now() - 24 * 3600 * 1000).toISOString();
+        const cronQuery = sb.from('cron_runs')
+            .select('job_name, status, error_message, started_at, finished_at, items_failed')
+            .or(`project_id.is.null,project_id.eq.${projectId}`)
+            .gte('started_at', since)
+            .order('started_at', { ascending: false })
+            .limit(30);
+        const queueQuery = sb.from('send_queue').select('status').eq('project_id', projectId);
+        const dlqQuery = sb.from('send_dlq').select('final_error, attempts, created_at, resolved').eq('project_id', projectId).eq('resolved', false).order('created_at', { ascending: false }).limit(10);
+        let domainHealthQuery = sb.from('domain_health').select('site_id, spf_valid, dkim_valid, dmarc_valid, check_date, bounce_rate, complaint_rate, warmup_day').order('check_date', { ascending: false });
+        if (site_id)
+            domainHealthQuery = domainHealthQuery.eq('site_id', site_id);
+        else {
+            const { data: sites } = await sb.from('sites').select('id').eq('project_id', projectId);
+            const ids = (sites ?? []).map((row) => row.id);
+            if (ids.length)
+                domainHealthQuery = domainHealthQuery.in('site_id', ids);
+        }
+        const [cronRuns, queueStatus, dlq, domainHealth] = await Promise.all([cronQuery, queueQuery, dlqQuery, domainHealthQuery]);
+        const cronFailures = (cronRuns.data ?? []).filter((row) => row.status === 'failed');
+        const queueCounts = {};
+        for (const row of queueStatus.data ?? [])
+            queueCounts[row.status] = (queueCounts[row.status] ?? 0) + 1;
+        const domainIssues = (domainHealth.data ?? []).filter((row) => row.spf_valid !== true || row.dkim_valid !== true || row.dmarc_valid !== true);
+        const diagnosticData = {
+            cron: { total_recent: cronRuns.data?.length ?? 0, failures: cronFailures.length, failed_jobs: cronFailures },
+            queue: queueCounts,
+            dlq: { unresolved_count: dlq.data?.length ?? 0, samples: (dlq.data ?? []).slice(0, 3) },
+            domain_health: { sites_with_issues: domainIssues.length, issues: domainIssues.slice(0, 5) },
+        };
+        const analysisMsg = await getAnthropicClient().messages.create({
+            model: getAnthropicFastModelId(),
+            max_tokens: 1024,
+            messages: [{
+                    role: 'user',
+                    content: `You are a deliverability engineer. Diagnose this email delivery issue.
+${symptom ? `REPORTED SYMPTOM: ${symptom}` : ''}
+
+DIAGNOSTIC DATA:
+${JSON.stringify(diagnosticData, null, 2)}
+
+Identify the most likely root cause and give 3-5 concise actionable next steps.`,
+                }],
+        });
+        const analysis = analysisMsg.content[0].text;
+        return j({
+            diagnostic_data: diagnosticData,
+            analysis,
+            severity: cronFailures.length > 0 ? 'high' : domainIssues.length > 0 || (dlq.data?.length ?? 0) > 0 ? 'medium' : 'low',
+        });
+    });
+    server.registerTool('onboard_new_site', {
+        description: 'Create a new site, register a sending domain, and return warmup guidance plus a next-step checklist.',
+        inputSchema: {
+            name: z.string().min(1),
+            domain: z.string().min(1),
+            provider: z.enum(['resend', 'sendgrid', 'ses', 'postmark']).default('resend'),
+            daily_send_volume: z.number().int().min(1).default(100),
+            brand_settings: z.object({
+                mission: z.string().optional(),
+                tone_words: z.array(z.string()).optional(),
+                signoff_name: z.string().optional(),
+            }).optional(),
+        },
+    }, async ({ name, domain, provider, daily_send_volume, brand_settings }) => {
+        const projectId = getProjectId();
+        const sb = db();
+        const slug = name.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 48) || 'site';
+        const fromName = brand_settings?.signoff_name ?? name;
+        const fromEmail = `hello@${domain}`;
+        const { data: createdDomain, error: domainErr } = await sb.from('domains')
+            .upsert({
+            project_id: projectId,
+            name: domain,
+            provider,
+            region: 'us-east-1',
+            status: 'pending',
+            dns_records: [
+                { type: 'TXT', name: domain, value: 'v=spf1 include:amazonses.com ~all', required: true },
+                { type: 'TXT', name: `_dmarc.${domain}`, value: 'v=DMARC1; p=none; rua=mailto:dmarc@sendinel.ai', required: false },
+            ],
+        }, { onConflict: 'project_id,name' })
+            .select('id, name, provider, status, dns_records')
+            .single();
+        if (domainErr)
+            return j({ error: `Domain registration failed: ${domainErr.message}` });
+        const { data: site, error: siteErr } = await sb.from('sites')
+            .insert({
+            project_id: projectId,
+            name,
+            slug,
+            provider,
+            sending_domain: domain,
+            from_name: fromName,
+            from_email: fromEmail,
+            active: true,
+            domain_id: createdDomain.id,
+            brand_voice: brand_settings?.tone_words ? { tone_words: brand_settings.tone_words, mission: brand_settings.mission } : {},
+        })
+            .select('id, name, slug, sending_domain, from_name, from_email, provider, created_at')
+            .single();
+        if (siteErr)
+            return j({ error: `Site creation failed: ${siteErr.message}` });
+        const warmupPlan = [];
+        let volume = Math.max(10, Math.floor(daily_send_volume * 0.05));
+        for (let day = 1; day <= 14; day += 3) {
+            warmupPlan.push({ day, volume: Math.min(volume, daily_send_volume) });
+            volume = Math.min(volume * 2, daily_send_volume);
+        }
+        try {
+            await sb.from('warmup_schedules')
+                .upsert({ site_id: site.id, project_id: projectId, target_volume: daily_send_volume, schedule: warmupPlan, status: 'active', created_at: new Date().toISOString() }, { onConflict: 'site_id' });
+        }
+        catch {
+            // warmup_schedules may not exist; this is non-blocking
+        }
+        return j({
+            ok: true,
+            site,
+            domain: createdDomain,
+            warmup_plan: warmupPlan,
+            checklist: [
+                `Site "${name}" created (id: ${site.id})`,
+                'Add the required DNS records for the sending domain',
+                'Wait for DNS propagation, then run get_domain_health',
+                `Configure the ${provider} provider key before sending`,
+                'Send a test email after DNS and provider setup are complete',
+            ],
+            next_step: `Run get_domain_health with site_id "${site.id}" after DNS records are in place.`,
+        });
+    });
+}

package/build/tools/contacts.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerContactTools(server: McpServer): void;