@access-mcp/system-status 0.3.0 → 0.4.1

package/README.md

@@ -1,10 +1,44 @@
 # System Status MCP Server
 
-MCP server providing real-time system status information for ACCESS-CI resources.
+MCP server providing real-time system status information for ACCESS-CI resources. Provides critical operational information about ACCESS-CI systems, including current outages, scheduled maintenance, and system-wide announcements.
 
-## Overview
+## Usage Examples
+
+### **Monitor Current Issues**
+
+```
+"Are there any current outages on ACCESS-CI?"
+"Is Delta currently operational?"
+"What systems are experiencing issues right now?"
+"Show me all systems that are down"
+```
 
-This server provides critical operational information about ACCESS-CI systems, including current outages, scheduled maintenance, and system-wide announcements.
+### **Track Maintenance Windows**
+
+```
+"When is the next maintenance for Expanse?"
+"Show me all scheduled maintenance for this week"
+"Is there upcoming maintenance on Bridges-2?"
+"What maintenance is planned for GPU systems?"
+```
+
+### **System Announcements**
+
+```
+"What are the latest system announcements?"
+"Are there any important notices for ACCESS users?"
+"Show me recent updates about system changes"
+"Any policy updates I should know about?"
+```
+
+### **Check Resource Status**
+
+```
+"What's the current status of Anvil?"
+"Is Frontera available for job submission?"
+"Check if all GPU systems are operational"
+"Get status for all TACC resources"
+```
 
 ## Tools
 
@@ -16,6 +50,14 @@ Get current system outages and issues affecting ACCESS-CI resources.
 
 - `resource_filter` (string, optional): Filter by specific resource name or ID
 
+**Example:**
+```typescript
+// User: "Are there any current outages on Delta?"
+const outages = await get_current_outages({
+  resource_filter: "delta"
+});
+```
+
 ### get_scheduled_maintenance
 
 Get scheduled maintenance and future outages for ACCESS-CI resources.

package/dist/__tests__/server.integration.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/server.integration.test.js

