@fruition/fcp-mcp-server 1.23.0 → 1.24.0

package/dist/index.js

@@ -169,6 +169,28 @@ const TOOL_PERMISSIONS = {
     unroo_get_my_tasks: 'viewer',
     unroo_get_parking_lot: 'viewer',
     unroo_get_backlog: 'viewer',
+    // --- Alerting ---
+    // admin: hard-delete of a rule and client-facing bulk notifications are
+    // higher-stakes than internal alert create/close, so gate them tighter.
+    fcp_delete_alert_rule: 'admin',
+    fcp_bulk_notify_clients: 'admin',
+    // operator: routine alert/outage writes (create, close, update).
+    fcp_create_alert: 'operator',
+    fcp_update_alert: 'operator',
+    fcp_create_alert_rule: 'operator',
+    fcp_update_alert_rule: 'operator',
+    fcp_create_outage: 'operator',
+    fcp_update_outage: 'operator',
+    fcp_resolve_outage: 'operator',
+    // viewer: reads.
+    fcp_list_alerts: 'viewer',
+    fcp_get_alert: 'viewer',
+    fcp_get_alert_stats: 'viewer',
+    fcp_list_alert_rules: 'viewer',
+    fcp_get_alert_rule: 'viewer',
+    fcp_list_outages: 'viewer',
+    fcp_get_outage: 'viewer',
+    fcp_get_bulk_notify_history: 'viewer',
 };
 // Resolved role for the current API key. Cached only on successful lookup so
 // transient FCP outages don't pin us to 'none' for the rest of the session.
@@ -368,6 +390,97 @@ class FCPClient {
             method: 'DELETE',
         });
     }
