@sendinel/mcp-server 1.0.0

package/build/tools/delivery-ops.d.ts

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

package/build/tools/delivery-ops.js

@@ -0,0 +1,387 @@
+import { z } from 'zod';
+import { db } from '../db.js';
+import { getProjectId } from '../project.js';
+const j = (data) => ({ content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] });
+export function registerDeliveryOpsTools(server) {
+    server.registerTool('refresh_domain_dns', {
+        description: 'Refresh and return stored DNS verification status for a sending domain.',
+        inputSchema: { domain_id: z.string().uuid() },
+    }, async ({ domain_id }) => {
+        const { data, error } = await db().from('domains')
+            .select('id, status, dns_records, spf_valid, dkim_valid, dmarc_valid')
+            .eq('project_id', getProjectId())
+            .eq('id', domain_id)
+            .maybeSingle();
+        if (error)
+            return j({ error: error.message });
+        if (!data)
+            return j({ error: 'Domain not found', code: 'NOT_FOUND' });
+        const records = Array.isArray(data.dns_records) ? data.dns_records : [];
+        const spf = data.spf_valid ?? records.some((record) => String(record.value ?? '').includes('v=spf1'));
+        const dkim = data.dkim_valid ?? records.some((record) => /dkim/i.test(`${record.name ?? ''} ${record.type ?? ''}`));
+        const dmarc = data.dmarc_valid ?? records.some((record) => String(record.name ?? '').includes('_dmarc'));
+        return j({ spf, dkim, dmarc, all_verified: Boolean(spf && dkim && dmarc) });
+    });
+    server.registerTool('dnsbl_check', {
+        description: 'Return the latest DNSBL snapshot for all monitored zones for a site sending domain.',
+        inputSchema: {
+            siteId: z.string().uuid(),
+        },
+    }, async ({ siteId }) => {
+        const projectId = getProjectId();
+        const { data: site, error: siteErr } = await db().from('sites')
+            .select('id, sending_domain')
+            .eq('id', siteId)
+            .eq('project_id', projectId)
+            .maybeSingle();
+        if (siteErr || !site)
+            return j({ error: siteErr?.message ?? 'Site not found', code: 'NOT_FOUND' });
+        const { data, error } = await db().from('dnsbl_snapshots')
+            .select('domain, zone, listed, response_code, checked_at')
+            .eq('site_id', siteId)
+            .order('checked_at', { ascending: false })
+            .limit(60);
+        if (error)
+            return j({ error: error.message });
+        const latestByZone = new Map();
+        for (const row of data ?? []) {
+            if (!latestByZone.has(row.zone))
+                latestByZone.set(row.zone, row);
+        }
+        const snapshots = Array.from(latestByZone.values());
+        return j({
+            site_id: siteId,
+            domain: site.sending_domain,
+            snapshots,
+            active_listings: snapshots.filter((row) => row.listed),
+            checked_at: snapshots.map((row) => row.checked_at).sort().at(-1) ?? null,
+        });
+    });
+    server.registerTool('dnsbl_delisting_draft', {
+        description: 'Draft a DNSBL delisting ticket using tenant send metrics as evidence. Does not auto-submit.',
+        inputSchema: {
+            siteId: z.string().uuid(),
+            zone: z.string().min(3),
+        },
+    }, async ({ siteId, zone }) => {
+        const projectId = getProjectId();
+        const [{ data: site, error: siteErr }, { data: snapshot }, { data: metrics }] = await Promise.all([
+            db().from('sites').select('id, name, sending_domain').eq('id', siteId).eq('project_id', projectId).maybeSingle(),
+            db().from('dnsbl_snapshots')
+                .select('domain, zone, response_code, checked_at')
+                .eq('site_id', siteId)
+                .eq('zone', zone)
+                .eq('listed', true)
+                .order('checked_at', { ascending: false })
+                .limit(1)
+                .maybeSingle(),
+            db().from('tenant_email_metrics')
+                .select('window_30d_sent, window_30d_complaints, complaint_rate, updated_at')
+                .eq('site_id', siteId)
+                .maybeSingle(),
+        ]);
+        if (siteErr || !site)
+            return j({ error: siteErr?.message ?? 'Site not found', code: 'NOT_FOUND' });
+        const complaintRate = Number(metrics?.complaint_rate ?? 0);
+        const draft = [
+            `Subject: Delisting request for ${site.sending_domain} from ${zone}`,
+            '',
+            'Hello,',
+            '',
+            `Please review ${site.sending_domain} for delisting from ${zone}. We operate this sending domain for ${site.name ?? 'our tenant'} and have remediated the source of the listing.`,
+            '',
+            'Evidence for review:',
+            `- Domain: ${site.sending_domain}`,
+            `- Zone: ${zone}`,
+            `- Latest response code: ${snapshot?.response_code ?? 'unknown'}`,
+            `- Latest checked_at: ${snapshot?.checked_at ?? 'unknown'}`,
+            `- 30-day send volume: ${metrics?.window_30d_sent ?? 0}`,
+            `- 30-day complaints: ${metrics?.window_30d_complaints ?? 0}`,
+            `- 30-day complaint rate: ${(complaintRate * 100).toFixed(4)}%`,
+            '',
+            'We have confirmed our suppression and complaint handling pipeline is active, and will continue monitoring DNSBL status daily.',
+            '',
+            'Thank you.',
+        ].join('\n');
+        return j({
+            site_id: siteId,
+            zone,
+            auto_submitted: false,
+            draft,
+            metrics,
+            listing: snapshot ?? null,
+        });
+    });
+    server.registerTool('get_cron_runs', {
+        description: 'List recent cron job executions to diagnose why scheduled sends are not firing.',
+        inputSchema: {
+            job_name: z.string().optional(),
+            limit: z.number().int().min(1).max(50).default(20).optional(),
+            since_hours: z.number().int().min(1).max(168).default(24).optional(),
+        },
+    }, async ({ job_name, limit = 20, since_hours = 24 }) => {
+        const since = new Date(Date.now() - since_hours * 3600 * 1000).toISOString();
+        let query = db().from('cron_runs')
+            .select('id, job_name, project_id, status, started_at, finished_at, duration_ms, items_processed, items_failed, error_message')
+            .or(`project_id.is.null,project_id.eq.${getProjectId()}`)
+            .gte('started_at', since)
+            .order('started_at', { ascending: false })
+            .limit(limit);
+        if (job_name)
+            query = query.eq('job_name', job_name);
+        const { data, error } = await query;
+        if (error)
+            return j({ error: error.message });
+        const failed = (data ?? []).filter((row) => row.status === 'failed');
+        return j({ runs: data ?? [], recent_failures: failed.length, total: data?.length ?? 0 });
+    });
+    server.registerTool('get_queue_status', {
+        description: 'Get the current send queue status — pending, processing, retry, and failed counts.',
+        inputSchema: {
+            site_id: z.string().uuid().optional(),
+        },
+    }, async ({ site_id }) => {
+        const projectId = getProjectId();
+        let queueQuery = db().from('send_queue').select('status').eq('project_id', projectId);
+        if (site_id)
+            queueQuery = queueQuery.eq('site_id', site_id);
+        const [{ data: queueRows, error: queueErr }, { data: dlqRows, error: dlqErr }] = await Promise.all([
+            queueQuery,
+            db().from('send_dlq').select('id', { count: 'exact' }).eq('project_id', projectId).eq('resolved', false),
+        ]);
+        if (queueErr)
+            return j({ error: queueErr.message });
+        if (dlqErr)
+            return j({ error: dlqErr.message });
+        const counts = {};
+        for (const row of queueRows ?? []) {
+            counts[row.status] = (counts[row.status] ?? 0) + 1;
+        }
+        return j({
+            queue: counts,
+            total: queueRows?.length ?? 0,
+            pending: counts.pending ?? 0,
+            processing: counts.processing ?? 0,
+            retry: counts.retry ?? 0,
+            failed: dlqRows?.length ?? 0,
+        });
+    });
+    server.registerTool('get_send_dlq', {
+        description: 'List messages in the send dead-letter queue — emails that failed all retries.',
+        inputSchema: {
+            limit: z.number().int().min(1).max(50).default(20).optional(),
+            unresolved_only: z.boolean().default(true).optional(),
+        },
+    }, async ({ limit = 20, unresolved_only = true }) => {
+        const projectId = getProjectId();
+        let query = db().from('send_dlq')
+            .select('id, final_error, attempts, created_at, resolved, resolved_at, email_log_id')
+            .eq('project_id', projectId)
+            .order('created_at', { ascending: false })
+            .limit(limit);
+        if (unresolved_only)
+            query = query.eq('resolved', false);
+        const { data, error } = await query;
+        if (error)
+            return j({ error: error.message });
+        return j({ dlq: data ?? [], count: data?.length ?? 0 });
+    });
+    server.registerTool('get_scoring_rules', {
+        description: 'Get contact scoring rules for the current project.',
+        inputSchema: {},
+    }, async () => {
+        const projectId = getProjectId();
+        const { data, error } = await db().from('scoring_rules')
+            .select('*')
+            .eq('project_id', projectId)
+            .maybeSingle();
+        if (error)
+            return j({ error: error.message });
+        return j({ rules: data });
+    });
+    server.registerTool('update_scoring_rules', {
+        description: 'Update contact scoring rules. Only the provided fields are changed.',
+        inputSchema: {
+            open_weight: z.number().min(0).max(100).optional(),
+            click_weight: z.number().min(0).max(100).optional(),
+            send_weight: z.number().min(0).max(100).optional(),
+            open_cap: z.number().int().min(0).optional(),
+            click_cap: z.number().int().min(0).optional(),
+            send_cap: z.number().int().min(0).optional(),
+            recency_boost_7d: z.number().int().optional(),
+            recency_boost_30d: z.number().int().optional(),
+            recency_boost_90d: z.number().int().optional(),
+            decay_penalty_30d: z.number().int().optional(),
+            decay_penalty_60d: z.number().int().optional(),
+            decay_penalty_90d: z.number().int().optional(),
+            active_threshold: z.number().int().optional(),
+            cooling_threshold: z.number().int().optional(),
+            cold_threshold: z.number().int().optional(),
+        },
+    }, async (updates) => {
+        const projectId = getProjectId();
+        const row = { project_id: projectId, ...updates, updated_at: new Date().toISOString() };
+        const { data, error } = await db().from('scoring_rules')
+            .upsert(row, { onConflict: 'project_id' })
+            .select('*')
+            .single();
+        if (error)
+            return j({ error: error.message });
+        return j({ rules: data, ok: true });
+    });
+    server.registerTool('explain_contact_score', {
+        description: 'Explain why a subscriber has their current engagement score.',
+        inputSchema: {
+            contact_id: z.string().uuid().optional(),
+            email: z.string().email().optional(),
+        },
+    }, async ({ contact_id, email }) => {
+        const projectId = getProjectId();
+        if (!contact_id && !email)
+            return j({ error: 'contact_id or email is required', code: 'BAD_REQUEST' });
+        let contactQuery = db().from('subscribers')
+            .select('id, email, first_name, last_name, engagement_score, lifecycle_stage, total_opens, total_clicks, total_emails_sent, last_engaged_at')
+            .eq('project_id', projectId);
+        if (contact_id)
+            contactQuery = contactQuery.eq('id', contact_id);
+        else
+            contactQuery = contactQuery.eq('email', email.toLowerCase());
+        const [{ data: contact, error: contactErr }, { data: rules }] = await Promise.all([
+            contactQuery.maybeSingle(),
+            db().from('scoring_rules').select('*').eq('project_id', projectId).maybeSingle(),
+        ]);
+        if (contactErr || !contact)
+            return j({ error: contactErr?.message ?? 'Contact not found', code: 'NOT_FOUND' });
+        const effectiveRules = rules ?? {
+            click_weight: 5,
+            open_weight: 2,
+            send_weight: 0.5,
+            click_cap: 20,
+            open_cap: 30,
+            send_cap: 50,
+            active_threshold: 60,
+            cooling_threshold: 30,
+            cold_threshold: 10,
+        };
+        const openPoints = Math.min(contact.total_opens ?? 0, effectiveRules.open_cap) * effectiveRules.open_weight;
+        const clickPoints = Math.min(contact.total_clicks ?? 0, effectiveRules.click_cap) * effectiveRules.click_weight;
+        const sendPoints = Math.min(contact.total_emails_sent ?? 0, effectiveRules.send_cap) * effectiveRules.send_weight;
+        const breakdown = [
+            `${contact.total_opens ?? 0} opens × ${effectiveRules.open_weight} pts (cap ${effectiveRules.open_cap}) = ${openPoints} pts`,
+            `${contact.total_clicks ?? 0} clicks × ${effectiveRules.click_weight} pts (cap ${effectiveRules.click_cap}) = ${clickPoints} pts`,
+            `${contact.total_emails_sent ?? 0} sends × ${effectiveRules.send_weight} pts (cap ${effectiveRules.send_cap}) = ${sendPoints} pts`,
+        ];
+        if (contact.last_engaged_at) {
+            const daysSince = Math.floor((Date.now() - new Date(contact.last_engaged_at).getTime()) / 86400000);
+            if (daysSince > 90)
+                breakdown.push(`No engagement for ${daysSince} days -> decay penalties likely apply`);
+            else if (daysSince <= 7)
+                breakdown.push('Engaged within 7 days -> strongest recency boost window');
+            else if (daysSince <= 30)
+                breakdown.push('Engaged within 30 days -> recency boost window');
+        }
+        return j({
+            contact: {
+                id: contact.id,
+                email: contact.email,
+                name: `${contact.first_name ?? ''} ${contact.last_name ?? ''}`.trim(),
+                score: contact.engagement_score ?? 0,
+                lifecycle_stage: contact.lifecycle_stage ?? 'new',
+                last_engaged_at: contact.last_engaged_at ?? null,
+            },
+            rules: effectiveRules,
+            score_breakdown: breakdown,
+            thresholds: {
+                active: `>= ${effectiveRules.active_threshold}`,
+                cooling: `>= ${effectiveRules.cooling_threshold}`,
+                cold: `>= ${effectiveRules.cold_threshold}`,
+            },
+        });
+    });
+    server.registerTool('export_data', {
+        description: 'Export contacts, email log, campaign, or suppression data as JSON.',
+        inputSchema: {
+            resource: z.enum(['contacts', 'email_log', 'campaigns', 'suppressions']),
+            site_id: z.string().uuid().optional(),
+            since: z.string().datetime().optional(),
+            limit: z.number().int().min(1).max(5000).default(1000).optional(),
+        },
+    }, async ({ resource, site_id, since, limit = 1000 }) => {
+        const projectId = getProjectId();
+        const tableMap = {
+            contacts: 'subscribers',
+            email_log: 'email_log',
+            campaigns: 'campaigns',
+            suppressions: 'suppressions',
+        };
+        let query = db().from(tableMap[resource]).select('*').eq('project_id', projectId).limit(limit);
+        if (site_id && (resource === 'email_log' || resource === 'campaigns'))
+            query = query.eq('site_id', site_id);
+        if (since)
+            query = query.gte('created_at', since);
+        query = query.order('created_at', { ascending: false });
+        const { data, error } = await query;
+        if (error)
+            return j({ error: error.message });
+        return j({ resource, count: data?.length ?? 0, data: data ?? [], truncated: (data?.length ?? 0) === limit });
+    });
+    server.registerTool('list_domains', {
+        description: 'List sending domains configured for the project and their current verification status.',
+        inputSchema: { site_id: z.string().uuid().optional() },
+    }, async ({ site_id }) => {
+        const projectId = getProjectId();
+        let domainQuery = db().from('domains')
+            .select('id, name, provider, provider_id, region, status, dns_records, verified_at, created_at')
+            .eq('project_id', projectId)
+            .order('created_at', { ascending: false });
+        if (site_id) {
+            const { data: site } = await db().from('sites')
+                .select('domain_id')
+                .eq('id', site_id)
+                .eq('project_id', projectId)
+                .maybeSingle();
+            if (!site?.domain_id)
+                return j({ domains: [], count: 0 });
+            domainQuery = domainQuery.eq('id', site.domain_id);
+        }
+        const { data, error } = await domainQuery;
+        if (error)
+            return j({ error: error.message });
+        return j({ domains: data ?? [], count: data?.length ?? 0 });
+    });
+    server.registerTool('register_domain', {
+        description: 'Register a sending domain for a site and link it to the site record.',
+        inputSchema: {
+            site_id: z.string().uuid(),
+            domain: z.string().min(1),
+            provider: z.enum(['resend', 'sendgrid', 'ses', 'postmark']).optional().default('ses'),
+            region: z.string().optional().default('us-east-1'),
+        },
+    }, async ({ site_id, domain, provider = 'ses', region = 'us-east-1' }) => {
+        const projectId = getProjectId();
+        const { data: site, error: siteErr } = await db().from('sites')
+            .select('id, name')
+            .eq('id', site_id)
+            .eq('project_id', projectId)
+            .maybeSingle();
+        if (siteErr || !site)
+            return j({ error: siteErr?.message ?? 'Site not found', code: 'NOT_FOUND' });
+        const dnsRecords = [
+            { type: 'TXT', name: domain, value: 'v=spf1 include:amazonses.com ~all' },
+            { type: 'TXT', name: `_dmarc.${domain}`, value: 'v=DMARC1; p=none; rua=mailto:dmarc@sendinel.ai' },
+        ];
+        const { data: created, error } = await db().from('domains')
+            .upsert({ project_id: projectId, name: domain, provider, region, status: 'pending', dns_records: dnsRecords }, { onConflict: 'project_id,name' })
+            .select('id, name, provider, region, status, dns_records, created_at')
+            .single();
+        if (error)
+            return j({ error: error.message });
+        const { error: linkErr } = await db().from('sites')
+            .update({ domain_id: created.id, sending_domain: domain, updated_at: new Date().toISOString() })
+            .eq('id', site_id)
+            .eq('project_id', projectId);
+        if (linkErr)
+            return j({ error: linkErr.message });
+        return j({ ok: true, site_id: site.id, domain: created });
+    });
+}

