@sendinel/mcp-server 1.0.34 → 1.0.36

package/README.md

@@ -12,7 +12,7 @@ AI-controlled email operations control plane for campaigns, contacts, segments,
 
 ## Tool groups
 
-Sendinel currently exposes 34 tool groups and 318 tools (gateway mode adds 3 meta-tools). These counts are checked against the tool registry in CI, so this table matches what ships.
+Sendinel currently exposes 34 tool groups and 319 tools (gateway mode adds 3 meta-tools). These counts are checked against the tool registry in CI, so this table matches what ships.
 
 | Group | Count | Purpose |
 |-------|-------|---------|
@@ -23,7 +23,7 @@ Sendinel currently exposes 34 tool groups and 318 tools (gateway mode adds 3 met
 | `approvals` | 2 | Poll and list risk-tiered action approvals |
 | `automations` | 7 | Automation triggers, previews, and response-gated escalation ladders |
 | `brand_kit` | 5 | Brand Core text import, media library upload/URL ingest, asset-context reads |
-| `campaigns` | 42 | Full campaign lifecycle: create, edit, approve, launch, enroll, schedule, sequence templates |
+| `campaigns` | 43 | Full campaign lifecycle: create, edit, approve, launch, enroll, schedule, sequence templates, convert imported campaigns |
 | `cloud-import` | 6 | Cloud storage import |
 | `compound` | 4 | Higher-level campaign/template/site setup and delivery diagnosis workflows |
 | `connector` | 6 | BYOD connector status, table discovery, schema/view setup, mapping, resync |

package/build/lib/action-approvals.js

@@ -1,3 +1,4 @@
+import { decodeHtmlEntities, stripHtmlComments } from '@sendinel/domain';
 import { db, requestContext } from '../db.js';
 import { getProjectId } from '../project.js';
 import { fireWebhookEvent } from './webhook-events.js';
@@ -131,12 +132,14 @@ export function currentChannelContext() {
 }
 /** Tag-stripped, whitespace-collapsed, length-capped text. HTML is untrusted input. */
 export function approvalExcerpt(html, max = 200) {
-    const text = String(html ?? '')
+    // Outlook-only comment content ("96") is dropped and character codes decoded, so an approver
+    // reads the email the way a recipient does.
+    const text = decodeHtmlEntities(stripHtmlComments(String(html ?? ''))
         .replace(/<style[\s\S]*?<\/style>/gi, ' ')
         .replace(/<script[\s\S]*?<\/script>/gi, ' ')
-        .replace(/<[^>]+>/g, ' ')
-        .replace(/&nbsp;/g, ' ')
-        .replace(/\s+/g, ' ')
+        .replace(/<title[\s\S]*?<\/title>/gi, ' ')
+        .replace(/<[^>]+>/g, ' '))
+        .replace(/[\s\u00A0\u2002\u2003\u2009\u200A]+/g, ' ')
         .trim();
     return text.length > max ? `${text.slice(0, max - 1)}…` : text;
 }

package/build/server.js

@@ -2,6 +2,7 @@ import { runWithToolContext } from './db.js';
 import { registerAnalyticsTools } from './tools/analytics.js';
 import { registerCampaignTools } from './tools/campaigns.js';
 import { registerCampaignSetTools } from './tools/campaign-sets.js';
+import { registerConvertImportedTools } from './tools/convert-imported.js';
 import { registerContactTools } from './tools/contacts.js';
 import { registerDraftTools } from './tools/drafts.js';
 import { registerGdprTools } from './tools/gdpr.js';
@@ -38,7 +39,7 @@ import { registerCloudImportTools } from './tools/cloud-import.js';
 const GROUP_REGISTRY = {
     analytics: registerAnalyticsTools,
     // Campaign sets (#3669) live in their own module but belong to the campaigns group.
-    campaigns: (server) => { registerCampaignTools(server); registerCampaignSetTools(server); },
+    campaigns: (server) => { registerCampaignTools(server); registerCampaignSetTools(server); registerConvertImportedTools(server); },
     contacts: registerContactTools,
     segments: registerSegmentTools,
     lists: registerListTools,
@@ -85,7 +86,7 @@ const WRITE_TOOLS = new Set([
     'add_campaign_branch', 'remove_campaign_branch', 'set_campaign_goal', 'remove_campaign_goal',
     'review_campaign_portfolio',
     'list_campaign_steps', 'update_campaign_step', 'delete_campaign_step',
-    'enroll_contact', 'enroll_segment', 'broadcast_to_segment', 'send_broadcast', 'create_campaign_set', 'activate_campaigns', 'get_enrollment_status', 'clone_campaign', 'clone_sequence_template', 'generate_email',
+    'enroll_contact', 'enroll_segment', 'broadcast_to_segment', 'send_broadcast', 'create_campaign_set', 'activate_campaigns', 'convert_imported_campaigns', 'get_enrollment_status', 'clone_campaign', 'clone_sequence_template', 'generate_email',
     'create_social_campaign', 'schedule_social_post',
     'create_social_post', 'update_social_post', 'delete_social_post',
     'create_draft', 'approve_draft', 'reject_draft',

package/build/tools/automations.js

@@ -5,41 +5,10 @@ import { getProjectId } from '../project.js';
 import { decrypt } from '../crypto.js';
 import { buildVoicePrompt, buildEmailSystemPrompt } from '../lib/voice.js';
 import { getAnthropicModelId } from '../anthropic-model.js';
+// Shared with the dashboard, including trigger_config.where event-data filters (#3689).
+import { campaignMatchesTrigger, normalizeTriggerList as normalizeList } from '@sendinel/domain';
 const txt = (text) => ({ content: [{ type: 'text', text }] });
 const j = (data) => txt(JSON.stringify(data, null, 2));
-function normalizeValue(value) {
-    if (typeof value !== 'string')
-        return null;
-    const normalized = value.trim().toLowerCase().replace(/[\s-]+/g, '_');
-    return normalized || null;
-}
-function normalizeList(value) {
-    const raw = Array.isArray(value) ? value : typeof value === 'string' ? [value] : [];
-    return Array.from(new Set(raw.map(normalizeValue).filter((item) => Boolean(item))));
-}
-function triggerConfig(value) {
-    if (!value || typeof value !== 'object' || Array.isArray(value))
-        return { events: [], tags: [] };
-    const config = value;
-    return {
-        events: normalizeList(config.events ?? config.event_names ?? config.trigger_event_names),
-        tags: normalizeList(config.tags ?? config.trigger_tags ?? config.entity_tags ?? config.project_tags),
-    };
-}
-function campaignMatchesTrigger(campaign, input) {
-    const config = triggerConfig(campaign.trigger_config);
-    const legacyEvent = normalizeValue(campaign.trigger_event_name);
-    const legacyTag = normalizeValue(campaign.trigger_tag);
-    const campaignEvents = Array.from(new Set([...(legacyEvent ? [legacyEvent] : []), ...config.events]));
-    const campaignTags = Array.from(new Set([...(legacyTag ? [legacyTag] : []), ...config.tags]));
-    const event = normalizeValue(input.event);
-    const tags = new Set((input.tags ?? []).map(normalizeValue).filter((tag) => Boolean(tag)));
-    if (campaignEvents.length > 0 && (!event || !campaignEvents.includes(event)))
-        return false;
-    if (campaignTags.length > 0 && !campaignTags.some((tag) => tags.has(tag)))
-        return false;
-    return campaignEvents.length > 0 || campaignTags.length > 0;
-}
 async function enrollSubscriberIntoTriggeredCampaigns(input) {
     const { subscriber_id, campaign_id, site_id, trigger_event_name, trigger_event_names, trigger_tag, trigger_tags, next_send_at, context } = input;
     const triggerEvents = Array.from(new Set([...normalizeList(trigger_event_names), ...(trigger_event_name ? [trigger_event_name] : [])]));
@@ -85,7 +54,7 @@ async function enrollSubscriberIntoTriggeredCampaigns(input) {
         return txt(`Error: ${campaignError.message}`);
     const campaigns = campaign_id
         ? (candidateCampaigns ?? [])
-        : (candidateCampaigns ?? []).filter((campaign) => triggerEvents.some(event => campaignMatchesTrigger(campaign, { event, tags: triggerTags }))
+        : (candidateCampaigns ?? []).filter((campaign) => triggerEvents.some(event => campaignMatchesTrigger(campaign, { event, tags: triggerTags, data: context ?? null }))
             || (!triggerEvents.length && campaignMatchesTrigger(campaign, { tags: triggerTags })));
     if (!campaigns?.length)
         return j({ enrolled: 0, campaigns: [], skipped: 'no_matching_active_automation' });

package/build/tools/campaign-sets.d.ts

@@ -5,6 +5,7 @@ type CampaignSetRow = {
     status: string;
     trigger_event_name: string | null;
     trigger_tag: string | null;
+    trigger_config?: unknown;
     send_class: string | null;
     site_id: string;
 };
@@ -20,5 +21,58 @@ type StepRow = {
 };
 /** Fingerprint of everything an approver saw: triggers and every email's exact content. */
 export declare function campaignSetContentHash(campaigns: CampaignSetRow[], steps: StepRow[]): string;
+export declare function previewOf(campaigns: CampaignSetRow[], steps: StepRow[]): {
+    campaign_id: string;
+    name: string;
+    status: string;
+    trigger: {
+        event: string;
+        only_when?: Record<string, string> | null | undefined;
+        tag?: undefined;
+    } | {
+        tag: string;
+    } | null;
+    send_class: string | null;
+    emails: {
+        step_order: number;
+        wait: string;
+        subject: string;
+        body_text: string;
+    }[];
+}[];
+export declare function loadSet(projectId: string, campaignIds: string[]): Promise<{
+    campaigns: CampaignSetRow[];
+    steps: StepRow[];
+}>;
+export type DraftEmail = {
+    subject: string;
+    body_html: string;
+    body_text: string | null;
+    blocks: unknown[] | null;
+    delay_days: number | null;
+    delay_hours: number | null;
+};
+export type DraftCampaign = {
+    name: string;
+    trigger_event_name?: string | null;
+    trigger_tag?: string | null;
+    /** Event-data filter: the campaign starts only when the event's data has these values. */
+    where?: Record<string, string> | null;
+    send_class?: string | null;
+    description?: string | null;
+    metadata?: Record<string, unknown>;
+    emails: DraftEmail[];
+};
+/**
+ * Writes checked drafts as one campaign set. Shared by create_campaign_set and
+ * convert_imported_campaigns (#3689), so both produce the same rows and activate_campaigns
+ * treats them the same way. Returns the new set, or an error result to hand back as is.
+ */
+export declare function writeCampaignDrafts(projectId: string, siteId: string, drafts: DraftCampaign[], source: string): Promise<{
+    setId: string;
+    createdIds: string[];
+} | {
+    error: Record<string, unknown>;
+}>;
 export declare function registerCampaignSetTools(server: McpServer): void;
 export {};

package/build/tools/campaign-sets.js

@@ -37,12 +37,21 @@ const CampaignInput = z.object({
     description: z.string().max(1000).optional(),
     emails: z.array(EmailInput).min(1).max(10),
 });
+/** The event-data filter a campaign starts on, if any (#3689). */
+function triggerWhere(config) {
+    if (!config || typeof config !== 'object' || Array.isArray(config))
+        return null;
+    const where = config.where;
+    return where && typeof where === 'object' && !Array.isArray(where) && Object.keys(where).length ? where : null;
+}
 /** Fingerprint of everything an approver saw: triggers and every email's exact content. */
 export function campaignSetContentHash(campaigns, steps) {
     const ordered = [...campaigns].sort((a, b) => a.id.localeCompare(b.id)).map((c) => ({
         id: c.id,
         trigger_event_name: c.trigger_event_name,
         trigger_tag: c.trigger_tag,
+        // Only present when set, so fingerprints of campaigns without a filter are unchanged.
+        ...(triggerWhere(c.trigger_config) ? { trigger_where: triggerWhere(c.trigger_config) } : {}),
         send_class: c.send_class,
         site_id: c.site_id,
         steps: steps
@@ -52,12 +61,14 @@ export function campaignSetContentHash(campaigns, steps) {
     }));
     return createHash('sha256').update(JSON.stringify(ordered)).digest('hex');
 }
-function previewOf(campaigns, steps) {
+export function previewOf(campaigns, steps) {
     return campaigns.map((c) => ({
         campaign_id: c.id,
         name: c.name,
         status: c.status,
-        trigger: c.trigger_event_name ? { event: c.trigger_event_name } : c.trigger_tag ? { tag: c.trigger_tag } : null,
+        trigger: c.trigger_event_name
+            ? { event: c.trigger_event_name, ...(triggerWhere(c.trigger_config) ? { only_when: triggerWhere(c.trigger_config) } : {}) }
+            : c.trigger_tag ? { tag: c.trigger_tag } : null,
         send_class: c.send_class,
         emails: steps
             .filter((s) => s.campaign_id === c.id)
@@ -70,10 +81,10 @@ function previewOf(campaigns, steps) {
         })),
     }));
 }
-async function loadSet(projectId, campaignIds) {
+export async function loadSet(projectId, campaignIds) {
     const { data: campaigns, error } = await db()
         .from('campaigns')
-        .select('id, name, status, trigger_event_name, trigger_tag, send_class, site_id')
+        .select('id, name, status, trigger_event_name, trigger_tag, trigger_config, send_class, site_id')
         .eq('project_id', projectId)
         .in('id', campaignIds);
     if (error)
@@ -86,6 +97,54 @@ async function loadSet(projectId, campaignIds) {
         throw stepsError;
     return { campaigns: (campaigns ?? []), steps: (steps ?? []) };
 }
+/**
+ * Writes checked drafts as one campaign set. Shared by create_campaign_set and
+ * convert_imported_campaigns (#3689), so both produce the same rows and activate_campaigns
+ * treats them the same way. Returns the new set, or an error result to hand back as is.
+ */
+export async function writeCampaignDrafts(projectId, siteId, drafts, source) {
+    const setId = randomUUID();
+    const createdIds = [];
+    for (const c of drafts) {
+        const insertPayload = {
+            project_id: projectId,
+            site_id: siteId,
+            name: c.name,
+            type: 'triggered',
+            status: 'draft',
+            description: c.description ?? null,
+            requires_approval: true,
+            ...(c.send_class ? { send_class: c.send_class } : {}),
+            metadata: { ...(c.metadata ?? {}), source, campaign_set_id: setId },
+        };
+        const targetingError = await applyCampaignTargetingFields(insertPayload, {
+            trigger_event_name: c.trigger_event_name ?? null,
+            trigger_tag: c.trigger_tag ?? null,
+            ...(c.where && Object.keys(c.where).length && c.trigger_event_name ? { trigger_config: { events: [c.trigger_event_name], where: c.where } } : {}),
+        }, projectId);
+        if (targetingError)
+            return { error: { error: targetingError, code: 'INVALID_FIELD', campaign: c.name, created_before_failure: createdIds } };
+        const { data: campaign, error } = await db().from('campaigns').insert(insertPayload).select('id').single();
+        if (error || !campaign)
+            return { error: { error: error?.message ?? 'Failed to create campaign', code: 'CAMPAIGN_CREATE_FAILED', campaign: c.name, created_before_failure: createdIds } };
+        createdIds.push(campaign.id);
+        const rows = c.emails.map((e, k) => ({
+            campaign_id: campaign.id,
+            step_order: k,
+            subject: e.subject,
+            body_html: e.body_html,
+            body_text: e.body_text,
+            blocks: e.blocks,
+            delay_days: e.delay_days,
+            delay_hours: e.delay_hours,
+            variant_label: 'A',
+        }));
+        const { error: stepError } = await db().from('campaign_steps').insert(rows);
+        if (stepError)
+            return { error: { error: stepError.message, code: 'STEP_CREATE_FAILED', campaign: c.name, created_before_failure: createdIds } };
+    }
+    return { setId, createdIds };
+}
 export function registerCampaignSetTools(server) {
     server.registerTool('create_campaign_set', {
         title: 'Create Campaign Set',
@@ -164,43 +223,17 @@ export function registerCampaignSetTools(server) {
         if (problems.length)
             return j({ error: 'Nothing was created. Fix these first.', code: 'INVALID_SET', problems });
         // Write the drafts.
-        const setId = randomUUID();
-        const createdIds = [];
-        for (let i = 0; i < campaigns.length; i++) {
-            const c = campaigns[i];
-            const insertPayload = {
-                project_id: projectId,
-                site_id: site.id,
-                name: c.name,
-                type: 'triggered',
-                status: 'draft',
-                description: c.description ?? null,
-                requires_approval: true,
-                ...(c.send_class ? { send_class: c.send_class } : {}),
-                metadata: { source: 'mcp_create_campaign_set', campaign_set_id: setId },
-            };
-            const targetingError = await applyCampaignTargetingFields(insertPayload, { trigger_event_name: c.trigger_event_name ?? null, trigger_tag: c.trigger_tag ?? null }, projectId);
-            if (targetingError)
-                return j({ error: targetingError, code: 'INVALID_FIELD', campaign: c.name, created_before_failure: createdIds });
-            const { data: campaign, error } = await db().from('campaigns').insert(insertPayload).select('id').single();
-            if (error || !campaign)
-                return j({ error: error?.message ?? 'Failed to create campaign', code: 'CAMPAIGN_CREATE_FAILED', campaign: c.name, created_before_failure: createdIds });
-            createdIds.push(campaign.id);
-            const rows = drafted[i].map((e, k) => ({
-                campaign_id: campaign.id,
-                step_order: k,
-                subject: e.subject,
-                body_html: e.body_html,
-                body_text: e.body_text,
-                blocks: e.blocks,
-                delay_days: e.delay_days,
-                delay_hours: e.delay_hours,
-                variant_label: 'A',
-            }));
-            const { error: stepError } = await db().from('campaign_steps').insert(rows);
-            if (stepError)
-                return j({ error: stepError.message, code: 'STEP_CREATE_FAILED', campaign: c.name, created_before_failure: createdIds });
-        }
+        const written = await writeCampaignDrafts(projectId, site.id, campaigns.map((c, i) => ({
+            name: c.name,
+            trigger_event_name: c.trigger_event_name ?? null,
+            trigger_tag: c.trigger_tag ?? null,
+            send_class: c.send_class ?? null,
+            description: c.description ?? null,
+            emails: drafted[i],
+        })), 'mcp_create_campaign_set');
+        if ('error' in written)
+            return j(written.error);
+        const { setId, createdIds } = written;
         await logAudit({ action: 'campaign.set_created', resourceType: 'campaign_set', resourceId: setId, details: { campaign_ids: createdIds, site_id: site.id, source: 'mcp' } }).catch(() => { });
         let preview;
         try {

package/build/tools/campaigns.js

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 import Anthropic from '@anthropic-ai/sdk';
-import { NAME_FALLBACKS, renderTemplateString as renderTemplateVars, resolveBrandTokens, } from '@sendinel/domain';
+import { NAME_FALLBACKS, normalizeTriggerConfig, renderTemplateString as renderTemplateVars, resolveBrandTokens, } from '@sendinel/domain';
 // Subpath import, not the barrel above -- reply-actions.ts uses node:crypto,
 // and MCP-server-side that's fine (this never runs in an Edge Function), but
 // keeping it off the shared barrel avoids re-creating the Edge-Function
@@ -45,14 +45,11 @@ function normalizeTriggerList(value) {
     return Array.from(new Set(raw.map(normalizeTriggerValue).filter((item) => Boolean(item))));
 }
 function buildCampaignTriggerConfig(value) {
-    if (!value || typeof value !== 'object' || Array.isArray(value))
-        return null;
-    const config = value;
-    const events = normalizeTriggerList(config.events ?? config.event_names ?? config.trigger_event_names);
-    const tags = normalizeTriggerList(config.tags ?? config.trigger_tags ?? config.entity_tags ?? config.project_tags);
+    // Keeps an event-data filter (where), so editing a campaign never widens who it starts for (#3689).
+    const { events, tags, where } = normalizeTriggerConfig(value);
     if (!events.length && !tags.length)
         return null;
-    return { events, tags };
+    return { events, tags, ...(Object.keys(where).length ? { where } : {}) };
 }
 function applyCampaignSendAtField(updates, sendAt, campaignType) {
     if (sendAt === undefined)

package/build/tools/convert-imported.d.ts

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

package/build/tools/convert-imported.js

@@ -0,0 +1,259 @@
+import { z } from 'zod';
+import { planCampaignConversion } from '@sendinel/domain';
+import { db } from '../db.js';
+import { getProjectId } from '../project.js';
+import { checkPlanLimit } from '../plan-limits.js';
+import { validateTemplate } from '../lib/voice.js';
+import { logAudit } from '../audit.js';
+import { loadSet, previewOf, writeCampaignDrafts } from './campaign-sets.js';
+/**
+ * convert_imported_campaigns (#3689): turns campaigns imported from another platform (Customer.io
+ * first) into new Sendinel drafts that can send. Call it without create to preview: converted
+ * subject and text per email, the wait before each, the trigger, and every flag (prices, codes,
+ * billing claims, testimonials, blank placeholders). Call it again with create: true to write
+ * the drafts as one campaign set. The imported campaigns are never changed. Drafts send nothing;
+ * activate_campaigns turns them on behind one approval.
+ */
+const txt = (text) => ({ content: [{ type: 'text', text }] });
+const j = (data) => txt(JSON.stringify(data, null, 2));
+const Conversion = z.object({
+    campaign_id: z.string().uuid().describe('An imported campaign (from list_campaigns; imported ones have imported_from set).'),
+    name: z.string().min(1).max(200).optional().describe('Name for the new draft. Defaults to the imported name.'),
+    trigger_event_name: z.string().min(1).max(120).optional().describe('Event (POST /v1/events) that starts the new campaign.'),
+    where: z.record(z.string(), z.string()).optional().describe('Start only when the event data has these values, e.g. {"variant":"free_low"}. Also picks that version of the copy. Use it to make one campaign per version.'),
+    choose: z.record(z.string(), z.string()).optional().describe('Which version to keep where the copy changes with a value, e.g. {"variant":"paid_engaged"}.'),
+    emails: z.array(z.number().int().min(1)).optional().describe('Emails to keep, numbered from 1. Defaults to all.'),
+    waits: z.array(z.object({ email: z.number().int().min(1), days: z.number().int().min(0).max(365).optional(), hours: z.number().int().min(0).max(23).optional() })).optional()
+        .describe('Wait before an email (numbered as in the import). Overrides the import.'),
+    edits: z.array(z.object({ email: z.number().int().min(1).optional(), find: z.string().min(1), replace: z.string() })).optional()
+        .describe('Exact text replacements on the converted copy, e.g. to remove an offer. Without email they apply to every email.'),
+    event_keys: z.array(z.string()).optional().describe('Data keys the trigger event sends. Used to catch placeholders that would come out blank.'),
+    send_class: z.enum(['broadcast', 'product']).optional().describe('product for account, trial and onboarding email; broadcast for marketing.'),
+});
+/** Data keys seen on an event in the project's history, or null when the lookup failed. */
+async function eventKeysFromHistory(projectId, eventName) {
+    const { data, error } = await db()
+        .from('contact_events')
+        .select('metadata')
+        .eq('project_id', projectId)
+        .eq('title', eventName)
+        .order('created_at', { ascending: false })
+        .limit(200);
+    if (error)
+        return null;
+    const keys = new Set();
+    for (const row of (data ?? [])) {
+        if (row.metadata && typeof row.metadata === 'object' && !Array.isArray(row.metadata))
+            for (const key of Object.keys(row.metadata))
+                keys.add(key);
+    }
+    return Array.from(keys);
+}
+const CONTACT_SAMPLE = 1000;
+/**
+ * Contact property keys the project's contacts actually have, from the most recent contacts.
+ * complete is true only when every contact was read. Null when the lookup failed.
+ */
+async function contactPropertyKeys(projectId) {
+    const { data, count, error } = await db()
+        .from('subscribers')
+        .select('custom_properties', { count: 'exact' })
+        .eq('project_id', projectId)
+        .order('created_at', { ascending: false })
+        .limit(CONTACT_SAMPLE);
+    if (error)
+        return null;
+    const keys = new Set();
+    for (const row of (data ?? [])) {
+        const props = row.custom_properties;
+        if (props && typeof props === 'object' && !Array.isArray(props)) {
+            for (const [key, value] of Object.entries(props))
+                if (value !== null && value !== undefined && value !== '')
+                    keys.add(key);
+        }
+    }
+    const checked = (data ?? []).length;
+    return { keys: Array.from(keys), complete: typeof count === 'number' && count <= checked, checked };
+}
+function reviewView(plan) {
+    return {
+        source: { campaign_id: plan.source_campaign_id, name: plan.source_name },
+        name: plan.name,
+        trigger: plan.trigger_event_name ? { event: plan.trigger_event_name, ...(Object.keys(plan.where).length ? { only_when: plan.where } : {}) } : null,
+        version_chosen: Object.keys(plan.choose).length ? plan.choose : undefined,
+        emails: plan.emails.map((email) => ({
+            email: email.email,
+            from_import_email: email.source_step,
+            wait: email.delay_days === null && email.delay_hours === null ? 'not set' : `${email.delay_days ?? 0}d ${email.delay_hours ?? 0}h`,
+            original_subject: email.original_subject,
+            subject: email.subject,
+            text: email.preview_text,
+            check_these: email.flags.map((flag) => ({ kind: flag.kind, message: flag.message, ...(flag.excerpt ? { where: flag.excerpt } : {}) })),
+        })),
+        ...(plan.blocking.length ? { must_fix: plan.blocking } : {}),
+        ...(plan.notes.length ? { notes: plan.notes } : {}),
+    };
+}
+export function registerConvertImportedTools(server) {
+    server.registerTool('convert_imported_campaigns', {
+        title: 'Convert Imported Campaigns',
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
+        description: 'Turn campaigns imported from another email platform (Customer.io, Mailchimp, …) into new Sendinel drafts that can send. Without create it only previews: each email\'s converted subject and text, its wait, the trigger, and plain-words flags for anything to check (prices, discount codes, billing claims, testimonials, numbers, placeholders the event doesn\'t send). Fix what it lists under must_fix with trigger_event_name, choose/where, emails, waits and edits, then call again with create: true to write the drafts as one set. The imported campaigns are not changed. Drafts send nothing; turn them on with activate_campaigns.',
+        inputSchema: {
+            conversions: z.array(Conversion).min(1).max(20).describe('One entry per new campaign. The same imported campaign can appear twice with different where values to make one campaign per version.'),
+            site_id: z.string().uuid().optional().describe('Sender. Optional when the project has exactly one sender.'),
+            known_codes: z.array(z.string()).optional().describe('Discount codes that really exist in your payment platform. Other codes in the copy are then flagged as not found.'),
+            create: z.boolean().optional().describe('false (default): preview only. true: write the drafts.'),
+        },
+    }, async ({ conversions, site_id, known_codes, create }) => {
+        const projectId = getProjectId();
+        const ids = [...new Set(conversions.map((c) => c.campaign_id))];
+        const { data: sources, error: sourceErr } = await db()
+            .from('campaigns')
+            .select('id, name, status, site_id, imported_from, trigger_event_name, metadata')
+            .eq('project_id', projectId)
+            .in('id', ids);
+        if (sourceErr)
+            return j({ error: sourceErr.message, code: 'CAMPAIGN_LOOKUP_FAILED' });
+        const byId = new Map((sources ?? []).map((c) => [c.id, c]));
+        const missing = ids.filter((id) => !byId.has(id));
+        if (missing.length)
+            return j({ error: 'Some campaigns were not found in this project.', code: 'NOT_FOUND', missing });
+        const notImported = ids.filter((id) => !byId.get(id).imported_from);
+        if (notImported.length)
+            return j({ error: 'Only imported campaigns can be converted.', code: 'NOT_IMPORTED', campaigns: notImported.map((id) => ({ id, name: byId.get(id).name })) });
+        const { data: stepRows, error: stepErr } = await db()
+            .from('campaign_steps')
+            .select('campaign_id, step_order, subject, body_html, body_text, delay_days, delay_hours')
+            .in('campaign_id', ids);
+        if (stepErr)
+            return j({ error: stepErr.message, code: 'STEP_LOOKUP_FAILED' });
+        const steps = (stepRows ?? []);
+        // Event data seen in history, per trigger. A failed lookup is reported, never treated as "none".
+        const historyNotes = [];
+        const historyKeys = new Map();
+        for (const eventName of new Set(conversions.map((c) => c.trigger_event_name ?? byId.get(c.campaign_id).trigger_event_name).filter((e) => Boolean(e)))) {
+            const keys = await eventKeysFromHistory(projectId, eventName);
+            if (keys === null)
+                historyNotes.push(`Couldn't read the event history for "${eventName}"; only event_keys were used to check placeholders.`);
+            else
+                historyKeys.set(eventName, keys);
+        }
+        const contactProperties = await contactPropertyKeys(projectId);
+        if (contactProperties === null)
+            historyNotes.push("Couldn't read your contacts, so contact properties in the copy weren't checked.");
+        const plans = conversions.map((c) => {
+            const source = byId.get(c.campaign_id);
+            const eventName = c.trigger_event_name ?? source.trigger_event_name ?? '';
+            return planCampaignConversion({ id: source.id, name: source.name, trigger_event_name: source.trigger_event_name }, steps.filter((s) => s.campaign_id === source.id), c, { knownEventKeys: historyKeys.get(eventName) ?? [], knownCodes: known_codes, ...(contactProperties ? { contactProperties } : {}) });
+        });
+        // Converting the same import into the same name twice is almost always a mistake.
+        const { data: existing, error: existingErr } = await db()
+            .from('campaigns')
+            .select('id, name, status, metadata')
+            .eq('project_id', projectId)
+            .in('metadata->>converted_from', ids);
+        if (existingErr)
+            return j({ error: existingErr.message, code: 'CAMPAIGN_LOOKUP_FAILED' });
+        const earlier = (existing ?? []);
+        plans.forEach((plan) => {
+            const twin = earlier.find((e) => e.metadata?.converted_from === plan.source_campaign_id && e.name === plan.name);
+            if (twin)
+                plan.blocking.push(`"${plan.name}" was already made from this import (campaign ${twin.id}, ${twin.status}). Use a different name or work on that one.`);
+        });
+        const names = plans.map((p) => p.name);
+        names.forEach((name, i) => { if (names.indexOf(name) !== i)
+            plans[i].blocking.push(`Two new campaigns would both be called "${name}". Give each a different name.`); });
+        const review = plans.map(reviewView);
+        const mustFix = plans.flatMap((p) => p.blocking.map((b) => `${p.name}: ${b}`));
+        if (!create) {
+            return j({
+                mode: 'preview',
+                nothing_written: true,
+                campaigns: review,
+                ...(historyNotes.length ? { notes: historyNotes } : {}),
+                next: mustFix.length
+                    ? 'Fix everything under must_fix, then preview again. Show the person every subject, text and check_these item before creating.'
+                    : 'Show the person every subject, text and check_these item. When they are happy, call again with create: true.',
+            });
+        }
+        if (mustFix.length)
+            return j({ error: 'Nothing was created. Fix these first.', code: 'CONVERSION_NOT_READY', must_fix: mustFix, campaigns: review });
+        // Sender: the given one, the imports' own, or the only one. Never guessed between several.
+        const { data: sites, error: sitesErr } = await db().from('sites').select('id, name, from_email, unsub_link_enabled').eq('project_id', projectId);
+        if (sitesErr)
+            return j({ error: sitesErr.message, code: 'SITE_LOOKUP_FAILED' });
+        const importSites = [...new Set(ids.map((id) => byId.get(id).site_id).filter(Boolean))];
+        const pick = site_id ?? (importSites.length === 1 ? importSites[0] : sites?.length === 1 ? sites[0].id : null);
+        const site = (sites ?? []).find((s) => s.id === pick);
+        if (!site) {
+            return j({
+                error: site_id ? 'Site not found in this project.' : 'Pick the sender for the new campaigns. Pass site_id.',
+                code: site_id ? 'SITE_NOT_FOUND' : 'SITE_REQUIRED',
+                sites: (sites ?? []).map((s) => ({ id: s.id, name: s.name, from_email: s.from_email })),
+            });
+        }
+        const limit = await checkPlanLimit('active_campaigns');
+        if (!limit.allowed)
+            return j({ error: `Campaign limit reached (${limit.current}/${limit.limit}). Upgrade your plan for more campaigns.`, code: 'PLAN_LIMIT' });
+        const footerAdded = site.unsub_link_enabled !== false;
+        const problems = [];
+        const drafts = plans.map((plan, i) => {
+            const customVariables = plan.contact_properties.map((key) => `custom.${key}`);
+            for (const email of plan.emails) {
+                const check = validateTemplate(email.body_html, null, { subject: email.subject, bodyText: email.body_text ?? undefined, customVariables });
+                const blocking = check.errors.filter((msg) => !(footerAdded && msg.startsWith('Missing unsubscribe link')));
+                problems.push(...blocking.map((msg) => `${plan.name}, email ${email.email}: ${msg}`));
+            }
+            return {
+                name: plan.name,
+                trigger_event_name: plan.trigger_event_name,
+                where: Object.keys(plan.where).length ? plan.where : null,
+                send_class: conversions[i].send_class ?? null,
+                description: `Converted from the imported campaign "${plan.source_name}".`,
+                metadata: {
+                    converted_from: plan.source_campaign_id,
+                    converted_from_name: plan.source_name,
+                    review_flags: plan.emails.flatMap((email) => email.flags.map((flag) => ({ email: email.email, kind: flag.kind, message: flag.message, ...(flag.excerpt ? { excerpt: flag.excerpt } : {}) }))),
+                },
+                emails: plan.emails.map((email) => ({
+                    subject: email.subject,
+                    body_html: email.body_html,
+                    body_text: email.body_text,
+                    blocks: null,
+                    delay_days: email.delay_days,
+                    delay_hours: email.delay_hours,
+                })),
+            };
+        });
+        if (problems.length)
+            return j({ error: 'Nothing was created. Fix these first.', code: 'INVALID_SET', problems });
+        const written = await writeCampaignDrafts(projectId, site.id, drafts, 'mcp_convert_imported_campaigns');
+        if ('error' in written)
+            return j(written.error);
+        const { setId, createdIds } = written;
+        await logAudit({
+            action: 'campaign.converted_from_import',
+            resourceType: 'campaign_set',
+            resourceId: setId,
+            details: { campaign_ids: createdIds, converted_from: plans.map((p) => p.source_campaign_id), site_id: site.id, source: 'mcp' },
+        }).catch(() => { });
+        let preview;
+        try {
+            const loaded = await loadSet(projectId, createdIds);
+            preview = previewOf(loaded.campaigns, loaded.steps);
+        }
+        catch (error) {
+            return j({ campaign_set_id: setId, campaign_ids: createdIds, status: 'draft', warning: `Created, but the preview could not be read back: ${error instanceof Error ? error.message : String(error)}` });
+        }
+        return j({
+            campaign_set_id: setId,
+            campaign_ids: createdIds,
+            status: 'draft',
+            site: { id: site.id, name: site.name, from_email: site.from_email },
+            campaigns: preview,
+            check_these: review.map((r) => ({ name: r.name, emails: r.emails.map((e) => ({ email: e.email, check_these: e.check_these })) })),
+            next: 'These are drafts and send nothing. Show the person every subject, text and check_these item. To turn them on, call activate_campaigns with campaign_set_id; it asks for one approval for the whole set.',
+        });
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sendinel/mcp-server",
-  "version": "1.0.34",
+  "version": "1.0.36",
   "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",