@@ -0,0 +1,225 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { SystemStatusServer } from "../server.js";
+describe("SystemStatusServer Integration Tests", () => {
+    let server;
+    beforeEach(() => {
+        server = new SystemStatusServer();
+    });
+    describe("Real API Integration", () => {
+        it("should fetch current outages from real API", async () => {
+            const result = await server["handleToolCall"]({
+                params: {
+                    name: "get_current_outages",
+                    arguments: { limit: 5 }
+                }
+            });
+            const responseData = JSON.parse(result.content[0].text);
+            expect(responseData).toHaveProperty("total_outages");
+            expect(responseData).toHaveProperty("affected_resources");
+            expect(responseData).toHaveProperty("severity_counts");
+            expect(responseData.severity_counts).toHaveProperty("high");
+            expect(responseData.severity_counts).toHaveProperty("medium");
+            expect(responseData.severity_counts).toHaveProperty("low");
+            expect(responseData.severity_counts).toHaveProperty("unknown");
+            expect(Array.isArray(responseData.outages)).toBe(true);
+            // Check enhanced fields
+            if (responseData.outages.length > 0) {
+                const outage = responseData.outages[0];
+                expect(outage).toHaveProperty("severity");
+                expect(outage).toHaveProperty("posted_time");
+                expect(outage).toHaveProperty("last_updated");
+            }
+        }, 10000);
+        it("should fetch scheduled maintenance from real API", async () => {
+            const result = await server["handleToolCall"]({
+                params: {
+                    name: "get_scheduled_maintenance",
+                    arguments: { limit: 5 }
+                }
+            });
+            const responseData = JSON.parse(result.content[0].text);
+            expect(responseData).toHaveProperty("total_scheduled");
+            expect(responseData).toHaveProperty("upcoming_24h");
+            expect(responseData).toHaveProperty("upcoming_week");
+            expect(responseData).toHaveProperty("affected_resources");
+            expect(Array.isArray(responseData.maintenance)).toBe(true);
+            // Check enhanced fields
+            if (responseData.maintenance.length > 0) {
+                const maintenance = responseData.maintenance[0];
+                expect(maintenance).toHaveProperty("hours_until_start");
+                expect(maintenance).toHaveProperty("has_scheduled_time");
+                expect(maintenance.hours_until_start).toSatisfy((val) => val === null || typeof val === "number");
+            }
+        }, 10000);
+        it("should fetch past outages from real API", async () => {
+            const result = await server["handleToolCall"]({
+                params: {
+                    name: "get_past_outages",
+                    arguments: { limit: 10 }
+                }
+            });
+            const responseData = JSON.parse(result.content[0].text);
+            expect(responseData).toHaveProperty("total_past_outages");
+            expect(responseData).toHaveProperty("recent_outages_30_days");
+            expect(responseData).toHaveProperty("affected_resources");
+            expect(responseData).toHaveProperty("outage_types");
+            expect(responseData).toHaveProperty("average_duration_hours");
+            expect(Array.isArray(responseData.outages)).toBe(true);
+            // Check enhanced fields
+            if (responseData.outages.length > 0) {
+                const outage = responseData.outages[0];
+                expect(outage).toHaveProperty("duration_hours");
+                expect(outage).toHaveProperty("days_ago");
+                expect(outage).toHaveProperty("outage_type");
+                expect(outage.days_ago).toSatisfy((val) => val === null || typeof val === "number");
+            }
+        }, 10000);
+        it("should get comprehensive system announcements", async () => {
+            const result = await server["handleToolCall"]({
+                params: {
+                    name: "get_system_announcements",
+                    arguments: { limit: 20 }
+                }
+            });
+            const responseData = JSON.parse(result.content[0].text);
+            expect(responseData).toHaveProperty("total_announcements");
+            expect(responseData).toHaveProperty("current_outages");
+            expect(responseData).toHaveProperty("scheduled_maintenance");
+            expect(responseData).toHaveProperty("recent_past_outages");
+            expect(responseData).toHaveProperty("categories");
+            expect(responseData.categories).toHaveProperty("current");
+            expect(responseData.categories).toHaveProperty("scheduled");
+            expect(responseData.categories).toHaveProperty("recent_past");
+            expect(Array.isArray(responseData.announcements)).toBe(true);
+            // Check categorization
+            if (responseData.announcements.length > 0) {
+                const announcement = responseData.announcements[0];
+                expect(announcement).toHaveProperty("category");
+                expect(["current", "scheduled", "recent_past"]).toContain(announcement.category);
+            }
+        }, 15000);
+        it("should check resource status with direct method", async () => {
+            // Test with common resource names that might exist
+            const result = await server["handleToolCall"]({
+                params: {
+                    name: "check_resource_status",
+                    arguments: {
+                        resource_ids: ["anvil", "bridges", "jetstream"],
+                        use_group_api: false
+                    }
+                }
+            });
+            const responseData = JSON.parse(result.content[0].text);
+            expect(responseData).toHaveProperty("checked_at");
+            expect(responseData).toHaveProperty("resources_checked", 3);
+            expect(responseData).toHaveProperty("operational");
+            expect(responseData).toHaveProperty("affected");
+            expect(responseData).toHaveProperty("api_method", "direct_outages_check");
+            expect(Array.isArray(responseData.resource_status)).toBe(true);
+            expect(responseData.resource_status).toHaveLength(3);
+            // Check resource status structure
+            responseData.resource_status.forEach((resource) => {
+                expect(resource).toHaveProperty("resource_id");
+                expect(resource).toHaveProperty("status");
+                expect(["operational", "affected"]).toContain(resource.status);
+                expect(resource).toHaveProperty("active_outages");
+                expect(Array.isArray(resource.outage_details)).toBe(true);
+            });
+        }, 10000);
+        it("should test group API functionality", async () => {
+            // Test group API with a resource that might have a group ID
+            const result = await server["handleToolCall"]({
+                params: {
+                    name: "check_resource_status",
+                    arguments: {
+                        resource_ids: ["anvil"],
+                        use_group_api: true
+                    }
+                }
+            });
+            const responseData = JSON.parse(result.content[0].text);
+            expect(responseData).toHaveProperty("api_method", "resource_group_api");
+            expect(responseData).toHaveProperty("resources_checked", 1);
+            expect(responseData.resource_status).toHaveLength(1);
+            const resourceStatus = responseData.resource_status[0];
+            expect(resourceStatus).toHaveProperty("resource_id", "anvil");
+            expect(resourceStatus).toHaveProperty("api_method");
+            expect(["group_specific", "group_specific_failed"]).toContain(resourceStatus.api_method);
+            // If it succeeded, check structure
+            if (resourceStatus.api_method === "group_specific") {
+                expect(resourceStatus).toHaveProperty("status");
+                expect(["operational", "affected"]).toContain(resourceStatus.status);
+            }
+            // If it failed, check error handling
+            if (resourceStatus.api_method === "group_specific_failed") {
+                expect(resourceStatus.status).toBe("unknown");
+                expect(resourceStatus).toHaveProperty("error");
+            }
+        }, 10000);
+        it("should filter outages by resource correctly", async () => {
+            const result = await server["handleToolCall"]({
+                params: {
+                    name: "get_current_outages",
+                    arguments: { resource_filter: "anvil" }
+                }
+            });
+            const responseData = JSON.parse(result.content[0].text);
+            expect(responseData).toHaveProperty("total_outages");
+            // If there are any results, they should match the filter
+            responseData.outages.forEach((outage) => {
+                const matchesFilter = outage.Subject?.toLowerCase().includes("anvil") ||
+                    outage.AffectedResources?.some((resource) => resource.ResourceName?.toLowerCase().includes("anvil") ||
+                        resource.ResourceID?.toString().includes("anvil"));
+                expect(matchesFilter).toBe(true);
+            });
+        }, 10000);
+        it("should handle resource reads for all endpoints", async () => {
+            const resources = [
+                "accessci://system-status",
+                "accessci://outages/current",
+                "accessci://outages/scheduled",
+                "accessci://outages/past"
+            ];
+            for (const uri of resources) {
+                const result = await server["handleResourceRead"]({
+                    params: { uri }
+                });
+                expect(result.contents).toHaveLength(1);
+                expect(result.contents[0]).toHaveProperty("uri", uri);
+                expect(result.contents[0]).toHaveProperty("mimeType");
+                expect(result.contents[0]).toHaveProperty("text");
+                if (uri !== "accessci://system-status") {
+                    // JSON resources should have valid JSON
+                    expect(() => JSON.parse(result.contents[0].text)).not.toThrow();
+                }
+            }
+        }, 15000);
+    });
+    describe("Edge Cases and Error Handling", () => {
+        it("should handle empty API responses", async () => {
+            // This tests the robustness of our logic with potentially empty responses
+            const result = await server["handleToolCall"]({
+                params: {
+                    name: "get_current_outages",
+                    arguments: { resource_filter: "nonexistent-resource-xyz" }
+                }
+            });
+            const responseData = JSON.parse(result.content[0].text);
+            expect(responseData).toHaveProperty("total_outages", 0);
+            expect(responseData.outages).toHaveLength(0);
+            expect(responseData.affected_resources).toHaveLength(0);
+        }, 10000);
+        it("should handle large limit values gracefully", async () => {
+            const result = await server["handleToolCall"]({
+                params: {
+                    name: "get_past_outages",
+                    arguments: { limit: 1000 }
+                }
+            });
+            const responseData = JSON.parse(result.content[0].text);
+            expect(responseData).toHaveProperty("total_past_outages");
+            // Should not crash or timeout
+            expect(responseData.outages.length).toBeLessThanOrEqual(1000);
+        }, 15000);
+    });
+});