package/build/tools/drafts.d.ts

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

package/build/tools/drafts.js

@@ -0,0 +1,204 @@
+import { z } from 'zod';
+import { db } from '../db.js';
+import { getProjectId } from '../project.js';
+import { checkPlanLimit } from '../plan-limits.js';
+export function registerDraftTools(server) {
+    server.registerTool('create_draft', {
+        description: 'Create an AI-generated email draft pending human approval',
+        inputSchema: {
+            site_id: z.string().uuid(),
+            subject: z.string().min(1),
+            body_html: z.string().min(1),
+            body_text: z.string().optional(),
+            campaign_id: z.string().uuid().optional(),
+            prompt: z.string().optional().describe('The prompt or brief used to generate this draft'),
+            model: z.string().optional().describe('Model that generated the draft, defaults to ANTHROPIC_MODEL_ID'),
+        },
+    }, async ({ site_id, subject, body_html, body_text, campaign_id, prompt, model }) => {
+        const limit = await checkPlanLimit('ai_drafts');
+        if (!limit.allowed) {
+            return { content: [{ type: 'text', text: `AI draft limit reached (${limit.current}/${limit.limit}). Upgrade to BYOD for unlimited drafts.` }] };
+        }
+        const { data, error } = await db()
+            .from('ai_drafts')
+            .insert({ project_id: getProjectId(), site_id, subject, body_html, body_text, campaign_id, prompt, model })
+            .select()
+            .single();
+        if (error)
+            return { content: [{ type: 'text', text: `Error: ${error.message}` }] };
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+    });
+    server.registerTool('list_drafts', {
+        description: 'List AI email drafts by status',
+        inputSchema: {
+            site_id: z.string().uuid().optional(),
+            status: z.enum(['pending', 'approved', 'rejected', 'expired']).optional().default('pending'),
+            limit: z.number().int().min(1).max(100).optional().default(25),
+        },
+    }, async ({ site_id, status, limit }) => {
+        let q = db()
+            .from('ai_drafts')
+            .select('id, site_id, campaign_id, subject, status, created_at, expires_at, reviewed_at, reviewer_notes')
+            .eq('project_id', getProjectId())
+            .order('created_at', { ascending: false })
+            .limit(limit ?? 25);
+        if (status)
+            q = q.eq('status', status);
+        if (site_id)
+            q = q.eq('site_id', site_id);
+        const { data, error } = await q;
+        if (error)
+            return { content: [{ type: 'text', text: `Error: ${error.message}` }] };
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+    });
+    server.registerTool('get_draft', {
+        description: 'Get one AI email draft by ID, including full body content.',
+        inputSchema: {
+            draft_id: z.string().uuid(),
+        },
+    }, async ({ draft_id }) => {
+        const { data, error } = await db()
+            .from('ai_drafts')
+            .select('id, project_id, site_id, campaign_id, subject, body_html, body_text, prompt, model, status, created_at, expires_at, reviewed_at, reviewer_notes')
+            .eq('id', draft_id)
+            .eq('project_id', getProjectId())
+            .maybeSingle();
+        if (error)
+            return { content: [{ type: 'text', text: `Error: ${error.message}` }] };
+        if (!data)
+            return { content: [{ type: 'text', text: JSON.stringify({ error: 'Draft not found', code: 'NOT_FOUND' }, null, 2) }] };
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+    });
+    server.registerTool('promote_draft_to_campaign', {
+        description: 'Promote an AI draft into an email campaign in one call. Creates the campaign and first campaign step, then links the draft to the campaign. The campaign is created as draft for review/launch.',
+        inputSchema: {
+            draft_id: z.string().uuid(),
+            name: z.string().min(1).max(200).optional().describe('Campaign name. Defaults to the draft subject.'),
+            type: z.enum(['broadcast', 'sequence', 'triggered']).optional().default('broadcast'),
+            description: z.string().optional(),
+            send_at: z.string().datetime().optional().describe('Optional broadcast send time. Campaign still remains draft.'),
+            trigger_event_name: z.string().optional().describe('Event name for triggered campaigns.'),
+            trigger_tag: z.string().optional().describe('Tag trigger for triggered campaigns.'),
+            reviewer_notes: z.string().optional(),
+        },
+    }, async ({ draft_id, name, type, description, send_at, trigger_event_name, trigger_tag, reviewer_notes }) => {
+        const projectId = getProjectId();
+        const limit = await checkPlanLimit('active_campaigns');
+        if (!limit.allowed) {
+            return { content: [{ type: 'text', text: `Campaign limit reached (${limit.current}/${limit.limit}). Upgrade your plan for more campaigns.` }] };
+        }
+        const { data: draft, error: draftError } = await db()
+            .from('ai_drafts')
+            .select('id, site_id, campaign_id, subject, body_html, body_text, status')
+            .eq('id', draft_id)
+            .eq('project_id', projectId)
+            .maybeSingle();
+        if (draftError)
+            return { content: [{ type: 'text', text: `Error: ${draftError.message}` }] };
+        if (!draft)
+            return { content: [{ type: 'text', text: JSON.stringify({ error: 'Draft not found', code: 'NOT_FOUND' }, null, 2) }] };
+        const { data: site, error: siteError } = await db()
+            .from('sites')
+            .select('id')
+            .eq('id', draft.site_id)
+            .eq('project_id', projectId)
+            .maybeSingle();
+        if (siteError)
+            return { content: [{ type: 'text', text: `Error: ${siteError.message}` }] };
+        if (!site)
+            return { content: [{ type: 'text', text: 'Draft site not found for this project.' }] };
+        const insert = {
+            project_id: projectId,
+            site_id: draft.site_id,
+            name: name ?? draft.subject,
+            description: description ?? `Promoted from AI draft ${draft.id}`,
+            type: type ?? 'broadcast',
+            status: 'draft',
+            ai_drafted: true,
+            requires_approval: true,
+        };
+        if (send_at)
+            insert.send_at = send_at;
+        if (trigger_event_name)
+            insert.trigger_event_name = trigger_event_name;
+        if (trigger_tag)
+            insert.trigger_tag = trigger_tag.trim().toLowerCase();
+        const { data: campaign, error: campaignError } = await db()
+            .from('campaigns')
+            .insert(insert)
+            .select()
+            .single();
+        if (campaignError)
+            return { content: [{ type: 'text', text: `Failed to create campaign: ${campaignError.message}` }] };
+        const { data: step, error: stepError } = await db()
+            .from('campaign_steps')
+            .insert({
+            campaign_id: campaign.id,
+            step_order: 0,
+            subject: draft.subject,
+            body_html: draft.body_html,
+            body_text: draft.body_text ?? null,
+            delay_days: 0,
+            delay_hours: 0,
+        })
+            .select()
+            .single();
+        if (stepError)
+            return { content: [{ type: 'text', text: `Campaign created (${campaign.id}) but failed to create step: ${stepError.message}` }] };
+        const { data: updatedDraft } = await db()
+            .from('ai_drafts')
+            .update({
+            campaign_id: campaign.id,
+            status: draft.status === 'pending' ? 'approved' : draft.status,
+            reviewed_at: new Date().toISOString(),
+            reviewer_notes: reviewer_notes ?? 'Promoted to campaign via MCP.',
+        })
+            .eq('id', draft.id)
+            .eq('project_id', projectId)
+            .select('id, campaign_id, status, reviewed_at, reviewer_notes')
+            .single();
+        return { content: [{ type: 'text', text: JSON.stringify({ campaign, first_step: step, draft: updatedDraft }, null, 2) }] };
+    });
+    server.registerTool('approve_draft', {
+        description: 'Approve a pending AI draft, marking it ready to send',
+        inputSchema: {
+            draft_id: z.string().uuid(),
+            reviewer_notes: z.string().optional(),
+        },
+    }, async ({ draft_id, reviewer_notes }) => {
+        const { data, error } = await db()
+            .from('ai_drafts')
+            .update({ status: 'approved', reviewed_at: new Date().toISOString(), reviewer_notes })
+            .eq('id', draft_id)
+            .eq('project_id', getProjectId())
+            .eq('status', 'pending')
+            .select()
+            .single();
+        if (error)
+            return { content: [{ type: 'text', text: `Error: ${error.message}` }] };
+        if (!data)
+            return { content: [{ type: 'text', text: 'Draft not found or not in pending status.' }] };
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+    });
+    server.registerTool('reject_draft', {
+        description: 'Reject a pending AI draft with optional feedback',
+        inputSchema: {
+            draft_id: z.string().uuid(),
+            reviewer_notes: z.string().optional(),
+        },
+    }, async ({ draft_id, reviewer_notes }) => {
+        const { data, error } = await db()
+            .from('ai_drafts')
+            .update({ status: 'rejected', reviewed_at: new Date().toISOString(), reviewer_notes })
+            .eq('id', draft_id)
+            .eq('project_id', getProjectId())
+            .eq('status', 'pending')
+            .select()
+            .single();
+        if (error)
+            return { content: [{ type: 'text', text: `Error: ${error.message}` }] };
+        if (!data)
+            return { content: [{ type: 'text', text: 'Draft not found or not in pending status.' }] };
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+    });
+}

