@access-mcp/system-status 0.2.3 → 0.4.0

package/dist/server.js

@@ -1,65 +1,88 @@
-import { BaseAccessServer, handleApiError } from '@access-mcp/shared';
+import { BaseAccessServer, handleApiError } from "@access-mcp/shared";
 export class SystemStatusServer extends BaseAccessServer {
     constructor() {
-        super('access-mcp-system-status', '0.1.0', 'https://operations-api.access-ci.org');
+        super("access-mcp-system-status", "0.4.0", "https://operations-api.access-ci.org");
     }
     getTools() {
         return [
             {
-                name: 'get_current_outages',
-                description: 'Get current system outages and issues affecting ACCESS-CI resources',
+                name: "get_current_outages",
+                description: "Get current system outages and issues affecting ACCESS-CI resources",
                 inputSchema: {
-                    type: 'object',
+                    type: "object",
                     properties: {
                         resource_filter: {
-                            type: 'string',
-                            description: 'Optional: filter by specific resource name or ID',
+                            type: "string",
+                            description: "Optional: filter by specific resource name or ID",
                         },
                     },
                     required: [],
                 },
             },
             {
-                name: 'get_scheduled_maintenance',
-                description: 'Get scheduled maintenance and future outages for ACCESS-CI resources',
+                name: "get_scheduled_maintenance",
+                description: "Get scheduled maintenance and future outages for ACCESS-CI resources",
                 inputSchema: {
-                    type: 'object',
+                    type: "object",
                     properties: {
                         resource_filter: {
-                            type: 'string',
-                            description: 'Optional: filter by specific resource name or ID',
+                            type: "string",
+                            description: "Optional: filter by specific resource name or ID",
                         },
                     },
                     required: [],
                 },
             },
             {
-                name: 'get_system_announcements',
-                description: 'Get all system announcements (current and scheduled)',
+                name: "get_past_outages",
+                description: "Get historical outages and past incidents affecting ACCESS-CI resources",
                 inputSchema: {
-                    type: 'object',
+                    type: "object",
                     properties: {
+                        resource_filter: {
+                            type: "string",
+                            description: "Optional: filter by specific resource name or ID",
+                        },
                         limit: {
-                            type: 'number',
-                            description: 'Maximum number of announcements to return (default: 50)',
+                            type: "number",
+                            description: "Maximum number of past outages to return (default: 100)",
                         },
                     },
                     required: [],
                 },
             },
             {
-                name: 'check_resource_status',
-                description: 'Check the operational status of specific ACCESS-CI resources',
+                name: "get_system_announcements",
+                description: "Get all system announcements (current and scheduled)",
                 inputSchema: {
-                    type: 'object',
+                    type: "object",
+                    properties: {
+                        limit: {
+                            type: "number",
+                            description: "Maximum number of announcements to return (default: 50)",
+                        },
+                    },
+                    required: [],
+                },
+            },
+            {
+                name: "check_resource_status",
+                description: "Check the operational status of specific ACCESS-CI resources",
+                inputSchema: {
+                    type: "object",
                     properties: {
                         resource_ids: {
-                            type: 'array',
-                            items: { type: 'string' },
-                            description: 'List of resource IDs to check status for',
+                            type: "array",
+                            items: { type: "string" },
+                            description: "List of resource IDs or names to check status for",
+                        },
+                        use_group_api: {
+                            type: "boolean",
+                            description: "Use resource group API for more efficient querying (default: false)",
+                            default: false,
                         },
                     },
-                    required: ['resource_ids'],
+                    required: ["resource_ids"],
                 },
             },
         ];
@@ -67,22 +90,28 @@ export class SystemStatusServer extends BaseAccessServer {
     getResources() {
         return [
             {
-                uri: 'accessci://system-status',
-                name: 'ACCESS-CI System Status',
-                description: 'Real-time status of ACCESS-CI infrastructure, outages, and maintenance',
-                mimeType: 'application/json',
+                uri: "accessci://system-status",
+                name: "ACCESS-CI System Status",
+                description: "Real-time status of ACCESS-CI infrastructure, outages, and maintenance",
+                mimeType: "application/json",
             },
             {
-                uri: 'accessci://outages/current',
-                name: 'Current Outages',
-                description: 'Currently active outages and system issues',
-                mimeType: 'application/json',
+                uri: "accessci://outages/current",
+                name: "Current Outages",
+                description: "Currently active outages and system issues",
+                mimeType: "application/json",
             },
             {
-                uri: 'accessci://outages/scheduled',
-                name: 'Scheduled Maintenance',
-                description: 'Upcoming scheduled maintenance and planned outages',
-                mimeType: 'application/json',
+                uri: "accessci://outages/scheduled",
+                name: "Scheduled Maintenance",
+                description: "Upcoming scheduled maintenance and planned outages",
+                mimeType: "application/json",
+            },
+            {
+                uri: "accessci://outages/past",
+                name: "Past Outages",
+                description: "Historical outages and past incidents",
+                mimeType: "application/json",
             },
         ];
     }
@@ -90,14 +119,16 @@ export class SystemStatusServer extends BaseAccessServer {
         const { name, arguments: args = {} } = request.params;
         try {
             switch (name) {
-                case 'get_current_outages':
+                case "get_current_outages":
                     return await this.getCurrentOutages(args.resource_filter);
-                case 'get_scheduled_maintenance':
+                case "get_scheduled_maintenance":
                     return await this.getScheduledMaintenance(args.resource_filter);
-                case 'get_system_announcements':
+                case "get_past_outages":
+                    return await this.getPastOutages(args.resource_filter, args.limit);
+                case "get_system_announcements":
                     return await this.getSystemAnnouncements(args.limit);
-                case 'check_resource_status':
-                    return await this.checkResourceStatus(args.resource_ids);
+                case "check_resource_status":
+                    return await this.checkResourceStatus(args.resource_ids, args.use_group_api);
                 default:
                     throw new Error(`Unknown tool: ${name}`);
             }
@@ -106,7 +137,7 @@ export class SystemStatusServer extends BaseAccessServer {
             return {
                 content: [
                     {
-                        type: 'text',
+                        type: "text",
                         text: `Error: ${handleApiError(error)}`,
                     },
                 ],
@@ -116,44 +147,55 @@ export class SystemStatusServer extends BaseAccessServer {
     async handleResourceRead(request) {
         const { uri } = request.params;
         switch (uri) {
-            case 'accessci://system-status':
+            case "accessci://system-status":
                 return {
                     contents: [
                         {
                             uri,
-                            mimeType: 'text/plain',
-                            text: 'ACCESS-CI System Status API - Monitor real-time status, outages, and maintenance for ACCESS-CI resources.',
+                            mimeType: "text/plain",
+                            text: "ACCESS-CI System Status API - Monitor real-time status, outages, and maintenance for ACCESS-CI resources.",
                         },
                     ],
                 };
-            case 'accessci://outages/current':
+            case "accessci://outages/current":
                 const currentOutages = await this.getCurrentOutages();
                 return {
                     contents: [
                         {
                             uri,
-                            mimeType: 'application/json',
+                            mimeType: "application/json",
                             text: currentOutages.content[0].text,
                         },
                     ],
                 };
-            case 'accessci://outages/scheduled':
+            case "accessci://outages/scheduled":
                 const scheduledMaintenance = await this.getScheduledMaintenance();
                 return {
                     contents: [
                         {
                             uri,
-                            mimeType: 'application/json',
+                            mimeType: "application/json",
                             text: scheduledMaintenance.content[0].text,
                         },
                     ],
                 };
+            case "accessci://outages/past":
+                const pastOutages = await this.getPastOutages();
+                return {
+                    contents: [
+                        {
+                            uri,
+                            mimeType: "application/json",
+                            text: pastOutages.content[0].text,
+                        },
+                    ],
+                };
             default:
                 throw new Error(`Unknown resource: ${uri}`);
         }
     }
     async getCurrentOutages(resourceFilter) {
-        const response = await this.httpClient.get('/wh2/news/v1/affiliation/access-ci.org/current_outages/');
+        const response = await this.httpClient.get("/wh2/news/v1/affiliation/access-ci.org/current_outages/");
         let outages = response.data.results || [];
         // Filter by resource if specified
         if (resourceFilter) {
@@ -172,16 +214,17 @@ export class SystemStatusServer extends BaseAccessServer {
                 affectedResources.add(resource.ResourceName);
             });
             // Categorize severity (basic heuristic)
-            const subject = outage.Subject?.toLowerCase() || '';
-            let severity = 'unknown';
-            if (subject.includes('emergency') || subject.includes('critical')) {
-                severity = 'high';
+            const subject = outage.Subject?.toLowerCase() || "";
+            let severity = "unknown";
+            if (subject.includes("emergency") || subject.includes("critical")) {
+                severity = "high";
             }
-            else if (subject.includes('maintenance') || subject.includes('scheduled')) {
-                severity = 'low';
+            else if (subject.includes("maintenance") ||
+                subject.includes("scheduled")) {
+                severity = "low";
             }
             else {
-                severity = 'medium';
+                severity = "medium";
             }
             severityCounts[severity]++;
             return {
@@ -195,22 +238,19 @@ export class SystemStatusServer extends BaseAccessServer {
             total_outages: outages.length,
             affected_resources: Array.from(affectedResources),
             severity_counts: severityCounts,
-            outages: enhancedOutages
+            outages: enhancedOutages,
         };
         return {
             content: [
                 {
-                    type: 'text',
-                    text: JSON.stringify({
-                        ...summary,
-                        affected_resources: summary.affected_resources
-                    }, null, 2),
+                    type: "text",
+                    text: JSON.stringify(summary, null, 2),
                 },
             ],
         };
     }
     async getScheduledMaintenance(resourceFilter) {
-        const response = await this.httpClient.get('/wh2/news/v1/affiliation/access-ci.org/future_outages/');
+        const response = await this.httpClient.get("/wh2/news/v1/affiliation/access-ci.org/future_outages/");
         let maintenance = response.data.results || [];
         // Filter by resource if specified
         if (resourceFilter) {
@@ -225,97 +265,217 @@ export class SystemStatusServer extends BaseAccessServer {
             const dateB = new Date(b.OutageStartDateTime || b.CreationTime);
             return dateA.getTime() - dateB.getTime();
         });
+        // Initialize tracking variables
+        const affectedResources = new Set();
+        let upcoming24h = 0;
+        let upcomingWeek = 0;
+        const enhancedMaintenance = maintenance.map((item) => {
+            // Track affected resources
+            item.AffectedResources?.forEach((resource) => {
+                affectedResources.add(resource.ResourceName);
+            });
+            // Check timing - only use OutageStartDateTime for scheduling, fallback shows warning
+            const hasScheduledTime = !!item.OutageStartDateTime;
+            const startTime = new Date(item.OutageStartDateTime || item.CreationTime);
+            const now = new Date();
+            const hoursUntil = (startTime.getTime() - now.getTime()) / (1000 * 60 * 60);
+            if (hoursUntil <= 24)
+                upcoming24h++;
+            if (hoursUntil <= 168)
+                upcomingWeek++; // 7 days * 24 hours
+            return {
+                ...item,
+                scheduled_start: item.OutageStartDateTime,
+                scheduled_end: item.OutageEndDateTime,
+                hours_until_start: Math.max(0, Math.round(hoursUntil)),
+                duration_hours: item.OutageEndDateTime && item.OutageStartDateTime
+                    ? Math.round((new Date(item.OutageEndDateTime).getTime() -
+                        new Date(item.OutageStartDateTime).getTime()) /
+                        (1000 * 60 * 60))
+                    : null,
+                has_scheduled_time: hasScheduledTime,
+            };
+        });
         const summary = {
             total_scheduled: maintenance.length,
-            upcoming_24h: 0,
-            upcoming_week: 0,
-            affected_resources: new Set(),
-            maintenance: maintenance.map((item) => {
-                // Track affected resources
-                item.AffectedResources?.forEach((resource) => {
-                    summary.affected_resources.add(resource.ResourceName);
-                });
-                // Check timing
-                const startTime = new Date(item.OutageStartDateTime || item.CreationTime);
-                const now = new Date();
-                const hoursUntil = (startTime.getTime() - now.getTime()) / (1000 * 60 * 60);
-                if (hoursUntil <= 24)
-                    summary.upcoming_24h++;
-                if (hoursUntil <= 168)
-                    summary.upcoming_week++; // 7 days * 24 hours
-                return {
-                    ...item,
-                    scheduled_start: item.OutageStartDateTime,
-                    scheduled_end: item.OutageEndDateTime,
-                    hours_until_start: Math.max(0, Math.round(hoursUntil)),
-                    duration_hours: item.OutageEndDateTime && item.OutageStartDateTime
-                        ? Math.round((new Date(item.OutageEndDateTime).getTime() -
-                            new Date(item.OutageStartDateTime).getTime()) / (1000 * 60 * 60))
-                        : null,
-                };
-            })
+            upcoming_24h: upcoming24h,
+            upcoming_week: upcomingWeek,
+            affected_resources: Array.from(affectedResources),
+            maintenance: enhancedMaintenance,
         };
         return {
             content: [
                 {
-                    type: 'text',
-                    text: JSON.stringify({
-                        ...summary,
-                        affected_resources: summary.affected_resources
-                    }, null, 2),
+                    type: "text",
+                    text: JSON.stringify(summary, null, 2),
+                },
+            ],
+        };
+    }
+    async getPastOutages(resourceFilter, limit = 100) {
+        const response = await this.httpClient.get("/wh2/news/v1/affiliation/access-ci.org/past_outages/");
+        let pastOutages = response.data.results || [];
+        // Filter by resource if specified
+        if (resourceFilter) {
+            const filter = resourceFilter.toLowerCase();
+            pastOutages = pastOutages.filter((outage) => outage.Subject?.toLowerCase().includes(filter) ||
+                outage.AffectedResources?.some((resource) => resource.ResourceName?.toLowerCase().includes(filter) ||
+                    resource.ResourceID?.toString().includes(filter)));
+        }
+        // Sort by outage end time (most recent first)
+        pastOutages.sort((a, b) => {
+            const dateA = new Date(a.OutageEndDateTime || a.LastModificationTime);
+            const dateB = new Date(b.OutageEndDateTime || b.LastModificationTime);
+            return dateB.getTime() - dateA.getTime();
+        });
+        // Apply limit
+        if (limit && pastOutages.length > limit) {
+            pastOutages = pastOutages.slice(0, limit);
+        }
+        // Initialize tracking variables
+        const affectedResources = new Set();
+        const outageTypes = new Set();
+        const recentOutages = pastOutages.filter((outage) => {
+            const endTime = new Date(outage.OutageEndDateTime || outage.LastModificationTime);
+            const daysAgo = (Date.now() - endTime.getTime()) / (1000 * 60 * 60 * 24);
+            return daysAgo <= 30; // Last 30 days
+        });
+        // Enhance outages with calculated fields
+        const enhancedOutages = pastOutages.map((outage) => {
+            // Track affected resources
+            outage.AffectedResources?.forEach((resource) => {
+                affectedResources.add(resource.ResourceName);
+            });
+            // Track outage types
+            if (outage.OutageType) {
+                outageTypes.add(outage.OutageType);
+            }
+            // Calculate duration
+            const startTime = new Date(outage.OutageStartDateTime);
+            const endTime = new Date(outage.OutageEndDateTime);
+            const durationHours = Math.round((endTime.getTime() - startTime.getTime()) / (1000 * 60 * 60));
+            // Calculate how long ago it ended
+            const daysAgo = Math.round((Date.now() - endTime.getTime()) / (1000 * 60 * 60 * 24));
+            return {
+                ...outage,
+                outage_start: outage.OutageStartDateTime,
+                outage_end: outage.OutageEndDateTime,
+                duration_hours: durationHours,
+                days_ago: daysAgo,
+                outage_type: outage.OutageType,
+                posted_time: outage.CreationTime,
+                last_updated: outage.LastModificationTime,
+            };
+        });
+        const summary = {
+            total_past_outages: enhancedOutages.length,
+            recent_outages_30_days: recentOutages.length,
+            affected_resources: Array.from(affectedResources),
+            outage_types: Array.from(outageTypes),
+            average_duration_hours: enhancedOutages.length > 0
+                ? Math.round(enhancedOutages
+                    .filter((o) => o.duration_hours > 0)
+                    .reduce((sum, o) => sum + o.duration_hours, 0) /
+                    enhancedOutages.filter((o) => o.duration_hours > 0).length)
+                : 0,
+            outages: enhancedOutages,
+        };
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify(summary, null, 2),
                 },
             ],
         };
     }
     async getSystemAnnouncements(limit = 50) {
-        // Get both current and future announcements
-        const [currentResponse, futureResponse] = await Promise.all([
-            this.httpClient.get('/wh2/news/v1/affiliation/access-ci.org/current_outages/'),
-            this.httpClient.get('/wh2/news/v1/affiliation/access-ci.org/future_outages/')
+        // Get current, future, and recent past announcements for comprehensive view
+        const [currentResponse, futureResponse, pastResponse] = await Promise.all([
+            this.httpClient.get("/wh2/news/v1/affiliation/access-ci.org/current_outages/"),
+            this.httpClient.get("/wh2/news/v1/affiliation/access-ci.org/future_outages/"),
+            this.httpClient.get("/wh2/news/v1/affiliation/access-ci.org/past_outages/"),
         ]);
         const currentOutages = currentResponse.data.results || [];
         const futureOutages = futureResponse.data.results || [];
-        // Combine and sort by creation time
-        const allAnnouncements = [...currentOutages, ...futureOutages]
+        const pastOutages = pastResponse.data.results || [];
+        // Filter recent past outages (last 30 days) for announcements
+        const recentPastOutages = pastOutages.filter((outage) => {
+            const endTime = new Date(outage.OutageEndDateTime || outage.LastModificationTime);
+            const daysAgo = (Date.now() - endTime.getTime()) / (1000 * 60 * 60 * 24);
+            return daysAgo <= 30;
+        });
+        // Combine all announcements and sort by most relevant date
+        const allAnnouncements = [
+            ...currentOutages.map((item) => ({ ...item, category: 'current' })),
+            ...futureOutages.map((item) => ({ ...item, category: 'scheduled' })),
+            ...recentPastOutages.map((item) => ({ ...item, category: 'recent_past' })),
+        ]
             .sort((a, b) => {
-            const dateA = new Date(a.CreationTime);
-            const dateB = new Date(b.CreationTime);
+            // Sort by most relevant date: current first, then future by start time, then past by end time
+            if (a.category === 'current' && b.category !== 'current')
+                return -1;
+            if (b.category === 'current' && a.category !== 'current')
+                return 1;
+            const dateA = new Date(a.OutageStartDateTime || a.CreationTime);
+            const dateB = new Date(b.OutageStartDateTime || b.CreationTime);
             return dateB.getTime() - dateA.getTime(); // Most recent first
         })
             .slice(0, limit);
+        const summary = {
+            total_announcements: allAnnouncements.length,
+            current_outages: currentOutages.length,
+            scheduled_maintenance: futureOutages.length,
+            recent_past_outages: recentPastOutages.length,
+            categories: {
+                current: allAnnouncements.filter(a => a.category === 'current').length,
+                scheduled: allAnnouncements.filter(a => a.category === 'scheduled').length,
+                recent_past: allAnnouncements.filter(a => a.category === 'recent_past').length,
+            },
+            announcements: allAnnouncements,
+        };
         return {
             content: [
                 {
-                    type: 'text',
-                    text: JSON.stringify({
-                        total_announcements: allAnnouncements.length,
-                        current_outages: currentOutages.length,
-                        scheduled_maintenance: futureOutages.length,
-                        announcements: allAnnouncements
-                    }, null, 2),
+                    type: "text",
+                    text: JSON.stringify(summary, null, 2),
                 },
             ],
         };
     }
-    async checkResourceStatus(resourceIds) {
-        // Get current outages to check against resource IDs
-        const currentOutages = await this.getCurrentOutages();
-        const outageData = JSON.parse(currentOutages.content[0].text);
-        const resourceStatus = resourceIds.map(resourceId => {
-            const affectedOutages = outageData.outages.filter((outage) => outage.AffectedResources?.some((resource) => resource.ResourceID?.toString() === resourceId ||
+    async checkResourceStatus(resourceIds, useGroupApi = false) {
+        if (useGroupApi) {
+            return await this.checkResourceStatusViaGroups(resourceIds);
+        }
+        // Efficient approach: fetch raw current outages data once
+        const response = await this.httpClient.get("/wh2/news/v1/affiliation/access-ci.org/current_outages/");
+        const rawOutages = response.data.results || [];
+        const resourceStatus = resourceIds.map((resourceId) => {
+            const affectedOutages = rawOutages.filter((outage) => outage.AffectedResources?.some((resource) => resource.ResourceID?.toString() === resourceId ||
                 resource.ResourceName?.toLowerCase().includes(resourceId.toLowerCase())));
-            let status = 'operational';
+            let status = "operational";
             let severity = null;
             if (affectedOutages.length > 0) {
-                status = 'affected';
-                // Get highest severity
-                const severities = affectedOutages.map((o) => o.severity);
-                if (severities.includes('high'))
-                    severity = 'high';
-                else if (severities.includes('medium'))
-                    severity = 'medium';
+                status = "affected";
+                // Get highest severity using same logic as getCurrentOutages
+                const severities = affectedOutages.map((outage) => {
+                    const subject = outage.Subject?.toLowerCase() || "";
+                    if (subject.includes("emergency") || subject.includes("critical")) {
+                        return "high";
+                    }
+                    else if (subject.includes("maintenance") || subject.includes("scheduled")) {
+                        return "low";
+                    }
+                    else {
+                        return "medium";
+                    }
+                });
+                if (severities.includes("high"))
+                    severity = "high";
+                else if (severities.includes("medium"))
+                    severity = "medium";
                 else
-                    severity = 'low';
+                    severity = "low";
             }
             return {
                 resource_id: resourceId,
@@ -324,21 +484,77 @@ export class SystemStatusServer extends BaseAccessServer {
                 active_outages: affectedOutages.length,
                 outage_details: affectedOutages.map((outage) => ({
                     subject: outage.Subject,
-                    severity: outage.severity,
-                    posted: outage.posted_time
-                }))
+                    severity,
+                    posted: outage.CreationTime,
+                    last_updated: outage.LastModificationTime,
+                })),
             };
         });
         return {
             content: [
                 {
-                    type: 'text',
+                    type: "text",
+                    text: JSON.stringify({
+                        checked_at: new Date().toISOString(),
+                        resources_checked: resourceIds.length,
+                        operational: resourceStatus.filter((r) => r.status === "operational").length,
+                        affected: resourceStatus.filter((r) => r.status === "affected")
+                            .length,
+                        api_method: "direct_outages_check",
+                        resource_status: resourceStatus,
+                    }, null, 2),
+                },
+            ],
+        };
+    }
+    async checkResourceStatusViaGroups(resourceIds) {
+        // Try to use the more efficient group-based API
+        const statusPromises = resourceIds.map(async (resourceId) => {
+            try {
+                const response = await this.httpClient.get(`/wh2/news/v1/info_groupid/${resourceId}/`);
+                const groupData = response.data.results || [];
+                const hasOutages = groupData.length > 0;
+                return {
+                    resource_id: resourceId,
+                    status: hasOutages ? "affected" : "operational",
+                    severity: hasOutages ? "medium" : null,
+                    active_outages: groupData.length,
+                    outage_details: groupData.map((outage) => ({
+                        subject: outage.Subject,
+                        posted: outage.CreationTime,
+                        last_updated: outage.LastModificationTime,
+                    })),
+                    api_method: "group_specific",
+                };
+            }
+            catch (error) {
+                // Fallback to general check if group API fails
+                return {
+                    resource_id: resourceId,
+                    status: "unknown",
+                    severity: null,
+                    active_outages: 0,
+                    outage_details: [],
+                    error: `Group API failed for ${resourceId}`,
+                    api_method: "group_specific_failed",
+                };
+            }
+        });
+        const resourceStatus = await Promise.all(statusPromises);
+        return {
+            content: [
+                {
+                    type: "text",
                     text: JSON.stringify({
                         checked_at: new Date().toISOString(),
                         resources_checked: resourceIds.length,
-                        operational: resourceStatus.filter(r => r.status === 'operational').length,
-                        affected: resourceStatus.filter(r => r.status === 'affected').length,
-                        resource_status: resourceStatus
+                        operational: resourceStatus.filter((r) => r.status === "operational").length,
+                        affected: resourceStatus.filter((r) => r.status === "affected")
+                            .length,
+                        unknown: resourceStatus.filter((r) => r.status === "unknown")
+                            .length,
+                        api_method: "resource_group_api",
+                        resource_status: resourceStatus,
                     }, null, 2),
                 },
             ],