@sendinel/mcp-server 1.0.0

package/build/tools/data.js

@@ -0,0 +1,707 @@
+import { createHash, randomBytes } from 'crypto';
+import { z } from 'zod';
+import { adminDb, db } from '../db.js';
+import { decrypt, encrypt } from '../crypto.js';
+import { normalizeActiveCampaignAccountUrl } from '../lib/url-validation.js';
+import { getProjectId } from '../project.js';
+import { logAudit } from '../audit.js';
+const j = (data) => ({ content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] });
+function generateApiKey() {
+    const secret = `snk_${randomBytes(32).toString('hex')}`;
+    return {
+        secret,
+        hash: createHash('sha256').update(secret).digest('hex'),
+        prefix: secret.slice(0, 8),
+    };
+}
+function sanitizeSuppression(row) {
+    return {
+        ...row,
+        email: row.reason === 'gdpr_deleted' || row.email?.startsWith('sha256:') ? '[deleted]' : row.email,
+    };
+}
+function csvEscape(value) {
+    const s = value == null ? '' : typeof value === 'object' ? JSON.stringify(value) : String(value);
+    return /[",\n\r]/.test(s) ? `"${s.replace(/"/g, '""')}"` : s;
+}
+function toCsv(rows, columns) {
+    return [columns.join(','), ...rows.map((row) => columns.map((column) => csvEscape(row[column])).join(','))].join('\n');
+}
+function toJsonl(rows) {
+    return rows.map((row) => JSON.stringify(row)).join('\n');
+}
+const MIGRATION_PROVIDERS = ['customerio', 'mailchimp', 'klaviyo', 'activecampaign', 'convertkit', 'kit', 'resend'];
+const CONNECTED_PLATFORMS = [
+    'stripe',
+    'shopify',
+    'woocommerce',
+    'bigcommerce',
+    'square',
+    'hubspot',
+    'salesforce',
+    'pipedrive',
+    'zoho_crm',
+    'typeform',
+    'tally',
+    'gravity_forms',
+    'google_forms',
+    'calendly',
+    'cal_com',
+    'acuity_scheduling',
+    'mailchimp',
+    'klaviyo',
+    'activecampaign',
+    'convertkit',
+    'kit',
+    'intercom',
+    'zendesk',
+    'google_sheets',
+    'airtable',
+    'customerio',
+    'resend',
+];
+const PLATFORM_STATUSES = ['connected', 'pending', 'error', 'not_connected'];
+function normalizePlatform(platform) {
+    return platform === 'kit' ? 'convertkit' : platform;
+}
+function sanitizeConnection(row) {
+    return {
+        id: row.id,
+        org_id: row.org_id,
+        project_id: row.project_id,
+        platform: row.platform,
+        display_name: row.display_name,
+        status: row.status ?? (row.is_active ? 'connected' : 'not_connected'),
+        is_active: row.is_active,
+        config: row.config ?? row.meta ?? {},
+        last_synced_at: row.last_synced_at,
+        last_error: row.last_error ?? null,
+        created_at: row.created_at,
+        updated_at: row.updated_at,
+    };
+}
+async function getPlatformProjectContext(client = adminDb(), orgId) {
+    const projectId = getProjectId();
+    const { data: project, error } = await client
+        .schema('email')
+        .from('projects')
+        .select('id, org_id, owner_user_id')
+        .eq('id', projectId)
+        .maybeSingle();
+    if (error)
+        throw new Error(error.message);
+    if (!project?.org_id)
+        throw new Error('project has no organization');
+    if (orgId && orgId !== project.org_id)
+        throw new Error('org_id does not match current project');
+    let userId = project.owner_user_id;
+    if (!userId) {
+        const { data: member, error: memberError } = await client
+            .schema('email')
+            .from('org_members')
+            .select('user_id')
+            .eq('org_id', project.org_id)
+            .not('user_id', 'is', null)
+            .order('created_at', { ascending: true })
+            .limit(1)
+            .maybeSingle();
+        if (memberError)
+            throw new Error(memberError.message);
+        userId = member?.user_id;
+    }
+    if (!userId)
+        throw new Error('organization has no Supabase-auth user to own the connection');
+    return { projectId, orgId: project.org_id, userId: userId };
+}
+function createCampaignMigrationTotals(options) {
+    return {
+        contacts: { total: options.includeContacts ? 1 : 0, processed: 0 },
+        templates: { total: 1, processed: 0 },
+        campaigns: { total: 1, processed: 0 },
+        suppressions: { total: options.includeSuppressions ? 1 : 0, processed: 0 },
+        processed: 0,
+        errors: 0,
+        account_name: 'MCP campaign migration',
+        options: {
+            import_contacts: options.includeContacts,
+            import_templates: true,
+            import_campaigns: true,
+            import_suppressions: options.includeSuppressions,
+            migration_entry_point: 'mcp',
+        },
+    };
+}
+function createPlatformMigrationTotals(artifactTypes) {
+    const requested = artifactTypes?.length ? new Set(artifactTypes) : null;
+    const enabled = (key) => !requested || requested.has(key);
+    return {
+        contacts: { total: enabled('contacts') ? 1 : 0, processed: 0 },
+        templates: { total: enabled('templates') ? 1 : 0, processed: 0 },
+        campaigns: { total: enabled('campaigns') ? 1 : 0, processed: 0 },
+        suppressions: { total: enabled('suppressions') ? 1 : 0, processed: 0 },
+        processed: 0,
+        errors: 0,
+        account_name: 'Platform migration',
+        options: {
+            import_contacts: enabled('contacts'),
+            import_templates: enabled('templates'),
+            import_campaigns: enabled('campaigns'),
+            import_suppressions: enabled('suppressions'),
+            migration_entry_point: 'mcp_connection',
+        },
+    };
+}
+function crc32(buf) {
+    let crc = -1;
+    for (let i = 0; i < buf.length; i++) {
+        crc ^= buf[i];
+        for (let bit = 0; bit < 8; bit++)
+            crc = (crc >>> 1) ^ (0xedb88320 & -(crc & 1));
+    }
+    return (crc ^ -1) >>> 0;
+}
+function createZip(files) {
+    const localParts = [];
+    const centralParts = [];
+    let offset = 0;
+    for (const file of files) {
+        const name = Buffer.from(file.name);
+        const content = Buffer.from(file.content);
+        const crc = crc32(content);
+        const local = Buffer.alloc(30);
+        local.writeUInt32LE(0x04034b50, 0);
+        local.writeUInt16LE(20, 4);
+        local.writeUInt16LE(0, 6);
+        local.writeUInt16LE(0, 8);
+        local.writeUInt32LE(crc, 14);
+        local.writeUInt32LE(content.length, 18);
+        local.writeUInt32LE(content.length, 22);
+        local.writeUInt16LE(name.length, 26);
+        localParts.push(local, name, content);
+        const central = Buffer.alloc(46);
+        central.writeUInt32LE(0x02014b50, 0);
+        central.writeUInt16LE(20, 4);
+        central.writeUInt16LE(20, 6);
+        central.writeUInt32LE(crc, 16);
+        central.writeUInt32LE(content.length, 20);
+        central.writeUInt32LE(content.length, 24);
+        central.writeUInt16LE(name.length, 28);
+        central.writeUInt32LE(offset, 42);
+        centralParts.push(central, name);
+        offset += local.length + name.length + content.length;
+    }
+    const centralSize = centralParts.reduce((sum, part) => sum + part.length, 0);
+    const end = Buffer.alloc(22);
+    end.writeUInt32LE(0x06054b50, 0);
+    end.writeUInt16LE(files.length, 8);
+    end.writeUInt16LE(files.length, 10);
+    end.writeUInt32LE(centralSize, 12);
+    end.writeUInt32LE(offset, 16);
+    return Buffer.concat([...localParts, ...centralParts, end]);
+}
+export function registerDataTools(server) {
+    server.registerTool('list_connected_platforms', {
+        description: 'List connected external platforms and integration status for the current project organization. Does not return credential material.',
+        inputSchema: {
+            org_id: z.string().uuid().optional(),
+            include_inactive: z.boolean().optional().default(false),
+        },
+    }, async ({ org_id, include_inactive = false }) => {
+        try {
+            const client = adminDb();
+            const context = await getPlatformProjectContext(client, org_id);
+            let query = client
+                .schema('email')
+                .from('platform_connections')
+                .select('id, org_id, project_id, platform, display_name, config, meta, status, is_active, last_synced_at, last_error, created_at, updated_at')
+                .eq('org_id', context.orgId)
+                .eq('project_id', context.projectId)
+                .order('platform', { ascending: true });
+            if (!include_inactive)
+                query = query.eq('is_active', true);
+            const { data, error } = await query;
+            if (error)
+                return j({ error: error.message });
+            return j({
+                platforms: CONNECTED_PLATFORMS.filter((platform) => platform !== 'kit'),
+                connections: (data ?? []).map(sanitizeConnection),
+            });
+        }
+        catch (error) {
+            return j({ error: error instanceof Error ? error.message : 'Failed to list connected platforms' });
+        }
+    });
+    server.registerTool('connect_platform', {
+        description: 'Store encrypted credentials for an external platform connection and mark it ready for trigger configuration.',
+        inputSchema: {
+            org_id: z.string().uuid().optional(),
+            platform: z.enum(CONNECTED_PLATFORMS),
+            credentials: z.record(z.unknown()),
+            display_name: z.string().min(1).optional(),
+            config: z.record(z.unknown()).optional().default({}),
+            status: z.enum(PLATFORM_STATUSES).optional().default('connected'),
+        },
+    }, async ({ org_id, platform, credentials, display_name, config = {}, status = 'connected' }) => {
+        try {
+            if (Object.keys(credentials ?? {}).length === 0)
+                return j({ error: 'credentials are required' });
+            const client = adminDb();
+            const context = await getPlatformProjectContext(client, org_id);
+            const normalizedPlatform = normalizePlatform(platform);
+            const safeConfig = {
+                ...config,
+                connected_by: 'mcp',
+                credential_keys: Object.keys(credentials).sort(),
+            };
+            const { data, error } = await client
+                .schema('email')
+                .from('platform_connections')
+                .upsert({
+                user_id: context.userId,
+                org_id: context.orgId,
+                project_id: context.projectId,
+                platform: normalizedPlatform,
+                display_name: display_name ?? normalizedPlatform,
+                credentials_enc: encrypt(JSON.stringify(credentials)),
+                config: safeConfig,
+                meta: safeConfig,
+                status,
+                is_active: status !== 'not_connected',
+                last_error: null,
+                updated_at: new Date().toISOString(),
+            }, { onConflict: 'user_id,org_id,project_id,platform' })
+                .select('id, org_id, project_id, platform, display_name, config, status, is_active, last_synced_at, last_error, created_at, updated_at')
+                .single();
+            if (error)
+                return j({ error: error.message });
+            await logAudit({
+                action: 'platform_connection.connected',
+                resourceType: 'platform_connection',
+                resourceId: data.id,
+                details: { platform: normalizedPlatform, status },
+            });
+            return j({
+                connection: sanitizeConnection(data),
+                credential_keys: Object.keys(credentials).sort(),
+                connection_test: { status: 'stored', message: 'Credentials were encrypted and saved. Live provider validation is handled by provider-specific connector workers.' },
+            });
+        }
+        catch (error) {
+            return j({ error: error instanceof Error ? error.message : 'Failed to connect platform' });
+        }
+    });
+    server.registerTool('disconnect_platform', {
+        description: 'Disconnect an external platform connection for the current project organization and remove stored credentials.',
+        inputSchema: {
+            org_id: z.string().uuid().optional(),
+            platform: z.enum(CONNECTED_PLATFORMS).optional(),
+            connection_id: z.string().uuid().optional(),
+        },
+    }, async ({ org_id, platform, connection_id }) => {
+        try {
+            if (!platform && !connection_id)
+                return j({ error: 'platform or connection_id is required' });
+            const client = adminDb();
+            const context = await getPlatformProjectContext(client, org_id);
+            let query = client
+                .schema('email')
+                .from('platform_connections')
+                .delete()
+                .eq('org_id', context.orgId)
+                .eq('project_id', context.projectId);
+            if (connection_id)
+                query = query.eq('id', connection_id);
+            if (platform)
+                query = query.eq('platform', normalizePlatform(platform));
+            const { data, error } = await query.select('id, platform');
+            if (error)
+                return j({ error: error.message });
+            await logAudit({
+                action: 'platform_connection.disconnected',
+                resourceType: 'platform_connection',
+                resourceId: connection_id,
+                details: { platform: platform ? normalizePlatform(platform) : null, disconnected_count: data?.length ?? 0 },
+            });
+            return j({ disconnected: data?.length ?? 0, connections: data ?? [] });
+        }
+        catch (error) {
+            return j({ error: error instanceof Error ? error.message : 'Failed to disconnect platform' });
+        }
+    });
+    server.registerTool('list_platform_events', {
+        description: 'List recent raw events received from connected platforms for troubleshooting trigger mappings.',
+        inputSchema: {
+            org_id: z.string().uuid().optional(),
+            platform: z.enum(CONNECTED_PLATFORMS).optional(),
+            limit: z.number().int().min(1).max(100).optional().default(25),
+        },
+    }, async ({ org_id, platform, limit = 25 }) => {
+        try {
+            const client = adminDb();
+            const context = await getPlatformProjectContext(client, org_id);
+            let query = client
+                .schema('email')
+                .from('platform_events')
+                .select('id, platform, event_type, source_event_id, payload, processed_at, contact_id, received_at')
+                .eq('org_id', context.orgId)
+                .eq('project_id', context.projectId)
+                .order('received_at', { ascending: false })
+                .limit(limit);
+            if (platform)
+                query = query.eq('platform', normalizePlatform(platform));
+            const { data, error } = await query;
+            if (error)
+                return j({ error: error.message });
+            return j({ events: data ?? [] });
+        }
+        catch (error) {
+            return j({ error: error instanceof Error ? error.message : 'Failed to list platform events' });
+        }
+    });
+    server.registerTool('configure_platform_trigger', {
+        description: 'Configure an event-to-action mapping for a connected platform, such as adding a Shopify customer to a list after an order.',
+        inputSchema: {
+            org_id: z.string().uuid().optional(),
+            platform: z.enum(CONNECTED_PLATFORMS),
+            event_type: z.string().min(1),
+            action: z.object({
+                type: z.enum(['add_to_list', 'add_tag', 'trigger_campaign', 'update_field', 'record_event', 'noop']),
+                target_id: z.string().optional(),
+                list_id: z.string().uuid().optional(),
+                tag: z.string().optional(),
+                campaign_id: z.string().uuid().optional(),
+                field: z.string().optional(),
+                value: z.unknown().optional(),
+            }).passthrough(),
+        },
+    }, async ({ org_id, platform, event_type, action }) => {
+        try {
+            const client = adminDb();
+            const context = await getPlatformProjectContext(client, org_id);
+            const normalizedPlatform = normalizePlatform(platform);
+            const { data: connection, error: connectionError } = await client
+                .schema('email')
+                .from('platform_connections')
+                .select('id, config, meta')
+                .eq('org_id', context.orgId)
+                .eq('project_id', context.projectId)
+                .eq('platform', normalizedPlatform)
+                .eq('is_active', true)
+                .maybeSingle();
+            if (connectionError)
+                return j({ error: connectionError.message });
+            if (!connection)
+                return j({ error: 'active platform connection not found' });
+            const currentConfig = connection.config ?? connection.meta ?? {};
+            const existingTriggers = Array.isArray(currentConfig.triggers) ? currentConfig.triggers : [];
+            const trigger = { event_type, action, updated_at: new Date().toISOString() };
+            const nextTriggers = [
+                ...existingTriggers.filter((item) => item?.event_type !== event_type),
+                trigger,
+            ];
+            const nextConfig = { ...currentConfig, triggers: nextTriggers };
+            const { data, error } = await client
+                .schema('email')
+                .from('platform_connections')
+                .update({ config: nextConfig, meta: nextConfig, updated_at: new Date().toISOString() })
+                .eq('id', connection.id)
+                .select('id, platform, display_name, config, status, is_active, last_synced_at, updated_at')
+                .single();
+            if (error)
+                return j({ error: error.message });
+            await logAudit({
+                action: 'platform_trigger.configured',
+                resourceType: 'platform_connection',
+                resourceId: connection.id,
+                details: { platform: normalizedPlatform, event_type, action_type: action.type },
+            });
+            return j({ connection: sanitizeConnection(data), trigger });
+        }
+        catch (error) {
+            return j({ error: error instanceof Error ? error.message : 'Failed to configure platform trigger' });
+        }
+    });
+    server.registerTool('list_import_history', {
+        description: 'List recent subscriber import history rows.',
+        inputSchema: { limit: z.number().int().min(1).max(100).optional().default(25) },
+    }, async ({ limit = 25 }) => {
+        const { data, error } = await db().from('import_log')
+            .select('id, source, status, imported_count, failed_count, created_at')
+            .eq('project_id', getProjectId())
+            .order('created_at', { ascending: false })
+            .limit(limit);
+        if (error)
+            return j({ error: error.message });
+        return j({ imports: data ?? [] });
+    });
+    server.registerTool('list_api_keys', {
+        description: 'List API keys without returning secret material.',
+        inputSchema: {},
+    }, async () => {
+        const { data, error } = await db().from('api_keys')
+            .select('id, name, slug, key_prefix, scopes, tool_groups, created_at, last_used_at, revoked_at')
+            .eq('project_id', getProjectId())
+            .is('revoked_at', null)
+            .order('created_at', { ascending: false });
+        if (error)
+            return j({ error: error.message });
+        return j({ keys: data ?? [] });
+    });
+    server.registerTool('create_api_key', {
+        description: 'Create an API key and return the secret once.',
+        inputSchema: {
+            name: z.string().min(1),
+            slug: z.string().optional(),
+            scopes: z.array(z.string()).optional().default(['read']),
+        },
+    }, async ({ name, slug, scopes = ['read'] }) => {
+        const { secret, hash, prefix } = generateApiKey();
+        const cleanSlug = slug?.trim().toLowerCase().replace(/[^a-z0-9-]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 50) || null;
+        const { data, error } = await db().from('api_keys')
+            .insert({ project_id: getProjectId(), name, slug: cleanSlug, key_hash: hash, key_prefix: prefix, scopes })
+            .select('id, name, slug')
+            .single();
+        if (error)
+            return j({ error: error.message });
+        return j({ key_id: data.id, name: data.name, slug: data.slug, secret });
+    });
+    server.registerTool('revoke_api_key', {
+        description: 'Revoke an API key.',
+        inputSchema: { key_id: z.string().uuid() },
+    }, async ({ key_id }) => {
+        const { error } = await db().from('api_keys').update({ revoked_at: new Date().toISOString() }).eq('project_id', getProjectId()).eq('id', key_id);
+        if (error)
+            return j({ error: error.message });
+        return j({ revoked: true });
+    });
+    server.registerTool('migrate_campaigns_from', {
+        description: 'Start a campaign-artifact migration from a provider token. Imports templates and campaigns as draft, approval-required Sendinel assets; Customer.io is the first-class path.',
+        inputSchema: {
+            provider: z.enum(MIGRATION_PROVIDERS),
+            oauth_token: z.string().min(1),
+            account_url: z.string().optional(),
+            include_contacts: z.boolean().optional().default(false),
+            include_suppressions: z.boolean().optional().default(true),
+        },
+    }, async ({ provider, oauth_token, account_url, include_contacts = false, include_suppressions = true }) => {
+        const projectId = getProjectId();
+        const client = adminDb();
+        const { data: project, error: projectError } = await client
+            .schema('email')
+            .from('projects')
+            .select('id, org_id')
+            .eq('id', projectId)
+            .maybeSingle();
+        if (projectError)
+            return j({ error: projectError.message });
+        if (!project?.org_id)
+            return j({ error: 'project not found' });
+        let normalizedAccountUrl = account_url;
+        if (provider === 'activecampaign') {
+            try {
+                normalizedAccountUrl = normalizeActiveCampaignAccountUrl(account_url ?? '');
+            }
+            catch (error) {
+                return j({ error: error instanceof Error ? error.message : 'Invalid ActiveCampaign account URL' });
+            }
+        }
+        const credentials = { api_key: oauth_token, account_url: normalizedAccountUrl };
+        const { data, error } = await client
+            .schema('email')
+            .from('import_jobs')
+            .insert({
+            org_id: project.org_id,
+            project_id: projectId,
+            provider,
+            status: 'pending',
+            progress_pct: 0,
+            totals: createCampaignMigrationTotals({ includeContacts: include_contacts, includeSuppressions: include_suppressions }),
+            errors: [],
+            credentials_enc: encrypt(JSON.stringify(credentials)),
+            field_mapping: null,
+            created_by: null,
+        })
+            .select('id')
+            .single();
+        if (error)
+            return j({ error: error.message });
+        return j({
+            job_id: data.id,
+            status: 'pending',
+            review_required: true,
+            imported_categories: {
+                contacts: include_contacts,
+                templates: true,
+                campaigns: true,
+                suppressions: include_suppressions,
+            },
+            note: 'Campaign artifacts are imported as drafts and require approval before sending.',
+        });
+    });
+    server.registerTool('start_platform_migration', {
+        description: 'Start a migration from a stored external platform connection into Sendinel. Returns a job_id for status polling.',
+        inputSchema: {
+            connection_id: z.string().uuid(),
+            artifact_types: z.array(z.enum(['contacts', 'templates', 'campaigns', 'suppressions'])).optional(),
+            dry_run: z.boolean().optional().default(false),
+        },
+    }, async ({ connection_id, artifact_types, dry_run = false }) => {
+        const projectId = getProjectId();
+        const client = adminDb();
+        const { data: connection, error: connectionError } = await client
+            .schema('email')
+            .from('platform_connections')
+            .select('id, org_id, project_id, platform, credentials_enc')
+            .eq('id', connection_id)
+            .eq('project_id', projectId)
+            .eq('is_active', true)
+            .maybeSingle();
+        if (connectionError)
+            return j({ error: connectionError.message });
+        if (!connection)
+            return j({ error: 'platform connection not found' });
+        if (!MIGRATION_PROVIDERS.includes(connection.platform))
+            return j({ error: 'unsupported platform' });
+        if (dry_run)
+            return j({ error: 'dry_run staging is not available through MCP yet; start from the dashboard preview first.' });
+        const credentials = JSON.parse(decrypt(connection.credentials_enc));
+        const { data, error } = await client
+            .schema('email')
+            .from('import_jobs')
+            .insert({
+            org_id: connection.org_id,
+            project_id: projectId,
+            provider: connection.platform,
+            status: 'pending',
+            progress_pct: 0,
+            totals: createPlatformMigrationTotals(artifact_types),
+            errors: [],
+            credentials_enc: encrypt(JSON.stringify(credentials)),
+            field_mapping: null,
+            created_by: null,
+        })
+            .select('id')
+            .single();
+        if (error)
+            return j({ error: error.message });
+        await client.schema('email').from('platform_connections').update({ last_synced_at: new Date().toISOString() }).eq('id', connection_id);
+        return j({ job_id: data.id, status: 'pending', connection_id, provider: connection.platform });
+    });
+    server.registerTool('list_notifications', {
+        description: 'List in-app notifications.',
+        inputSchema: { unread_only: z.boolean().optional().default(false) },
+    }, async ({ unread_only = false }) => {
+        let query = db().from('notifications').select('id, type, title, body, severity, read_at, created_at, action_url').eq('project_id', getProjectId()).order('created_at', { ascending: false }).limit(50);
+        if (unread_only)
+            query = query.is('read_at', null);
+        const { data, error } = await query;
+        if (error)
+            return j({ error: error.message });
+        return j({ notifications: data ?? [] });
+    });
+    server.registerTool('mark_notifications_read', {
+        description: 'Mark selected notifications read, or all unread notifications if ids is omitted.',
+        inputSchema: { ids: z.array(z.string().uuid()).optional() },
+    }, async ({ ids }) => {
+        let query = db().from('notifications').update({ read_at: new Date().toISOString() }).eq('project_id', getProjectId()).is('read_at', null);
+        if (ids?.length)
+            query = query.in('id', ids);
+        const { data, error } = await query.select('id');
+        if (error)
+            return j({ error: error.message });
+        return j({ updated: data?.length ?? 0 });
+    });
+    server.registerTool('tenant_export_full', {
+        description: 'Export all tenant data classes for portability. Returns inline data for small exports or a signed archive URL for large exports.',
+        inputSchema: {
+            siteId: z.string().uuid(),
+            format: z.enum(['json', 'csv']).optional().default('json'),
+        },
+    }, async ({ siteId, format = 'json' }) => {
+        const projectId = getProjectId();
+        const since = new Date(Date.now() - 90 * 24 * 3600 * 1000).toISOString();
+        const client = db();
+        const { data: siteSubscriptions } = await client.from('site_subscriptions')
+            .select('contact_id')
+            .eq('site_id', siteId)
+            .eq('subscribed', true);
+        const contactIds = (siteSubscriptions ?? []).map((row) => row.contact_id);
+        const contactsQuery = client.from('subscribers')
+            .select('id, email, first_name, last_name, tags, custom_properties, created_at, last_engaged_at, source')
+            .eq('project_id', projectId);
+        const [{ data: contacts }, { data: emailHistory }, { data: suppressions }, { data: templates }, { data: site }] = await Promise.all([
+            contactIds.length ? contactsQuery.in('id', contactIds) : Promise.resolve({ data: [], error: null }),
+            client.from('email_log')
+                .select('id, to_email, from_email, subject, status, sent_at, opened_at, clicked_at, bounced_at, complained_at, campaign_id')
+                .eq('project_id', projectId)
+                .eq('site_id', siteId)
+                .not('to_email', 'like', 'sha256:%')
+                .gte('sent_at', since),
+            client.from('suppressions').select('email, reason, source, created_at').eq('project_id', projectId),
+            client.from('campaign_templates').select('name, subject_hint, body_html, body_text, brief_template').eq('project_id', projectId),
+            client.from('sites')
+                .select('id, name, brand_voice, projects(org_id, organizations(brand_settings))')
+                .eq('id', siteId)
+                .eq('project_id', projectId)
+                .maybeSingle(),
+        ]);
+        const safeSuppressions = (suppressions ?? []).map(sanitizeSuppression);
+        const brandVoiceProfile = {
+            site_id: siteId,
+            site_name: site?.name ?? null,
+            site_brand_voice: site?.brand_voice ?? {},
+            organization_brand_settings: site?.projects?.organizations?.brand_settings ?? {},
+        };
+        const recordCounts = {
+            contacts: contacts?.length ?? 0,
+            email_history: emailHistory?.length ?? 0,
+            suppressions: safeSuppressions.length,
+            templates: templates?.length ?? 0,
+        };
+        const totalRecords = Object.values(recordCounts).reduce((sum, count) => sum + count, 0);
+        const files = format === 'csv'
+            ? [
+                { name: 'contacts.csv', content: toCsv(contacts ?? [], ['id', 'email', 'first_name', 'last_name', 'tags', 'custom_properties', 'created_at', 'last_engaged_at', 'source']) },
+                { name: 'email_history.jsonl', content: toJsonl(emailHistory ?? []) },
+                { name: 'suppressions.csv', content: toCsv(safeSuppressions, ['email', 'reason', 'source', 'created_at']) },
+                { name: 'templates.json', content: JSON.stringify(templates ?? [], null, 2) },
+                { name: 'brand_voice_profile.json', content: JSON.stringify(brandVoiceProfile, null, 2) },
+            ]
+            : [
+                { name: 'contacts.json', content: JSON.stringify(contacts ?? [], null, 2) },
+                { name: 'email_history.jsonl', content: toJsonl(emailHistory ?? []) },
+                { name: 'suppressions.json', content: JSON.stringify(safeSuppressions, null, 2) },
+                { name: 'templates.json', content: JSON.stringify(templates ?? [], null, 2) },
+                { name: 'brand_voice_profile.json', content: JSON.stringify(brandVoiceProfile, null, 2) },
+            ];
+        if (totalRecords < 5000) {
+            return j({
+                inline: {
+                    contacts: contacts ?? [],
+                    email_history: emailHistory ?? [],
+                    suppressions: safeSuppressions,
+                    templates: templates ?? [],
+                    brand_voice_profile: brandVoiceProfile,
+                },
+                record_counts: recordCounts,
+            });
+        }
+        const bucket = 'tenant-exports';
+        const path = `${projectId}/${siteId}/${Date.now()}-export.zip`;
+        let upload = await client.storage.from(bucket).upload(path, createZip(files), { contentType: 'application/zip', upsert: true });
+        if (upload.error && /bucket/i.test(upload.error.message)) {
+            await client.storage.createBucket(bucket, { public: false });
+            upload = await client.storage.from(bucket).upload(path, createZip(files), { contentType: 'application/zip', upsert: true });
+        }
+        if (upload.error)
+            return j({ error: upload.error.message });
+        const { data, error } = await client.storage.from(bucket).createSignedUrl(path, 24 * 3600);
+        if (error)
+            return j({ error: error.message });
+        return j({
+            download_url: data.signedUrl,
+            expires_at: new Date(Date.now() + 24 * 3600 * 1000).toISOString(),
+            record_counts: recordCounts,
+        });
+    });
+}