package/build/tools/forms.d.ts

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

package/build/tools/forms.js

@@ -0,0 +1,46 @@
+import { z } from 'zod';
+import { db } from '../db.js';
+import { getProjectId } from '../project.js';
+const j = (data) => ({ content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] });
+export function registerFormTools(server) {
+    server.registerTool('list_forms', {
+        description: 'List signup forms with field and submission counts.',
+        inputSchema: { site_id: z.string().uuid().optional() },
+    }, async ({ site_id }) => {
+        let query = db().from('forms').select('id, name, slug, fields, active, site_id, created_at').eq('project_id', getProjectId()).order('created_at', { ascending: false });
+        if (site_id)
+            query = query.eq('site_id', site_id);
+        const { data, error } = await query;
+        if (error)
+            return j({ error: error.message });
+        return j({ forms: (data ?? []).map((form) => ({ ...form, field_count: Array.isArray(form.fields) ? form.fields.length : 0, submission_count: 0 })) });
+    });
+    server.registerTool('get_form_stats', {
+        description: 'Get submission stats for a signup form.',
+        inputSchema: { form_id: z.string().uuid() },
+    }, async ({ form_id }) => {
+        const { count } = await db().from('form_submissions').select('id', { count: 'exact', head: true }).eq('form_id', form_id).eq('project_id', getProjectId());
+        const since = new Date(Date.now() - 7 * 86400000).toISOString();
+        const { count: sevenDay } = await db().from('form_submissions').select('id', { count: 'exact', head: true }).eq('form_id', form_id).eq('project_id', getProjectId()).gte('created_at', since);
+        return j({ submissions_total: count ?? 0, submissions_7d: sevenDay ?? 0, top_sources: [], conversion_rate: null });
+    });
+    server.registerTool('create_form', {
+        description: 'Create a signup form.',
+        inputSchema: {
+            site_id: z.string().uuid(),
+            name: z.string().min(1),
+            fields: z.array(z.record(z.unknown())),
+            redirect_url: z.string().url().optional(),
+            double_opt_in: z.boolean().optional(),
+        },
+    }, async ({ site_id, name, fields, redirect_url, double_opt_in }) => {
+        const slug = name.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 80);
+        const { data, error } = await db().from('forms')
+            .insert({ project_id: getProjectId(), site_id, name, slug, fields, redirect_url: redirect_url ?? null, double_opt_in: double_opt_in ?? false, active: true })
+            .select('id, name, slug, fields, active')
+            .single();
+        if (error)
+            return j({ error: error.message });
+        return j({ form: data });
+    });
+}

package/build/tools/gdpr.d.ts

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