@sendinel/mcp-server 1.0.0

package/build/tools/approvals.d.ts

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

package/build/tools/approvals.js

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+import { db } from '../db.js';
+import { getProjectId } from '../project.js';
+import { checkApproval } from '../lib/action-approvals.js';
+const txt = (text) => ({ content: [{ type: 'text', text }] });
+const j = (data) => txt(JSON.stringify(data, null, 2));
+export function registerApprovalTools(server) {
+    server.registerTool('check_approval', {
+        description: 'Check the status of a pending action approval. Use this to poll after requesting an action that requires human approval. Returns approved/pending/rejected/expired.',
+        inputSchema: {
+            approval_id: z.string().uuid().describe('The approval ID returned by the original tool call'),
+        },
+    }, async ({ approval_id }) => {
+        const result = await checkApproval(approval_id);
+        return j(result);
+    });
+    server.registerTool('list_pending_approvals', {
+        description: 'List all pending approval requests for this project. Shows what actions are waiting for human approval.',
+        inputSchema: {},
+    }, async () => {
+        const { data, error } = await db()
+            .from('action_approvals')
+            .select('id, action, tier, summary, status, requested_at, expires_at')
+            .eq('project_id', getProjectId())
+            .eq('status', 'pending')
+            .order('requested_at', { ascending: false })
+            .limit(25);
+        if (error)
+            return txt(`Error: ${error.message}`);
+        return j({ pending: data ?? [], count: data?.length ?? 0 });
+    });
+}

package/build/tools/automations.d.ts

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

package/build/tools/automations.js

