@sendinel/mcp-server 1.0.0

package/build/tools/content.d.ts

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

package/build/tools/content.js

@@ -0,0 +1,68 @@
+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 registerContentTools(server) {
+    server.registerTool('list_content_blocks', {
+        description: 'List reusable content blocks for the project, optionally filtered by category.',
+        inputSchema: { category: z.enum(['header', 'footer', 'cta', 'legal', 'general']).optional() },
+    }, async ({ category }) => {
+        let query = db().from('content_blocks').select('id, name, description, category, html, updated_at').eq('project_id', getProjectId()).order('updated_at', { ascending: false });
+        if (category)
+            query = query.eq('category', category);
+        const { data, error } = await query;
+        if (error)
+            return j({ error: error.message });
+        return j({ blocks: data ?? [] });
+    });
+    server.registerTool('create_content_block', {
+        description: 'Create a reusable content block.',
+        inputSchema: {
+            name: z.string().min(1),
+            category: z.enum(['header', 'footer', 'cta', 'legal', 'general']).optional().default('general'),
+            html: z.string().min(1),
+            description: z.string().optional(),
+        },
+    }, async ({ name, category = 'general', html, description }) => {
+        const { data, error } = await db().from('content_blocks')
+            .insert({ project_id: getProjectId(), name, category, html, description: description ?? null })
+            .select('id, name, category, html, description, created_at')
+            .single();
+        if (error)
+            return j({ error: error.message });
+        return j({ block: data });
+    });
+    server.registerTool('delete_content_block', {
+        description: 'Delete a reusable content block.',
+        inputSchema: { block_id: z.string().uuid() },
+    }, async ({ block_id }) => {
+        const { error } = await db().from('content_blocks').delete().eq('project_id', getProjectId()).eq('id', block_id);
+        if (error)
+            return j({ error: error.message });
+        return j({ deleted: true });
+    });
+    server.registerTool('list_content_sources', {
+        description: 'List configured content sources and draft counts.',
+        inputSchema: {},
+    }, async () => {
+        const { data, error } = await db().from('content_sources')
+            .select('id, name, source_type, feed_url, active, last_polled_at, items_generated')
+            .eq('project_id', getProjectId())
+            .order('created_at', { ascending: false });
+        if (error)
+            return j({ error: error.message });
+        return j({ sources: (data ?? []).map((row) => ({ id: row.id, name: row.name, type: row.source_type, url: row.feed_url, active: row.active, last_fetched: row.last_polled_at, draft_count: row.items_generated ?? 0 })) });
+    });
+    server.registerTool('trigger_content_pipeline', {
+        description: 'Mark one or all content sources ready for the content pipeline cron.',
+        inputSchema: { source_id: z.string().uuid().optional() },
+    }, async ({ source_id }) => {
+        let query = db().from('content_sources').update({ last_polled_at: null }).eq('project_id', getProjectId());
+        if (source_id)
+            query = query.eq('id', source_id);
+        const { error } = await query;
+        if (error)
+            return j({ error: error.message });
+        return j({ drafts_created: 0, queued_for_pipeline: true });
+    });
+}

package/build/tools/data-proposals.d.ts

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

package/build/tools/data-proposals.js

