@sendinel/mcp-server 1.0.9 → 1.0.11

package/build/tools/lists.js

@@ -0,0 +1,428 @@
+import { z } from 'zod';
+import { applySegmentRules, buildSegmentBaseQuery, evaluateSegmentRules, normalizeSegmentRulesToTree, } from '@sendinel/domain';
+import { db } from '../db.js';
+import { getProjectId } from '../project.js';
+import { logAudit } from '../audit.js';
+import { assertChannelCanExecute, checkApproval, currentChannelContext, requestApproval, } from '../lib/action-approvals.js';
+const LIST_MEMBER_BATCH_SIZE = 500;
+const txt = (text) => ({ content: [{ type: 'text', text }] });
+const j = (data) => txt(JSON.stringify(data, null, 2));
+async function loadFieldTypes(projectId) {
+    const client = db();
+    const scoped = typeof client.schema === 'function' ? client.schema('email') : client;
+    const { data, error } = await scoped
+        .from('custom_field_definitions')
+        .select('key, type, options')
+        .eq('project_id', projectId);
+    if (error) {
+        console.warn('[lists] custom field definition load failed:', error.message ?? error);
+        return {};
+    }
+    const fields = {};
+    for (const row of data ?? []) {
+        if (typeof row.key !== 'string' || typeof row.type !== 'string')
+            continue;
+        fields[row.key] = { type: row.type, options: Array.isArray(row.options) ? row.options : null };
+    }
+    return fields;
+}
+async function getSegmentContactIds(rules) {
+    const projectId = getProjectId();
+    const tree = normalizeSegmentRulesToTree(rules);
+    const fieldTypes = rules.custom_property ? await loadFieldTypes(projectId) : {};
+    const q = buildSegmentBaseQuery(db(), projectId);
+    const { query: filtered, siteContactIds } = await applySegmentRules(q, rules, db(), projectId, fieldTypes);
+    if (siteContactIds && siteContactIds.length === 0)
+        return [];
+    const { data, error } = await filtered;
+    if (error || !data)
+        return [];
+    const contacts = data.filter((contact) => evaluateSegmentRules(contact, tree, fieldTypes));
+    let ids = contacts.map((contact) => String(contact.id));
+    if (tree.exclude_suppressed !== false && ids.length > 0) {
+        const { data: suppressed } = await db()
+            .from('suppressions')
+            .select('email')
+            .eq('project_id', projectId);
+        if (suppressed?.length) {
+            const suppressedEmails = new Set(suppressed.map((row) => row.email));
+            ids = contacts
+                .filter((contact) => !suppressedEmails.has(String(contact.email)))
+                .map((contact) => String(contact.id));
+        }
+    }
+    return ids;
+}
+async function readValidContactIds(projectId, contactIds) {
+    const { data, error } = await db()
+        .from('subscribers')
+        .select('id')
+        .eq('project_id', projectId)
+        .in('id', contactIds);
+    return { ids: (data ?? []).map((row) => row.id), error };
+}
+async function readMemberIds(listId, contactIds) {
+    if (contactIds.length === 0)
+        return { ids: [], error: null };
+    const { data, error } = await db()
+        .from('contact_list_members')
+        .select('contact_id')
+        .eq('list_id', listId)
+        .in('contact_id', contactIds);
+    return { ids: (data ?? []).map((row) => row.contact_id), error };
+}
+function difference(ids, excludedIds) {
+    const excluded = new Set(excludedIds);
+    return ids.filter((id) => !excluded.has(id));
+}
+export function registerListTools(server) {
+    server.registerTool('list_lists', {
+        title: 'List Contact Lists',
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+        description: 'List static contact lists for the current project, including grouped member counts.',
+        inputSchema: {
+            search: z.string().optional(),
+            limit: z.number().int().min(1).max(200).optional().default(50),
+        },
+    }, async ({ search, limit }) => {
+        const projectId = getProjectId();
+        let query = db()
+            .from('contact_lists')
+            .select('id, name, description, created_at, updated_at')
+            .eq('project_id', projectId);
+        const trimmedSearch = search?.trim();
+        if (trimmedSearch)
+            query = query.ilike('name', `%${trimmedSearch}%`);
+        const { data, error } = await query
+            .order('created_at', { ascending: false })
+            .limit(limit);
+        if (error)
+            return txt(`Error: ${error.message}`);
+        const lists = data ?? [];
+        const listIds = lists.map((list) => list.id);
+        const countMap = new Map();
+        if (listIds.length > 0) {
+            const { data: counts, error: countError } = await db().rpc('get_list_member_counts', { p_list_ids: listIds });
+            if (countError)
+                return txt(`Error: ${countError.message}`);
+            for (const row of counts ?? []) {
+                countMap.set(row.list_id, Number(row.member_count));
+            }
+        }
+        return j(lists.map((list) => ({
+            ...list,
+            member_count: countMap.get(list.id) ?? 0,
+        })));
+    });
+    server.registerTool('create_list', {
+        title: 'Create Contact List',
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
+        description: 'Create a static contact list for the current project.',
+        inputSchema: {
+            name: z.string().min(1).max(200),
+            description: z.string().optional(),
+        },
+    }, async ({ name, description }) => {
+        const projectId = getProjectId();
+        const normalizedName = name.trim();
+        const { data, error } = await db()
+            .from('contact_lists')
+            .insert({
+            project_id: projectId,
+            name: normalizedName,
+            description: description?.trim() ?? null,
+        })
+            .select('id, name, description, created_at')
+            .single();
+        if (error)
+            return txt(`Error: ${error.message}`);
+        await logAudit({
+            action: 'list.created',
+            resourceType: 'list',
+            resourceId: data.id,
+            details: { name: normalizedName },
+        });
+        return j(data);
+    });
+    server.registerTool('update_list', {
+        title: 'Update Contact List',
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+        description: 'Update the name or description of a static contact list.',
+        inputSchema: {
+            list_id: z.string().uuid(),
+            name: z.string().min(1).max(200).optional(),
+            description: z.string().optional(),
+        },
+    }, async ({ list_id, name, description }) => {
+        if (name === undefined && description === undefined)
+            return txt('Nothing to update');
+        const projectId = getProjectId();
+        const updates = { updated_at: new Date().toISOString() };
+        if (name !== undefined)
+            updates.name = name.trim();
+        if (description !== undefined)
+            updates.description = description.trim();
+        const { data, error } = await db()
+            .from('contact_lists')
+            .update(updates)
+            .eq('id', list_id)
+            .eq('project_id', projectId)
+            .select('id, name, description, updated_at')
+            .maybeSingle();
+        if (error)
+            return txt(`Error: ${error.message}`);
+        if (!data)
+            return txt('List not found');
+        await logAudit({
+            action: 'list.updated',
+            resourceType: 'list',
+            resourceId: list_id,
+            details: { name: name?.trim(), description: description?.trim() ?? null },
+        });
+        return j(data);
+    });
+    server.registerTool('delete_list', {
+        title: 'Delete Contact List',
+        annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false },
+        description: 'Permanently delete a static contact list and its memberships.',
+        inputSchema: { list_id: z.string().uuid() },
+    }, async ({ list_id }) => {
+        const projectId = getProjectId();
+        const { error } = await db()
+            .from('contact_lists')
+            .delete()
+            .eq('id', list_id)
+            .eq('project_id', projectId);
+        if (error)
+            return txt(`Error: ${error.message}`);
+        await logAudit({ action: 'list.deleted', resourceType: 'list', resourceId: list_id });
+        return j({ deleted: true, list_id });
+    });
+    server.registerTool('add_list_members', {
+        title: 'Add List Members',
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+        description: 'Add contacts to a static list after previewing the affected count and completing the standard bulk-action approval flow.',
+        inputSchema: {
+            list_id: z.string().uuid(),
+            contact_ids: z.array(z.string().uuid()).min(1),
+            confirmed: z.boolean().optional().default(false),
+            approval_id: z.string().uuid().optional(),
+        },
+    }, async ({ list_id, contact_ids, confirmed, approval_id }) => {
+        const projectId = getProjectId();
+        const approvalParams = { list_id, contact_ids };
+        const { data: list, error: listError } = await db()
+            .from('contact_lists')
+            .select('id, name')
+            .eq('id', list_id)
+            .eq('project_id', projectId)
+            .maybeSingle();
+        if (listError)
+            return j({ error: listError.message });
+        if (!list)
+            return j({ error: 'List not found', code: 'LIST_NOT_FOUND' });
+        const validResult = await readValidContactIds(projectId, contact_ids);
+        if (validResult.error)
+            return j({ error: validResult.error.message });
+        const memberResult = await readMemberIds(list_id, validResult.ids);
+        if (memberResult.error)
+            return j({ error: memberResult.error.message });
+        const wouldAdd = difference(validResult.ids, memberResult.ids);
+        if (!confirmed) {
+            return j({
+                confirmation_required: true,
+                tool: 'add_list_members',
+                list: { id: list.id, name: list.name },
+                requested: contact_ids.length,
+                valid_contacts: validResult.ids.length,
+                already_members: memberResult.ids.length,
+                would_add: wouldAdd.length,
+                message: `Adding ${contact_ids.length} contact(s) to list "${list.name}" will add ${wouldAdd.length} new member(s) (${memberResult.ids.length} already members). Call again with confirmed=true to proceed.`,
+            });
+        }
+        const channelContext = currentChannelContext();
+        const decision = assertChannelCanExecute('add_list_members', approvalParams, channelContext);
+        if (!decision.allowed)
+            return txt(decision.reason ?? 'This channel cannot request this action.');
+        if (decision.tier !== 'autonomous') {
+            if (!approval_id)
+                return j(await requestApproval('add_list_members', approvalParams, undefined, channelContext));
+            const check = await checkApproval(approval_id, { consume: true, action: 'add_list_members', params: approvalParams });
+            if (!check.approved) {
+                return txt(`Approval ${approval_id} is ${check.status}. ${check.status === 'pending' ? 'Waiting for human approval via dashboard.' : 'Request a new approval.'}`);
+            }
+        }
+        const freshValidResult = await readValidContactIds(projectId, contact_ids);
+        if (freshValidResult.error)
+            return j({ error: freshValidResult.error.message });
+        const freshMemberResult = await readMemberIds(list_id, freshValidResult.ids);
+        if (freshMemberResult.error)
+            return j({ error: freshMemberResult.error.message });
+        const freshWouldAdd = difference(freshValidResult.ids, freshMemberResult.ids);
+        let added = 0;
+        if (freshWouldAdd.length > 0) {
+            const { data: inserted, error } = await db()
+                .from('contact_list_members')
+                .upsert(freshWouldAdd.map((contact_id) => ({ list_id, contact_id })), {
+                onConflict: 'list_id,contact_id',
+                ignoreDuplicates: true,
+            })
+                .select('id');
+            if (error)
+                return j({ error: error.message });
+            added = inserted?.length ?? 0;
+        }
+        await logAudit({
+            action: 'list.member_added',
+            resourceType: 'list',
+            resourceId: list_id,
+            details: { contact_ids: added },
+        });
+        return j({ ok: true, added, list_id });
+    });
+    server.registerTool('remove_list_members', {
+        title: 'Remove List Members',
+        annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: false },
+        description: 'Remove contacts from a static list after previewing the affected count and completing the standard bulk-action approval flow.',
+        inputSchema: {
+            list_id: z.string().uuid(),
+            contact_ids: z.array(z.string().uuid()).min(1),
+            confirmed: z.boolean().optional().default(false),
+            approval_id: z.string().uuid().optional(),
+        },
+    }, async ({ list_id, contact_ids, confirmed, approval_id }) => {
+        const projectId = getProjectId();
+        const approvalParams = { list_id, contact_ids };
+        const { data: list, error: listError } = await db()
+            .from('contact_lists')
+            .select('id, name')
+            .eq('id', list_id)
+            .eq('project_id', projectId)
+            .maybeSingle();
+        if (listError)
+            return j({ error: listError.message });
+        if (!list)
+            return j({ error: 'List not found', code: 'LIST_NOT_FOUND' });
+        const memberResult = await readMemberIds(list_id, contact_ids);
+        if (memberResult.error)
+            return j({ error: memberResult.error.message });
+        if (!confirmed) {
+            return j({
+                confirmation_required: true,
+                tool: 'remove_list_members',
+                list: { id: list.id, name: list.name },
+                requested: contact_ids.length,
+                would_remove: memberResult.ids.length,
+                message: `Removing ${contact_ids.length} contact(s) from list "${list.name}" will remove ${memberResult.ids.length} current member(s). Call again with confirmed=true to proceed.`,
+            });
+        }
+        const channelContext = currentChannelContext();
+        const decision = assertChannelCanExecute('remove_list_members', approvalParams, channelContext);
+        if (!decision.allowed)
+            return txt(decision.reason ?? 'This channel cannot request this action.');
+        if (decision.tier !== 'autonomous') {
+            if (!approval_id)
+                return j(await requestApproval('remove_list_members', approvalParams, undefined, channelContext));
+            const check = await checkApproval(approval_id, { consume: true, action: 'remove_list_members', params: approvalParams });
+            if (!check.approved) {
+                return txt(`Approval ${approval_id} is ${check.status}. ${check.status === 'pending' ? 'Waiting for human approval via dashboard.' : 'Request a new approval.'}`);
+            }
+        }
+        const freshMemberResult = await readMemberIds(list_id, contact_ids);
+        if (freshMemberResult.error)
+            return j({ error: freshMemberResult.error.message });
+        const removed = freshMemberResult.ids.length;
+        if (removed > 0) {
+            const { error } = await db()
+                .from('contact_list_members')
+                .delete()
+                .eq('list_id', list_id)
+                .in('contact_id', freshMemberResult.ids);
+            if (error)
+                return j({ error: error.message });
+        }
+        await logAudit({
+            action: 'list.member_removed',
+            resourceType: 'list',
+            resourceId: list_id,
+            details: { contact_ids: removed },
+        });
+        return j({ ok: true, removed, list_id });
+    });
+    server.registerTool('add_list_members_by_filter', {
+        title: 'Add List Members By Filter',
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+        description: 'Add every eligible contact matching segment rules after previewing the affected count and completing the standard bulk-action approval flow.',
+        inputSchema: {
+            list_id: z.string().uuid(),
+            rules: z.record(z.string(), z.unknown()),
+            confirmed: z.boolean().optional().default(false),
+            approval_id: z.string().uuid().optional(),
+        },
+    }, async ({ list_id, rules, confirmed, approval_id }) => {
+        const projectId = getProjectId();
+        const normalizedRules = normalizeSegmentRulesToTree(rules);
+        const approvalParams = { list_id, rules: normalizedRules };
+        const { data: list, error: listError } = await db()
+            .from('contact_lists')
+            .select('id, name')
+            .eq('id', list_id)
+            .eq('project_id', projectId)
+            .maybeSingle();
+        if (listError)
+            return j({ error: listError.message });
+        if (!list)
+            return j({ error: 'List not found', code: 'LIST_NOT_FOUND' });
+        const matchedIds = await getSegmentContactIds(normalizedRules);
+        const memberResult = await readMemberIds(list_id, matchedIds);
+        if (memberResult.error)
+            return j({ error: memberResult.error.message });
+        const wouldAdd = difference(matchedIds, memberResult.ids);
+        if (!confirmed) {
+            return j({
+                confirmation_required: true,
+                tool: 'add_list_members_by_filter',
+                list: { id: list.id, name: list.name },
+                matched: matchedIds.length,
+                already_members: memberResult.ids.length,
+                would_add: wouldAdd.length,
+                message: `Filter matches ${matchedIds.length} contact(s); ${wouldAdd.length} would be newly added to list "${list.name}". Call again with confirmed=true to proceed.`,
+            });
+        }
+        const channelContext = currentChannelContext();
+        const decision = assertChannelCanExecute('add_list_members_by_filter', approvalParams, channelContext);
+        if (!decision.allowed)
+            return txt(decision.reason ?? 'This channel cannot request this action.');
+        if (decision.tier !== 'autonomous') {
+            if (!approval_id)
+                return j(await requestApproval('add_list_members_by_filter', approvalParams, undefined, channelContext));
+            const check = await checkApproval(approval_id, { consume: true, action: 'add_list_members_by_filter', params: approvalParams });
+            if (!check.approved) {
+                return txt(`Approval ${approval_id} is ${check.status}. ${check.status === 'pending' ? 'Waiting for human approval via dashboard.' : 'Request a new approval.'}`);
+            }
+        }
+        const freshMatchedIds = await getSegmentContactIds(normalizedRules);
+        const freshMemberResult = await readMemberIds(list_id, freshMatchedIds);
+        if (freshMemberResult.error)
+            return j({ error: freshMemberResult.error.message });
+        const freshWouldAdd = difference(freshMatchedIds, freshMemberResult.ids);
+        let added = 0;
+        for (let index = 0; index < freshWouldAdd.length; index += LIST_MEMBER_BATCH_SIZE) {
+            const rows = freshWouldAdd.slice(index, index + LIST_MEMBER_BATCH_SIZE).map((contact_id) => ({ list_id, contact_id }));
+            const { data: inserted, error } = await db()
+                .from('contact_list_members')
+                .upsert(rows, { onConflict: 'list_id,contact_id', ignoreDuplicates: true })
+                .select('id');
+            if (error)
+                return j({ error: error.message });
+            added += inserted?.length ?? 0;
+        }
+        await logAudit({
+            action: 'list.members_added_by_filter',
+            resourceType: 'list',
+            resourceId: list_id,
+            details: { added, matched: freshMatchedIds.length, source: 'filter' },
+        });
+        return j({ ok: true, added, matched: freshMatchedIds.length, list_id });
+    });
+}