+    // --- Alerting: incidents (alert_events), rules, outages, bulk notifications ---
+    // Thin wrappers over the FCP alerting HTTP API. Request bodies are camelCase
+    // (the API maps to snake_case DB columns internally).
+    // Build a query string from defined params (skips undefined/empty values).
+    buildQuery(q) {
+        const entries = Object.entries(q)
+            .filter(([, v]) => v !== undefined && v !== null && v !== '')
+            .map(([k, v]) => [k, String(v)]);
+        const qs = new URLSearchParams(entries).toString();
+        return qs ? `?${qs}` : '';
+    }
+    // Incidents (individual alerts).
+    async listAlerts(q = {}) {
+        return this.fetch(`/api/incidents${this.buildQuery(q)}`);
+    }
+    async getAlert(id) {
+        return this.fetch(`/api/incidents/${id}`);
+    }
+    async createAlert(input) {
+        return this.fetch('/api/incidents', {
+            method: 'POST',
+            body: JSON.stringify(input),
+        });
+    }
+    async updateAlert(id, updates) {
+        return this.fetch(`/api/incidents/${id}`, {
+            method: 'PATCH',
+            body: JSON.stringify(updates),
+        });
+    }
+    async getAlertStats() {
+        return this.fetch('/api/incidents/stats');
+    }
+    // Alert rules (notification configuration).
+    async listAlertRules(accountId) {
+        return this.fetch(`/api/alerts/rules${this.buildQuery({ accountId })}`);
+    }
+    async getAlertRule(ruleId) {
+        return this.fetch(`/api/alerts/rules/${ruleId}`);
+    }
+    async createAlertRule(input) {
+        return this.fetch('/api/alerts/rules', {
+            method: 'POST',
+            body: JSON.stringify(input),
+        });
+    }
+    async updateAlertRule(ruleId, updates) {
+        return this.fetch(`/api/alerts/rules/${ruleId}`, {
+            method: 'PATCH',
+            body: JSON.stringify(updates),
+        });
+    }
+    async deleteAlertRule(ruleId) {
+        return this.fetch(`/api/alerts/rules/${ruleId}`, {
+            method: 'DELETE',
+        });
+    }
+    // Outages (admin outage tracking).
+    async listOutages(q = {}) {
+        return this.fetch(`/api/alerts/outages${this.buildQuery(q)}`);
+    }
+    async getOutage(outageId) {
+        return this.fetch(`/api/alerts/outages/${outageId}`);
+    }
+    async createOutage(input) {
+        return this.fetch('/api/alerts/outages', {
+            method: 'POST',
+            body: JSON.stringify(input),
+        });
+    }
+    async updateOutage(outageId, updates) {
+        return this.fetch(`/api/alerts/outages/${outageId}`, {
+            method: 'PATCH',
+            body: JSON.stringify(updates),
+        });
+    }
+    async resolveOutage(outageId) {
+        return this.fetch(`/api/alerts/outages/${outageId}`, {
+            method: 'DELETE',
+        });
+    }
+    // Bulk client notifications. Sends real emails/SMS to clients — handle with care.
+    async bulkNotifyClients(input) {
+        return this.fetch('/api/alerts/bulk-notify', {
+            method: 'POST',
+            body: JSON.stringify(input),
+        });
+    }
+    async getBulkNotifyHistory(limit) {
+        return this.fetch(`/api/alerts/bulk-notify${this.buildQuery({ limit })}`);
+    }
     async createLaunch(input) {
         return this.fetch('/api/launches', {
             method: 'POST',
@@ -3083,6 +3196,344 @@ const TOOLS = [
             required: ['siteId'],
         },
     },
+    // ===================== Alerting: incidents (alerts) =====================
+    {
+        name: 'fcp_list_alerts',
+        description: 'List alerts (incidents). Defaults to ACTIVE alerts (status firing,acknowledged). Pass status="resolved" for past alerts, or status="all" for everything. Alerts come from alertmanager, GCP monitoring, uptimerobot, cluster_health, or manual creation. Supports filtering by source, severity, cluster, namespace, domain, website, and time range.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                status: {
+                    type: 'string',
+                    description: 'Comma-separated statuses. Default "firing,acknowledged" (active). Use "resolved" for past, "silenced", or "all" for everything.',
+                },
+                source: {
+                    type: 'string',
+                    enum: ['alertmanager', 'gcp_monitoring', 'uptimerobot', 'cluster_health', 'manual'],
+                    description: 'Filter by alert source',
+                },
+                severity: {
+                    type: 'string',
+                    description: 'Comma-separated severities: critical, high, medium, low, info',
+                },
+                cluster: { type: 'string', description: 'Filter by cluster name' },
+                namespace: { type: 'string', description: 'Filter by namespace' },
+                domain: { type: 'string', description: 'Filter by domain (partial match)' },
+                websiteId: { type: 'number', description: 'Filter by FCP website ID' },
+                environment: { type: 'string', description: 'Filter by site environment (production, staging)' },
+                from: { type: 'string', description: 'Start of time range (ISO timestamp), filters started_at' },
+                to: { type: 'string', description: 'End of time range (ISO timestamp), filters started_at' },
+                page: { type: 'number', description: 'Page number (default 1)' },
+                limit: { type: 'number', description: 'Results per page (default 50, max 200)' },
+            },
+            required: [],
+        },
+    },
+    {
+        name: 'fcp_get_alert',
+        description: 'Get full detail for a single alert (incident) by ID, including linked site/account info.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                id: { type: 'number', description: 'The alert (incident) ID' },
+            },
+            required: ['id'],
+        },
+    },
+    {
+        name: 'fcp_create_alert',
+        description: 'Create a MANUAL alert (incident). Source is always "manual". Use this to manually raise an alert that did not come from automated monitoring. Returns the created alert with status "firing".',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                alertName: { type: 'string', description: 'Short alert name/title (required)' },
+                severity: {
+                    type: 'string',
+                    enum: ['critical', 'high', 'medium', 'low', 'info'],
+                    description: 'Severity (default: medium)',
+                },
+                summary: { type: 'string', description: 'Human-readable summary of the alert' },
+                cluster: { type: 'string', description: 'Affected cluster, if any' },
+                namespace: { type: 'string', description: 'Affected namespace, if any' },
+                domain: { type: 'string', description: 'Affected domain, if any' },
+                websiteId: { type: 'number', description: 'Link to an FCP website ID, if applicable' },
+            },
+            required: ['alertName'],
+        },
+    },
+    {
+        name: 'fcp_update_alert',
+        description: 'Update an alert (incident): acknowledge, silence, resolve (CLOSE), add admin notes, link a site, or link a Unroo task. To CLOSE an alert, set status="resolved". Silencing requires silencedUntil.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                id: { type: 'number', description: 'The alert (incident) ID' },
+                status: {
+                    type: 'string',
+                    enum: ['acknowledged', 'resolved', 'silenced'],
+                    description: 'New status. "resolved" closes the alert; "silenced" requires silencedUntil.',
+                },
+                acknowledgedBy: { type: 'string', description: 'Who acknowledged (when status=acknowledged)' },
+                silencedUntil: { type: 'string', description: 'ISO timestamp to silence until (required when status=silenced)' },
+                silencedBy: { type: 'string', description: 'Who silenced (when status=silenced)' },
+                adminNotes: { type: 'string', description: 'Internal admin notes' },
+                websiteId: { type: 'number', description: 'Link/relink to an FCP website ID' },
+                unrooTaskId: { type: 'number', description: 'Link to a Unroo task ID' },
+            },
+            required: ['id'],
+        },
+    },
+    {
+        name: 'fcp_get_alert_stats',
+        description: 'Get alert summary statistics for the last 7 days: counts by status, by source, critical-active count, and per-cluster breakdown.',
+        inputSchema: {
+            type: 'object',
+            properties: {},
+            required: [],
+        },
+    },
+    // ===================== Alerting: rules (notification config) =====================
+    {
+        name: 'fcp_list_alert_rules',
+        description: 'List client alert rules (notification configuration). Optionally filter by account.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                accountId: { type: 'number', description: 'Filter rules by account ID' },
+            },
+            required: [],
+        },
+    },
+    {
+        name: 'fcp_get_alert_rule',
+        description: 'Get a single alert rule by ID, with account and website context.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                ruleId: { type: 'number', description: 'The alert rule ID' },
+            },
+            required: ['ruleId'],
+        },
+    },
+    {
+        name: 'fcp_create_alert_rule',
+        description: 'Create a client alert rule defining which events trigger notifications, on which channels, with flapping/business-hours controls.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                accountId: { type: 'number', description: 'Account this rule belongs to (required)' },
+                websiteId: { type: 'number', description: 'Specific website, or omit/null for all sites in the account' },
+                name: { type: 'string', description: 'Rule name (required)' },
+                description: { type: 'string', description: 'Optional description' },
+                eventType: {
+                    type: 'string',
+                    enum: ['uptime_down', 'uptime_up', 'maintenance', 'cve', 'ssl_expiry', 'domain_expiry'],
+                    description: 'Event type that triggers this rule (required)',
+                },
+                severityThreshold: {
+                    type: 'string',
+                    enum: ['critical', 'high', 'medium', 'low', 'info'],
+                    description: 'Minimum severity to trigger (default: info)',
+                },
+                notifyChannels: {
+                    type: 'array',
+                    items: { type: 'string', enum: ['email', 'teams', 'slack', 'sms'] },
+                    description: 'Channels to notify on',
+                },
+                delaySeconds: { type: 'number', description: 'Delay before notifying (flap prevention)' },
+                cooldownSeconds: { type: 'number', description: 'Cooldown between repeat notifications' },
+                businessHoursOnly: { type: 'boolean', description: 'Only notify during business hours' },
+                businessHoursStart: { type: 'string', description: 'Business hours start (e.g. "09:00")' },
+                businessHoursEnd: { type: 'string', description: 'Business hours end (e.g. "17:00")' },
+                businessHoursTimezone: { type: 'string', description: 'IANA timezone for business hours' },
+                createdBy: { type: 'string', description: 'Who created the rule' },
+            },
+            required: ['accountId', 'name', 'eventType'],
+        },
+    },
+    {
+        name: 'fcp_update_alert_rule',
+        description: 'Update an existing alert rule. Only provided fields are changed.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                ruleId: { type: 'number', description: 'The alert rule ID (required)' },
+                name: { type: 'string', description: 'Rule name' },
+                description: { type: 'string', description: 'Description' },
+                severityThreshold: {
+                    type: 'string',
+                    enum: ['critical', 'high', 'medium', 'low', 'info'],
+                    description: 'Minimum severity to trigger',
+                },
+                notifyChannels: {
+                    type: 'array',
+                    items: { type: 'string', enum: ['email', 'teams', 'slack', 'sms'] },
+                    description: 'Channels to notify on',
+                },
+                delaySeconds: { type: 'number', description: 'Delay before notifying' },
+                cooldownSeconds: { type: 'number', description: 'Cooldown between repeat notifications' },
+                businessHoursOnly: { type: 'boolean', description: 'Only notify during business hours' },
+                businessHoursStart: { type: 'string', description: 'Business hours start' },
+                businessHoursEnd: { type: 'string', description: 'Business hours end' },
+                businessHoursTimezone: { type: 'string', description: 'IANA timezone' },
+                isActive: { type: 'boolean', description: 'Enable/disable the rule' },
+                updatedBy: { type: 'string', description: 'Who updated the rule' },
+            },
+            required: ['ruleId'],
+        },
+    },
+    {
+        name: 'fcp_delete_alert_rule',
+        description: 'Permanently DELETE an alert rule (hard delete). Requires admin. This cannot be undone.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                ruleId: { type: 'number', description: 'The alert rule ID to delete' },
+            },
+            required: ['ruleId'],
+        },
+    },
+    // ===================== Alerting: outages =====================
+    {
+        name: 'fcp_list_outages',
+        description: 'List active outages (admin outage tracking). Filter by status (active/resolved/all), account, and limit.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                status: { type: 'string', description: 'Filter: active, resolved, or all (default: active)' },
+                accountId: { type: 'number', description: 'Filter by account ID' },
+                limit: { type: 'number', description: 'Max results' },
+            },
+            required: [],
+        },
+    },
+    {
+        name: 'fcp_get_outage',
+        description: 'Get a single outage by ID, with its timeline updates, notification history, and affected client contacts.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                outageId: { type: 'number', description: 'The outage ID' },
+            },
+            required: ['outageId'],
+        },
+    },
+    {
+        name: 'fcp_create_outage',
+        description: 'Create an outage record for centralized outage management, optionally linked to an incident.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                incidentId: { type: 'number', description: 'Linked incident ID (from downtime_incidents)' },
+                websiteId: { type: 'number', description: 'Affected website ID' },
+                accountId: { type: 'number', description: 'Affected account ID' },
+                startedAt: { type: 'string', description: 'Outage start (ISO timestamp)' },
+                domain: { type: 'string', description: 'Affected domain' },
+                environment: { type: 'string', description: 'Environment (production, staging)' },
+                status: {
+                    type: 'string',
+                    enum: ['active', 'investigating', 'identified', 'monitoring', 'resolved'],
+                    description: 'Outage status (default: active)',
+                },
+                severity: {
+                    type: 'string',
+                    enum: ['critical', 'high', 'medium', 'low', 'info'],
+                    description: 'Severity',
+                },
+                likelyCause: { type: 'string', description: 'Likely cause description' },
+            },
+            required: [],
+        },
+    },
+    {
+        name: 'fcp_update_outage',
+        description: 'Update an outage: status, severity, likely cause, admin notes, assignee. Optionally append a timeline updateMessage. ⚠️ Setting notifyClients=true SENDS REAL NOTIFICATIONS to affected clients.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                outageId: { type: 'number', description: 'The outage ID (required)' },
+                status: {
+                    type: 'string',
+                    enum: ['active', 'investigating', 'identified', 'monitoring', 'resolved'],
+                    description: 'New outage status',
+                },
+                severity: {
+                    type: 'string',
+                    enum: ['critical', 'high', 'medium', 'low', 'info'],
+                    description: 'New severity',
+                },
+                likelyCause: { type: 'string', description: 'Likely cause' },
+                adminNotes: { type: 'string', description: 'Internal admin notes' },
+                assignedTo: { type: 'string', description: 'Assignee' },
+                updateMessage: { type: 'string', description: 'Timeline update message to append' },
+                notifyClients: {
+                    type: 'boolean',
+                    description: '⚠️ If true, sends real notifications to affected clients. Default false.',
+                },
+                updatedBy: { type: 'string', description: 'Who made the update' },
+                confirm: {
+                    type: 'boolean',
+                    description: 'Safety gate for client notifications. Only consulted when notifyClients=true: must be explicitly true to actually send. notifyClients=true without confirm=true makes the tool refuse (the rest of the update is NOT applied). No effect when notifyClients is absent/false.',
+                },
+            },
+            required: ['outageId'],
+        },
+    },
+    {
+        name: 'fcp_resolve_outage',
+        description: 'Resolve and close an outage (soft resolve — sets status to resolved and stamps resolved_at). Adds a resolution timeline entry.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                outageId: { type: 'number', description: 'The outage ID to resolve' },
+            },
+            required: ['outageId'],
+        },
+    },
+    // ===================== Alerting: bulk client notifications =====================
+    {
+        name: 'fcp_bulk_notify_clients',
+        description: '⚠️ SENDS REAL NOTIFICATIONS (email/Teams/Slack/SMS) to all clients affected by the given outages. Requires admin. Use deliberately — this contacts real people.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                outageIds: {
+                    type: 'array',
+                    items: { type: 'number' },
+                    description: 'Non-empty array of outage IDs whose affected clients should be notified',
+                },
+                notificationType: {
+                    type: 'string',
+                    enum: ['outage_initial', 'outage_update', 'recovery'],
+                    description: 'Type of notification',
+                },
+                subject: { type: 'string', description: 'Notification subject (required)' },
+                message: { type: 'string', description: 'Notification body (required)' },
+                channels: {
+                    type: 'array',
+                    items: { type: 'string', enum: ['email', 'teams', 'slack', 'sms'] },
+                    description: 'Channels to send on (default: ["email"])',
+                },
+                sentBy: { type: 'string', description: 'Who sent the notification' },
+                confirm: {
+                    type: 'boolean',
+                    description: 'REQUIRED safety gate. Must be explicitly true to actually dispatch. Omitting or false makes the tool refuse and report who would be contacted — call again with confirm=true only after a human has approved sending.',
+                },
+            },
+            required: ['outageIds', 'notificationType', 'subject', 'message'],
+        },
+    },
+    {
+        name: 'fcp_get_bulk_notify_history',
+        description: 'Get history of bulk client notifications (batches sent), most recent first.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                limit: { type: 'number', description: 'Max results (default 20)' },
+            },
+            required: [],
+        },
+    },
 ];
 // Register tool handlers
 server.setRequestHandler(ListToolsRequestSchema, async () => {
@@ -4287,6 +4738,180 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
                 };
             }
