@sendinel/mcp-server 1.0.0

package/build/tools/sites.js

@@ -0,0 +1,182 @@
+import { z } from 'zod';
+import { db } from '../db.js';
+import { getProjectId } from '../project.js';
+import { checkPlanLimit } from '../plan-limits.js';
+const txt = (text) => ({ content: [{ type: 'text', text }] });
+const j = (data) => txt(JSON.stringify(data, null, 2));
+const LOCAL_PART_RE = /^[a-z0-9._-]+$/;
+async function resolveSenderDomain(input) {
+    const projectId = getProjectId();
+    if (input.domain_id) {
+        const { data: domain, error } = await db()
+            .from('domains')
+            .select('id, name')
+            .eq('project_id', projectId)
+            .eq('id', input.domain_id)
+            .maybeSingle();
+        if (error)
+            return { error: error.message };
+        if (!domain?.id || !domain.name)
+            return { error: 'Domain not found.' };
+        const localPart = input.local_part?.trim().toLowerCase();
+        if (!localPart || !LOCAL_PART_RE.test(localPart)) {
+            return { error: 'local_part must contain only letters, numbers, dots, underscores, or hyphens.' };
+        }
+        const domainName = String(domain.name).toLowerCase();
+        return {
+            domain_id: String(domain.id),
+            sending_domain: domainName,
+            from_email: `${localPart}@${domainName}`,
+            is_shared_domain: false,
+        };
+    }
+    const sendingDomain = input.sending_domain?.trim().toLowerCase();
+    if (!sendingDomain)
+        return { error: 'domain_id or sending_domain is required.' };
+    if (!input.from_email?.trim())
+        return { error: 'from_email is required when using sending_domain.' };
+    const { data: existing, error: existingError } = await db()
+        .from('domains')
+        .select('id, name')
+        .eq('project_id', projectId)
+        .eq('name', sendingDomain)
+        .maybeSingle();
+    if (existingError)
+        return { error: existingError.message };
+    if (existing?.id) {
+        return {
+            domain_id: String(existing.id),
+            sending_domain: sendingDomain,
+            from_email: input.from_email.trim(),
+            is_shared_domain: false,
+        };
+    }
+    const { data: created, error: createError } = await db()
+        .from('domains')
+        .insert({ project_id: projectId, name: sendingDomain, provider: 'unknown', status: 'legacy_imported' })
+        .select('id, name')
+        .single();
+    if (createError)
+        return { error: createError.message };
+    return {
+        domain_id: String(created.id),
+        sending_domain: sendingDomain,
+        from_email: input.from_email.trim(),
+        is_shared_domain: false,
+    };
+}
+const createSenderSchema = {
+    name: z.string().min(1),
+    slug: z.string().min(1).describe('URL-safe identifier'),
+    domain_id: z.string().uuid().optional().describe('Preferred verified domain UUID'),
+    local_part: z.string().optional().describe('Local part before @ when using domain_id'),
+    sending_domain: z.string().min(1).optional().describe('Legacy domain text'),
+    from_email: z.string().email().optional().describe('Legacy full from address'),
+    from_name: z.string().min(1),
+    reply_to: z.string().email().optional(),
+};
+async function createSender({ name, slug, domain_id, local_part, sending_domain, from_email, from_name, reply_to, }) {
+    const limit = await checkPlanLimit('sites');
+    if (!limit.allowed)
+        return txt(`Site limit reached (${limit.current}/${limit.limit}).`);
+    const domain = await resolveSenderDomain({ domain_id, local_part, sending_domain, from_email });
+    if ('error' in domain)
+        return txt(`Error: ${domain.error}`);
+    const { data, error } = await db()
+        .from('sites')
+        .insert({
+        project_id: getProjectId(),
+        name,
+        slug,
+        sending_domain: domain.sending_domain,
+        domain_id: domain.domain_id,
+        is_shared_domain: domain.is_shared_domain,
+        from_email: domain.from_email,
+        from_name,
+        reply_to: reply_to ?? null,
+    })
+        .select()
+        .single();
+    if (error)
+        return txt(`Error: ${error.message}`);
+    return j(data);
+}
+export function registerSiteTools(server) {
+    server.registerTool('get_brand_voice', {
+        description: 'Read the brand voice configuration for a sender/site.',
+        inputSchema: {
+            site_id: z.string().uuid(),
+        },
+    }, async ({ site_id }) => {
+        const { data, error } = await db()
+            .from('sites')
+            .select('id, name, brand_voice')
+            .eq('project_id', getProjectId())
+            .eq('id', site_id)
+            .maybeSingle();
+        if (error)
+            return txt(`Error: ${error.message}`);
+        if (!data)
+            return j({ error: 'Site not found', code: 'NOT_FOUND' });
+        return j(data);
+    });
+    server.registerTool('update_brand_voice', {
+        description: 'Replace the brand voice configuration for a sender/site. Stores JSON in sites.brand_voice. Use the canonical Brand Brain keys so the dashboard and email generation can read the values: mission (string), audience (string), differentiators (string), tone_words (string[], max 8), forbidden_phrases (string[], max 20), default_signoff_name (string), ps_line (string). This REPLACES the whole object and overrides the org default — read the current value first if you only mean to change one field.',
+        inputSchema: {
+            site_id: z.string().uuid(),
+            brand_voice: z.record(z.string(), z.unknown()).describe('Brand voice JSON using the canonical keys: mission, audience, differentiators, tone_words, forbidden_phrases, default_signoff_name, ps_line.'),
+        },
+    }, async ({ site_id, brand_voice }) => {
+        const { data, error } = await db()
+            .from('sites')
+            .update({ brand_voice, updated_at: new Date().toISOString() })
+            .eq('project_id', getProjectId())
+            .eq('id', site_id)
+            .select('id, name, brand_voice, updated_at')
+            .single();
+        if (error)
+            return txt(`Error: ${error.message}`);
+        return j(data);
+    });
+    server.registerTool('create_site', {
+        description: 'Create a new sender. Accepts preferred domain_id + local_part or legacy sending_domain + from_email.',
+        inputSchema: createSenderSchema,
+    }, createSender);
+    server.registerTool('create_sender', {
+        description: 'Create a new sender under an existing verified domain.',
+        inputSchema: createSenderSchema,
+    }, createSender);
+    server.registerTool('update_site', {
+        description: 'Update a site name, from address, or other settings',
+        inputSchema: {
+            site_id: z.string().uuid(),
+            name: z.string().optional(),
+            from_email: z.string().email().optional(),
+            from_name: z.string().optional(),
+            active: z.boolean().optional(),
+        },
+    }, async ({ site_id, name, from_email, from_name, active }) => {
+        const updates = {};
+        if (name)
+            updates.name = name;
+        if (from_email)
+            updates.from_email = from_email;
+        if (from_name)
+            updates.from_name = from_name;
+        if (active !== undefined)
+            updates.active = active;
+        if (!Object.keys(updates).length)
+            return txt('No fields to update.');
+        updates.updated_at = new Date().toISOString();
+        const { data, error } = await db()
+            .from('sites')
+            .update(updates)
+            .eq('id', site_id)
+            .eq('project_id', getProjectId())
+            .select()
+            .single();
+        if (error)
+            return txt(`Error: ${error.message}`);
+        return j(data);
+    });
+}