package/build/tools/newsletters.js

@@ -1,6 +1,7 @@
 import { z } from 'zod';
 import { db } from '../db.js';
 import { getProjectId } from '../project.js';
+import { parseFutureDate } from '../lib/schedule.js';
 const txt = (text) => ({ content: [{ type: 'text', text }] });
 const j = (data) => txt(JSON.stringify(data, null, 2));
 const NEWSLETTER_COLUMNS = 'id, org_id, project_id, site_id, name, slug, description, sender_name, sender_email, reply_to, cadence, branding, public_signup_enabled, double_opt_in, status, subscriber_count, source, source_payload, created_at, updated_at';
@@ -144,14 +145,6 @@ async function ensureNewsletterCampaign(newsletter, issue, projectId, scheduledA
         return { error: statusError.message };
     return { campaignId, enrolled: rows.length };
 }
-function parseFutureDate(value) {
-    const date = new Date(value);
-    if (Number.isNaN(date.getTime()))
-        return { error: 'scheduled_at must be a valid ISO timestamp' };
-    if (date.getTime() <= Date.now())
-        return { error: 'scheduled_at must be in the future' };
-    return { scheduledAt: date.toISOString() };
-}
 export function registerNewsletterTools(server) {
     server.registerTool('list_newsletters', {
         title: 'List Newsletters',