@sendinel/mcp-server 1.0.139 → 1.0.141

package/build/tools/content.js

@@ -2,6 +2,9 @@ import { withApproval } from '../lib/action-approvals.js';
 import { z } from 'zod';
 import { adminDb, db } from '../db.js';
 import { getProjectId } from '../project.js';
+import { stripActiveEmailContent, validateUnsubscribeFooterTemplate } from '@sendinel/domain';
+import { dbToolError, toolError } from '../lib/db-error.js';
+import { logAudit } from '../audit.js';
 import { assertHttpUrl } from '../lib/url-validation.js';
 const j = (data) => ({ content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] });
 const BLOG_IMAGE_FORMATS = ['square_image', 'story_image', 'animated_gif', 'short_video', 'carousel'];
@@ -219,7 +222,7 @@ export function registerContentTools(server) {
             idempotentHint: false,
             openWorldHint: false,
         },
-        description: 'Create a reusable content block.',
+        description: 'Create a reusable content block. Active HTML is rejected; footer blocks require an unsubscribe link or merge tag.',
         inputSchema: {
             name: z.string().min(1),
             category: z.enum(['header', 'footer', 'cta', 'legal', 'general']).optional().default('general'),
@@ -227,12 +230,19 @@ export function registerContentTools(server) {
             description: z.string().optional(),
         },
     }, async ({ name, category = 'general', html, description }) => {
+        const active = stripActiveEmailContent(html);
+        if (active.removed.length)
+            return toolError({ error: 'Active HTML is not allowed in content blocks', code: 'validation_failed' });
+        if (category === 'footer' && !/href\s*=\s*["']\s*\{\{\s*unsubscribe_url\s*\}\}/i.test(html) && !validateUnsubscribeFooterTemplate(html).ok) {
+            return toolError({ error: 'Footer blocks require {{unsubscribe_url}} in a link or <unsubscribe>link text</unsubscribe>', code: 'validation_failed' });
+        }
         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 toolError(dbToolError(error));
+        await logAudit({ action: 'content_block.created', resourceType: 'content_block', resourceId: data.id });
         return j({ block: data });
     });
     server.registerTool('delete_content_block', {

package/build/tools/delivery-ops.js

@@ -6,6 +6,7 @@ import { adminDb, db } from '../db.js';
 import { assertChannelCanExecute, checkApproval, currentChannelContext, requestApproval, withApproval } from '../lib/action-approvals.js';
 import { callSendinelV1 } from '../lib/v1-client.js';
 import { getProjectId } from '../project.js';
+import { dbToolError, toolError } from '../lib/db-error.js';
 const j = (data) => ({ content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] });
 function asRecord(value) {
     return value && typeof value === 'object' ? value : {};
@@ -154,18 +155,18 @@ export function registerDeliveryOpsTools(server) {
             .eq('id', domain_id)
             .maybeSingle();
         if (error)
-            return j({ error: error.message });
+            return toolError(dbToolError(error, 'Unable to load domain'));
         if (!data)
-            return j({ error: 'Domain not found', code: 'NOT_FOUND' });
+            return toolError({ error: 'Domain not found', code: 'NOT_FOUND' });
         const { data: health, error: healthError } = await db().from('domain_health')
             .select('spf_valid, dkim_valid, dmarc_valid, sites!inner(domain_id)')
-            .eq('project_id', getProjectId())
+            .eq('sites.project_id', getProjectId())
             .eq('sites.domain_id', domain_id)
             .order('check_date', { ascending: false })
             .limit(1)
             .maybeSingle();
         if (healthError)
-            return j({ error: healthError.message });
+            return toolError(dbToolError(healthError, 'Unable to load domain health'));
         const spf = health?.spf_valid ?? null;
         const dkim = health?.dkim_valid ?? null;
         const dmarc = health?.dmarc_valid ?? null;

package/build/tools/landing-pages.js

@@ -3,10 +3,55 @@ import { z } from 'zod';
 import { db } from '../db.js';
 import { getProjectId } from '../project.js';
 import { logAudit } from '../audit.js';
+import { stripActiveEmailContent } from '@sendinel/domain';
+import { dbToolError, toolError } from '../lib/db-error.js';
 const j = (data) => ({ content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] });
 const SLUG_RE = /^[a-z0-9][a-z0-9\-]{0,62}$/;
 const VALID_STATUSES = ['draft', 'published', 'archived'];
 const LIST_COLUMNS = 'id, title, slug, site_id, status, form_id, blocks, meta_title, meta_description, conversion_event, views, conversions, background_color, accent_color, custom_css, created_at, updated_at, published_at';
+// Types rendered by LandingPageRenderer. Reuse the domain active-content pass.
+const BLOCK_TYPES = new Set(['hero', 'text', 'image', 'form', 'features', 'testimonial', 'cta', 'spacer']);
+const COLOR_RE = /^#(?:[0-9a-f]{3}|[0-9a-f]{6})$/i;
+function validatePageContent(input) {
+    for (const key of ['background_color', 'accent_color']) {
+        if (input[key] !== undefined && (typeof input[key] !== 'string' || !COLOR_RE.test(input[key]))) {
+            return `${key} must be a three- or six-digit hex color`;
+        }
+    }
+    if (input.custom_css != null && (typeof input.custom_css !== 'string' || /<\s*\/\s*style|<\s*script|javascript\s*:|expression\s*\(|@import/i.test(input.custom_css))) {
+        return 'custom_css contains unsafe content';
+    }
+    if (input.blocks !== undefined && (!Array.isArray(input.blocks) || input.blocks.some(block => !block || typeof block !== 'object' || !BLOCK_TYPES.has(block.type)))) {
+        return `Each block must have a recognized type: ${[...BLOCK_TYPES].join(', ')}`;
+    }
+    return null;
+}
+function sanitizeBlockValue(value) {
+    if (typeof value === 'string') {
+        // Also inspect bare URL fields (ctaUrl/url/src), using the same URL decoder
+        // as HTML attributes rather than a second scheme blacklist.
+        const url = stripActiveEmailContent(`<a href="${value.replace(/"/g, '&quot;')}">`);
+        if (url.removed.some(finding => finding.endsWith(' URL')))
+            return '';
+        return stripActiveEmailContent(value).html;
+    }
+    if (Array.isArray(value))
+        return value.map(sanitizeBlockValue);
+    if (value && typeof value === 'object')
+        return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, sanitizeBlockValue(item)]));
+    return value;
+}
+async function validatePageForm(formId) {
+    if (!formId)
+        return null;
+    const { data, error } = await db().from('signup_forms').select('id')
+        .eq('project_id', getProjectId()).eq('id', formId).maybeSingle();
+    if (error)
+        return dbToolError(error, 'Unable to load form');
+    if (!data)
+        return { error: 'form_id not found in this project', code: 'not_found' };
+    return null;
+}
 function slugify(text) {
     return text
         .toLowerCase()
@@ -53,7 +98,7 @@ export function registerLandingPageTools(server) {
     server.registerTool('create_landing_page', {
         title: 'Create Landing Page',
         annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
-        description: 'Create a draft landing page. Publish it with update_landing_page by setting status to published.',
+        description: 'Create a draft landing page. Blocks require a renderer type and have active content stripped; colors must be hex and custom_css must be safe. Publish with update_landing_page.',
         inputSchema: {
             title: z.string().trim().min(1).max(200),
             slug: z.string().trim().regex(SLUG_RE, 'Lowercase alphanumeric + hyphens, max 63 chars').optional(),
@@ -72,7 +117,13 @@ export function registerLandingPageTools(server) {
         const normalizedTitle = title.trim();
         const normalizedSlug = (slug ?? slugify(normalizedTitle)).trim();
         if (!SLUG_RE.test(normalizedSlug))
-            return j({ error: 'Invalid slug (lowercase alphanumeric + hyphens, max 63 chars)' });
+            return toolError({ error: 'Invalid slug (lowercase alphanumeric + hyphens, max 63 chars)', code: 'validation_failed' });
+        const contentError = validatePageContent({ blocks, background_color, accent_color, custom_css });
+        if (contentError)
+            return toolError({ error: contentError, code: 'validation_failed' });
+        const formError = await validatePageForm(form_id);
+        if (formError)
+            return toolError(formError);
         const insert = {
             project_id: projectId,
             title: normalizedTitle,
@@ -83,7 +134,7 @@ export function registerLandingPageTools(server) {
         if (form_id)
             insert.form_id = form_id;
         if (blocks)
-            insert.blocks = blocks;
+            insert.blocks = sanitizeBlockValue(blocks);
         if (meta_title)
             insert.meta_title = meta_title;
         if (meta_description)
@@ -103,8 +154,10 @@ export function registerLandingPageTools(server) {
             .single();
         if (error) {
             if (error.code === '23505')
-                return j({ error: 'A page with this slug already exists' });
-            return j({ error: error.message });
+                return toolError({ error: 'A page with this slug already exists', code: 'conflict' });
+            if (error.code === '23503')
+                return toolError({ error: 'Referenced form or site not found', code: 'not_found' });
+            return toolError(dbToolError(error));
         }
         await logAudit({
             action: 'landing_page.created',
@@ -136,6 +189,24 @@ export function registerLandingPageTools(server) {
         },
     }, withApproval('update_landing_page', async ({ page_id, title, slug, status, site_id, form_id, blocks, meta_title, meta_description, conversion_event, background_color, accent_color, custom_css }) => {
         const projectId = getProjectId();
+        // Validate the effective document on publish, including unsafe older drafts.
+        let content = { blocks, background_color, accent_color, custom_css };
+        if (status === 'published') {
+            const { data: existing, error: readError } = await db().from('landing_pages')
+                .select('blocks, background_color, accent_color, custom_css, form_id')
+                .eq('id', page_id).eq('project_id', projectId).maybeSingle();
+            if (readError)
+                return toolError(dbToolError(readError));
+            if (!existing)
+                return toolError({ error: 'Landing page not found', code: 'not_found' });
+            content = { ...existing, ...Object.fromEntries(Object.entries(content).filter(([, value]) => value !== undefined)) };
+        }
+        const contentError = validatePageContent(content);
+        if (contentError)
+            return toolError({ error: contentError, code: 'validation_failed' });
+        const formError = await validatePageForm(form_id === undefined ? content.form_id : form_id);
+        if (formError)
+            return toolError(formError);
         const updates = { updated_at: new Date().toISOString() };
         if (title !== undefined)
             updates.title = title.trim();
@@ -151,7 +222,7 @@ export function registerLandingPageTools(server) {
         if (form_id !== undefined)
             updates.form_id = form_id;
         if (blocks !== undefined)
-            updates.blocks = blocks;
+            updates.blocks = sanitizeBlockValue(blocks);
         if (meta_title !== undefined)
             updates.meta_title = meta_title;
         if (meta_description !== undefined)
@@ -164,18 +235,24 @@ export function registerLandingPageTools(server) {
             updates.accent_color = accent_color;
         if (custom_css !== undefined)
             updates.custom_css = custom_css;
+        if (status === 'published' && content.blocks !== undefined)
+            updates.blocks = sanitizeBlockValue(content.blocks);
         const { data, error } = await db()
             .from('landing_pages')
             .update(updates)
             .eq('id', page_id)
             .eq('project_id', projectId)
             .select()
-            .single();
+            .maybeSingle();
         if (error) {
             if (error.code === '23505')
-                return j({ error: 'A page with this slug already exists' });
-            return j({ error: error.message });
+                return toolError({ error: 'A page with this slug already exists', code: 'conflict' });
+            if (error.code === '23503')
+                return toolError({ error: 'Referenced form or site not found', code: 'not_found' });
+            return toolError(dbToolError(error));
         }
+        if (!data)
+            return toolError({ error: 'Landing page not found', code: 'not_found' });
         await logAudit({
             action: 'landing_page.updated',
             resourceType: 'landing_page',

package/build/tools/segments.js

@@ -1,8 +1,10 @@
+import { dbErrorResult } from '../lib/db-errors.js';
 import { withApproval } from '../lib/action-approvals.js';
 import { z } from 'zod';
 import Anthropic from '@anthropic-ai/sdk';
 import { db } from '../db.js';
 import { getProjectId } from '../project.js';
+import { dbToolError, toolError } from '../lib/db-error.js';
 import { getAnthropicModelId } from '../anthropic-model.js';
 import { AI_MAX_TOKENS, outputConfig, anthropicCheckedText } from '@sendinel/domain';
 import { applySegmentRules, buildSegmentBaseQuery, evaluateSegmentRules, hydrateEmailSendsContacts, isSegmentRulesError, normalizeSegmentRulesToTree, prepareSegmentRulesForStorage, readAllRows, } from '@sendinel/domain';
@@ -80,31 +82,38 @@ export function registerSegmentTools(server) {
             rules: z.record(z.string(), z.unknown()).describe('Segment rule tree: {op:"AND"|"OR", conditions:[{field, operator, value}]} or legacy flat rules. Supported fields include lifecycle_stage, engagement_score, source, created_at, last_opened_at, last_clicked_at, introduced_by_subscriber_id, tags, custom_properties.<key>, payment.<key>, email_sends (eq only, value: {min_count: positive integer, within_days: positive number}; at most one per segment). tag may be a plain string (one tag) or {values: string[], mode: "any"|"all"} to match several tags at once.'),
         },
     }, async ({ name, description, rules }) => {
-        let storedRules;
         try {
-            storedRules = prepareSegmentRulesForStorage(rules);
+            let storedRules;
+            try {
+                storedRules = prepareSegmentRulesForStorage(rules);
+            }
+            catch (rulesError) {
+                const invalid = invalidRules(rulesError);
+                if (invalid)
+                    return toolError({ error: rulesError instanceof Error ? rulesError.message : 'Invalid segment rules', code: 'validation_failed' });
+                throw rulesError;
+            }
+            const { data, error } = await db()
+                .from('segments')
+                .insert({ project_id: getProjectId(), name, description, rules: storedRules })
+                .select('id, name, description, rules, created_at')
+                .single();
+            if (error?.code === '23505')
+                return toolError({ error: 'A segment with this name already exists', code: 'conflict' });
+            if (error)
+                return toolError(dbToolError(error));
+            // Count against the stored (normalized) tree, not the raw input: a tree skips
+            // applySegmentRules' SQL push-down and filters in JS, which is what list_segments
+            // does for this same segment a moment later. Pushing the flat rules down instead
+            // makes the two disagree wherever SQL and JS compare differently -- notably
+            // custom_property against a non-string JSONB value (boolean/number), where
+            // `@> {"k":"true"}` misses a stored `true` but String(actual)===String(expected) matches.
+            const ids = await getSegmentContactIds(data.rules);
+            return j({ ...data, estimated_contacts: ids.length });
         }
-        catch (rulesError) {
-            const invalid = invalidRules(rulesError);
-            if (invalid)
-                return invalid;
-            throw rulesError;
+        catch (error) {
+            return dbErrorResult(error);
         }
-        const { data, error } = await db()
-            .from('segments')
-            .insert({ project_id: getProjectId(), name, description, rules: storedRules })
-            .select('id, name, description, rules, created_at')
-            .single();
-        if (error)
-            return txt(`Error: ${error.message}`);
-        // Count against the stored (normalized) tree, not the raw input: a tree skips
-        // applySegmentRules' SQL push-down and filters in JS, which is what list_segments
-        // does for this same segment a moment later. Pushing the flat rules down instead
-        // makes the two disagree wherever SQL and JS compare differently -- notably
-        // custom_property against a non-string JSONB value (boolean/number), where
-        // `@> {"k":"true"}` misses a stored `true` but String(actual)===String(expected) matches.
-        const ids = await getSegmentContactIds(data.rules);
-        return j({ ...data, estimated_contacts: ids.length });
     });
     server.registerTool('list_segments', {
         title: 'List Segments',
@@ -157,32 +166,37 @@ export function registerSegmentTools(server) {
             rules: z.record(z.string(), z.unknown()).optional(),
         },
     }, async ({ segment_id, name, description, rules }) => {
-        const updates = { updated_at: new Date().toISOString() };
-        if (name)
-            updates.name = name;
-        if (description !== undefined)
-            updates.description = description;
-        if (rules) {
-            try {
-                updates.rules = prepareSegmentRulesForStorage(rules);
-            }
-            catch (rulesError) {
-                const invalid = invalidRules(rulesError);
-                if (invalid)
-                    return invalid;
-                throw rulesError;
+        try {
+            const updates = { updated_at: new Date().toISOString() };
+            if (name)
+                updates.name = name;
+            if (description !== undefined)
+                updates.description = description;
+            if (rules) {
+                try {
+                    updates.rules = prepareSegmentRulesForStorage(rules);
+                }
+                catch (rulesError) {
+                    const invalid = invalidRules(rulesError);
+                    if (invalid)
+                        return invalid;
+                    throw rulesError;
+                }
             }
+            const { data, error } = await db()
+                .from('segments')
+                .update(updates)
+                .eq('id', segment_id)
+                .eq('project_id', getProjectId())
+                .select('id, name, description, rules, updated_at')
+                .single();
+            if (error)
+                return dbErrorResult(error);
+            return j(data);
+        }
+        catch (error) {
+            return dbErrorResult(error);
         }
-        const { data, error } = await db()
-            .from('segments')
-            .update(updates)
-            .eq('id', segment_id)
-            .eq('project_id', getProjectId())
-            .select('id, name, description, rules, updated_at')
-            .single();
-        if (error)
-            return txt(`Error: ${error.message}`);
-        return j(data);
     });
     server.registerTool('delete_segment', {
         title: 'Delete Segment',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sendinel/mcp-server",
-  "version": "1.0.139",
+  "version": "1.0.141",
   "description": "AI-controlled email operations control plane for campaigns, contacts, segments, analytics, and multi-provider sending via MCP.",
   "mcpName": "ai.sendinel/mcp-server",
   "type": "module",