@sendinel/mcp-server 1.0.103 → 1.0.104

package/build/lib/action-approvals.js

@@ -1,4 +1,4 @@
-import { decodeHtmlEntities, stripHtmlComments } from '@sendinel/domain';
+import { triggerChangeSummary, decodeHtmlEntities, stripHtmlComments } from '@sendinel/domain';
 import { db, requestContext } from '../db.js';
 import { getProjectId } from '../project.js';
 import { fireWebhookEvent } from './webhook-events.js';
@@ -28,6 +28,7 @@ const GATED_ACTIONS = new Set([
     'import_subscribers', // bulk data ingestion
     'subscribe_webhook', // outbound data channel
     'send_transactional', // sends a real email
+    'update_campaign', // live trigger edits only; the domain rule gates callers
     'set_campaign_trigger', // changes who starts an active or paused campaign
     'update_campaign_status', // activation sends real emails (see special case below)
     'add_list_members', // bulk contact-list membership write
@@ -230,6 +231,8 @@ function launchSummary(p, d) {
 }
 /** Build a human-readable summary of the action for the approval screen */
 export function buildApprovalSummary(action, params, display = {}) {
+    if ((action === 'update_campaign' || action === 'set_campaign_trigger') && params.previous_campaign && params.updates)
+        return triggerChangeSummary(String(params.previous_campaign.name ?? params.campaign_id), params.previous_campaign, params.updates);
     const summaries = {
         launch_campaign: (p) => launchSummary(p, display) ?? `Launch campaign "${p.name || p.campaign_name || 'unknown'}" — will send emails to real contacts`,
         install_connector_schema: (p) => `Install connector schema for project ${p.project_id ?? 'current'}`,

package/build/lib/approval-exempt.js

@@ -116,7 +116,6 @@ export const APPROVAL_EXEMPT = {
     trigger_automation: 'generates a draft into the approval queue (or returns it with dry_run); nothing is sent until a person approves the draft',
     unsubscribe_subscriber: "only stops mail to a contact; reduces sending",
     update_brand_voice: "edits brand voice text on the caller own project; internal",
-    update_campaign: "edits campaign settings; status changes go through update_campaign_status (gated). FOLLOW-UP: same live-edit caveat as update_campaign_step",
     update_campaign_step: "edits email copy; sends only through an already-gated activation. FOLLOW-UP: editing a live campaign changes what goes out (#4005 summary)",
     update_custom_field: "renames or edits a field definition; values are untouched",
     update_hygiene_config: "changes hygiene settings; suppression runs are gated (identify_inactive) or only reduce sending",

package/build/lib/campaign-trigger-approval.d.ts

@@ -0,0 +1,10 @@
+type Row = Record<string, any>;
+export declare const TRIGGER_EDIT_SELECT = "id, name, type, status, trigger_type, trigger_event_name, trigger_tag, trigger_config, updated_at";
+export declare const campaignEditError: (error: string, code: string) => {
+    error: string;
+    code: string;
+};
+export declare function finishCampaignEdit(action: string, input: Row, existing: Row, updates: Row, request: (params: Row) => Promise<Row>): Promise<any>;
+/** The second call may carry only approval_id. Never rebuild a frozen edit from fresh arguments. */
+export declare function resumeCampaignEdit(action: string, approvalId: string, input: Row): Promise<any>;
+export {};

package/build/lib/campaign-trigger-approval.js

@@ -0,0 +1,66 @@
+import { isDeepStrictEqual } from 'node:util';
+import { campaignTriggerChanges, campaignTriggerRevision, triggerChangeNeedsApproval } from '@sendinel/domain';
+import { db } from '../db.js';
+import { getProjectId } from '../project.js';
+import { logAudit } from '../audit.js';
+import { assertChannelCanExecute, currentChannelContext, checkApproval } from './action-approvals.js';
+export const TRIGGER_EDIT_SELECT = 'id, name, type, status, trigger_type, trigger_event_name, trigger_tag, trigger_config, updated_at';
+export const campaignEditError = (error, code) => ({ error, code });
+/** All writes include the revision used for the approval decision, including ungated drafts. */
+async function writeEdit(campaignId, previous, updates) {
+    let query = db().from('campaigns').update({ ...updates, updated_at: new Date().toISOString() })
+        .eq('id', campaignId).eq('project_id', getProjectId()).eq('status', previous.status);
+    if (previous.updated_at)
+        query = query.eq('updated_at', previous.updated_at);
+    const { data, error } = await query.select().single();
+    if (error || !data)
+        return campaignEditError(error?.message ?? 'Campaign changed; read it and request a new approval', 'CAMPAIGN_CHANGED');
+    await logAudit({ action: 'campaign.updated', resourceType: 'campaign', resourceId: campaignId, details: { previous, updates } });
+    return data;
+}
+export async function finishCampaignEdit(action, input, existing, updates, request) {
+    if (campaignTriggerChanges(existing, updates) && !['draft', 'active', 'paused'].includes(existing.status)) {
+        return campaignEditError(`Cannot change a ${existing.status} campaign trigger`, 'INVALID_STATUS');
+    }
+    if (!triggerChangeNeedsApproval(existing, updates))
+        return writeEdit(input.campaign_id, existing, updates);
+    const params = { campaign_id: input.campaign_id, input, previous_campaign: existing, updates };
+    const context = currentChannelContext();
+    const decision = assertChannelCanExecute(action, params, context);
+    if (!decision.allowed)
+        return campaignEditError(decision.reason ?? 'Channel cannot request approval', 'FORBIDDEN');
+    // This trigger policy requires a human decision even if the integration uses autonomous mode.
+    return request(params);
+}
+/** The second call may carry only approval_id. Never rebuild a frozen edit from fresh arguments. */
+export async function resumeCampaignEdit(action, approvalId, input) {
+    const { data: approval, error } = await db().from('action_approvals').select('*')
+        .eq('id', approvalId).eq('project_id', getProjectId()).maybeSingle();
+    if (error || !approval || approval.action !== action)
+        return campaignEditError('Approval not found for this action', 'APPROVAL_MISMATCH');
+    if (approval.used_at || approval.status === 'used')
+        return campaignEditError('Approval consumed', 'APPROVAL_CONSUMED');
+    const params = approval.params;
+    if (!params?.previous_campaign || !params.updates || !params.campaign_id)
+        return campaignEditError('Approval has no frozen campaign edit', 'APPROVAL_MISMATCH');
+    for (const [key, value] of Object.entries(input)) {
+        if (value !== undefined && !isDeepStrictEqual(value, params.input?.[key]))
+            return campaignEditError('params_mismatch: request differs from the frozen edit', 'APPROVAL_MISMATCH');
+    }
+    const { data: existing, error: loadError } = await db().from('campaigns').select(TRIGGER_EDIT_SELECT)
+        .eq('id', params.campaign_id).eq('project_id', getProjectId()).maybeSingle();
+    if (loadError || !existing)
+        return campaignEditError('Campaign not found', 'NOT_FOUND');
+    if (campaignTriggerRevision(existing) !== campaignTriggerRevision(params.previous_campaign)) {
+        return campaignEditError('Campaign changed after approval was requested; request a new approval', 'CAMPAIGN_CHANGED');
+    }
+    if (!Number.isFinite(Date.parse(approval.expires_at)) || Date.parse(approval.expires_at) <= Date.now())
+        return campaignEditError('Approval expired', 'APPROVAL_EXPIRED');
+    const decision = assertChannelCanExecute(action, params, currentChannelContext());
+    if (!decision.allowed)
+        return campaignEditError(decision.reason ?? 'Channel cannot use approval', 'FORBIDDEN');
+    const check = await checkApproval(approvalId, { consume: true, action, params });
+    if (!check.approved)
+        return campaignEditError(`Approval ${approvalId} is ${check.status}`, 'APPROVAL_REQUIRED');
+    return writeEdit(params.campaign_id, existing, params.updates);
+}

package/build/tools/campaigns.js

@@ -9,6 +9,7 @@ import { assertSendAccepted, providerSendError, sendError, SendRefusedError, BLO
 // bundling problem this subpath was introduced to fix. See the comment in
 // packages/domain/src/index.ts.
 import { ensureReplyActionSecretConfigured, mintReplyAction, } from '@sendinel/domain/reply-actions';
+import { finishCampaignEdit, resumeCampaignEdit, TRIGGER_EDIT_SELECT } from '../lib/campaign-trigger-approval.js';
 import { adminDb, db, requestContext } from '../db.js';
 import { getProjectId } from '../project.js';
 import { checkPlanLimit } from '../plan-limits.js';
@@ -3345,7 +3346,7 @@ Return ONLY valid JSON with this exact shape:
         annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
         description: 'Set or clear what a campaign fires on: trigger event name, tag, date_field, contact_event, or trigger_config events/tags and where event-data filter. Use for dunning on invoice_payment_failed or trial_ending. Drafts save directly; active/paused campaigns require standard human approval. Archived/completed campaigns cannot change. Returns saved trigger fields, fires_on and trigger_diagnostics.',
         inputSchema: {
-            campaign_id: z.string().uuid(),
+            campaign_id: z.string().uuid().optional(),
             trigger_event_name: z.string().nullable().optional(),
             trigger_tag: z.string().nullable().optional(),
             trigger_type: z.enum(['manual', 'date_field', 'contact_event']).nullable().optional(),
@@ -3354,9 +3355,15 @@ Return ONLY valid JSON with this exact shape:
             approval_id: z.string().uuid().optional(),
         },
     }, async ({ approval_id, ...args }) => {
+        if (approval_id) {
+            const result = await resumeCampaignEdit('set_campaign_trigger', approval_id, args);
+            return j(result.error ? result : { ...result, fires_on: buildCampaignFiresOn(result), trigger_diagnostics: buildCampaignTriggerDiagnostics(result) });
+        }
+        if (!args.campaign_id)
+            return j({ error: 'campaign_id is required', code: 'INVALID_FIELD' });
         const projectId = getProjectId();
         const { data: existing, error: loadError } = await db().from('campaigns')
-            .select('id, name, type, status, trigger_type, trigger_event_name, trigger_tag, trigger_config, updated_at')
+            .select(TRIGGER_EDIT_SELECT)
             .eq('id', args.campaign_id).eq('project_id', projectId).maybeSingle();
         if (loadError)
             return j({ error: loadError.message });
@@ -3381,36 +3388,8 @@ Return ONLY valid JSON with this exact shape:
             && (updates.trigger_event_name || updates.trigger_tag || normalized.events.length || normalized.tags.length)) {
             updates.type = 'triggered';
         }
-        const execute = async () => {
-            // A draft activated during this call must never bypass approval. The timestamp also
-            // guards against overwriting edits made while an approved call is executing.
-            let query = db().from('campaigns').update({ ...updates, updated_at: new Date().toISOString() })
-                .eq('id', args.campaign_id).eq('project_id', projectId).eq('status', existing.status);
-            if (existing.updated_at)
-                query = query.eq('updated_at', existing.updated_at);
-            const { data, error } = await query.select().maybeSingle();
-            if (error)
-                return j({ error: error.message });
-            if (!data)
-                return j({ error: 'Campaign changed; read it and retry', code: 'CAMPAIGN_CHANGED' });
-            await logAudit({ action: 'campaign.trigger_updated', resourceType: 'campaign', resourceId: args.campaign_id, details: { previous: existing, updates } });
-            return j({ ...data, fires_on: buildCampaignFiresOn(data), trigger_diagnostics: buildCampaignTriggerDiagnostics(data) });
-        };
-        if (existing.status === 'draft')
-            return execute();
-        // The saved state is internal, never caller-supplied. Approval is for this exact before/after.
-        return withApproval('set_campaign_trigger', async (_params) => execute(), {
-            display: async () => {
-                const { count, error } = await db().from('subscribers').select('id', { count: 'exact', head: true })
-                    .eq('project_id', projectId).eq('global_unsubscribed', false);
-                return {
-                    campaign_name: existing.name,
-                    from_trigger: `${buildCampaignFiresOn(existing)} Config: ${JSON.stringify(existing.trigger_config)}`,
-                    to_trigger: `${buildCampaignFiresOn({ ...existing, ...updates })} Config: ${JSON.stringify(updates.trigger_config === undefined ? existing.trigger_config : updates.trigger_config)}`,
-                    recipient_count: error ? null : count,
-                };
-            },
-        })({ ...args, previous_trigger: existing, approval_id });
+        const result = await finishCampaignEdit('set_campaign_trigger', args, existing, updates, params => requestApproval('set_campaign_trigger', params));
+        return j(result.error || result.requires_approval ? result : { ...result, fires_on: buildCampaignFiresOn(result), trigger_diagnostics: buildCampaignTriggerDiagnostics(result) });
     });
     server.registerTool('update_campaign', {
         title: 'Update Campaign',
@@ -3420,9 +3399,10 @@ Return ONLY valid JSON with this exact shape:
             idempotentHint: true,
             openWorldHint: false,
         },
-        description: 'Update a campaign name, site, segment, send time, topic, trigger event name/tag/config (including where filters for dunning), or send class (broadcast vs product). trigger_type null (or manual) clears a date_field or contact_event trigger; type switches a draft between sequence and triggered. The response includes fires_on, a plain summary of what the saved campaign fires on, and trigger_diagnostics naming any trigger problems. send_at schedules a broadcast send (type=broadcast only) and must be a future ISO 8601 instant; set null to clear a pending schedule. Only provided fields are updated.',
+        description: 'Update a campaign name, site, segment, send time, topic, trigger event name/tag/config (including where filters for dunning), or send class (broadcast vs product). trigger_type null (or manual) clears a date_field or contact_event trigger; type switches a draft between sequence and triggered. The response includes fires_on, a plain summary of what the saved campaign fires on, and trigger_diagnostics naming any trigger problems. send_at schedules a broadcast send (type=broadcast only) and must be a future ISO 8601 instant; set null to clear a pending schedule. Only provided fields are updated. Changed triggers on active/paused campaigns return an approval request; retry with only approval_id to apply the frozen edit.',
         inputSchema: {
-            campaign_id: z.string().uuid(),
+            campaign_id: z.string().uuid().optional(),
+            approval_id: z.string().uuid().optional(),
             name: z.string().min(1).max(200).optional(),
             site_id: z.string().uuid().optional(),
             segment_id: z.string().uuid().nullable().optional(),
@@ -3437,12 +3417,19 @@ Return ONLY valid JSON with this exact shape:
             send_in_contact_timezone: z.boolean().optional(),
             send_class: z.enum(['broadcast', 'product']).optional().describe("Who may receive it when the project's consent gate is on: 'broadcast' (default) = only contacts who opted in to marketing; 'product' = also the customer's signed-up users (onboarding, trial, account mail)."),
         },
-    }, async ({ campaign_id, name, site_id, segment_id, send_at, topic, trigger_event_name, trigger_tag, trigger_type, trigger_config, type, sends_per_hour, send_in_contact_timezone, send_class }) => {
+    }, async ({ approval_id, ...input }) => {
+        if (approval_id) {
+            const result = await resumeCampaignEdit('update_campaign', approval_id, input);
+            return j(result.error ? result : { ...result, fires_on: buildCampaignFiresOn(result), trigger_diagnostics: buildCampaignTriggerDiagnostics(result) });
+        }
+        const { campaign_id, name, site_id, segment_id, send_at, topic, trigger_event_name, trigger_tag, trigger_type, trigger_config, type, sends_per_hour, send_in_contact_timezone, send_class } = input;
+        if (!campaign_id)
+            return j({ error: 'campaign_id is required', code: 'INVALID_FIELD' });
         const projectId = getProjectId();
         let campaignType;
         const loadExisting = () => db()
             .from('campaigns')
-            .select('id, type, status, trigger_type, trigger_config, trigger_event_name, trigger_tag')
+            .select(TRIGGER_EDIT_SELECT)
             .eq('id', campaign_id)
             .eq('project_id', projectId)
             .maybeSingle();
@@ -3486,7 +3473,7 @@ Return ONLY valid JSON with this exact shape:
                 return j({ error: 'Campaign not found', code: 'NOT_FOUND' });
             existingCampaignForTargeting = existing;
         }
-        const updates = { updated_at: new Date().toISOString() };
+        const updates = {};
         if (name !== undefined)
             updates.name = name;
         if (site_id !== undefined)
@@ -3517,15 +3504,20 @@ Return ONLY valid JSON with this exact shape:
                 updates.type = 'triggered';
             }
         }
-        const { data, error } = await db()
-            .from('campaigns')
-            .update(updates)
-            .eq('id', campaign_id)
-            .eq('project_id', projectId)
-            .select()
-            .single();
-        if (error)
-            return j({ error: error.message });
+        let data;
+        if (existingCampaignForTargeting) {
+            data = await finishCampaignEdit('update_campaign', input, existingCampaignForTargeting, updates, params => requestApproval('update_campaign', params));
+            if (data.error || data.requires_approval)
+                return j(data);
+        }
+        else {
+            const result = await db().from('campaigns').update({ ...updates, updated_at: new Date().toISOString() })
+                .eq('id', campaign_id).eq('project_id', projectId).select().single();
+            if (result.error)
+                return j({ error: result.error.message });
+            data = result.data;
+            await logAudit({ action: 'campaign.updated', resourceType: 'campaign', resourceId: campaign_id, details: { updates } });
+        }
         const diagnostics = buildCampaignTriggerDiagnostics(data);
         const warning = diagnostics.find((d) => d.includes('never fire')) || (diagnostics.length ? diagnostics[0] : null);
         return j({

package/package.json

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