package/dist/__tests__/server.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/server.test.js

@@ -0,0 +1,380 @@
+import { describe, it, expect, beforeEach, vi, afterEach } from "vitest";
+import { SystemStatusServer } from "../server.js";
+// Mock axios
+vi.mock("axios");
+describe("SystemStatusServer", () => {
+    let server;
+    let mockHttpClient;
+    const mockCurrentOutagesData = [
+        {
+            id: "1",
+            Subject: "Emergency maintenance on Anvil",
+            Content: "Critical issue requiring immediate attention",
+            CreationTime: "2024-08-27T10:00:00Z",
+            LastModificationTime: "2024-08-27T11:00:00Z",
+            AffectedResources: [
+                { ResourceName: "Anvil", ResourceID: "anvil-1" }
+            ]
+        },
+        {
+            id: "2",
+            Subject: "Scheduled maintenance on Bridges-2",
+            Content: "Regular maintenance window",
+            CreationTime: "2024-08-27T08:00:00Z",
+            LastModificationTime: "2024-08-27T08:30:00Z",
+            AffectedResources: [
+                { ResourceName: "Bridges-2", ResourceID: "bridges2-1" }
+            ]
+        }
+    ];
+    const mockFutureOutagesData = [
+        {
+            id: "3",
+            Subject: "Scheduled Jetstream maintenance",
+            Content: "Planned maintenance",
+            CreationTime: "2024-08-27T09:00:00Z",
+            LastModificationTime: "2024-08-27T09:00:00Z",
+            OutageStartDateTime: "2024-08-30T10:00:00Z",
+            OutageEndDateTime: "2024-08-30T14:00:00Z",
+            AffectedResources: [
+                { ResourceName: "Jetstream", ResourceID: "jetstream-1" }
+            ]
+        }
+    ];
+    const mockPastOutagesData = [
+        {
+            id: "4",
+            Subject: "Past maintenance on Stampede3",
+            Content: "Completed maintenance",
+            CreationTime: new Date(Date.now() - 5 * 24 * 60 * 60 * 1000).toISOString(), // 5 days ago
+            LastModificationTime: new Date(Date.now() - 2 * 24 * 60 * 60 * 1000).toISOString(), // 2 days ago
+            OutageStartDateTime: new Date(Date.now() - 3 * 24 * 60 * 60 * 1000).toISOString(), // 3 days ago
+            OutageEndDateTime: new Date(Date.now() - 3 * 24 * 60 * 60 * 1000 + 6 * 60 * 60 * 1000).toISOString(), // 3 days ago + 6 hours  
+            OutageType: "Full",
+            AffectedResources: [
+                { ResourceName: "Stampede3", ResourceID: "stampede3-1" }
+            ]
+        }
+    ];
+    beforeEach(() => {
+        server = new SystemStatusServer();
+        // Set up mock HTTP client
+        mockHttpClient = {
+            get: vi.fn(),
+        };
+        // Override the httpClient getter
+        Object.defineProperty(server, "httpClient", {
+            get: () => mockHttpClient,
+            configurable: true,
+        });
+    });
+    afterEach(() => {
+        vi.clearAllMocks();
+    });
+    describe("Server Initialization", () => {
+        it("should initialize with correct server info", () => {
+            expect(server).toBeDefined();
+            expect(server["serverName"]).toBe("access-mcp-system-status");
+            expect(server["version"]).toBe("0.4.0");
+            expect(server["baseURL"]).toBe("https://operations-api.access-ci.org");
+        });
+        it("should provide correct tools", () => {
+            const tools = server["getTools"]();
+            expect(tools).toHaveLength(5);
+            expect(tools.map(t => t.name)).toEqual([
+                "get_current_outages",
+                "get_scheduled_maintenance",
+                "get_past_outages",
+                "get_system_announcements",
+                "check_resource_status"
+            ]);
+        });
+        it("should provide correct resources", () => {
+            const resources = server["getResources"]();
+            expect(resources).toHaveLength(4);
+            expect(resources.map(r => r.uri)).toEqual([
+                "accessci://system-status",
+                "accessci://outages/current",
+                "accessci://outages/scheduled",
+                "accessci://outages/past"
+            ]);
+        });
+    });
+    describe("getCurrentOutages", () => {
+        it("should fetch and enhance current outages", async () => {
+            mockHttpClient.get.mockResolvedValue({
+                status: 200,
+                data: { results: mockCurrentOutagesData }
+            });
+            const result = await server["handleToolCall"]({
+                params: { name: "get_current_outages", arguments: {} }
+            });
+            expect(mockHttpClient.get).toHaveBeenCalledWith("/wh2/news/v1/affiliation/access-ci.org/current_outages/");
+            const response = JSON.parse(result.content[0].text);
+            expect(response.total_outages).toBe(2);
+            expect(response.affected_resources).toEqual(["Anvil", "Bridges-2"]);
+            expect(response.severity_counts).toHaveProperty("high", 1); // Emergency
+            expect(response.severity_counts).toHaveProperty("low", 1); // Scheduled maintenance
+            expect(response.outages[0]).toHaveProperty("severity");
+            expect(response.outages[0]).toHaveProperty("posted_time");
+        });
+        it("should filter outages by resource", async () => {
+            mockHttpClient.get.mockResolvedValue({
+                status: 200,
+                data: { results: mockCurrentOutagesData }
+            });
+            const result = await server["handleToolCall"]({
+                params: {
+                    name: "get_current_outages",
+                    arguments: { resource_filter: "Anvil" }
+                }
+            });
+            const response = JSON.parse(result.content[0].text);
+            expect(response.total_outages).toBe(1);
+            expect(response.outages[0].Subject).toContain("Anvil");
+        });
+        it("should categorize severity correctly", async () => {
+            mockHttpClient.get.mockResolvedValue({
+                status: 200,
+                data: { results: mockCurrentOutagesData }
+            });
+            const result = await server["handleToolCall"]({
+                params: { name: "get_current_outages", arguments: {} }
+            });
+            const response = JSON.parse(result.content[0].text);
+            const emergencyOutage = response.outages.find((o) => o.Subject.includes("Emergency"));
+            const maintenanceOutage = response.outages.find((o) => o.Subject.includes("Scheduled"));
+            expect(emergencyOutage.severity).toBe("high");
+            expect(maintenanceOutage.severity).toBe("low");
+        });
+    });
+    describe("getScheduledMaintenance", () => {
+        it("should fetch and enhance scheduled maintenance", async () => {
+            mockHttpClient.get.mockResolvedValue({
+                status: 200,
+                data: { results: mockFutureOutagesData }
+            });
+            const result = await server["handleToolCall"]({
+                params: { name: "get_scheduled_maintenance", arguments: {} }
+            });
+            const response = JSON.parse(result.content[0].text);
+            expect(response.total_scheduled).toBe(1);
+            expect(response.affected_resources).toEqual(["Jetstream"]);
+            expect(response.maintenance[0]).toHaveProperty("hours_until_start");
+            expect(response.maintenance[0]).toHaveProperty("duration_hours", 4); // 10am to 2pm = 4 hours
+            expect(response.maintenance[0]).toHaveProperty("has_scheduled_time", true);
+        });
+        it("should handle missing scheduled times", async () => {
+            const dataWithoutSchedule = [{
+                    ...mockFutureOutagesData[0],
+                    OutageStartDateTime: null,
+                    OutageEndDateTime: null
+                }];
+            mockHttpClient.get.mockResolvedValue({
+                status: 200,
+                data: { results: dataWithoutSchedule }
+            });
+            const result = await server["handleToolCall"]({
+                params: { name: "get_scheduled_maintenance", arguments: {} }
+            });
+            const response = JSON.parse(result.content[0].text);
+            expect(response.maintenance[0].has_scheduled_time).toBe(false);
+            expect(response.maintenance[0].duration_hours).toBe(null);
+        });
+        it("should sort by scheduled start time", async () => {
+            const multipleMaintenanceData = [
+                {
+                    ...mockFutureOutagesData[0],
+                    OutageStartDateTime: "2024-08-31T10:00:00Z", // Later
+                    Subject: "Later maintenance"
+                },
+                {
+                    ...mockFutureOutagesData[0],
+                    OutageStartDateTime: "2024-08-30T10:00:00Z", // Earlier
+                    Subject: "Earlier maintenance"
+                }
+            ];
+            mockHttpClient.get.mockResolvedValue({
+                status: 200,
+                data: { results: multipleMaintenanceData }
+            });
+            const result = await server["handleToolCall"]({
+                params: { name: "get_scheduled_maintenance", arguments: {} }
+            });
+            const response = JSON.parse(result.content[0].text);
+            expect(response.maintenance[0].Subject).toBe("Earlier maintenance");
+            expect(response.maintenance[1].Subject).toBe("Later maintenance");
+        });
+    });
+    describe("getPastOutages", () => {
+        it("should fetch and enhance past outages", async () => {
+            mockHttpClient.get.mockResolvedValue({
+                status: 200,
+                data: { results: mockPastOutagesData }
+            });
+            const result = await server["handleToolCall"]({
+                params: { name: "get_past_outages", arguments: {} }
+            });
+            const response = JSON.parse(result.content[0].text);
+            expect(response.total_past_outages).toBe(1);
+            expect(response.outage_types).toEqual(["Full"]);
+            expect(response.average_duration_hours).toBe(6); // 6 hour duration
+            expect(response.outages[0]).toHaveProperty("duration_hours", 6);
+            expect(response.outages[0]).toHaveProperty("days_ago");
+        });
+        it("should apply limit correctly", async () => {
+            const manyOutages = Array(50).fill(0).map((_, i) => ({
+                ...mockPastOutagesData[0],
+                id: `past-${i}`,
+                Subject: `Past outage ${i}`
+            }));
+            mockHttpClient.get.mockResolvedValue({
+                status: 200,
+                data: { results: manyOutages }
+            });
+            const result = await server["handleToolCall"]({
+                params: {
+                    name: "get_past_outages",
+                    arguments: { limit: 10 }
+                }
+            });
+            const response = JSON.parse(result.content[0].text);
+            expect(response.outages).toHaveLength(10);
+        });
+    });
+    describe("getSystemAnnouncements", () => {
+        it("should combine current, future, and recent past outages", async () => {
+            mockHttpClient.get
+                .mockResolvedValueOnce({ status: 200, data: { results: mockCurrentOutagesData } })
+                .mockResolvedValueOnce({ status: 200, data: { results: mockFutureOutagesData } })
+                .mockResolvedValueOnce({ status: 200, data: { results: mockPastOutagesData } });
+            const result = await server["handleToolCall"]({
+                params: { name: "get_system_announcements", arguments: {} }
+            });
+            expect(mockHttpClient.get).toHaveBeenCalledTimes(3);
+            const response = JSON.parse(result.content[0].text);
+            expect(response.current_outages).toBe(2);
+            expect(response.scheduled_maintenance).toBe(1);
+            expect(response.recent_past_outages).toBe(1); // Within 30 days
+            expect(response.categories).toHaveProperty("current");
+            expect(response.categories).toHaveProperty("scheduled");
+            expect(response.categories).toHaveProperty("recent_past");
+        });
+        it("should prioritize current outages in sorting", async () => {
+            mockHttpClient.get
+                .mockResolvedValueOnce({ status: 200, data: { results: mockCurrentOutagesData } })
+                .mockResolvedValueOnce({ status: 200, data: { results: mockFutureOutagesData } })
+                .mockResolvedValueOnce({ status: 200, data: { results: mockPastOutagesData } });
+            const result = await server["handleToolCall"]({
+                params: { name: "get_system_announcements", arguments: {} }
+            });
+            const response = JSON.parse(result.content[0].text);
+            const firstAnnouncement = response.announcements[0];
+            expect(firstAnnouncement.category).toBe("current");
+        });
+    });
+    describe("checkResourceStatus", () => {
+        it("should check resource status efficiently (direct method)", async () => {
+            mockHttpClient.get.mockResolvedValue({
+                status: 200,
+                data: { results: mockCurrentOutagesData }
+            });
+            const result = await server["handleToolCall"]({
+                params: {
+                    name: "check_resource_status",
+                    arguments: { resource_ids: ["anvil-1", "unknown-resource"] }
+                }
+            });
+            const response = JSON.parse(result.content[0].text);
+            expect(response.api_method).toBe("direct_outages_check");
+            expect(response.resources_checked).toBe(2);
+            expect(response.operational).toBe(1); // unknown-resource
+            expect(response.affected).toBe(1); // anvil-1
+            const anvilStatus = response.resource_status.find((r) => r.resource_id === "anvil-1");
+            expect(anvilStatus.status).toBe("affected");
+            expect(anvilStatus.severity).toBe("high"); // Emergency maintenance
+        });
+        it("should use group API when requested", async () => {
+            mockHttpClient.get.mockResolvedValue({
+                status: 200,
+                data: { results: [] } // No outages for this group
+            });
+            const result = await server["handleToolCall"]({
+                params: {
+                    name: "check_resource_status",
+                    arguments: {
+                        resource_ids: ["anvil"],
+                        use_group_api: true
+                    }
+                }
+            });
+            expect(mockHttpClient.get).toHaveBeenCalledWith("/wh2/news/v1/info_groupid/anvil/");
+            const response = JSON.parse(result.content[0].text);
+            expect(response.api_method).toBe("resource_group_api");
+            expect(response.resource_status[0].status).toBe("operational");
+            expect(response.resource_status[0].api_method).toBe("group_specific");
+        });
+        it("should handle group API failures gracefully", async () => {
+            mockHttpClient.get.mockRejectedValue(new Error("API Error"));
+            const result = await server["handleToolCall"]({
+                params: {
+                    name: "check_resource_status",
+                    arguments: {
+                        resource_ids: ["invalid-resource"],
+                        use_group_api: true
+                    }
+                }
+            });
+            const response = JSON.parse(result.content[0].text);
+            expect(response.unknown).toBe(1);
+            expect(response.resource_status[0].status).toBe("unknown");
+            expect(response.resource_status[0].api_method).toBe("group_specific_failed");
+            expect(response.resource_status[0]).toHaveProperty("error");
+        });
+    });
+    describe("Error Handling", () => {
+        it("should handle API errors gracefully", async () => {
+            mockHttpClient.get.mockResolvedValue({
+                status: 500,
+                statusText: "Internal Server Error"
+            });
+            const result = await server["handleToolCall"]({
+                params: { name: "get_current_outages", arguments: {} }
+            });
+            expect(result.content[0].text).toContain("Error");
+        });
+        it("should handle network errors", async () => {
+            mockHttpClient.get.mockRejectedValue(new Error("Network error"));
+            const result = await server["handleToolCall"]({
+                params: { name: "get_current_outages", arguments: {} }
+            });
+            expect(result.content[0].text).toContain("Error");
+        });
+        it("should handle unknown tools", async () => {
+            const result = await server["handleToolCall"]({
+                params: { name: "unknown_tool", arguments: {} }
+            });
+            expect(result.content[0].text).toContain("Unknown tool");
+        });
+    });
+    describe("Resource Handling", () => {
+        it("should handle resource reads correctly", async () => {
+            mockHttpClient.get.mockResolvedValue({
+                status: 200,
+                data: { results: mockCurrentOutagesData }
+            });
+            const result = await server["handleResourceRead"]({
+                params: { uri: "accessci://outages/current" }
+            });
+            expect(result.contents[0].mimeType).toBe("application/json");
+            expect(result.contents[0].text).toBeDefined();
+        });
+        it("should handle unknown resources", async () => {
+            await expect(async () => {
+                await server["handleResourceRead"]({
+                    params: { uri: "accessci://unknown" }
+                });
+            }).rejects.toThrow("Unknown resource");
+        });
+    });
+});