+            // ===================== Alerting: incidents (alerts) =====================
+            case 'fcp_list_alerts': {
+                const result = await client.listAlerts(args);
+                return {
+                    content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                };
+            }
+            case 'fcp_get_alert': {
+                const { id } = args;
+                const result = await client.getAlert(id);
+                return {
+                    content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                };
+            }
+            case 'fcp_create_alert': {
+                const { alertName, severity, summary, cluster, namespace, domain, websiteId } = args;
+                const result = await client.createAlert({ alertName, severity, summary, cluster, namespace, domain, websiteId });
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({ success: true, message: `Alert created: "${alertName}"`, alert: result?.incident ?? result }, null, 2),
+                        },
+                    ],
+                };
+            }
+            case 'fcp_update_alert': {
+                const { id, ...updates } = args;
+                const result = await client.updateAlert(id, updates);
+                const verb = updates.status === 'resolved' ? 'closed (resolved)' : `updated${updates.status ? ` to ${updates.status}` : ''}`;
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({ success: true, message: `Alert ${id} ${verb}`, alert: result?.incident ?? result }, null, 2),
+                        },
+                    ],
+                };
+            }
+            case 'fcp_get_alert_stats': {
+                const result = await client.getAlertStats();
+                return {
+                    content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                };
+            }
+            // ===================== Alerting: rules =====================
+            case 'fcp_list_alert_rules': {
+                const { accountId } = args;
+                const result = await client.listAlertRules(accountId);
+                return {
+                    content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                };
+            }
+            case 'fcp_get_alert_rule': {
+                const { ruleId } = args;
+                const result = await client.getAlertRule(ruleId);
+                return {
+                    content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                };
+            }
+            case 'fcp_create_alert_rule': {
+                const result = await client.createAlertRule(args);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({ success: true, message: 'Alert rule created', rule: result?.rule ?? result }, null, 2),
+                        },
+                    ],
+                };
+            }
+            case 'fcp_update_alert_rule': {
+                const { ruleId, ...updates } = args;
+                const result = await client.updateAlertRule(ruleId, updates);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({ success: true, message: `Alert rule ${ruleId} updated`, rule: result?.rule ?? result }, null, 2),
+                        },
+                    ],
+                };
+            }
+            case 'fcp_delete_alert_rule': {
+                const { ruleId } = args;
+                const result = await client.deleteAlertRule(ruleId);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({ success: true, message: `Alert rule ${ruleId} deleted`, result }, null, 2),
+                        },
+                    ],
+                };
+            }
+            // ===================== Alerting: outages =====================
+            case 'fcp_list_outages': {
+                const result = await client.listOutages(args);
+                return {
+                    content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                };
+            }
+            case 'fcp_get_outage': {
+                const { outageId } = args;
+                const result = await client.getOutage(outageId);
+                return {
+                    content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                };
+            }
+            case 'fcp_create_outage': {
+                const result = await client.createOutage(args);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({ success: true, message: 'Outage created', outage: result?.outage ?? result }, null, 2),
+                        },
+                    ],
+                };
+            }
+            case 'fcp_update_outage': {
+                const { outageId, confirm, ...updates } = args;
+                // Safety gate: a notifying update must be explicitly confirmed. We refuse the
+                // WHOLE update (not just the notify) so a half-applied state can't occur.
+                if (updates.notifyClients === true && confirm !== true) {
+                    throw new Error(`Refusing to update: outage ${outageId} update has notifyClients=true, which SENDS REAL notifications ` +
+                        `to affected clients. Re-call with confirm=true to apply this update and notify, or drop notifyClients ` +
+                        `to update silently.`);
+                }
+                const result = await client.updateOutage(outageId, updates);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({ success: true, message: `Outage ${outageId} updated`, outage: result?.outage ?? result }, null, 2),
+                        },
+                    ],
+                };
+            }
+            case 'fcp_resolve_outage': {
+                const { outageId } = args;
+                const result = await client.resolveOutage(outageId);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({ success: true, message: `Outage ${outageId} resolved`, result }, null, 2),
+                        },
+                    ],
+                };
+            }
+            // ===================== Alerting: bulk client notifications =====================
+            case 'fcp_bulk_notify_clients': {
+                const { outageIds, notificationType, subject, message, channels, sentBy, confirm } = args;
+                // Safety gate: refuse to email/SMS real clients unless explicitly confirmed.
+                if (confirm !== true) {
+                    const ch = (channels && channels.length ? channels : ['email']).join(', ');
+                    const n = Array.isArray(outageIds) ? outageIds.length : 0;
+                    throw new Error(`Refusing to send: fcp_bulk_notify_clients dispatches REAL ${ch} notifications to clients ` +
+                        `affected by ${n} outage(s) [${Array.isArray(outageIds) ? outageIds.join(', ') : ''}]. ` +
+                        `Confirm with a human, then re-call with confirm=true to proceed.`);
+                }
+                const result = await client.bulkNotifyClients({ outageIds, notificationType, subject, message, channels, sentBy });
+                return {
+                    content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                };
+            }
+            case 'fcp_get_bulk_notify_history': {
+                const { limit } = args;
+                const result = await client.getBulkNotifyHistory(limit);
+                return {
+                    content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                };
+            }
             default:
                 throw new Error(`Unknown tool: ${name}`);
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fruition/fcp-mcp-server",
-  "version": "1.23.0",
+  "version": "1.24.0",
   "description": "MCP Server for FCP Launch Coordination System - enables Claude Code to interact with FCP launches and track development time",
   "main": "dist/index.js",
   "type": "module",