@@ -0,0 +1,155 @@
+import { z } from 'zod';
+import { db } from '../db.js';
+import { getProjectId } from '../project.js';
+import { getAnthropicModelId } from '../anthropic-model.js';
+const txt = (text) => ({ content: [{ type: 'text', text }] });
+const j = (data) => txt(JSON.stringify(data, null, 2));
+async function engagementSnapshot(projectId) {
+    const since = new Date(Date.now() - 7 * 86400000).toISOString();
+    const [{ data: logs }, { count: audienceSize }, { data: segments }] = await Promise.all([
+        db().from('email_log').select('status, created_at').eq('project_id', projectId).gte('created_at', since).limit(10000),
+        db().from('subscribers').select('id', { count: 'exact', head: true }).eq('project_id', projectId).eq('is_test', false).eq('global_unsubscribed', false),
+        db().from('segments').select('id, name, subscriber_count, updated_at').eq('project_id', projectId).order('updated_at', { ascending: false }).limit(5),
+    ]);
+    const rows = logs ?? [];
+    const sent = rows.filter((row) => ['sent', 'delivered', 'opened', 'clicked', 'bounced', 'complained'].includes(row.status)).length;
+    const opened = rows.filter((row) => row.status === 'opened' || row.status === 'clicked').length;
+    const clicked = rows.filter((row) => row.status === 'clicked').length;
+    return {
+        period_days: 7,
+        sent,
+        open_rate: sent > 0 ? Number((opened / sent).toFixed(4)) : 0,
+        click_rate: sent > 0 ? Number((clicked / sent).toFixed(4)) : 0,
+        audience_size: audienceSize ?? 0,
+        recent_segments: segments ?? [],
+    };
+}
+export function registerDataProposalTools(server) {
+    server.registerTool('propose_campaign_from_data', {
+        description: 'Create an approve-gated campaign proposal from recent engagement signals and project Brand Brain.',
+        inputSchema: {
+            source_type: z.enum(['engagement_signal', 'segment_trend', 'cross_channel_synthesis']).optional().default('engagement_signal'),
+            segment_id: z.string().uuid().optional(),
+        },
+    }, async ({ source_type, segment_id }) => {
+        const projectId = getProjectId();
+        const { data: project, error: projectError } = await db()
+            .from('projects')
+            .select('id, org_id, owner_user_id, name, brand_settings')
+            .eq('id', projectId)
+            .maybeSingle();
+        if (projectError)
+            return txt(`Error: ${projectError.message}`);
+        if (!project)
+            return txt('Project not found.');
+        const snapshot = await engagementSnapshot(projectId);
+        const audience = project.brand_settings?.audience ?? 'subscribers';
+        const title = `Re-engage ${audience}`;
+        const subject = `A useful update from ${project.name}`;
+        const body = `Here is a timely update for ${audience}.\n\nRecent engagement suggests subscribers need one clear next step.\n\n{{cta_url|Read the update}}`;
+        const { data, error } = await db()
+            .from('data_proposals')
+            .insert({
+            org_id: project.org_id,
+            project_id: projectId,
+            user_id: project.owner_user_id,
+            source_type,
+            engagement_snapshot: snapshot,
+            campaign_title: title,
+            campaign_subject: subject,
+            campaign_body_draft: body,
+            campaign_cta: 'Read the update',
+            target_segment_id: segment_id ?? null,
+            target_audience_size: snapshot.audience_size,
+            premises: `Recent engagement data: ${JSON.stringify(snapshot)}`,
+            execution_trace: 'MCP proposal generated from first-party engagement snapshot and project Brand Brain.',
+            brand_voice_used: project.brand_settings ?? {},
+        })
+            .select('*')
+            .single();
+        if (error)
+            return txt(`Error: ${error.message}`);
+        return j({ proposal: data });
+    });
+    server.registerTool('list_data_proposals', {
+        description: 'List data-triggered campaign proposals for the current project.',
+        inputSchema: {
+            status: z.enum(['pending', 'approved', 'rejected', 'converted_to_draft', 'expired']).optional(),
+            limit: z.number().int().min(1).max(100).optional().default(25),
+        },
+    }, async ({ status, limit }) => {
+        let query = db()
+            .from('data_proposals')
+            .select('*')
+            .eq('project_id', getProjectId())
+            .order('created_at', { ascending: false })
+            .limit(limit ?? 25);
+        if (status)
+            query = query.eq('status', status);
+        const { data, error } = await query;
+        if (error)
+            return txt(`Error: ${error.message}`);
+        return j({ proposals: data ?? [] });
+    });
+    server.registerTool('approve_data_proposal', {
+        description: 'Approve a data-triggered campaign proposal and convert it into an AI draft for review.',
+        inputSchema: {
+            proposal_id: z.string().uuid(),
+        },
+    }, async ({ proposal_id }) => {
+        const projectId = getProjectId();
+        const { data: proposal, error: proposalError } = await db()
+            .from('data_proposals')
+            .select('*')
+            .eq('id', proposal_id)
+            .eq('project_id', projectId)
+            .maybeSingle();
+        if (proposalError)
+            return txt(`Error: ${proposalError.message}`);
+        if (!proposal)
+            return txt('Proposal not found.');
+        if (!['pending', 'approved'].includes(proposal.status))
+            return txt('Proposal is not approvable.');
+        const { data: site, error: siteError } = await db()
+            .from('sites')
+            .select('id')
+            .eq('project_id', projectId)
+            .eq('active', true)
+            .order('created_at', { ascending: true })
+            .limit(1)
+            .maybeSingle();
+        if (siteError)
+            return txt(`Error: ${siteError.message}`);
+        if (!site)
+            return txt('No active site available for draft conversion.');
+        const { data: draft, error: draftError } = await db()
+            .from('ai_drafts')
+            .insert({
+            project_id: projectId,
+            site_id: site.id,
+            subject: proposal.campaign_subject ?? proposal.campaign_title,
+            body_html: String(proposal.campaign_body_draft).replace(/\n/g, '<br>'),
+            body_text: proposal.campaign_body_draft,
+            prompt: `[Data proposal] ${proposal.premises}`,
+            model: getAnthropicModelId(),
+        })
+            .select('id')
+            .single();
+        if (draftError)
+            return txt(`Error: ${draftError.message}`);
+        const { data: updated, error: updateError } = await db()
+            .from('data_proposals')
+            .update({
+            status: 'converted_to_draft',
+            approved_at: new Date().toISOString(),
+            converted_to_draft_id: draft.id,
+        })
+            .eq('id', proposal.id)
+            .eq('project_id', projectId)
+            .select('*')
+            .single();
+        if (updateError)
+            return txt(`Error: ${updateError.message}`);
+        return j({ proposal: updated, draft_id: draft.id });
+    });
+}

package/build/tools/data.d.ts

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