package/dist/index.js

@@ -1,16 +1,15 @@
 #!/usr/bin/env node
 import { SystemStatusServer } from "./server.js";
-import { startWebServer } from "./web-server.js";
 async function main() {
-    // Check if we should run as web server (for deployment)
+    // Check if we should run as HTTP server (for deployment)
     const port = process.env.PORT;
+    const server = new SystemStatusServer();
     if (port) {
-        // Running in web mode (deployment)
-        startWebServer(parseInt(port));
+        // Running in HTTP mode (deployment)
+        await server.start({ httpPort: parseInt(port) });
     }
     else {
         // Running in MCP mode (stdio)
-        const server = new SystemStatusServer();
         await server.start();
     }
 }

package/dist/server.d.ts

@@ -13,6 +13,26 @@ export declare class SystemStatusServer extends BaseAccessServer {
                 };
                 limit?: undefined;
                 resource_ids?: undefined;
+                use_group_api?: undefined;
+            };
+            required: never[];
+        };
+    } | {
+        name: string;
+        description: string;
+        inputSchema: {
+            type: string;
+            properties: {
+                resource_filter: {
+                    type: string;
+                    description: string;
+                };
+                limit: {
+                    type: string;
+                    description: string;
+                };
+                resource_ids?: undefined;
+                use_group_api?: undefined;
             };
             required: never[];
         };
@@ -28,6 +48,7 @@ export declare class SystemStatusServer extends BaseAccessServer {
                 };
                 resource_filter?: undefined;
                 resource_ids?: undefined;
+                use_group_api?: undefined;
             };
             required: never[];
         };