@@ -0,0 +1,344 @@
+import { z } from 'zod';
+import Anthropic from '@anthropic-ai/sdk';
+import { db } from '../db.js';
+import { getProjectId } from '../project.js';
+import { decrypt } from '../crypto.js';
+import { buildVoicePrompt, buildEmailSystemPrompt } from '../lib/voice.js';
+import { getAnthropicModelId } from '../anthropic-model.js';
+const txt = (text) => ({ content: [{ type: 'text', text }] });
+const j = (data) => txt(JSON.stringify(data, null, 2));
+export function registerAutomationTools(server) {
+    // ── list_automations ──────────────────────────────────────────────────────
+    server.registerTool('list_automations', {
+        description: 'List content automation sources (RSS feeds, GitHub Issues, webhooks, schedules). Each source auto-generates email drafts when new content is found.',
+        inputSchema: {
+            site_id: z.string().uuid().optional().describe('Filter by site UUID'),
+            active_only: z.boolean().optional().default(true),
+        },
+    }, async ({ site_id, active_only }) => {
+        let q = db()
+            .from('content_sources')
+            .select('id, name, source_type, format, feed_url, schedule_cron, github_repo, github_label_filter, active, last_polled_at, items_generated, created_at, site_id')
+            .eq('project_id', getProjectId())
+            .order('created_at', { ascending: false });
+        if (site_id)
+            q = q.eq('site_id', site_id);
+        if (active_only)
+            q = q.eq('active', true);
+        const { data, error } = await q;
+        if (error)
+            return txt(`Error: ${error.message}`);
+        return j(data ?? []);
+    });
+    server.registerTool('enroll_automation', {
+        description: 'Enroll a subscriber into active triggered automation campaigns. Match by campaign_id, trigger_event_name, or trigger_tag. Safe to call repeatedly.',
+        inputSchema: {
+            subscriber_id: z.string().uuid().describe('Subscriber/contact UUID to enroll'),
+            campaign_id: z.string().uuid().optional().describe('Specific triggered campaign UUID'),
+            site_id: z.string().uuid().optional().describe('Optional site scope when matching by trigger'),
+            trigger_event_name: z.string().optional().describe('Event trigger name, e.g. signup'),
+            trigger_tag: z.string().optional().describe('Tag trigger name'),
+            next_send_at: z.string().datetime().optional().describe('First send time. Defaults to now.'),
+            context: z.record(z.string(), z.unknown()).optional().describe('Optional enrollment context metadata'),
+        },
+    }, async ({ subscriber_id, campaign_id, site_id, trigger_event_name, trigger_tag, next_send_at, context }) => {
+        const projectId = getProjectId();
+        const { data: subscriber, error: subscriberError } = await db()
+            .from('subscribers')
+            .select('id, email, global_unsubscribed')
+            .eq('id', subscriber_id)
+            .eq('project_id', projectId)
+            .maybeSingle();
+        if (subscriberError)
+            return txt(`Error: ${subscriberError.message}`);
+        if (!subscriber)
+            return j({ error: 'Subscriber not found', code: 'NOT_FOUND' });
+        if (subscriber.global_unsubscribed)
+            return j({ enrolled: 0, skipped: 'global_unsubscribed' });
+        const { data: suppression } = await db()
+            .from('suppressions')
+            .select('id')
+            .eq('project_id', projectId)
+            .eq('email', subscriber.email)
+            .maybeSingle();
+        if (suppression)
+            return j({ enrolled: 0, skipped: 'suppressed' });
+        let query = db()
+            .from('campaigns')
+            .select('id, name, site_id, trigger_event_name, trigger_tag')
+            .eq('project_id', projectId)
+            .eq('type', 'triggered')
+            .eq('status', 'active');
+        if (campaign_id)
+            query = query.eq('id', campaign_id);
+        if (site_id)
+            query = query.eq('site_id', site_id);
+        if (trigger_event_name)
+            query = query.eq('trigger_event_name', trigger_event_name.trim());
+        if (trigger_tag)
+            query = query.eq('trigger_tag', trigger_tag.trim().toLowerCase());
+        if (!campaign_id && !trigger_event_name && !trigger_tag) {
+            return txt('Provide campaign_id, trigger_event_name, or trigger_tag.');
+        }
+        const { data: campaigns, error: campaignError } = await query;
+        if (campaignError)
+            return txt(`Error: ${campaignError.message}`);
+        if (!campaigns?.length)
+            return j({ enrolled: 0, campaigns: [], skipped: 'no_matching_active_automation' });
+        const sendAt = next_send_at ?? new Date().toISOString();
+        const rows = campaigns.map((campaign) => ({
+            campaign_id: campaign.id,
+            contact_id: subscriber_id,
+            current_step: 0,
+            status: 'active',
+            enrolled_at: new Date().toISOString(),
+            next_send_at: sendAt,
+            enrollment_context: context ?? {},
+        }));
+        const { data: inserted, error: enrollError } = await db()
+            .from('campaign_enrollments')
+            .upsert(rows, { onConflict: 'campaign_id,contact_id', ignoreDuplicates: true })
+            .select('id, campaign_id');
+        if (enrollError)
+            return txt(`Error: ${enrollError.message}`);
+        if (inserted?.length) {
+            for (const campaign of campaigns) {
+                const count = inserted.filter((row) => row.campaign_id === campaign.id).length;
+                if (count > 0) {
+                    const { data: current } = await db().from('campaigns').select('total_enrolled').eq('id', campaign.id).maybeSingle();
+                    await db().from('campaigns').update({ total_enrolled: (current?.total_enrolled ?? 0) + count }).eq('id', campaign.id);
+                }
+            }
+        }
+        return j({
+            enrolled: inserted?.length ?? 0,
+            subscriber_id,
+            campaigns: campaigns.map((campaign) => ({
+                id: campaign.id,
+                name: campaign.name,
+                matched: Boolean(inserted?.some((row) => row.campaign_id === campaign.id)),
+            })),
+        });
+    });
+    // ── preview_automation ────────────────────────────────────────────────────
+    server.registerTool('preview_automation', {
+        description: 'Preview what content would be fetched from a source right now, without generating a draft. Use this to inspect GitHub issues, RSS items, etc. before triggering a full run.',
+        inputSchema: {
+            source_id: z.string().uuid().describe('The content source UUID to preview'),
+        },
+    }, async ({ source_id }) => {
+        const { data: source, error } = await db()
+            .from('content_sources')
+            .select('*')
+            .eq('id', source_id)
+            .eq('project_id', getProjectId())
+            .maybeSingle();
+        if (error || !source)
+            return txt('Source not found');
+        if (source.source_type === 'github') {
+            if (!source.github_repo)
+                return txt('No github_repo configured on this source');
+            let token;
+            if (source.github_token_enc) {
+                try {
+                    token = decrypt(source.github_token_enc);
+                }
+                catch { /* no token */ }
+            }
+            const since = source.last_polled_at
+                ? new Date(source.last_polled_at).toISOString()
+                : new Date(Date.now() - 7 * 24 * 60 * 60 * 1000).toISOString();
+            const params = new URLSearchParams({ state: 'closed', since, per_page: '20', sort: 'updated', direction: 'desc' });
+            if (source.github_label_filter)
+                params.set('labels', source.github_label_filter);
+            const headers = {
+                Accept: 'application/vnd.github.v3+json',
+                'User-Agent': 'Sendinel/1.0',
+            };
+            if (token)
+                headers.Authorization = `Bearer ${token}`;
+            const res = await fetch(`https://api.github.com/repos/${source.github_repo}/issues?${params.toString()}`, {
+                headers,
+                signal: AbortSignal.timeout(10000),
+            });
+            if (!res.ok)
+                return txt(`GitHub API error: ${res.status}`);
+            const issues = await res.json();
+            const realIssues = issues.filter((i) => !i.pull_request);
+            return j({
+                source_id,
+                source_type: 'github',
+                repo: source.github_repo,
+                since,
+                issue_count: realIssues.length,
+                issues: realIssues.map((i) => ({
+                    number: i.number,
+                    title: i.title,
+                    labels: i.labels?.map((l) => l.name) ?? [],
+                    closed_at: i.closed_at,
+                    url: i.html_url,
+                })),
+            });
+        }
+        if (source.source_type === 'rss') {
+            return j({
+                source_id,
+                source_type: 'rss',
+                feed_url: source.feed_url,
+                last_polled_at: source.last_polled_at,
+                note: 'RSS preview not yet implemented — use trigger_automation to run and generate a draft',
+            });
+        }
+        return j({
+            source_id,
+            source_type: source.source_type,
+            last_polled_at: source.last_polled_at,
+            items_generated: source.items_generated,
+            note: 'Use trigger_automation to run this source on demand',
+        });
+    });
+    // ── trigger_automation ────────────────────────────────────────────────────
+    server.registerTool('trigger_automation', {
+        description: 'Run a content source on demand right now — fetches new content, generates a certificate-prompted email draft, and adds it to the approval queue. Returns the draft ID. Use preview_automation first to confirm what content will be pulled.',
+        inputSchema: {
+            source_id: z.string().uuid().describe('The content source UUID to trigger'),
+            since_days: z.number().int().min(1).max(90).optional().describe('For GitHub sources: how many days back to look for closed issues (default: 7). Overrides last_polled_at for this run.'),
+            dry_run: z.boolean().optional().default(false).describe('If true, generates and returns the draft without saving it to the approval queue'),
+        },
+    }, async ({ source_id, since_days, dry_run }) => {
+        const projectId = getProjectId();
+        const { data: source, error: srcErr } = await db()
+            .from('content_sources')
+            .select('*, sites!inner(id, name, from_email, from_name, sending_domain, brand_voice)')
+            .eq('id', source_id)
+            .eq('project_id', projectId)
+            .maybeSingle();
+        if (srcErr || !source)
+            return txt('Source not found or access denied');
+        if (!source.active)
+            return txt('Source is paused. Resume it before triggering.');
+        const site = source.sites;
+        let items = [];
+        if (source.source_type === 'github') {
+            if (!source.github_repo)
+                return txt('No github_repo configured on this source');
+            let token;
+            if (source.github_token_enc) {
+                try {
+                    token = decrypt(source.github_token_enc);
+                }
+                catch { /* no token */ }
+            }
+            const since = since_days
+                ? new Date(Date.now() - since_days * 24 * 60 * 60 * 1000).toISOString()
+                : source.last_polled_at
+                    ? new Date(source.last_polled_at).toISOString()
+                    : new Date(Date.now() - 7 * 24 * 60 * 60 * 1000).toISOString();
+            const params = new URLSearchParams({ state: 'closed', since, per_page: '20', sort: 'updated', direction: 'desc' });
+            if (source.github_label_filter)
+                params.set('labels', source.github_label_filter);
+            const headers = {
+                Accept: 'application/vnd.github.v3+json',
+                'User-Agent': 'Sendinel/1.0',
+            };
+            if (token)
+                headers.Authorization = `Bearer ${token}`;
+            const ghRes = await fetch(`https://api.github.com/repos/${source.github_repo}/issues?${params.toString()}`, {
+                headers,
+                signal: AbortSignal.timeout(10000),
+            });
+            if (!ghRes.ok)
+                return txt(`GitHub API error: ${ghRes.status}`);
+            const issues = await ghRes.json();
+            const realIssues = issues.filter((i) => !i.pull_request);
+            if (!realIssues.length)
+                return txt(`No closed issues found in ${source.github_repo} for the requested period.`);
+            const sinceLabel = new Date(since).toLocaleDateString('en-US', { month: 'long', day: 'numeric' });
+            const issueList = realIssues.map((i) => `- ${i.title}${i.labels?.length ? ` [${i.labels.map((l) => l.name).join(', ')}]` : ''}${i.html_url ? ` (${i.html_url})` : ''}`).join('\n');
+            items = [{
+                    title: `${realIssues.length} issue${realIssues.length > 1 ? 's' : ''} closed since ${sinceLabel}`,
+                    body: `Repository: ${source.github_repo}\n\n${issueList}`,
+                    url: `https://github.com/${source.github_repo}/issues?q=is%3Aissue+is%3Aclosed`,
+                }];
+        }
+        else {
+            return txt(`On-demand triggering for source_type "${source.source_type}" is not yet supported via MCP. Use the cron pipeline or trigger via the dashboard.`);
+        }
+        if (!items.length)
+            return txt('No new content found for this source.');
+        const apiKey = process.env.ANTHROPIC_API_KEY;
+        if (!apiKey)
+            return txt('Error: ANTHROPIC_API_KEY not configured');
+        const brandVoice = site?.brand_voice ?? null;
+        const brandContext = site
+            ? `Brand: ${site.name}${site.from_name ? `, From: ${site.from_name}` : ''}${site.sending_domain ? `, Domain: ${site.sending_domain}` : ''}`
+            : 'No brand info available';
+        const voicePrompt = buildVoicePrompt(brandVoice);
+        const baseSystem = buildEmailSystemPrompt(brandContext, voicePrompt);
+        const item = items[0];
+        const brief = `Write a product update email summarizing recently closed GitHub issues.
+
+Repository: ${source.github_repo}
+${item.title ? `Period: ${item.title}` : ''}
+
+Issues closed:
+${item.body}
+
+Group issues by label where possible (Bugs Fixed, New Features, Improvements).
+Each issue should be one short line with a link to the issue URL.
+End with a CTA to view the full changelog on GitHub.`;
+        const anthropic = new Anthropic({ apiKey });
+        const response = await anthropic.messages.create({
+            model: getAnthropicModelId(),
+            max_tokens: 1800,
+            system: baseSystem,
+            messages: [{ role: 'user', content: brief }],
+        });
+        const textBlock = response.content.find((b) => b.type === 'text');
+        const raw = textBlock && 'text' in textBlock ? textBlock.text : '{}';
+        const jsonMatch = raw.match(/\{[\s\S]*\}/);
+        if (!jsonMatch)
+            return txt('Generation failed - could not parse Claude response');
+        let parsed;
+        try {
+            parsed = JSON.parse(jsonMatch[0]);
+        }
+        catch {
+            return txt('Generation failed - invalid JSON from Claude');
+        }
+        const htmlBody = parsed.html_body ?? parsed.text_body?.replace(/\n/g, '<br>') ?? '';
+        const textBody = parsed.text_body ?? '';
+        const subject = parsed.subject ?? `Update from ${source.github_repo}`;
+        if (dry_run) {
+            return j({ dry_run: true, subject, text_body: textBody, html_body: htmlBody, source_id, source_name: source.name });
+        }
+        const { data: draft, error: draftErr } = await db()
+            .from('ai_drafts')
+            .insert({
+            project_id: projectId,
+            site_id: source.site_id,
+            subject,
+            body_html: htmlBody,
+            body_text: textBody,
+            prompt: `[Automation] Source: ${source.name}. ${item.title ?? ''}`,
+            model: getAnthropicModelId(),
+        })
+            .select('id')
+            .single();
+        if (draftErr)
+            return txt(`Failed to save draft: ${draftErr.message}`);
+        await db()
+            .from('content_sources')
+            .update({ last_polled_at: new Date().toISOString(), items_generated: (source.items_generated ?? 0) + 1 })
+            .eq('id', source_id);
+        return j({
+            ok: true,
+            draft_id: draft.id,
+            subject,
+            site_id: source.site_id,
+            source_name: source.name,
+            items_processed: items.length,
+            message: 'Draft created and added to approval queue. Use approve_draft or the AI Drafts page to review.',
+        });
+    });
+}

package/build/tools/campaigns.d.ts

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