package/build/tools/sms.d.ts

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

package/build/tools/sms.js

@@ -0,0 +1,489 @@
+import { randomUUID } from 'crypto';
+import { z } from 'zod';
+import { decrypt } from '../crypto.js';
+import { db } from '../db.js';
+import { getProjectId } from '../project.js';
+const txt = (text) => ({ content: [{ type: 'text', text }] });
+const j = (data) => txt(JSON.stringify(data, null, 2));
+const GSM_BASIC = "@£$¥èéùìòÇ\nØø\rÅåΔ_ΦΓΛΩΠΨΣΘΞ !\"#¤%&'()*+,-./0123456789:;<=>?¡ABCDEFGHIJKLMNOPQRSTUVWXYZÄÖÑܧ¿abcdefghijklmnopqrstuvwxyzäöñüà";
+const GSM_EXTENDED = new Set(['^', '{', '}', '\\', '[', '~', ']', '|', '€']);
+const QUIET_HOURS = {
+    default: { start: 8, end: 20 },
+    FL: { start: 8, end: 20 },
+    CT: { start: 8, end: 20 },
+    OK: { start: 8, end: 20 },
+    WA: { start: 8, end: 20 },
+    TX: { start: 9, end: 21, sundayStart: 12 },
+};
+const AREA_CODES = {
+    '201': { timeZone: 'America/New_York', state: 'NJ' },
+    '202': { timeZone: 'America/New_York', state: 'DC' },
+    '203': { timeZone: 'America/New_York', state: 'CT' },
+    '205': { timeZone: 'America/Chicago', state: 'AL' },
+    '206': { timeZone: 'America/Los_Angeles', state: 'WA' },
+    '212': { timeZone: 'America/New_York', state: 'NY' },
+    '213': { timeZone: 'America/Los_Angeles', state: 'CA' },
+    '214': { timeZone: 'America/Chicago', state: 'TX' },
+    '305': { timeZone: 'America/New_York', state: 'FL' },
+    '310': { timeZone: 'America/Los_Angeles', state: 'CA' },
+    '312': { timeZone: 'America/Chicago', state: 'IL' },
+    '404': { timeZone: 'America/New_York', state: 'GA' },
+    '405': { timeZone: 'America/Chicago', state: 'OK' },
+    '415': { timeZone: 'America/Los_Angeles', state: 'CA' },
+    '469': { timeZone: 'America/Chicago', state: 'TX' },
+    '512': { timeZone: 'America/Chicago', state: 'TX' },
+    '602': { timeZone: 'America/Phoenix', state: 'AZ' },
+    '617': { timeZone: 'America/New_York', state: 'MA' },
+    '702': { timeZone: 'America/Los_Angeles', state: 'NV' },
+    '713': { timeZone: 'America/Chicago', state: 'TX' },
+    '714': { timeZone: 'America/Los_Angeles', state: 'CA' },
+    '808': { timeZone: 'Pacific/Honolulu', state: 'HI' },
+    '817': { timeZone: 'America/Chicago', state: 'TX' },
+    '832': { timeZone: 'America/Chicago', state: 'TX' },
+    '917': { timeZone: 'America/New_York', state: 'NY' },
+    '972': { timeZone: 'America/Chicago', state: 'TX' },
+};
+function normalizePhoneE164(value) {
+    const digits = String(value ?? '').replace(/[^\d+]/g, '');
+    if (!digits)
+        return null;
+    if (digits.startsWith('+1') && digits.length === 12)
+        return digits;
+    const numeric = digits.replace(/\D/g, '');
+    if (numeric.length === 10)
+        return `+1${numeric}`;
+    if (numeric.length === 11 && numeric.startsWith('1'))
+        return `+${numeric}`;
+    return null;
+}
+function inferTimezoneFromPhone(phone) {
+    const normalized = normalizePhoneE164(phone);
+    const area = normalized?.slice(2, 5) ?? '';
+    return AREA_CODES[area] ?? { timeZone: 'America/New_York', state: 'default' };
+}
+function detectSmsEncoding(body) {
+    for (const char of body) {
+        if (GSM_BASIC.includes(char) || GSM_EXTENDED.has(char))
+            continue;
+        return 'UCS-2';
+    }
+    return 'GSM-7';
+}
+function countSmsSegments(body) {
+    const text = String(body ?? '');
+    const encoding = detectSmsEncoding(text);
+    if (!text.length)
+        return { encoding, segments: 1, length: 0 };
+    if (encoding === 'UCS-2') {
+        const chars = Array.from(text).length;
+        return { encoding, segments: chars <= 70 ? 1 : Math.ceil(chars / 67), length: chars };
+    }
+    let units = 0;
+    for (const char of text)
+        units += GSM_EXTENDED.has(char) ? 2 : 1;
+    return { encoding, segments: units <= 160 ? 1 : Math.ceil(units / 153), length: units };
+}
+function parseCredentials(value) {
+    return JSON.parse(decrypt(value));
+}
+async function readJsonSafe(res) {
+    return res.json().catch(() => ({}));
+}
+async function sendViaProvider(provider, credentialsEnc, fromNumber, toNumber, body, webhookUrl, trackingToken) {
+    const credentials = parseCredentials(credentialsEnc);
+    const meta = countSmsSegments(body);
+    if (provider === 'twilio') {
+        if (!credentials.account_sid || !credentials.auth_token)
+            throw new Error('Twilio credentials missing');
+        const auth = `Basic ${Buffer.from(`${credentials.account_sid}:${credentials.auth_token}`).toString('base64')}`;
+        const url = `https://api.twilio.com/2010-04-01/Accounts/${credentials.account_sid}/Messages.json`;
+        const payload = new URLSearchParams({
+            From: fromNumber,
+            To: toNumber,
+            Body: body,
+            StatusCallback: webhookUrl,
+            ProvideFeedback: 'true',
+            SmartEncoded: 'true',
+        });
+        const res = await fetch(url, {
+            method: 'POST',
+            headers: { Authorization: auth, 'Content-Type': 'application/x-www-form-urlencoded' },
+            body: payload.toString(),
+        });
+        const json = await readJsonSafe(res);
+        if (!res.ok)
+            throw new Error(json?.message ?? `Twilio send failed (${res.status})`);
+        return {
+            provider_message_id: String(json?.sid ?? trackingToken),
+            estimated_cost_cents: Number((0.83 * meta.segments).toFixed(4)),
+            segments: meta.segments,
+            encoding: meta.encoding,
+        };
+    }
+    if (!credentials.api_key)
+        throw new Error('Telnyx API key missing');
+    const res = await fetch('https://api.telnyx.com/v2/messages', {
+        method: 'POST',
+        headers: {
+            Authorization: `Bearer ${credentials.api_key}`,
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+            from: fromNumber,
+            to: toNumber,
+            text: body,
+            webhook_url: webhookUrl,
+            client_state: trackingToken,
+        }),
+    });
+    const json = await readJsonSafe(res);
+    if (!res.ok)
+        throw new Error(json?.errors?.[0]?.detail ?? `Telnyx send failed (${res.status})`);
+    return {
+        provider_message_id: String(json?.data?.id ?? trackingToken),
+        estimated_cost_cents: Number((0.4 * meta.segments).toFixed(4)),
+        segments: meta.segments,
+        encoding: meta.encoding,
+    };
+}
+async function getDefaultProvider(projectId) {
+    const { data, error } = await db()
+        .from('sms_providers')
+        .select('id, provider, status, credentials_enc, default_from_number, brand_name')
+        .eq('project_id', projectId)
+        .eq('is_default', true)
+        .maybeSingle();
+    if (error)
+        throw new Error(error.message);
+    return data ?? null;
+}
+async function getProjectOrgId(projectId) {
+    const { data, error } = await db().from('projects').select('org_id').eq('id', projectId).maybeSingle();
+    if (error)
+        throw new Error(error.message);
+    return data?.org_id ?? null;
+}
+async function checkConsentGate(projectId, contactId, phone) {
+    const normalizedPhone = normalizePhoneE164(phone);
+    if (!normalizedPhone) {
+        return { ok: false, normalizedPhone: null, reasonCode: 'invalid_phone', reasonDetail: 'SMS requires a valid US E.164 number.' };
+    }
+    if (contactId) {
+        const { data: contact } = await db()
+            .from('subscribers')
+            .select('sms_opt_in_status')
+            .eq('project_id', projectId)
+            .eq('id', contactId)
+            .maybeSingle();
+        if (!contact || contact.sms_opt_in_status !== 'opted_in') {
+            return { ok: false, normalizedPhone, reasonCode: 'missing_sms_consent', reasonDetail: 'Contact does not have SMS opt-in on record.' };
+        }
+    }
+    const { data: suppression } = await db()
+        .from('suppressions')
+        .select('id')
+        .eq('project_id', projectId)
+        .eq('phone_e164', normalizedPhone)
+        .in('channel', ['sms', 'all'])
+        .maybeSingle();
+    if (suppression) {
+        return { ok: false, normalizedPhone, reasonCode: 'suppressed', reasonDetail: 'This number is suppressed for SMS.' };
+    }
+    const provider = await getDefaultProvider(projectId);
+    if (!provider || provider.status !== 'active') {
+        return { ok: false, normalizedPhone, reasonCode: 'provider_inactive', reasonDetail: 'No active default SMS provider is configured.' };
+    }
+    const { timeZone, state } = inferTimezoneFromPhone(normalizedPhone);
+    const quiet = QUIET_HOURS[state] ?? QUIET_HOURS.default;
+    const parts = new Intl.DateTimeFormat('en-US', { timeZone, hour: 'numeric', weekday: 'short', hour12: false }).formatToParts(new Date());
+    const hour = Number(parts.find((part) => part.type === 'hour')?.value ?? '12');
+    const weekday = parts.find((part) => part.type === 'weekday')?.value ?? 'Mon';
+    const start = weekday === 'Sun' && quiet.sundayStart != null ? quiet.sundayStart : quiet.start;
+    if (hour < start || hour >= quiet.end) {
+        return { ok: false, normalizedPhone, reasonCode: 'quiet_hours', reasonDetail: `Recipient local quiet hours block sending until ${start}:00 in ${timeZone}.` };
+    }
+    return { ok: true, normalizedPhone, provider };
+}
+async function logBlocked(projectId, orgId, siteId, contactId, phone, reasonCode, reasonDetail) {
+    await db().from('sms_send_blocked').insert({
+        org_id: orgId,
+        project_id: projectId,
+        site_id: siteId,
+        contact_id: contactId,
+        phone_e164: phone,
+        reason_code: reasonCode,
+        reason_detail: reasonDetail,
+        payload: {},
+    });
+}
+export function registerSmsTools(server) {
+    server.registerTool('list_sms_log', {
+        description: 'List recent SMS sends with delivery status and cost.',
+        inputSchema: {
+            status: z.enum(['queued', 'sending', 'sent', 'delivered', 'failed', 'undelivered']).optional(),
+            limit: z.number().int().min(1).max(100).optional().default(25),
+        },
+    }, async ({ status, limit }) => {
+        let query = db()
+            .from('sms_log')
+            .select('id, campaign_id, contact_id, provider, from_number, to_number, body, segments_count, encoding, status, cost_cents, classification, created_at, sent_at, delivered_at, failed_at')
+            .eq('project_id', getProjectId())
+            .order('created_at', { ascending: false })
+            .limit(limit ?? 25);
+        if (status)
+            query = query.eq('status', status);
+        const { data, error } = await query;
+        if (error)
+            return j({ error: error.message });
+        return j({ rows: data ?? [] });
+    });
+    server.registerTool('list_sms_inbound', {
+        description: 'List recent inbound SMS replies and their interpreted intent (stop/help/reply).',
+        inputSchema: {
+            interpreted_as: z.enum(['stop', 'help', 'start', 'reply', 'unknown']).optional(),
+            limit: z.number().int().min(1).max(100).optional().default(25),
+        },
+    }, async ({ interpreted_as, limit }) => {
+        let query = db()
+            .from('sms_inbound')
+            .select('id, provider, from_number, to_number, body, interpreted_as, contact_id, processed_at, created_at')
+            .eq('project_id', getProjectId())
+            .order('created_at', { ascending: false })
+            .limit(limit ?? 25);
+        if (interpreted_as)
+            query = query.eq('interpreted_as', interpreted_as);
+        const { data, error } = await query;
+        if (error)
+            return j({ error: error.message });
+        return j({ rows: data ?? [] });
+    });
+    server.registerTool('get_sms_provider_status', {
+        description: "Return the connection status, brand info, and recent error rate for the tenant's SMS provider.",
+        inputSchema: {},
+    }, async () => {
+        const projectId = getProjectId();
+        const [provider, recent] = await Promise.all([
+            getDefaultProvider(projectId),
+            db().from('sms_log').select('status, created_at').eq('project_id', projectId).order('created_at', { ascending: false }).limit(50),
+        ]);
+        if (recent.error)
+            return j({ error: recent.error.message });
+        const rows = recent.data ?? [];
+        const failures = rows.filter((row) => row.status === 'failed' || row.status === 'undelivered').length;
+        return j({
+            provider,
+            recent_message_count: rows.length,
+            recent_failure_count: failures,
+            recent_error_rate: rows.length ? Number((failures / rows.length).toFixed(3)) : 0,
+        });
+    });
+    server.registerTool('set_contact_sms_consent', {
+        description: 'Manually record an opt-in or opt-out for a contact (e.g., from a paper form or phone conversation).',
+        inputSchema: {
+            contact_id: z.string().uuid(),
+            status: z.enum(['opt_in', 'opt_out']),
+            source: z.string().optional(),
+            consent_text: z.string().optional(),
+            reason: z.string().optional(),
+        },
+    }, async ({ contact_id, status, source, consent_text, reason }) => {
+        const projectId = getProjectId();
+        const orgId = await getProjectOrgId(projectId);
+        if (!orgId)
+            return j({ error: 'Project org not found' });
+        const { data: contact, error: contactError } = await db()
+            .from('subscribers')
+            .select('id, phone_e164')
+            .eq('project_id', projectId)
+            .eq('id', contact_id)
+            .maybeSingle();
+        if (contactError)
+            return j({ error: contactError.message });
+        if (!contact?.phone_e164)
+            return j({ error: 'Contact not found or missing phone number', code: 'NOT_FOUND' });
+        const now = new Date().toISOString();
+        const patch = status === 'opt_out'
+            ? { sms_opt_in_status: 'opted_out', sms_opt_out_at: now }
+            : { sms_opt_in_status: 'opted_in', sms_opt_in_at: now, sms_opt_out_at: null };
+        const { error: updateError } = await db().from('subscribers').update(patch).eq('project_id', projectId).eq('id', contact_id);
+        if (updateError)
+            return j({ error: updateError.message });
+        const { error: consentError } = await db().from('consent_events').insert({
+            org_id: orgId,
+            project_id: projectId,
+            contact_id,
+            address: contact.phone_e164,
+            channel: 'sms',
+            event_type: status,
+            source: source ?? 'manual',
+            consent_text: consent_text ?? null,
+            metadata: {},
+        });
+        if (consentError)
+            return j({ error: consentError.message });
+        if (status === 'opt_out') {
+            const { error: suppressionError } = await db().from('suppressions').upsert({
+                org_id: orgId,
+                project_id: projectId,
+                channel: 'sms',
+                phone_e164: contact.phone_e164,
+                reason: reason ?? 'manual_opt_out',
+            }, { onConflict: 'project_id,channel,phone_e164' });
+            if (suppressionError)
+                return j({ error: suppressionError.message });
+        }
+        else {
+            const { error: suppressionError } = await db().from('suppressions').delete().eq('project_id', projectId).eq('channel', 'sms').eq('phone_e164', contact.phone_e164);
+            if (suppressionError)
+                return j({ error: suppressionError.message });
+        }
+        return j({ ok: true, contact_id, phone_e164: contact.phone_e164, status });
+    });
+    server.registerTool('preview_sms_cost', {
+        description: 'Given a draft SMS body and a segment, return the segment count, encoding, and estimated total cost.',
+        inputSchema: {
+            body: z.string().min(1),
+            recipient_count: z.number().int().min(0).optional().default(0),
+        },
+    }, async ({ body, recipient_count }) => {
+        const provider = await getDefaultProvider(getProjectId());
+        const meta = countSmsSegments(body);
+        const rate = provider?.provider === 'twilio' ? 0.83 : 0.4;
+        return j({
+            provider: provider?.provider ?? null,
+            body_length: meta.length,
+            encoding: meta.encoding,
+            segments_per_message: meta.segments,
+            recipient_count: recipient_count ?? 0,
+            estimated_total_cost_cents: Number((meta.segments * (recipient_count ?? 0) * rate).toFixed(4)),
+        });
+    });
+    server.registerTool('send_sms_campaign', {
+        description: "Launch an SMS campaign or broadcast to a segment. Same shape as email campaigns but with channel='sms'.",
+        inputSchema: {
+            site_id: z.string().uuid(),
+            name: z.string().min(1).max(200),
+            body: z.string().min(1),
+            type: z.enum(['broadcast', 'sequence', 'triggered']).optional().default('broadcast'),
+            segment_id: z.string().uuid().optional(),
+            scheduled_at: z.string().optional(),
+            activate: z.boolean().optional().default(false),
+        },
+    }, async ({ site_id, name, body, type, segment_id, scheduled_at, activate }) => {
+        const projectId = getProjectId();
+        const { data: campaign, error: campaignError } = await db()
+            .from('campaigns')
+            .insert({
+            project_id: projectId,
+            site_id,
+            name,
+            type,
+            status: activate ? 'active' : 'draft',
+            channel: 'sms',
+            send_at: scheduled_at ?? null,
+        })
+            .select('id, name, type, status, channel, site_id, send_at')
+            .single();
+        if (campaignError || !campaign)
+            return j({ error: campaignError?.message ?? 'Failed to create campaign' });
+        const { data: step, error: stepError } = await db()
+            .from('campaign_steps')
+            .insert({
+            project_id: projectId,
+            campaign_id: campaign.id,
+            site_id,
+            step_order: 0,
+            channel: 'sms',
+            subject: '',
+            body_sms: body,
+            body_text: body,
+            status: 'active',
+        })
+            .select('id, step_order, channel')
+            .single();
+        if (stepError)
+            return j({ error: stepError.message, campaign });
+        return j({
+            ok: true,
+            campaign,
+            first_step: step,
+            segment_id: segment_id ?? null,
+            note: segment_id ? 'Campaign created. Enroll the target segment through the campaign workflow to start delivery.' : 'Campaign created as SMS-ready.',
+        });
+    });
+    server.registerTool('send_sms', {
+        description: 'Send a single SMS through the active SMS provider to a contact or raw phone number. Validates consent and quiet hours before sending.',
+        inputSchema: {
+            body: z.string().min(1),
+            to_number: z.string().optional(),
+            contact_id: z.string().uuid().optional(),
+            site_id: z.string().uuid().optional(),
+            classification: z.enum(['marketing', 'transactional', 'conversational']).optional().default('marketing'),
+        },
+    }, async ({ body, to_number, contact_id, site_id, classification }) => {
+        const projectId = getProjectId();
+        const orgId = await getProjectOrgId(projectId);
+        if (!orgId)
+            return j({ error: 'Project org not found' });
+        let targetNumber = to_number ?? null;
+        if (contact_id && !targetNumber) {
+            const { data: contact, error: contactError } = await db().from('subscribers').select('phone_e164').eq('project_id', projectId).eq('id', contact_id).maybeSingle();
+            if (contactError)
+                return j({ error: contactError.message });
+            targetNumber = contact?.phone_e164 ?? null;
+        }
+        if (!targetNumber)
+            return j({ error: 'to_number or contact_id is required' });
+        const gate = await checkConsentGate(projectId, contact_id ?? null, targetNumber);
+        if (!gate.ok) {
+            await logBlocked(projectId, orgId, site_id ?? null, contact_id ?? null, gate.normalizedPhone ?? targetNumber, gate.reasonCode ?? 'blocked', gate.reasonDetail ?? 'SMS send blocked');
+            return j(gate);
+        }
+        const meta = countSmsSegments(body);
+        const trackingToken = randomUUID();
+        const { data: logRow, error: logError } = await db()
+            .from('sms_log')
+            .insert({
+            org_id: orgId,
+            project_id: projectId,
+            site_id: site_id ?? null,
+            contact_id: contact_id ?? null,
+            provider: gate.provider.provider,
+            from_number: gate.provider.default_from_number,
+            to_number: gate.normalizedPhone,
+            body,
+            segments_count: meta.segments,
+            encoding: meta.encoding,
+            tracking_token: trackingToken,
+            classification: classification ?? 'marketing',
+            status: 'sending',
+        })
+            .select('id')
+            .single();
+        if (logError || !logRow)
+            return j({ error: logError?.message ?? 'Failed to create sms_log row' });
+        const sendResult = await sendViaProvider(gate.provider.provider, gate.provider.credentials_enc, gate.provider.default_from_number, gate.normalizedPhone, body, `${process.env.NEXT_PUBLIC_APP_URL ?? 'http://localhost:3000'}/api/sms/inbound/${gate.provider.provider}`, trackingToken);
+        const { error: updateError } = await db()
+            .from('sms_log')
+            .update({
+            provider_message_id: sendResult.provider_message_id,
+            cost_cents: sendResult.estimated_cost_cents,
+            segments_count: sendResult.segments,
+            encoding: sendResult.encoding,
+            status: 'sent',
+            sent_at: new Date().toISOString(),
+        })
+            .eq('id', logRow.id);
+        if (updateError)
+            return j({ error: updateError.message });
+        return j({
+            ok: true,
+            sms_log_id: logRow.id,
+            provider: gate.provider.provider,
+            provider_message_id: sendResult.provider_message_id,
+            segments: sendResult.segments,
+            encoding: sendResult.encoding,
+            estimated_cost_cents: sendResult.estimated_cost_cents,
+        });
+    });
+}

package/build/tools/social-posts.d.ts

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