@@ -44,6 +65,11 @@ export declare class SystemStatusServer extends BaseAccessServer {
                     };
                     description: string;
                 };
+                use_group_api: {
+                    type: string;
+                    description: string;
+                    default: boolean;
+                };
                 resource_filter?: undefined;
                 limit?: undefined;
             };
@@ -71,6 +97,8 @@ export declare class SystemStatusServer extends BaseAccessServer {
     }>;
     private getCurrentOutages;
     private getScheduledMaintenance;
+    private getPastOutages;
     private getSystemAnnouncements;
     private checkResourceStatus;
+    private checkResourceStatusViaGroups;
 }

package/dist/server.js

@@ -1,7 +1,7 @@
 import { BaseAccessServer, handleApiError } from "@access-mcp/shared";
 export class SystemStatusServer extends BaseAccessServer {
     constructor() {
-        super("access-mcp-system-status", "0.3.0", "https://operations-api.access-ci.org");
+        super("access-mcp-system-status", "0.4.0", "https://operations-api.access-ci.org");
     }
     getTools() {
         return [
@@ -33,6 +33,24 @@ export class SystemStatusServer extends BaseAccessServer {
                     required: [],
                 },
             },
+            {
+                name: "get_past_outages",
+                description: "Get historical outages and past incidents affecting ACCESS-CI resources",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        resource_filter: {
+                            type: "string",
+                            description: "Optional: filter by specific resource name or ID",
+                        },
+                        limit: {
+                            type: "number",
+                            description: "Maximum number of past outages to return (default: 100)",
+                        },
+                    },
+                    required: [],
+                },
+            },
             {
                 name: "get_system_announcements",
                 description: "Get all system announcements (current and scheduled)",
@@ -56,7 +74,12 @@ export class SystemStatusServer extends BaseAccessServer {
                         resource_ids: {
                             type: "array",
                             items: { type: "string" },
-                            description: "List of resource IDs to check status for",
+                            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"],
@@ -84,6 +107,12 @@ export class SystemStatusServer extends BaseAccessServer {
                 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",
+            },
         ];
     }
     async handleToolCall(request) {
@@ -94,10 +123,12 @@ export class SystemStatusServer extends BaseAccessServer {
                     return await this.getCurrentOutages(args.resource_filter);
                 case "get_scheduled_maintenance":
                     return await this.getScheduledMaintenance(args.resource_filter);
+                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);
+                    return await this.checkResourceStatus(args.resource_ids, args.use_group_api);
                 default:
                     throw new Error(`Unknown tool: ${name}`);
             }
@@ -148,6 +179,17 @@ export class SystemStatusServer extends BaseAccessServer {
                         },
                     ],
                 };
