@fruition/fcp-mcp-server 1.24.0 → 1.24.1

package/dist/index.js

@@ -169,28 +169,6 @@ 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.
@@ -390,97 +368,6 @@ 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',
@@ -3196,344 +3083,6 @@ 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 () => {
@@ -4738,180 +4287,6 @@ 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/dist/skills-sync.js

@@ -422,9 +422,18 @@ async function pullOnce(ctx, state, result) {
         if (!slug)
             continue;
         const props = node.properties ?? {};
-        const bodyMarkdown = typeof props.bodyMarkdown === 'string' ? props.bodyMarkdown : '';
+        // The capture endpoint receives `bodyMarkdown` from the wire but persists
+        // it to kg_nodes.properties as `body_md` (see knowledge-graph.ts upsertSkill).
+        // The search endpoint returns properties verbatim, so the pull side reads
+        // `body_md`. Accept either for forward-compat in case the storage shape
+        // is normalized later.
+        const bodyMarkdown = typeof props.body_md === 'string'
+            ? props.body_md
+            : typeof props.bodyMarkdown === 'string'
+                ? props.bodyMarkdown
+                : '';
         if (!bodyMarkdown) {
-            result.skipped.push({ slug, why: 'remote has no bodyMarkdown' });
+            result.skipped.push({ slug, why: 'remote has no body_md' });
             continue;
         }
         const localPath = join(ctx.skillsDir, slug, 'SKILL.md');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fruition/fcp-mcp-server",
-  "version": "1.24.0",
+  "version": "1.24.1",
   "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",