@sendinel/mcp-server 1.0.0

package/build/tools/gdpr.js

@@ -0,0 +1,61 @@
+import { z } from 'zod';
+import { db } from '../db.js';
+import { getProjectId } from '../project.js';
+import { logAudit } from '../audit.js';
+import { requestApproval, checkApproval } from '../lib/action-approvals.js';
+const txt = (text) => ({ content: [{ type: 'text', text }] });
+const j = (data) => txt(JSON.stringify(data, null, 2));
+export function registerGdprTools(server) {
+    server.registerTool('delete_subscriber_data', {
+        description: 'GDPR Article 17: Permanently delete a subscriber and all their data. Anonymizes email_log, hashes suppressions, cascades to subscriptions/enrollments/tokens. This action is IRREVERSIBLE. Requires human approval via dashboard.',
+        inputSchema: {
+            contact_id: z.string().uuid().describe('UUID of the subscriber to delete'),
+            reason: z.enum(['gdpr_request', 'user_request', 'admin']).optional().default('gdpr_request'),
+            approval_id: z.string().uuid().optional().describe('Required — get this by calling once without it, then have a human approve via dashboard.'),
+        },
+    }, async ({ contact_id, reason, approval_id }) => {
+        // Verify contact belongs to this project (defense in depth)
+        const { data: contact } = await db()
+            .from('subscribers')
+            .select('id, email')
+            .eq('id', contact_id)
+            .eq('project_id', getProjectId())
+            .maybeSingle();
+        if (!contact)
+            return txt('Contact not found or does not belong to this project.');
+        // Human approval required (always, even in autonomous mode — protected tier)
+        if (!approval_id) {
+            const approval = await requestApproval('delete_subscriber_data', { contact_id, email: contact.email, reason });
+            return j(approval);
+        }
+        const check = await checkApproval(approval_id, { consume: true });
+        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 { data, error } = await db()
+            .rpc('delete_contact_gdpr', {
+            p_contact_id: contact_id,
+            p_reason: reason ?? 'gdpr_request',
+            p_deleted_by: 'mcp',
+        });
+        if (error)
+            return txt(`Error: ${error.message}`);
+        logAudit({ action: 'contact.gdpr_deleted', resourceType: 'contact', resourceId: contact_id, details: { reason, result: data } });
+        return j(data);
+    });
+    server.registerTool('list_deletion_log', {
+        description: 'List GDPR deletion audit log entries',
+        inputSchema: {
+            limit: z.number().int().min(1).max(200).optional().default(50),
+        },
+    }, async ({ limit }) => {
+        const { data, error } = await db()
+            .from('deletion_log')
+            .select('id, contact_email_hash, reason, deleted_by, tables_affected, created_at')
+            .order('created_at', { ascending: false })
+            .limit(limit ?? 50);
+        if (error)
+            return { content: [{ type: 'text', text: `Error: ${error.message}` }] };
+        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+    });
+}

package/build/tools/org.d.ts

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

package/build/tools/org.js

