@sendinel/mcp-server 1.0.0

package/build/tools/social-posts.js

@@ -0,0 +1,380 @@
+import Anthropic from '@anthropic-ai/sdk';
+import { z } from 'zod';
+import { db } from '../db.js';
+import { getProjectId } from '../project.js';
+import { getAnthropicModelId } from '../anthropic-model.js';
+import { buildVoicePrompt } from '../lib/voice.js';
+import { buildSocialSystemPrompt, buildSocialUserPrompt, parseSocialResponse, selectArchetype, } from '../lib/social-engine/index.js';
+import { fireWebhookEvent } from '../lib/webhook-events.js';
+const txt = (text) => ({ content: [{ type: 'text', text }] });
+const j = (data) => txt(JSON.stringify(data, null, 2));
+const PLATFORMS = [
+    'instagram', 'linkedin', 'twitter', 'x', 'facebook', 'tiktok',
+    'youtube', 'pinterest', 'threads', 'reddit', 'bluesky', 'google_business',
+];
+const STATUSES = ['draft', 'scheduled', 'queued', 'publishing', 'published', 'failed', 'archived'];
+function cleanText(value) {
+    return typeof value === 'string' && value.trim() ? value.trim() : null;
+}
+function stripHtml(value) {
+    return value.replace(/<[^>]+>/g, ' ').replace(/\s+/g, ' ').trim();
+}
+// Brand-context line for the social engine prompt — mirrors the dashboard's
+// buildBrandContext output (plain "Brand: X. Mission: Y." string, no label).
+// Project brand_settings is loosely typed; read canonical fields defensively.
+function buildSocialBrandContext(siteName, projectSettings) {
+    const parts = [];
+    if (siteName)
+        parts.push(`Brand: ${siteName}`);
+    const str = (key) => (typeof projectSettings?.[key] === 'string' && projectSettings[key].trim() ? projectSettings[key].trim() : null);
+    const mission = str('mission');
+    const audience = str('audience');
+    const differentiators = str('differentiators');
+    if (mission)
+        parts.push(`Mission: ${mission}`);
+    if (audience)
+        parts.push(`Audience: ${audience}`);
+    if (differentiators)
+        parts.push(`Differentiators: ${differentiators}`);
+    return parts.join('. ');
+}
+function isoOrNull(value) {
+    if (!value)
+        return null;
+    const date = new Date(String(value));
+    if (Number.isNaN(date.getTime()))
+        throw new Error('Expected a valid ISO 8601 datetime.');
+    return date.toISOString();
+}
+function statusFromSchedule(scheduledAt, queueRequested) {
+    if (queueRequested)
+        return 'queued';
+    if (scheduledAt)
+        return 'scheduled';
+    return 'draft';
+}
+function trackedUrl(input) {
+    const url = new URL(input.destinationUrl);
+    const source = input.platform === 'x' ? 'twitter' : input.platform;
+    const campaign = input.utmCampaign || input.title.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '').slice(0, 80) || 'social-post';
+    url.searchParams.set('utm_source', source);
+    url.searchParams.set('utm_medium', 'social');
+    url.searchParams.set('utm_campaign', campaign);
+    return { tracked_url: url.toString(), utm_source: source, utm_medium: 'social', utm_campaign: campaign };
+}
+async function projectOrgId(projectId) {
+    const { data } = await db().from('projects').select('org_id').eq('id', projectId).maybeSingle();
+    return data?.org_id ?? null;
+}
+async function requireProjectSite(siteId) {
+    if (!siteId)
+        return;
+    const { data, error } = await db().from('sites').select('id').eq('project_id', getProjectId()).eq('id', siteId).maybeSingle();
+    if (error)
+        throw new Error(error.message);
+    if (!data)
+        throw new Error('Site not found for this project');
+}
+async function requireProjectCampaign(campaignId) {
+    if (!campaignId)
+        return;
+    const { data, error } = await db().from('campaigns').select('id').eq('project_id', getProjectId()).eq('id', campaignId).maybeSingle();
+    if (error)
+        throw new Error(error.message);
+    if (!data)
+        throw new Error('Email campaign not found for this project');
+}
+export function registerSocialPostTools(server) {
+    server.registerTool('list_social_posts', {
+        description: 'List first-class social posts for the current project.',
+        inputSchema: {
+            status: z.enum(STATUSES).optional(),
+            platform: z.enum(PLATFORMS).optional(),
+            limit: z.number().int().min(1).max(100).optional().default(25),
+        },
+    }, async ({ status, platform, limit }) => {
+        let query = db()
+            .from('social_posts')
+            .select('*')
+            .eq('project_id', getProjectId())
+            .neq('status', 'archived')
+            .order('scheduled_at', { ascending: true, nullsFirst: false })
+            .order('created_at', { ascending: false })
+            .limit(limit ?? 25);
+        if (status)
+            query = query.eq('status', status);
+        if (platform)
+            query = query.contains('platforms', [platform]);
+        const { data, error } = await query;
+        if (error)
+            return txt(`Error: ${error.message}`);
+        return j({ posts: data ?? [] });
+    });
+    server.registerTool('get_social_post', {
+        description: 'Get one social post by ID.',
+        inputSchema: { post_id: z.string().uuid() },
+    }, async ({ post_id }) => {
+        const { data, error } = await db()
+            .from('social_posts')
+            .select('*')
+            .eq('project_id', getProjectId())
+            .eq('id', post_id)
+            .maybeSingle();
+        if (error)
+            return txt(`Error: ${error.message}`);
+        if (!data)
+            return j({ error: 'Social post not found', code: 'NOT_FOUND' });
+        return j(data);
+    });
+    server.registerTool('adapt_social_post', {
+        description: 'Adapt an existing email campaign into channel-specific social captions using the creator-archetype engine (deterministic archetype selection, multi-layer brand/voice prompts, A/B/C variants per platform, gen-time constraint enforcement) — without creating a post. Returns platform_captions (variant A per platform, back-compat) plus a full generation record with variants, media plans, and constraint warnings.',
+        inputSchema: {
+            email_campaign_id: z.string().uuid(),
+            platforms: z.array(z.enum(PLATFORMS)).min(1),
+        },
+    }, async ({ email_campaign_id, platforms }) => {
+        const projectId = getProjectId();
+        const [{ data: campaign, error: campaignError }, { data: step }, { data: project }] = await Promise.all([
+            db().from('campaigns').select('id, name, description, site_id').eq('project_id', projectId).eq('id', email_campaign_id).maybeSingle(),
+            db().from('campaign_steps').select('subject, body_html, body_text').eq('campaign_id', email_campaign_id).order('step_order', { ascending: true }).limit(1).maybeSingle(),
+            db().from('projects').select('org_id').eq('id', projectId).maybeSingle(),
+        ]);
+        if (campaignError)
+            return txt(`Error: ${campaignError.message}`);
+        if (!campaign)
+            return j({ error: 'Campaign not found', code: 'NOT_FOUND' });
+        const [{ data: site }, { data: projectSettingsRow }] = await Promise.all([
+            campaign.site_id
+                ? db().from('sites').select('name, brand_voice').eq('project_id', projectId).eq('id', campaign.site_id).maybeSingle()
+                : Promise.resolve({ data: null }),
+            db().from('projects').select('brand_settings').eq('id', projectId).maybeSingle(),
+        ]);
+        const seed = stripHtml(step?.body_text ?? step?.body_html ?? campaign.description ?? campaign.name);
+        const subject = step?.subject ?? campaign.name;
+        const projectSettings = (projectSettingsRow?.brand_settings ?? null);
+        const voiceRules = buildVoicePrompt(site?.brand_voice ?? null, projectSettings);
+        const brandContext = buildSocialBrandContext(site?.name ?? null, projectSettings);
+        // Dedupe while preserving order (x and twitter are distinct platforms).
+        const requested = Array.from(new Set(platforms));
+        const brief = {
+            goal: `announce: ${campaign.name}`,
+            source_content: seed,
+            format: 'text',
+            platforms: requested,
+        };
+        const archetype = selectArchetype(brief);
+        const apiKey = process.env.ANTHROPIC_API_KEY;
+        if (!apiKey) {
+            return j({ error: 'ANTHROPIC_API_KEY not configured', code: 'NO_API_KEY', title: campaign.name, content: seed, platform_captions: {} });
+        }
+        const anthropic = new Anthropic({ apiKey });
+        const model = getAnthropicModelId();
+        // One model call per platform — each a multi-layer engine prompt returning
+        // A/B/C variants as a structured IR. Independent calls so a partial failure
+        // surfaces per platform instead of failing the whole adaptation.
+        const settled = await Promise.allSettled(requested.map(async (platform) => {
+            const promptInput = { brief, platform, archetype, brandContext, voiceRules };
+            const response = await anthropic.messages.create({
+                model,
+                max_tokens: 1600,
+                system: [{ type: 'text', text: buildSocialSystemPrompt(promptInput), cache_control: { type: 'ephemeral' } }],
+                messages: [{ role: 'user', content: buildSocialUserPrompt(promptInput) }],
+            });
+            const textBlock = response.content.find((b) => b.type === 'text');
+            const raw = textBlock && 'text' in textBlock ? textBlock.text : '{}';
+            return parseSocialResponse(raw, platform, archetype.id);
+        }));
+        const posts = {};
+        const captions = {};
+        const failures = [];
+        settled.forEach((result, index) => {
+            if (result.status === 'fulfilled') {
+                posts[requested[index]] = result.value;
+                captions[requested[index]] = result.value.variants[0].caption;
+            }
+            else {
+                failures.push(`${requested[index]}: ${result.reason instanceof Error ? result.reason.message : 'generation failed'}`);
+            }
+        });
+        const generation = {
+            brief,
+            archetype_id: archetype.id,
+            posts,
+            generated_at: new Date().toISOString(),
+        };
+        return j({
+            title: campaign.name,
+            content: seed,
+            platform_captions: captions,
+            generation,
+            archetype: { id: archetype.id, name: archetype.name, trigger: archetype.neurodesign_trigger },
+            failures,
+            source: {
+                email_campaign_id: campaign.id,
+                subject,
+                brand_voice: site?.brand_voice ?? null,
+                brand_rules: voiceRules,
+            },
+        });
+    });
+    server.registerTool('create_social_post', {
+        description: 'Create a first-class social post, optionally linked to an email campaign and UTM-tracked social campaign.',
+        inputSchema: {
+            title: z.string().min(1),
+            content: z.string().min(1),
+            platforms: z.array(z.enum(PLATFORMS)).min(1),
+            site_id: z.string().uuid().optional(),
+            email_campaign_id: z.string().uuid().optional(),
+            platform_captions: z.record(z.string(), z.string()).optional(),
+            media_urls: z.array(z.string().url()).optional().default([]),
+            destination_url: z.string().url().optional(),
+            utm_campaign: z.string().optional(),
+            scheduled_at: z.string().datetime().optional(),
+            queue_requested: z.boolean().optional().default(false),
+            timezone: z.string().optional().default('Pacific/Honolulu'),
+        },
+    }, async ({ title, content, platforms, site_id, email_campaign_id, platform_captions, media_urls, destination_url, utm_campaign, scheduled_at, queue_requested, timezone }) => {
+        const projectId = getProjectId();
+        const orgId = await projectOrgId(projectId);
+        if (!orgId)
+            return txt('Project organization not found.');
+        try {
+            await requireProjectSite(site_id);
+            await requireProjectCampaign(email_campaign_id);
+        }
+        catch (err) {
+            return txt(`Error: ${err instanceof Error ? err.message : 'Invalid linked resource'}`);
+        }
+        let scheduledAt;
+        try {
+            scheduledAt = isoOrNull(scheduled_at);
+            if (scheduledAt && queue_requested)
+                return txt('Choose either a scheduled time or queue delivery, not both.');
+        }
+        catch (err) {
+            return txt(`Error: ${err instanceof Error ? err.message : 'Invalid schedule'}`);
+        }
+        let socialCampaignId = null;
+        let tracked = null;
+        if (destination_url) {
+            tracked = trackedUrl({ destinationUrl: destination_url, title, platform: platforms.includes('x') ? 'twitter' : platforms[0], utmCampaign: cleanText(utm_campaign) });
+            const { data: socialCampaign, error: campaignError } = await db()
+                .from('social_campaigns')
+                .insert({
+                project_id: projectId,
+                site_id: site_id ?? null,
+                name: title,
+                platform: tracked.utm_source,
+                destination_url,
+                utm_source: tracked.utm_source,
+                utm_medium: tracked.utm_medium,
+                utm_campaign: tracked.utm_campaign,
+                tracked_url: tracked.tracked_url,
+                notes: content,
+                scheduled_at: scheduledAt,
+                status: scheduledAt ? 'active' : 'draft',
+            })
+                .select('id')
+                .single();
+            if (campaignError)
+                return txt(`Error: ${campaignError.message}`);
+            socialCampaignId = socialCampaign.id;
+        }
+        const status = statusFromSchedule(scheduledAt, Boolean(queue_requested));
+        const { data, error } = await db()
+            .from('social_posts')
+            .insert({
+            org_id: orgId,
+            project_id: projectId,
+            site_id: site_id ?? null,
+            email_campaign_id: email_campaign_id ?? null,
+            social_campaign_id: socialCampaignId,
+            title,
+            content,
+            platform_captions: platform_captions ?? {},
+            media_urls: media_urls ?? [],
+            platforms,
+            destination_url: destination_url ?? null,
+            tracked_url: tracked?.tracked_url ?? null,
+            scheduled_at: scheduledAt,
+            timezone: timezone ?? 'Pacific/Honolulu',
+            queue_requested: Boolean(queue_requested),
+            status,
+        })
+            .select()
+            .single();
+        if (error)
+            return txt(`Error: ${error.message}`);
+        fireWebhookEvent('social.post.created', { social_post_id: data.id, title: data.title, status: data.status, platforms: data.platforms }, projectId).catch(() => { });
+        if (status === 'scheduled' || status === 'queued') {
+            fireWebhookEvent('social.post.scheduled', { social_post_id: data.id, title: data.title, status: data.status, scheduled_at: data.scheduled_at, platforms: data.platforms }, projectId).catch(() => { });
+        }
+        return j(data);
+    });
+    server.registerTool('update_social_post', {
+        description: 'Update a social post by ID. Supports copy, captions, schedule, status, and metrics fields.',
+        inputSchema: {
+            post_id: z.string().uuid(),
+            title: z.string().min(1).optional(),
+            content: z.string().min(1).optional(),
+            platforms: z.array(z.enum(PLATFORMS)).min(1).optional(),
+            platform_captions: z.record(z.string(), z.string()).optional(),
+            media_urls: z.array(z.string().url()).optional(),
+            destination_url: z.string().url().nullable().optional(),
+            scheduled_at: z.string().datetime().nullable().optional(),
+            queue_requested: z.boolean().optional(),
+            status: z.enum(STATUSES).optional(),
+            reach: z.number().int().min(0).optional(),
+            impressions: z.number().int().min(0).optional(),
+            engagements: z.number().int().min(0).optional(),
+            link_clicks: z.number().int().min(0).optional(),
+            conversions: z.number().int().min(0).optional(),
+            publish_error: z.string().nullable().optional(),
+        },
+    }, async ({ post_id, ...input }) => {
+        const updates = { updated_at: new Date().toISOString() };
+        for (const key of ['title', 'content', 'platforms', 'platform_captions', 'media_urls', 'destination_url', 'status', 'reach', 'impressions', 'engagements', 'link_clicks', 'conversions', 'publish_error']) {
+            if (input[key] !== undefined)
+                updates[key] = input[key];
+        }
+        if (input.scheduled_at !== undefined)
+            updates.scheduled_at = input.scheduled_at ? isoOrNull(input.scheduled_at) : null;
+        if (input.queue_requested !== undefined)
+            updates.queue_requested = input.queue_requested;
+        if (updates.scheduled_at && updates.queue_requested)
+            return txt('Choose either a scheduled time or queue delivery, not both.');
+        if (!Object.keys(updates).some((key) => key !== 'updated_at'))
+            return txt('No fields to update.');
+        const { data, error } = await db()
+            .from('social_posts')
+            .update(updates)
+            .eq('project_id', getProjectId())
+            .eq('id', post_id)
+            .select()
+            .single();
+        if (error)
+            return txt(`Error: ${error.message}`);
+        fireWebhookEvent('social.post.updated', { social_post_id: data.id, title: data.title, status: data.status, fields: Object.keys(updates) }, getProjectId()).catch(() => { });
+        if (data.status === 'published')
+            fireWebhookEvent('social.post.published', { social_post_id: data.id, title: data.title, platforms: data.platforms, published_at: data.published_at }, getProjectId()).catch(() => { });
+        if (data.status === 'failed')
+            fireWebhookEvent('social.post.failed', { social_post_id: data.id, title: data.title, publish_error: data.publish_error }, getProjectId()).catch(() => { });
+        return j(data);
+    });
+    server.registerTool('delete_social_post', {
+        description: 'Archive a social post so it disappears from active planner and list views.',
+        inputSchema: { post_id: z.string().uuid() },
+    }, async ({ post_id }) => {
+        const { data, error } = await db()
+            .from('social_posts')
+            .update({ status: 'archived', updated_at: new Date().toISOString() })
+            .eq('project_id', getProjectId())
+            .eq('id', post_id)
+            .select()
+            .single();
+        if (error)
+            return txt(`Error: ${error.message}`);
+        fireWebhookEvent('social.post.archived', { social_post_id: data.id, title: data.title }, getProjectId()).catch(() => { });
+        return j(data);
+    });
+}

