@sendinel/mcp-server 1.0.4 → 1.0.5

package/build/tools/newsletters.js

@@ -0,0 +1,583 @@
+import { z } from 'zod';
+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 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';
+const ISSUE_COLUMNS = 'id, newsletter_id, org_id, project_id, campaign_id, blog_post_id, issue_number, subject, content, preheader, status, scheduled_at, sent_at, archive_url, source, source_payload, created_at, updated_at';
+const SUBSCRIPTION_COLUMNS = 'id, newsletter_id, org_id, project_id, subscriber_id, email, status, opt_in_state, source, subscribed_at, unsubscribed_at, unsubscribe_reason, created_at, updated_at';
+const EMAIL_RE = /^[^\s@<>]+@[^\s@<>]+\.[^\s@<>]+$/;
+function slugifyNewsletter(input) {
+    return input
+        .toLowerCase()
+        .trim()
+        .replace(/[^a-z0-9\s-]/g, '')
+        .replace(/\s+/g, '-')
+        .replace(/-+/g, '-')
+        .slice(0, 120)
+        .replace(/^-|-$/g, '') || 'newsletter';
+}
+async function getProjectOrgId(projectId) {
+    const { data } = await db().from('projects').select('org_id').eq('id', projectId).maybeSingle();
+    return data?.org_id ?? null;
+}
+async function loadSendableIssue(newsletterId, issueId, projectId) {
+    const [{ data: newsletter, error: newsletterError }, { data: issue, error: issueError }] = await Promise.all([
+        db().from('newsletters')
+            .select('id, org_id, project_id, site_id, name, status')
+            .eq('id', newsletterId)
+            .eq('project_id', projectId)
+            .maybeSingle(),
+        db().from('newsletter_issues')
+            .select(ISSUE_COLUMNS)
+            .eq('id', issueId)
+            .eq('newsletter_id', newsletterId)
+            .eq('project_id', projectId)
+            .maybeSingle(),
+    ]);
+    if (newsletterError)
+        return { error: newsletterError.message };
+    if (issueError)
+        return { error: issueError.message };
+    if (!newsletter)
+        return { error: 'Newsletter not found', code: 'NOT_FOUND' };
+    if (!issue)
+        return { error: 'Newsletter issue not found', code: 'NOT_FOUND' };
+    if (newsletter.status !== 'active')
+        return { error: 'Newsletter must be active before sending', code: 'CONFLICT' };
+    if (!newsletter.site_id)
+        return { error: 'Newsletter requires site_id before issue sending can use the campaign pipeline', code: 'MISSING_FIELD' };
+    if (!String(issue.content ?? '').trim())
+        return { error: 'Issue content is required before sending', code: 'MISSING_FIELD' };
+    if (['sent', 'archived'].includes(String(issue.status)))
+        return { error: 'Issue has already been sent', code: 'CONFLICT' };
+    return { newsletter, issue };
+}
+async function ensureNewsletterCampaign(newsletter, issue, projectId, scheduledAt) {
+    const metadata = { source: 'newsletter_issue', newsletter_id: newsletter.id, issue_id: issue.id };
+    const campaignName = `${newsletter.name} #${issue.issue_number}: ${issue.subject}`.slice(0, 200);
+    let campaignId = issue.campaign_id;
+    if (campaignId) {
+        const { data: campaign, error } = await db().from('campaigns')
+            .update({ name: campaignName, send_at: scheduledAt, metadata })
+            .eq('id', campaignId)
+            .eq('project_id', projectId)
+            .select('id')
+            .maybeSingle();
+        if (error)
+            return { error: error.message };
+        if (!campaign)
+            campaignId = null;
+    }
+    if (!campaignId) {
+        const { data: campaign, error } = await db().from('campaigns').insert({
+            project_id: projectId,
+            site_id: newsletter.site_id,
+            name: campaignName,
+            type: 'broadcast',
+            status: 'draft',
+            requires_approval: false,
+            send_at: scheduledAt,
+            metadata,
+        }).select('id').single();
+        if (error || !campaign)
+            return { error: error?.message ?? 'Campaign create failed' };
+        campaignId = campaign.id;
+    }
+    const { data: firstStep, error: stepFetchError } = await db().from('campaign_steps')
+        .select('id')
+        .eq('campaign_id', campaignId)
+        .eq('step_order', 0)
+        .maybeSingle();
+    if (stepFetchError)
+        return { error: stepFetchError.message };
+    if (firstStep?.id) {
+        const { error } = await db().from('campaign_steps')
+            .update({ subject: issue.subject, body_html: issue.content, body_text: issue.preheader })
+            .eq('id', firstStep.id);
+        if (error)
+            return { error: error.message };
+    }
+    else {
+        const { error } = await db().from('campaign_steps').insert({
+            campaign_id: campaignId,
+            step_order: 0,
+            subject: issue.subject,
+            body_html: issue.content,
+            body_text: issue.preheader,
+            delay_days: 0,
+            delay_hours: 0,
+        });
+        if (error)
+            return { error: error.message };
+    }
+    const { data: subscriptions, error: subscriptionError } = await db().from('newsletter_subscriptions')
+        .select('subscriber_id')
+        .eq('newsletter_id', newsletter.id)
+        .eq('project_id', projectId)
+        .eq('status', 'active')
+        .not('subscriber_id', 'is', null);
+    if (subscriptionError)
+        return { error: subscriptionError.message };
+    const now = new Date().toISOString();
+    const nextSendAt = scheduledAt ?? now;
+    const rows = (subscriptions ?? []).map((subscription) => ({
+        campaign_id: campaignId,
+        contact_id: subscription.subscriber_id,
+        status: 'active',
+        current_step: 0,
+        enrolled_at: now,
+        next_send_at: nextSendAt,
+        enrollment_context: { source: 'newsletter_issue', newsletter_id: newsletter.id, issue_id: issue.id },
+    }));
+    if (rows.length) {
+        const { error } = await db().from('campaign_enrollments')
+            .upsert(rows, { onConflict: 'campaign_id,contact_id', ignoreDuplicates: true });
+        if (error)
+            return { error: error.message };
+    }
+    const { error: statusError } = await db().from('campaigns')
+        .update({ status: 'active', updated_at: now })
+        .eq('id', campaignId)
+        .eq('project_id', projectId);
+    if (statusError)
+        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',
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+        description: 'List newsletter publications for the current project.',
+        inputSchema: {
+            status: z.enum(['active', 'paused', 'archived']).optional(),
+            limit: z.number().int().min(1).max(200).default(50).optional(),
+        },
+    }, async ({ status, limit = 50 }) => {
+        const projectId = getProjectId();
+        let query = db().from('newsletters').select(NEWSLETTER_COLUMNS).eq('project_id', projectId).order('created_at', { ascending: false }).limit(limit);
+        query = status ? query.eq('status', status) : query.neq('status', 'archived');
+        const { data, error } = await query;
+        if (error)
+            return j({ error: error.message });
+        return j({ newsletters: data ?? [], count: data?.length ?? 0 });
+    });
+    server.registerTool('get_newsletter', {
+        title: 'Get Newsletter',
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+        description: 'Get one newsletter publication by ID.',
+        inputSchema: { newsletter_id: z.string().uuid() },
+    }, async ({ newsletter_id }) => {
+        const { data, error } = await db().from('newsletters').select(NEWSLETTER_COLUMNS).eq('id', newsletter_id).eq('project_id', getProjectId()).maybeSingle();
+        if (error)
+            return j({ error: error.message });
+        if (!data)
+            return j({ error: 'Newsletter not found', code: 'NOT_FOUND' });
+        return j(data);
+    });
+    server.registerTool('create_newsletter', {
+        title: 'Create Newsletter',
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: false,
+            openWorldHint: false,
+        },
+        description: 'Create a newsletter publication for the current project.',
+        inputSchema: {
+            name: z.string().min(1).max(200),
+            slug: z.string().optional(),
+            description: z.string().optional(),
+            site_id: z.string().uuid().nullable().optional(),
+            sender_name: z.string().optional(),
+            sender_email: z.string().optional(),
+            reply_to: z.string().optional(),
+            cadence: z.string().optional(),
+            branding: z.record(z.string(), z.unknown()).optional(),
+            public_signup_enabled: z.boolean().default(true).optional(),
+            double_opt_in: z.boolean().default(false).optional(),
+            status: z.enum(['active', 'paused', 'archived']).default('active').optional(),
+        },
+    }, async (args) => {
+        const projectId = getProjectId();
+        const orgId = await getProjectOrgId(projectId);
+        if (!orgId)
+            return j({ error: 'Organization not found for project', code: 'NOT_FOUND' });
+        const { data, error } = await db().from('newsletters').insert({
+            org_id: orgId,
+            project_id: projectId,
+            site_id: args.site_id ?? null,
+            name: args.name,
+            slug: args.slug ? slugifyNewsletter(args.slug) : slugifyNewsletter(args.name),
+            description: args.description ?? null,
+            sender_name: args.sender_name ?? null,
+            sender_email: args.sender_email ?? null,
+            reply_to: args.reply_to ?? null,
+            cadence: args.cadence ?? null,
+            branding: args.branding ?? {},
+            public_signup_enabled: args.public_signup_enabled ?? true,
+            double_opt_in: args.double_opt_in ?? false,
+            status: args.status ?? 'active',
+            source: 'mcp',
+            source_payload: args,
+        }).select(NEWSLETTER_COLUMNS).single();
+        if (error)
+            return j({ error: error.message, code: error.code === '23505' ? 'CONFLICT' : undefined });
+        return j(data);
+    });
+    server.registerTool('update_newsletter', {
+        title: 'Update Newsletter',
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+        description: 'Update newsletter publication settings.',
+        inputSchema: {
+            newsletter_id: z.string().uuid(),
+            name: z.string().max(200).optional(),
+            slug: z.string().nullable().optional(),
+            description: z.string().nullable().optional(),
+            site_id: z.string().uuid().nullable().optional(),
+            sender_name: z.string().nullable().optional(),
+            sender_email: z.string().nullable().optional(),
+            reply_to: z.string().nullable().optional(),
+            cadence: z.string().nullable().optional(),
+            branding: z.record(z.string(), z.unknown()).optional(),
+            public_signup_enabled: z.boolean().optional(),
+            double_opt_in: z.boolean().optional(),
+            status: z.enum(['active', 'paused', 'archived']).optional(),
+        },
+    }, async ({ newsletter_id, ...fields }) => {
+        const updates = Object.fromEntries(Object.entries(fields).filter(([, value]) => value !== undefined));
+        if (updates.slug && typeof updates.slug === 'string')
+            updates.slug = slugifyNewsletter(updates.slug);
+        if (!Object.keys(updates).length)
+            return j({ error: 'No fields to update', code: 'MISSING_FIELD' });
+        const { data, error } = await db().from('newsletters')
+            .update(updates)
+            .eq('id', newsletter_id)
+            .eq('project_id', getProjectId())
+            .select(NEWSLETTER_COLUMNS)
+            .maybeSingle();
+        if (error)
+            return j({ error: error.message, code: error.code === '23505' ? 'CONFLICT' : undefined });
+        if (!data)
+            return j({ error: 'Newsletter not found', code: 'NOT_FOUND' });
+        return j(data);
+    });
+    server.registerTool('create_newsletter_issue', {
+        title: 'Create Newsletter Issue',
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: false,
+            openWorldHint: false,
+        },
+        description: 'Create a draft issue for a newsletter.',
+        inputSchema: {
+            newsletter_id: z.string().uuid(),
+            subject: z.string().min(1).max(300),
+            content: z.string().optional(),
+            preheader: z.string().optional(),
+        },
+    }, async ({ newsletter_id, subject, content, preheader }) => {
+        const projectId = getProjectId();
+        const { data: newsletter, error: newsletterError } = await db().from('newsletters').select('id, org_id').eq('id', newsletter_id).eq('project_id', projectId).maybeSingle();
+        if (newsletterError)
+            return j({ error: newsletterError.message });
+        if (!newsletter)
+            return j({ error: 'Newsletter not found', code: 'NOT_FOUND' });
+        const { data: latest } = await db().from('newsletter_issues').select('issue_number').eq('newsletter_id', newsletter_id).order('issue_number', { ascending: false }).limit(1).maybeSingle();
+        const { data, error } = await db().from('newsletter_issues').insert({
+            newsletter_id,
+            org_id: newsletter.org_id,
+            project_id: projectId,
+            issue_number: Number(latest?.issue_number ?? 0) + 1,
+            subject,
+            content: content ?? null,
+            preheader: preheader ?? null,
+            source: 'mcp',
+            source_payload: { newsletter_id, subject, content, preheader },
+        }).select(ISSUE_COLUMNS).single();
+        if (error)
+            return j({ error: error.message });
+        return j(data);
+    });
+    server.registerTool('list_newsletter_issues', {
+        title: 'List Newsletter Issues',
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+        description: 'List issues for one newsletter.',
+        inputSchema: {
+            newsletter_id: z.string().uuid(),
+            status: z.enum(['draft', 'scheduled', 'sent', 'archived']).optional(),
+            limit: z.number().int().min(1).max(200).default(50).optional(),
+        },
+    }, async ({ newsletter_id, status, limit = 50 }) => {
+        let query = db().from('newsletter_issues')
+            .select(ISSUE_COLUMNS)
+            .eq('newsletter_id', newsletter_id)
+            .eq('project_id', getProjectId())
+            .order('issue_number', { ascending: false })
+            .limit(limit);
+        if (status)
+            query = query.eq('status', status);
+        const { data, error } = await query;
+        if (error)
+            return j({ error: error.message });
+        return j({ issues: data ?? [], count: data?.length ?? 0 });
+    });
+    server.registerTool('schedule_newsletter_issue', {
+        title: 'Schedule Newsletter Issue',
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: true,
+            idempotentHint: false,
+            openWorldHint: true,
+        },
+        description: 'Schedule a newsletter issue through the campaign send pipeline.',
+        inputSchema: {
+            newsletter_id: z.string().uuid(),
+            issue_id: z.string().uuid(),
+            scheduled_at: z.string(),
+        },
+    }, async ({ newsletter_id, issue_id, scheduled_at }) => {
+        const parsed = parseFutureDate(scheduled_at);
+        if ('error' in parsed)
+            return j({ error: parsed.error, code: 'INVALID_FIELD' });
+        const projectId = getProjectId();
+        const loaded = await loadSendableIssue(newsletter_id, issue_id, projectId);
+        if ('error' in loaded)
+            return j(loaded);
+        if (!['draft', 'scheduled'].includes(String(loaded.issue.status)))
+            return j({ error: 'Only draft or scheduled issues can be scheduled', code: 'CONFLICT' });
+        const campaign = await ensureNewsletterCampaign(loaded.newsletter, loaded.issue, projectId, parsed.scheduledAt);
+        if ('error' in campaign)
+            return j(campaign);
+        const { data, error } = await db().from('newsletter_issues')
+            .update({ campaign_id: campaign.campaignId, status: 'scheduled', scheduled_at: parsed.scheduledAt })
+            .eq('id', issue_id)
+            .eq('newsletter_id', newsletter_id)
+            .eq('project_id', projectId)
+            .select(ISSUE_COLUMNS)
+            .maybeSingle();
+        if (error)
+            return j({ error: error.message });
+        return j({ issue: data, campaign_id: campaign.campaignId, enrolled: campaign.enrolled });
+    });
+    server.registerTool('send_newsletter_issue', {
+        title: 'Send Newsletter Issue',
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: true,
+            idempotentHint: false,
+            openWorldHint: true,
+        },
+        description: 'Send a newsletter issue now through the campaign send pipeline and create archive metadata.',
+        inputSchema: {
+            newsletter_id: z.string().uuid(),
+            issue_id: z.string().uuid(),
+        },
+    }, async ({ newsletter_id, issue_id }) => {
+        const projectId = getProjectId();
+        const loaded = await loadSendableIssue(newsletter_id, issue_id, projectId);
+        if ('error' in loaded)
+            return j(loaded);
+        const campaign = await ensureNewsletterCampaign(loaded.newsletter, loaded.issue, projectId, null);
+        if ('error' in campaign)
+            return j(campaign);
+        const archiveSlug = slugifyNewsletter(`${loaded.newsletter.name}-${loaded.issue.issue_number}-${loaded.issue.subject}`);
+        const { data: post } = await db().from('blog_posts').insert({
+            org_id: loaded.newsletter.org_id,
+            project_id: projectId,
+            site_id: loaded.newsletter.site_id,
+            title: loaded.issue.subject,
+            slug: archiveSlug,
+            body: loaded.issue.content ?? '',
+            excerpt: loaded.issue.preheader,
+            tags: ['newsletter'],
+            status: 'published',
+            source: 'newsletter_issue',
+            source_payload: { newsletter_id, issue_id, issue_number: loaded.issue.issue_number },
+            published_at: new Date().toISOString(),
+        }).select('id, external_url').single();
+        const sentAt = new Date().toISOString();
+        const { data, error } = await db().from('newsletter_issues')
+            .update({
+            campaign_id: campaign.campaignId,
+            blog_post_id: post?.id ?? null,
+            archive_url: post?.external_url ?? null,
+            status: 'sent',
+            sent_at: sentAt,
+            scheduled_at: null,
+        })
+            .eq('id', issue_id)
+            .eq('newsletter_id', newsletter_id)
+            .eq('project_id', projectId)
+            .select(ISSUE_COLUMNS)
+            .maybeSingle();
+        if (error)
+            return j({ error: error.message });
+        return j({ issue: data, campaign_id: campaign.campaignId, enrolled: campaign.enrolled, blog_post_id: post?.id ?? null, archive_url: post?.external_url ?? null });
+    });
+    server.registerTool('subscribe_to_newsletter', {
+        title: 'Subscribe To Newsletter',
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: false,
+            openWorldHint: false,
+        },
+        description: 'Add or reactivate a subscriber for one newsletter.',
+        inputSchema: {
+            newsletter_id: z.string().uuid(),
+            email: z.string().email(),
+            first_name: z.string().nullable().optional(),
+            last_name: z.string().nullable().optional(),
+            source: z.string().default('mcp').optional(),
+        },
+    }, async ({ newsletter_id, email, first_name, last_name, source = 'mcp' }) => {
+        const normalizedEmail = email.trim().toLowerCase();
+        if (!EMAIL_RE.test(normalizedEmail))
+            return j({ error: 'A valid email is required', code: 'INVALID_FIELD' });
+        const projectId = getProjectId();
+        const { data: newsletter, error: newsletterError } = await db().from('newsletters')
+            .select('id, org_id, project_id, double_opt_in, status')
+            .eq('id', newsletter_id)
+            .eq('project_id', projectId)
+            .eq('status', 'active')
+            .maybeSingle();
+        if (newsletterError)
+            return j({ error: newsletterError.message });
+        if (!newsletter)
+            return j({ error: 'Newsletter not found', code: 'NOT_FOUND' });
+        const { data: subscriber, error: subscriberError } = await db().from('subscribers').upsert({
+            project_id: projectId,
+            email: normalizedEmail,
+            first_name: first_name ?? null,
+            last_name: last_name ?? null,
+            source,
+        }, { onConflict: 'project_id,email' }).select('id').single();
+        if (subscriberError || !subscriber)
+            return j({ error: subscriberError?.message ?? 'Subscriber upsert failed' });
+        const activeImmediately = !newsletter.double_opt_in;
+        const { data, error } = await db().from('newsletter_subscriptions').upsert({
+            newsletter_id,
+            org_id: newsletter.org_id,
+            project_id: projectId,
+            subscriber_id: subscriber.id,
+            email: normalizedEmail,
+            status: activeImmediately ? 'active' : 'pending',
+            opt_in_state: activeImmediately ? 'single' : 'double_pending',
+            source,
+            subscribed_at: activeImmediately ? new Date().toISOString() : null,
+            unsubscribed_at: null,
+            unsubscribe_reason: null,
+        }, { onConflict: 'newsletter_id,email' }).select(SUBSCRIPTION_COLUMNS).single();
+        if (error)
+            return j({ error: error.message });
+        return j(data);
+    });
+    server.registerTool('unsubscribe_from_newsletter', {
+        title: 'Unsubscribe From Newsletter',
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: true,
+            idempotentHint: false,
+            openWorldHint: false,
+        },
+        description: 'Unsubscribe an address or subscriber ID from one newsletter without creating a global suppression.',
+        inputSchema: {
+            newsletter_id: z.string().uuid(),
+            subscriber_id: z.string().uuid().optional(),
+            email: z.string().email().optional(),
+            reason: z.string().default('mcp_request').optional(),
+        },
+    }, async ({ newsletter_id, subscriber_id, email, reason = 'mcp_request' }) => {
+        const projectId = getProjectId();
+        let resolvedSubscriberId = subscriber_id ?? null;
+        if (!resolvedSubscriberId && email) {
+            const { data: subscriber } = await db().from('subscribers').select('id').eq('project_id', projectId).eq('email', email.trim().toLowerCase()).maybeSingle();
+            resolvedSubscriberId = subscriber?.id ?? null;
+        }
+        if (!resolvedSubscriberId)
+            return j({ error: 'subscriber_id or email is required', code: 'MISSING_FIELD' });
+        const { data, error } = await db().rpc('process_newsletter_unsubscribe', {
+            p_newsletter_id: newsletter_id,
+            p_contact_id: resolvedSubscriberId,
+            p_reason: reason,
+        });
+        if (error)
+            return j({ error: error.message });
+        if (!data?.success)
+            return j({ error: data?.reason ?? 'Unsubscribe failed', code: 'NOT_FOUND' });
+        return j(data);
+    });
+    server.registerTool('list_newsletter_subscribers', {
+        title: 'List Newsletter Subscribers',
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+        description: 'List newsletter subscriptions for one newsletter.',
+        inputSchema: {
+            newsletter_id: z.string().uuid(),
+            status: z.enum(['pending', 'active', 'unsubscribed']).optional(),
+            limit: z.number().int().min(1).max(200).default(50).optional(),
+        },
+    }, async ({ newsletter_id, status, limit = 50 }) => {
+        let query = db().from('newsletter_subscriptions').select(SUBSCRIPTION_COLUMNS).eq('newsletter_id', newsletter_id).eq('project_id', getProjectId()).order('created_at', { ascending: false }).limit(limit);
+        if (status)
+            query = query.eq('status', status);
+        const { data, error } = await query;
+        if (error)
+            return j({ error: error.message });
+        return j({ subscribers: data ?? [], count: data?.length ?? 0 });
+    });
+    server.registerTool('get_newsletter_stats', {
+        title: 'Get Newsletter Stats',
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+        description: 'Get newsletter stats. Issue-level analytics are pending Phase 4.',
+        inputSchema: { newsletter_id: z.string().uuid() },
+    }, async ({ newsletter_id }) => {
+        const { count, error } = await db().from('newsletter_subscriptions')
+            .select('id', { count: 'exact', head: true })
+            .eq('newsletter_id', newsletter_id)
+            .eq('project_id', getProjectId())
+            .eq('status', 'active');
+        if (error)
+            return j({ error: error.message });
+        return j({ newsletter_id, active_subscribers: count ?? 0, issue_analytics_status: 'pending_phase_4' });
+    });
+}