@@ -0,0 +1,71 @@
+import { randomBytes } from 'crypto';
+import { z } from 'zod';
+import { db } from '../db.js';
+import { getProjectId } from '../project.js';
+const j = (data) => ({ content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] });
+const PLAN_LIMITS = {
+    free: { contacts: 500, monthly_sends: 1000, sites: 1, ai_drafts: 10, log_retention_days: 30 },
+    byod: { contacts: 50000, monthly_sends: 250000, sites: 10, ai_drafts: 500, log_retention_days: 180 },
+    managed: { contacts: 250000, monthly_sends: 1000000, sites: 50, ai_drafts: 2000, log_retention_days: 365 },
+};
+export function registerOrgTools(server) {
+    server.registerTool('list_team_members', {
+        description: 'List team members for the project organization.',
+        inputSchema: { org_id: z.string().uuid().optional() },
+    }, async ({ org_id }) => {
+        let orgId = org_id;
+        if (!orgId) {
+            const { data: project } = await db().from('projects').select('org_id').eq('id', getProjectId()).maybeSingle();
+            orgId = project?.org_id;
+        }
+        if (!orgId)
+            return j({ members: [] });
+        const { data, error } = await db().from('org_members').select('user_id, email, role, created_at').eq('org_id', orgId);
+        if (error)
+            return j({ error: error.message });
+        return j({ members: (data ?? []).map((member) => ({ user_id: member.user_id, email: member.email ?? null, role: member.role, joined_at: member.created_at })) });
+    });
+    server.registerTool('invite_team_member', {
+        description: 'Create a team invitation for the current project organization.',
+        inputSchema: { email: z.string().email(), role: z.enum(['owner', 'admin', 'member']).default('member') },
+    }, async ({ email, role }) => {
+        const { data: project } = await db().from('projects').select('org_id').eq('id', getProjectId()).maybeSingle();
+        if (!project?.org_id)
+            return j({ error: 'Project has no organization', code: 'NO_ORG' });
+        const token = randomBytes(16).toString('hex');
+        const expiresAt = new Date(Date.now() + 7 * 86400000).toISOString();
+        const { data, error } = await db().from('org_invitations')
+            .insert({ org_id: project.org_id, email, role, token, expires_at: expiresAt })
+            .select('id, expires_at')
+            .single();
+        if (error)
+            return j({ error: error.message });
+        return j({ invitation_id: data.id, expires_at: data.expires_at });
+    });
+    server.registerTool('get_plan_usage', {
+        description: 'Get current plan usage for the project.',
+        inputSchema: {},
+    }, async () => {
+        const projectId = getProjectId();
+        const { data: project } = await db().from('projects').select('plan').eq('id', projectId).maybeSingle();
+        const plan = project?.plan ?? 'free';
+        const limits = PLAN_LIMITS[plan] ?? PLAN_LIMITS.free ?? {};
+        const [{ count: contacts }, { count: sends }, { count: sites }] = await Promise.all([
+            db().from('subscribers').select('id', { count: 'exact', head: true }).eq('project_id', projectId),
+            db().from('email_log').select('id', { count: 'exact', head: true }).eq('project_id', projectId).gte('created_at', new Date(new Date().getUTCFullYear(), new Date().getUTCMonth(), 1).toISOString()),
+            db().from('sites').select('id', { count: 'exact', head: true }).eq('project_id', projectId),
+        ]);
+        return j({
+            plan,
+            contacts: { used: contacts ?? 0, limit: limits.contacts ?? null },
+            monthly_sends: { used: sends ?? 0, limit: limits.monthly_sends ?? limits.emails_per_month ?? null },
+            sites: { used: sites ?? 0, limit: limits.sites ?? null },
+            ai_drafts: { used: 0, limit: limits.ai_drafts ?? null },
+            log_retention_days: limits.log_retention_days ?? null,
+        });
+    });
+    server.registerTool('get_plan_limits', {
+        description: 'Return plan limits for all plan tiers.',
+        inputSchema: {},
+    }, async () => j(PLAN_LIMITS));
+}

package/build/tools/segments.d.ts

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

package/build/tools/segments.js