+            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}`);
         }
@@ -188,8 +230,8 @@ export class SystemStatusServer extends BaseAccessServer {
             return {
                 ...outage,
                 severity,
-                posted_time: outage.CreationTime,
-                last_updated: outage.LastModificationTime,
+                posted_time: outage.CreationTime || outage.DateTime || outage.created_at || outage.date_posted,
+                last_updated: outage.LastModificationTime || outage.DateTime || outage.updated_at || outage.date_modified,
             };
         });
         const summary = {
@@ -202,10 +244,7 @@ export class SystemStatusServer extends BaseAccessServer {
             content: [
                 {
                     type: "text",
-                    text: JSON.stringify({
-                        ...summary,
-                        affected_resources: summary.affected_resources,
-                    }, null, 2),
+                    text: JSON.stringify(summary, null, 2),
                 },
             ],
         };
@@ -226,92 +265,211 @@ 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),
+                    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([
+        // 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),
+                    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);
+    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 = outageData.outages.filter((outage) => outage.AffectedResources?.some((resource) => resource.ResourceID?.toString() === resourceId ||
+            const affectedOutages = rawOutages.filter((outage) => outage.AffectedResources?.some((resource) => resource.ResourceID?.toString() === resourceId ||
                 resource.ResourceName?.toLowerCase().includes(resourceId.toLowerCase())));
             let status = "operational";
             let severity = null;
             if (affectedOutages.length > 0) {
                 status = "affected";
-                // Get highest severity
-                const severities = affectedOutages.map((o) => o.severity);
+                // 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"))
@@ -326,8 +484,9 @@ 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,
                 })),
             };
         });
@@ -341,6 +500,60 @@ export class SystemStatusServer extends BaseAccessServer {
                         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,
+                        unknown: resourceStatus.filter((r) => r.status === "unknown")
+                            .length,
+                        api_method: "resource_group_api",
                         resource_status: resourceStatus,
                     }, null, 2),
                 },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@access-mcp/system-status",
-  "version": "0.3.0",
+  "version": "0.4.1",
   "description": "MCP server for ACCESS-CI System Status and Outages API",
   "type": "module",
   "main": "dist/index.js",
@@ -13,6 +13,14 @@
   ],
   "scripts": {
     "build": "tsc",
+    "start": "node dist/index.js",
+    "dev": "npm run build && npm start",
+    "test": "vitest run --exclude '**/**.integration.test.ts'",
+    "test:integration": "vitest run --config vitest.integration.config.ts",
+    "test:all": "vitest run",
+    "test:watch": "vitest",
+    "test:ui": "vitest --ui",
+    "test:coverage": "vitest run --coverage --exclude '**/**.integration.test.ts'",
     "prepublishOnly": "npm run build"
   },
   "keywords": [
@@ -38,5 +46,12 @@
   "dependencies": {
     "@access-mcp/shared": "^0.3.0",
     "express": "^4.18.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "@vitest/ui": "^2.1.9",
+    "c8": "^10.1.3",
+    "typescript": "^5.0.0",
+    "vitest": "^2.1.9"
   }
 }