package/build/tools/templates.d.ts

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

package/build/tools/templates.js

@@ -0,0 +1,282 @@
+import { z } from 'zod';
+import { db } from '../db.js';
+import { getProjectId } from '../project.js';
+const txt = (text) => ({ content: [{ type: 'text', text }] });
+const j = (data) => txt(JSON.stringify(data, null, 2));
+function stripHtml(value) {
+    return value
+        .replace(/<style[\s\S]*?<\/style>/gi, ' ')
+        .replace(/<script[\s\S]*?<\/script>/gi, ' ')
+        .replace(/<[^>]+>/g, ' ')
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+function translateMergeTags(body) {
+    const variables = new Set();
+    const unmapped = new Set();
+    const translated = body
+        .replace(/{{\s*customer\.first_name(?:\s*\|[^}]*)?\s*}}/gi, () => {
+        variables.add('first_name');
+        return '{{first_name}}';
+    })
+        .replace(/{{\s*customer\.last_name(?:\s*\|[^}]*)?\s*}}/gi, () => {
+        variables.add('last_name');
+        return '{{last_name}}';
+    })
+        .replace(/{{\s*customer\.email(?:\s*\|[^}]*)?\s*}}/gi, () => {
+        variables.add('email');
+        return '{{email}}';
+    })
+        .replace(/{{\s*unsubscribe_url\s*}}/gi, () => {
+        variables.add('unsubscribe_url');
+        return '{{unsubscribe_url}}';
+    })
+        .replace(/\*\|FNAME\|\*/g, () => {
+        variables.add('first_name');
+        return '{{first_name}}';
+    })
+        .replace(/\*\|LNAME\|\*/g, () => {
+        variables.add('last_name');
+        return '{{last_name}}';
+    })
+        .replace(/\*\|EMAIL\|\*/g, () => {
+        variables.add('email');
+        return '{{email}}';
+    })
+        .replace(/{{\s*customer\.([a-zA-Z0-9_.-]+)(?:\s*\|[^}]*)?\s*}}/g, (_match, token) => {
+        const name = `custom.${String(token).replace(/^custom\./, '')}`;
+        variables.add(name);
+        unmapped.add(`customer.${token}`);
+        return `{{${name}}}`;
+    });
+    const tokenPattern = /{{\s*([a-zA-Z0-9_.-]+)\s*}}/g;
+    let match;
+    while ((match = tokenPattern.exec(translated)) !== null) {
+        if (match[1])
+            variables.add(match[1]);
+    }
+    return { body: translated, variables: Array.from(variables), unmapped: Array.from(unmapped) };
+}
+export function registerTemplateTools(server) {
+    server.registerTool('list_templates', {
+        description: 'List email templates for the current project, including reusable system templates.',
+        inputSchema: {
+            limit: z.number().int().min(1).max(100).default(50).optional(),
+            category: z.string().optional(),
+            search: z.string().optional(),
+        },
+    }, async ({ limit = 50, category, search }) => {
+        const projectId = getProjectId();
+        let query = db().from('campaign_templates')
+            .select('id, name, category, description, subject_hint, brief_template, body_html, tags, project_id, created_at, updated_at')
+            .eq('is_archived', false)
+            .or(`project_id.is.null,project_id.eq.${projectId}`)
+            .order('created_at', { ascending: false })
+            .limit(limit);
+        if (category)
+            query = query.eq('category', category);
+        if (search)
+            query = query.ilike('name', `%${search}%`);
+        const { data, error } = await query;
+        if (error)
+            return j({ error: error.message });
+        return j({ templates: data ?? [], count: data?.length ?? 0 });
+    });
+    server.registerTool('translate_template', {
+        description: 'Translate rendered source-platform HTML into a Sendinel campaign template. Optionally save it.',
+        inputSchema: {
+            provider: z.enum(['customerio', 'mailchimp', 'klaviyo', 'activecampaign', 'kit', 'resend']).default('customerio').optional(),
+            source_template_id: z.string().optional(),
+            name: z.string().optional(),
+            subject: z.string().optional(),
+            html: z.string().optional(),
+            text: z.string().optional(),
+            save: z.boolean().default(false).optional(),
+        },
+    }, async ({ provider = 'customerio', source_template_id, name, subject, html, text, save = false }) => {
+        const projectId = getProjectId();
+        const { data: project, error: projectError } = await db().from('projects').select('org_id').eq('id', projectId).single();
+        if (projectError || !project?.org_id)
+            return j({ error: projectError?.message ?? 'Project not found' });
+        const source = String(html ?? text ?? '').trim();
+        if (!source)
+            return j({ error: 'html or text is required' });
+        const translatedBody = translateMergeTags(source);
+        const translatedSubject = translateMergeTags(String(subject ?? name ?? 'Imported template'));
+        const bodyHtml = html ? translatedBody.body : null;
+        const bodyText = text ? translatedBody.body : stripHtml(translatedBody.body);
+        const variables = Array.from(new Set([...translatedBody.variables, ...translatedSubject.variables]));
+        const unmapped = Array.from(new Set([...translatedBody.unmapped, ...translatedSubject.unmapped]));
+        const translated = {
+            provider,
+            source_template_id: source_template_id ?? null,
+            name: name ?? translatedSubject.body,
+            subject: translatedSubject.body,
+            body_html: bodyHtml,
+            body_text: bodyText,
+            variables,
+            unmapped_merge_tags: unmapped,
+            confidence: unmapped.length ? 'medium' : 'high',
+            translator: 'render_then_extract:mcp:v1',
+        };
+        const { data: row, error } = await db().from('template_translations').insert({
+            project_id: projectId,
+            org_id: project.org_id,
+            user_id: null,
+            source_provider: provider,
+            source_template_id: source_template_id ?? null,
+            source_name: translated.name,
+            source_subject: subject ?? null,
+            source_html: html ?? source,
+            source_text: text ?? null,
+            translated_subject: translated.subject,
+            translated_html: bodyHtml,
+            translated_text: bodyText,
+            variables,
+            unmapped_merge_tags: unmapped,
+            confidence: translated.confidence,
+            status: save ? 'saved' : 'completed',
+            extracted_json: translated,
+        }).select('id').single();
+        if (error)
+            return j({ error: error.message });
+        let savedTemplateId = null;
+        if (save) {
+            const { data: saved, error: saveError } = await db().from('campaign_templates').insert({
+                project_id: projectId,
+                name: translated.name,
+                category: 'migration',
+                description: `Imported from ${provider}. Translation confidence: ${translated.confidence}.`,
+                subject_hint: translated.subject,
+                brief_template: translated.body_text.slice(0, 240) || `Use imported ${provider} template.`,
+                body_html: bodyHtml,
+                body_text: bodyText,
+                body_source: bodyHtml ?? bodyText,
+                format: bodyHtml ? 'html' : 'text',
+                variables,
+                tags: ['migration', provider],
+                imported_from: provider,
+                external_id: source_template_id ?? null,
+            }).select('id').single();
+            if (saveError)
+                return j({ error: saveError.message });
+            savedTemplateId = saved?.id ?? null;
+            if (savedTemplateId) {
+                await db().from('template_translations').update({ saved_template_id: savedTemplateId, status: 'saved' }).eq('id', row.id);
+            }
+        }
+        return j({ ok: true, translation_id: row.id, saved_template_id: savedTemplateId, translated });
+    });
+    server.registerTool('get_template', {
+        description: 'Get a single email template by ID.',
+        inputSchema: { id: z.string().uuid() },
+    }, async ({ id }) => {
+        const projectId = getProjectId();
+        const { data, error } = await db().from('campaign_templates')
+            .select('id, name, category, description, subject_hint, brief_template, body_html, tags, project_id, created_at, updated_at')
+            .eq('id', id)
+            .or(`project_id.is.null,project_id.eq.${projectId}`)
+            .maybeSingle();
+        if (error)
+            return j({ error: error.message });
+        return j({ template: data });
+    });
+    server.registerTool('create_template', {
+        description: 'Create a new email template. Use create_template_from_brief to AI-generate the content.',
+        inputSchema: {
+            name: z.string().min(1),
+            brief: z.string().min(1),
+            subject_hint: z.string().optional(),
+            body_html: z.string().optional(),
+            category: z.string().optional(),
+            description: z.string().optional(),
+            tags: z.array(z.string()).optional(),
+        },
+    }, async ({ name, brief, subject_hint, body_html, category, description, tags }) => {
+        const projectId = getProjectId();
+        const { data, error } = await db().from('campaign_templates')
+            .insert({
+            project_id: projectId,
+            name,
+            brief_template: brief,
+            subject_hint: subject_hint ?? '',
+            body_html: body_html ?? null,
+            category: category ?? 'general',
+            description: description ?? '',
+            tags: tags ?? [],
+        })
+            .select('id, name, category, subject_hint, created_at')
+            .single();
+        if (error)
+            return j({ error: error.message });
+        return j({ template: data, ok: true });
+    });
+    server.registerTool('update_template', {
+        description: 'Update an existing email template.',
+        inputSchema: {
+            id: z.string().uuid(),
+            name: z.string().optional(),
+            brief: z.string().optional(),
+            subject_hint: z.string().optional(),
+            body_html: z.string().optional(),
+            category: z.string().optional(),
+            description: z.string().optional(),
+            tags: z.array(z.string()).optional(),
+        },
+    }, async ({ id, ...updates }) => {
+        const projectId = getProjectId();
+        const { data: existing, error: existingErr } = await db().from('campaign_templates')
+            .select('id, project_id')
+            .eq('id', id)
+            .maybeSingle();
+        if (existingErr || !existing)
+            return j({ error: existingErr?.message ?? 'Template not found', code: 'NOT_FOUND' });
+        if (!existing.project_id || existing.project_id !== projectId)
+            return j({ error: 'Cannot edit system templates', code: 'FORBIDDEN' });
+        const row = { updated_at: new Date().toISOString() };
+        if (updates.name !== undefined)
+            row.name = updates.name;
+        if (updates.brief !== undefined)
+            row.brief_template = updates.brief;
+        if (updates.subject_hint !== undefined)
+            row.subject_hint = updates.subject_hint;
+        if (updates.body_html !== undefined)
+            row.body_html = updates.body_html;
+        if (updates.category !== undefined)
+            row.category = updates.category;
+        if (updates.description !== undefined)
+            row.description = updates.description;
+        if (updates.tags !== undefined)
+            row.tags = updates.tags;
+        const { data, error } = await db().from('campaign_templates')
+            .update(row)
+            .eq('id', id)
+            .eq('project_id', projectId)
+            .select('id, name, category, subject_hint, updated_at')
+            .single();
+        if (error)
+            return j({ error: error.message });
+        return j({ template: data, ok: true });
+    });
+    server.registerTool('delete_template', {
+        description: 'Archive an email template. System templates cannot be deleted.',
+        inputSchema: { id: z.string().uuid() },
+    }, async ({ id }) => {
+        const projectId = getProjectId();
+        const { data: existing, error: existingErr } = await db().from('campaign_templates')
+            .select('id, project_id')
+            .eq('id', id)
+            .maybeSingle();
+        if (existingErr || !existing)
+            return j({ error: existingErr?.message ?? 'Template not found', code: 'NOT_FOUND' });
+        if (!existing.project_id || existing.project_id !== projectId)
+            return j({ error: 'Cannot delete system templates', code: 'FORBIDDEN' });
+        const { error } = await db().from('campaign_templates')
+            .update({ is_archived: true, updated_at: new Date().toISOString() })
+            .eq('id', id)
+            .eq('project_id', projectId);
+        if (error)
+            return j({ error: error.message });
+        return j({ ok: true, deleted: id });
+    });
+}

package/build/tools/warmup.d.ts

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