@@ -0,0 +1,384 @@
+import { z } from 'zod';
+import Anthropic from '@anthropic-ai/sdk';
+import { db } from '../db.js';
+import { getProjectId } from '../project.js';
+import { getAnthropicModelId } from '../anthropic-model.js';
+function isSegmentRuleGroup(value) {
+    const node = value;
+    return !!node && (node.op === 'AND' || node.op === 'OR') && Array.isArray(node.conditions);
+}
+function normalizeSegmentRulesToTree(rules) {
+    const source = (rules ?? {});
+    if (isSegmentRuleGroup(source))
+        return source;
+    const conditions = [];
+    if (source.lifecycle_stage)
+        conditions.push({ field: 'lifecycle_stage', operator: 'eq', value: source.lifecycle_stage });
+    if (source.min_score !== undefined)
+        conditions.push({ field: 'engagement_score', operator: 'gte', value: source.min_score });
+    if (source.max_score !== undefined)
+        conditions.push({ field: 'engagement_score', operator: 'lte', value: source.max_score });
+    if (source.source)
+        conditions.push({ field: 'source', operator: 'eq', value: source.source });
+    if (source.subscribed_after)
+        conditions.push({ field: 'created_at', operator: 'on_or_after', value: source.subscribed_after });
+    if (source.subscribed_before)
+        conditions.push({ field: 'created_at', operator: 'on_or_before', value: source.subscribed_before });
+    if (source.has_opened === true)
+        conditions.push({ field: 'last_opened_at', operator: 'exists' });
+    if (source.has_opened === false)
+        conditions.push({ field: 'last_opened_at', operator: 'not_exists' });
+    if (source.has_clicked === true)
+        conditions.push({ field: 'last_clicked_at', operator: 'exists' });
+    if (source.has_clicked === false)
+        conditions.push({ field: 'last_clicked_at', operator: 'not_exists' });
+    if (source.tag)
+        conditions.push({ field: 'tags', operator: 'contains', value: source.tag });
+    if (source.custom_property) {
+        const idx = source.custom_property.indexOf('=');
+        if (idx > 0)
+            conditions.push({ field: `custom_properties.${source.custom_property.slice(0, idx)}`, operator: 'eq', value: source.custom_property.slice(idx + 1) });
+    }
+    if (source.payment) {
+        for (const [field, value] of Object.entries(source.payment)) {
+            if (value == null || value === '')
+                continue;
+            if (typeof value === 'object' && !Array.isArray(value)) {
+                const rule = value;
+                if (typeof rule.within_days === 'number') {
+                    conditions.push({ field: `payment.${field}`, operator: 'on_or_after', value: new Date().toISOString() });
+                    conditions.push({ field: `payment.${field}`, operator: 'on_or_before', value: addDaysIso(rule.within_days) });
+                }
+                if (rule.after)
+                    conditions.push({ field: `payment.${field}`, operator: 'on_or_after', value: rule.after });
+                if (rule.before)
+                    conditions.push({ field: `payment.${field}`, operator: 'on_or_before', value: rule.before });
+            }
+            else {
+                conditions.push({ field: `payment.${field}`, operator: 'eq', value });
+            }
+        }
+    }
+    return { op: 'AND', conditions, exclude_suppressed: source.exclude_suppressed, site_id: source.site_id };
+}
+function addDaysIso(days) {
+    return new Date(Date.now() + days * 24 * 60 * 60 * 1000).toISOString();
+}
+function getComparableValue(contact, field) {
+    if (field.startsWith('custom_properties.')) {
+        return field.slice('custom_properties.'.length).split('.').reduce((acc, part) => acc == null ? undefined : acc[part], contact.custom_properties);
+    }
+    if (field.startsWith('payment.')) {
+        return field.slice('payment.'.length).split('.').reduce((acc, part) => acc == null ? undefined : acc[part], contact.custom_properties?.payment);
+    }
+    return contact[field];
+}
+function compareValues(actual, operator, expected) {
+    if (operator === 'exists')
+        return actual !== null && actual !== undefined && actual !== '';
+    if (operator === 'not_exists')
+        return actual === null || actual === undefined || actual === '';
+    if (operator === 'contains')
+        return Array.isArray(actual) ? actual.map(String).includes(String(expected)) : typeof actual === 'string' && actual.includes(String(expected));
+    if (operator === 'eq')
+        return String(actual ?? '') === String(expected ?? '');
+    if (operator === 'neq')
+        return String(actual ?? '') !== String(expected ?? '');
+    const actualNumber = Number(actual);
+    const expectedNumber = Number(expected);
+    const numeric = Number.isFinite(actualNumber) && Number.isFinite(expectedNumber);
+    const left = numeric ? actualNumber : Date.parse(String(actual ?? ''));
+    const right = numeric ? expectedNumber : Date.parse(String(expected ?? ''));
+    if (!Number.isFinite(left) || !Number.isFinite(right))
+        return false;
+    if (operator === 'gt' || operator === 'after')
+        return left > right;
+    if (operator === 'gte' || operator === 'on_or_after')
+        return left >= right;
+    if (operator === 'lt' || operator === 'before')
+        return left < right;
+    if (operator === 'lte' || operator === 'on_or_before')
+        return left <= right;
+    return false;
+}
+function evaluateNode(contact, node) {
+    if (isSegmentRuleGroup(node)) {
+        if (!node.conditions.length)
+            return true;
+        return node.op === 'OR' ? node.conditions.some((child) => evaluateNode(contact, child)) : node.conditions.every((child) => evaluateNode(contact, child));
+    }
+    return compareValues(getComparableValue(contact, node.field), node.operator ?? 'eq', node.value);
+}
+async function getSegmentContactIds(rules) {
+    const projectId = getProjectId();
+    const tree = normalizeSegmentRulesToTree(rules);
+    let q = db()
+        .from('subscribers')
+        .select('id, email, lifecycle_stage, engagement_score, source, created_at, last_opened_at, last_clicked_at, tags, custom_properties')
+        .eq('project_id', projectId)
+        .eq('global_unsubscribed', false);
+    if (!isSegmentRuleGroup(rules)) {
+        if (rules.lifecycle_stage)
+            q = q.eq('lifecycle_stage', rules.lifecycle_stage);
+        q = applyPaymentRules(q, rules.payment);
+        if (rules.min_score !== undefined)
+            q = q.gte('engagement_score', rules.min_score);
+        if (rules.max_score !== undefined)
+            q = q.lte('engagement_score', rules.max_score);
+        if (rules.source)
+            q = q.eq('source', rules.source);
+        if (rules.subscribed_after)
+            q = q.gte('created_at', `${rules.subscribed_after}T00:00:00Z`);
+        if (rules.subscribed_before)
+            q = q.lte('created_at', `${rules.subscribed_before}T23:59:59Z`);
+        if (rules.has_opened === true)
+            q = q.not('last_opened_at', 'is', null);
+        if (rules.has_opened === false)
+            q = q.is('last_opened_at', null);
+        if (rules.has_clicked === true)
+            q = q.not('last_clicked_at', 'is', null);
+        if (rules.has_clicked === false)
+            q = q.is('last_clicked_at', null);
+        if (rules.tag)
+            q = q.contains('tags', [rules.tag]);
+    }
+    if (tree.site_id) {
+        const { data: subs } = await db()
+            .from('site_subscriptions')
+            .select('contact_id')
+            .eq('site_id', tree.site_id)
+            .eq('subscribed', true);
+        const siteIds = (subs ?? []).map((s) => s.contact_id);
+        if (!siteIds.length)
+            return [];
+        q = q.in('id', siteIds);
+    }
+    const { data, error } = await q;
+    if (error || !data)
+        return [];
+    let contacts = data.filter((contact) => evaluateNode(contact, tree));
+    let ids = contacts.map((c) => String(c.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((s) => s.email));
+            ids = contacts
+                .filter((c) => !suppressedEmails.has(String(c.email)))
+                .map((c) => String(c.id));
+        }
+    }
+    return ids;
+}
+function applyPaymentRules(query, payment) {
+    if (!payment)
+        return query;
+    let q = query;
+    if (payment.plan)
+        q = q.contains('custom_properties', { payment: { plan: payment.plan } });
+    if (payment.mrr_cents !== undefined)
+        q = q.contains('custom_properties', { payment: { mrr_cents: payment.mrr_cents } });
+    if (payment.ltv_cents !== undefined)
+        q = q.contains('custom_properties', { payment: { ltv_cents: payment.ltv_cents } });
+    if (payment.subscription_status)
+        q = q.contains('custom_properties', { payment: { subscription_status: payment.subscription_status } });
+    q = applyPaymentDateRule(q, 'trial_ends_at', payment.trial_ends_at);
+    q = applyPaymentDateRule(q, 'churned_at', payment.churned_at);
+    q = applyPaymentDateRule(q, 'paid_at', payment.paid_at);
+    return q;
+}
+function applyPaymentDateRule(query, field, rule) {
+    if (!rule)
+        return query;
+    if (typeof rule === 'string') {
+        return query.contains('custom_properties', { payment: { [field]: rule } });
+    }
+    let q = query;
+    const column = `custom_properties->payment->>${field}`;
+    if (typeof rule.within_days === 'number') {
+        const start = new Date();
+        const end = new Date(start.getTime() + rule.within_days * 24 * 60 * 60 * 1000);
+        q = q.gte(column, start.toISOString()).lte(column, end.toISOString());
+    }
+    if (rule.after)
+        q = q.gte(column, rule.after);
+    if (rule.before)
+        q = q.lte(column, rule.before);
+    return q;
+}
+const txt = (text) => ({ content: [{ type: 'text', text }] });
+const j = (data) => txt(JSON.stringify(data, null, 2));
+export function registerSegmentTools(server) {
+    server.registerTool('create_segment', {
+        description: 'Create a saved segment with filter rules. Segments evaluate dynamically at send time.',
+        inputSchema: {
+            name: z.string().min(1).describe('Segment name (unique per project)'),
+            description: z.string().optional(),
+            rules: z.record(z.unknown()).describe('Segment rule tree: {op:"AND"|"OR", conditions:[{field, operator, value}]} or legacy flat rules. Supported fields include lifecycle_stage, engagement_score, source, created_at, last_opened_at, last_clicked_at, tags, custom_properties.<key>, payment.<key>.'),
+        },
+    }, async ({ name, description, rules }) => {
+        const { data, error } = await db()
+            .from('segments')
+            .insert({ project_id: getProjectId(), name, description, rules: normalizeSegmentRulesToTree(rules) })
+            .select('id, name, description, rules, created_at')
+            .single();
+        if (error)
+            return txt(`Error: ${error.message}`);
+        const ids = await getSegmentContactIds(data.rules);
+        return j({ ...data, estimated_contacts: ids.length });
+    });
+    server.registerTool('list_segments', {
+        description: 'List all saved segments with their contact counts',
+        inputSchema: {},
+    }, async () => {
+        const { data, error } = await db()
+            .from('segments')
+            .select('id, name, description, rules, created_at, updated_at')
+            .eq('project_id', getProjectId())
+            .order('created_at', { ascending: false });
+        if (error)
+            return txt(`Error: ${error.message}`);
+        const segments = [];
+        for (const seg of data ?? []) {
+            const ids = await getSegmentContactIds(seg.rules);
+            segments.push({ ...seg, contact_count: ids.length });
+        }
+        return j(segments);
+    });
+    server.registerTool('update_segment', {
+        description: 'Update a segment name, description, or rules',
+        inputSchema: {
+            segment_id: z.string().uuid(),
+            name: z.string().optional(),
+            description: z.string().optional(),
+            rules: z.record(z.unknown()).optional(),
+        },
+    }, async ({ segment_id, name, description, rules }) => {
+        const updates = { updated_at: new Date().toISOString() };
+        if (name)
+            updates.name = name;
+        if (description !== undefined)
+            updates.description = description;
+        if (rules)
+            updates.rules = normalizeSegmentRulesToTree(rules);
+        const { data, error } = await db()
+            .from('segments')
+            .update(updates)
+            .eq('id', segment_id)
+            .eq('project_id', getProjectId())
+            .select('id, name, description, rules, updated_at')
+            .single();
+        if (error)
+            return txt(`Error: ${error.message}`);
+        return j(data);
+    });
+    server.registerTool('delete_segment', {
+        description: 'Delete a saved segment. Campaigns using this segment will lose targeting.',
+        inputSchema: {
+            segment_id: z.string().uuid(),
+        },
+    }, async ({ segment_id }) => {
+        const { error } = await db()
+            .from('segments')
+            .delete()
+            .eq('id', segment_id)
+            .eq('project_id', getProjectId());
+        if (error)
+            return txt(`Error: ${error.message}`);
+        return j({ deleted: true, segment_id });
+    });
+    server.registerTool('preview_segment', {
+        description: 'Preview which contacts match a saved segment or inline rules. Returns count and sample.',
+        inputSchema: {
+            segment_id: z.string().uuid().optional(),
+            rules: z.record(z.unknown()).optional(),
+        },
+    }, async ({ segment_id, rules }) => {
+        let segRules;
+        if (segment_id) {
+            const { data: seg, error } = await db()
+                .from('segments')
+                .select('rules')
+                .eq('id', segment_id)
+                .eq('project_id', getProjectId())
+                .maybeSingle();
+            if (error || !seg)
+                return txt('Error: segment not found');
+            segRules = seg.rules;
+        }
+        else if (rules) {
+            segRules = rules;
+        }
+        else {
+            return txt('Provide either segment_id or rules.');
+        }
+        const ids = await getSegmentContactIds(segRules);
+        const sample = ids.slice(0, 10);
+        let sampleContacts = [];
+        if (sample.length) {
+            const { data } = await db()
+                .from('subscribers')
+                .select('id, email, first_name, last_name, engagement_score, lifecycle_stage, tags')
+                .in('id', sample);
+            sampleContacts = data ?? [];
+        }
+        return j({ total_contacts: ids.length, sample: sampleContacts });
+    });
+    server.registerTool('create_segment_nl', {
+        description: 'Create a segment from a natural language description. Parses description into filter rules using AI, previews contacts, creates on confirmation.',
+        inputSchema: {
+            name: z.string().min(1),
+            description: z.string().describe('Natural language audience description'),
+            confirmed: z.boolean().optional().describe('Set true to create after previewing'),
+        },
+    }, async ({ name, description, confirmed }) => {
+        const apiKey = process.env.ANTHROPIC_API_KEY;
+        if (!apiKey)
+            return txt('Error: ANTHROPIC_API_KEY not configured');
+        const anthropic = new Anthropic({ apiKey });
+        const resp = await anthropic.messages.create({
+            model: getAnthropicModelId(),
+            max_tokens: 512,
+            system: 'You translate natural language audience descriptions into a JSON segment rule tree. Return ONLY valid JSON. Format: {"op":"AND"|"OR","conditions":[conditionOrGroup],"exclude_suppressed":true}. Condition format: {"field": string, "operator":"eq|neq|gt|gte|lt|lte|contains|exists|not_exists|after|before|on_or_after|on_or_before","value": any}. Supported fields: lifecycle_stage, engagement_score, source, created_at, last_opened_at, last_clicked_at, tags, custom_properties.<key>, payment.plan, payment.mrr_cents, payment.ltv_cents, payment.subscription_status, payment.trial_ends_at, payment.churned_at, payment.paid_at. Example: {"op":"AND","conditions":[{"field":"lifecycle_stage","operator":"eq","value":"trial"},{"field":"payment.trial_ends_at","operator":"on_or_before","value":"' + new Date(Date.now() + 7 * 86400000).toISOString() + '"}]}. Today is ' + new Date().toISOString().slice(0, 10) + '.',
+            messages: [{ role: 'user', content: description }],
+        });
+        const tb = resp.content.find((b) => b.type === 'text');
+        const raw = tb && 'text' in tb ? tb.text : '{}';
+        let parsedRules;
+        try {
+            parsedRules = normalizeSegmentRulesToTree(JSON.parse(raw.replace(/```json?\n?|```/g, '').trim()));
+        }
+        catch {
+            return txt(`Error: Failed to parse rules from "${description}"`);
+        }
+        const ids = await getSegmentContactIds(parsedRules);
+        const sample = ids.slice(0, 5);
+        let sampleContacts = [];
+        if (sample.length) {
+            const { data } = await db()
+                .from('subscribers')
+                .select('id, email, first_name, last_name, engagement_score, lifecycle_stage, tags')
+                .in('id', sample);
+            sampleContacts = data ?? [];
+        }
+        if (!confirmed) {
+            return j({
+                confirmation_required: true,
+                parsed_rules: parsedRules,
+                total_contacts: ids.length,
+                sample: sampleContacts,
+                message: `Parsed "${description}" into rules. ${ids.length} contacts match. Call again with confirmed: true to create.`,
+            });
+        }
+        const { data, error } = await db()
+            .from('segments')
+            .insert({ project_id: getProjectId(), name, description, rules: parsedRules })
+            .select('id, name, description, rules, created_at')
+            .single();
+        if (error)
+            return txt(`Error: ${error.message}`);
+        return j({ ...data, estimated_contacts: ids.length });
+    });
+}

package/build/tools/sites.d.ts

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