@access-mcp/system-status 0.5.0 → 0.5.1

package/README.md

@@ -1,11 +1,10 @@
 # System Status MCP Server
 
-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.
+MCP server for real-time ACCESS-CI system status including current outages, scheduled maintenance, and operational status.
 
 ## Usage Examples
 
-### **Current Status**
-
+### Current Status
 ```
 "Current ACCESS-CI outages"
 "Delta operational status"
@@ -13,8 +12,7 @@ MCP server providing real-time system status information for ACCESS-CI resources
 "GPU systems status check"
 ```
 
-### **Maintenance & Incidents**
-
+### Maintenance & Incidents
 ```
 "Scheduled maintenance this week"
 "Next Expanse maintenance window"
@@ -24,36 +22,33 @@ MCP server providing real-time system status information for ACCESS-CI resources
 
 ## Tools
 
-### get_infrastructure_news
+### `get_infrastructure_news`
 
-Comprehensive ACCESS-CI infrastructure status and outage information. Get current outages, scheduled maintenance, past incidents, and operational status for ACCESS-CI resources. Provides real-time monitoring of system health and availability.
+Get infrastructure status, outages, and maintenance information for ACCESS-CI resources.
 
 **Parameters:**
-
-- `resource` (string, optional): Filter by specific resource name or ID (e.g., 'delta', 'bridges2')
-- `time` (string, optional): Time period for infrastructure news: 'current' (active outages), 'scheduled' (future maintenance), 'past' (historical incidents), 'all' (comprehensive overview). Default: 'current'
-- `resource_ids` (array of strings, optional): Check operational status for specific resource IDs (returns 'operational' or 'affected' status). Use instead of 'resource' parameter for status checking
-- `limit` (number, optional): Maximum number of items to return (default: 50 for 'all', 100 for 'past')
-- `use_group_api` (boolean, optional): Use resource group API for status checking (only with resource_ids parameter, default: false)
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `resource` | string | Filter by resource name (e.g., "delta", "bridges2") |
+| `time` | enum | Time period: `current`, `scheduled`, `past`, `all` (default: "current") |
+| `resource_ids` | array | Check status for specific resource IDs |
+| `limit` | number | Max results (default: 50 for "all", 100 for "past") |
+| `use_group_api` | boolean | Use resource group API for status checking (default: false) |
 
 **Examples:**
-
-```typescript
+```javascript
 // Get current outages across all resources
 get_infrastructure_news({})
 
 // Get scheduled maintenance
 get_infrastructure_news({ time: "scheduled" })
 
-// Get comprehensive overview of all infrastructure news
+// Get comprehensive overview
 get_infrastructure_news({ time: "all" })
 
 // Check current status for specific resource
 get_infrastructure_news({ resource: "delta", time: "current" })
 
-// Get all news for specific resource
-get_infrastructure_news({ resource: "delta", time: "all" })
-
 // Check operational status of specific resources
 get_infrastructure_news({
   resource_ids: ["delta.ncsa.access-ci.org", "bridges2.psc.access-ci.org"]
@@ -63,10 +58,6 @@ get_infrastructure_news({
 get_infrastructure_news({ time: "past", limit: 50 })
 ```
 
-## Resources
-
-- `accessci://system-status`: Current operational status of all ACCESS-CI resources
-
 ## Installation
 
 ```bash
@@ -75,8 +66,6 @@ npm install -g @access-mcp/system-status
 
 ## Configuration
 
-Add to your Claude Desktop configuration:
-
 ```json
 {
   "mcpServers": {
@@ -88,111 +77,6 @@ Add to your Claude Desktop configuration:
 }
 ```
 
-## Usage Examples
-
-### 🚨 **Monitor Current Issues**
-
-- "Are there any current outages on ACCESS-CI?"
-- "Is Delta currently operational?"
-- "What systems are experiencing issues right now?"
-
-### 🔧 **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?"
-
-### 📢 **System Announcements**
-
-- "What are the latest system announcements?"
-- "Are there any important notices for ACCESS users?"
-- "Show me recent updates about system changes"
-
-### ✅ **Check Resource Status**
-
-- "What's the current status of Anvil?"
-- "Is Frontera available for job submission?"
-- "Check if all GPU systems are operational"
-
-## Detailed Usage Examples
-
-### Checking Current Outages
-
-**Natural Language**: "Are there any systems down right now?"
-
-**Tool Call**:
-```typescript
-const outages = await get_infrastructure_news({});
-// or explicitly: get_infrastructure_news({ time: "current" })
-```
-
-**Returns**: List of active outages with:
-- Affected resources
-- Severity categorization (high/medium/low)
-- Start time and expected resolution
-- Impact description
-- Summary statistics (total outages, affected resources)
-
-### Finding Scheduled Maintenance
-
-**Natural Language**: "When is Delta scheduled for maintenance?"
-
-**Tool Call**:
-```typescript
-const maintenance = await get_infrastructure_news({
-  resource: "delta",
-  time: "scheduled"
-});
-```
-
-**Returns**: Upcoming maintenance windows including:
-- Scheduled start and end times
-- Systems affected
-- Duration in hours
-- Hours until maintenance starts
-- Summary (upcoming in 24h, upcoming this week)
-
-### Getting Comprehensive System Overview
-
-**Natural Language**: "What are the latest announcements?"
-
-**Tool Call**:
-```typescript
-const announcements = await get_infrastructure_news({
-  time: "all",
-  limit: 10
-});
-```
-
-**Returns**: Comprehensive overview including:
-- Current outages
-- Scheduled maintenance
-- Recent past outages (last 30 days)
-- Category breakdown
-- Sorted by relevance (current issues first)
-
-### Checking Specific Resource Status
-
-**Natural Language**: "Is Expanse available?"
-
-**Tool Call**:
-```typescript
-const status = await get_infrastructure_news({
-  resource_ids: ["expanse.sdsc.access-ci.org"]
-});
-```
-
-**Returns**: Current operational status:
-- Overall status ("operational" or "affected")
-- Severity level if affected
-- Number of active outages
-- Outage details with subjects
-- Timestamp of status check
-
-## API Endpoints
-
-This server connects to the ACCESS-CI Operations API at `https://operations-api.access-ci.org`
-
-## License
+## Resources
 
-MIT
+- `accessci://system-status` - Current operational status of all ACCESS-CI resources

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

@@ -8,12 +8,14 @@ describe("SystemStatusServer Integration Tests", () => {
     describe("Real API Integration", () => {
         it("should fetch current outages from real API", async () => {
             const result = await server["handleToolCall"]({
+                method: "tools/call",
                 params: {
                     name: "get_infrastructure_news",
-                    arguments: { time: "current", limit: 5 }
-                }
+                    arguments: { time: "current", limit: 5 },
+                },
             });
-            const responseData = JSON.parse(result.content[0].text);
+            const content = result.content[0];
+            const responseData = JSON.parse(content.text);
             expect(responseData).toHaveProperty("total_outages");
             expect(responseData).toHaveProperty("affected_resources");
             expect(responseData).toHaveProperty("severity_counts");
@@ -32,11 +34,14 @@ describe("SystemStatusServer Integration Tests", () => {
         }, 10000);
         it("should fetch scheduled maintenance from real API", async () => {
             const result = await server["handleToolCall"]({
+                method: "tools/call",
                 params: {
-                    name: "get_infrastructure_news", arguments: { time: "scheduled", limit: 5 }
-                }
+                    name: "get_infrastructure_news",
+                    arguments: { time: "scheduled", limit: 5 },
+                },
             });
-            const responseData = JSON.parse(result.content[0].text);
+            const content = result.content[0];
+            const responseData = JSON.parse(content.text);
             expect(responseData).toHaveProperty("total_scheduled");
             expect(responseData).toHaveProperty("upcoming_24h");
             expect(responseData).toHaveProperty("upcoming_week");
@@ -52,11 +57,14 @@ describe("SystemStatusServer Integration Tests", () => {
         }, 10000);
         it("should fetch past outages from real API", async () => {
             const result = await server["handleToolCall"]({
+                method: "tools/call",
                 params: {
-                    name: "get_infrastructure_news", arguments: { time: "past", limit: 5 }
-                }
+                    name: "get_infrastructure_news",
+                    arguments: { time: "past", limit: 5 },
+                },
             });
-            const responseData = JSON.parse(result.content[0].text);
+            const content = result.content[0];
+            const responseData = JSON.parse(content.text);
             expect(responseData).toHaveProperty("total_past_outages");
             expect(responseData).toHaveProperty("recent_outages_30_days");
             expect(responseData).toHaveProperty("affected_resources");
@@ -74,12 +82,14 @@ describe("SystemStatusServer Integration Tests", () => {
         }, 10000);
         it("should get comprehensive system announcements", async () => {
             const result = await server["handleToolCall"]({
+                method: "tools/call",
                 params: {
                     name: "get_infrastructure_news",
-                    arguments: { time: "all", limit: 20 }
-                }
+                    arguments: { time: "all", limit: 20 },
+                },
             });
-            const responseData = JSON.parse(result.content[0].text);
+            const content = result.content[0];
+            const responseData = JSON.parse(content.text);
             expect(responseData).toHaveProperty("total_announcements");
             expect(responseData).toHaveProperty("current_outages");
             expect(responseData).toHaveProperty("scheduled_maintenance");
@@ -99,15 +109,17 @@ describe("SystemStatusServer Integration Tests", () => {
         it("should check resource status with direct method", async () => {
             // Test with common resource names that might exist
             const result = await server["handleToolCall"]({
+                method: "tools/call",
                 params: {
                     name: "get_infrastructure_news",
                     arguments: {
                         ids: ["anvil", "bridges", "jetstream"],
-                        use_group_api: false
-                    }
-                }
+                        use_group_api: false,
+                    },
+                },
             });
-            const responseData = JSON.parse(result.content[0].text);
+            const content = result.content[0];
+            const responseData = JSON.parse(content.text);
             expect(responseData).toHaveProperty("checked_at");
             expect(responseData).toHaveProperty("resources_checked", 3);
             expect(responseData).toHaveProperty("operational");
@@ -127,15 +139,17 @@ describe("SystemStatusServer Integration Tests", () => {
         it("should test group API functionality", async () => {
             // Test group API with a resource that might have a group ID
             const result = await server["handleToolCall"]({
+                method: "tools/call",
                 params: {
                     name: "get_infrastructure_news",
                     arguments: {
                         ids: ["anvil"],
-                        use_group_api: true
-                    }
-                }
+                        use_group_api: true,
+                    },
+                },
             });
-            const responseData = JSON.parse(result.content[0].text);
+            const content = result.content[0];
+            const responseData = JSON.parse(content.text);
             expect(responseData).toHaveProperty("api_method", "resource_group_api");
             expect(responseData).toHaveProperty("resources_checked", 1);
             expect(responseData.resource_status).toHaveLength(1);
@@ -156,12 +170,14 @@ describe("SystemStatusServer Integration Tests", () => {
         }, 10000);
         it("should filter outages by resource correctly", async () => {
             const result = await server["handleToolCall"]({
+                method: "tools/call",
                 params: {
                     name: "get_infrastructure_news",
-                    arguments: { time: "current", query: "anvil" }
-                }
+                    arguments: { time: "current", query: "anvil" },
+                },
             });
-            const responseData = JSON.parse(result.content[0].text);
+            const content = result.content[0];
+            const responseData = JSON.parse(content.text);
             expect(responseData).toHaveProperty("total_outages");
             // If there are any results, they should match the filter
             if (responseData.outages.length > 0) {
@@ -178,11 +194,12 @@ describe("SystemStatusServer Integration Tests", () => {
                 "accessci://system-status",
                 "accessci://outages/current",
                 "accessci://outages/scheduled",
-                "accessci://outages/past"
+                "accessci://outages/past",
             ];
             for (const uri of resources) {
                 const result = await server["handleResourceRead"]({
-                    params: { uri }
+                    method: "resources/read",
+                    params: { uri },
                 });
                 expect(result.contents).toHaveLength(1);
                 expect(result.contents[0]).toHaveProperty("uri", uri);
@@ -199,24 +216,28 @@ describe("SystemStatusServer Integration Tests", () => {
         it("should handle empty API responses", async () => {
             // This tests the robustness of our logic with potentially empty responses
             const result = await server["handleToolCall"]({
+                method: "tools/call",
                 params: {
                     name: "get_infrastructure_news",
-                    arguments: { time: "current", query: "nonexistent-resource-xyz-12345" }
-                }
+                    arguments: { time: "current", query: "nonexistent-resource-xyz-12345" },
+                },
             });
-            const responseData = JSON.parse(result.content[0].text);
+            const content = result.content[0];
+            const responseData = JSON.parse(content.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"]({
+                method: "tools/call",
                 params: {
                     name: "get_infrastructure_news",
-                    arguments: { time: "past", limit: 1000 }
-                }
+                    arguments: { time: "past", limit: 1000 },
+                },
             });
-            const responseData = JSON.parse(result.content[0].text);
+            const content = result.content[0];
+            const responseData = JSON.parse(content.text);
             expect(responseData).toHaveProperty("total_past_outages");
             // Should not crash or timeout
             expect(responseData.outages.length).toBeLessThanOrEqual(1000);

package/dist/__tests__/server.test.js

@@ -1,5 +1,8 @@
 import { describe, it, expect, beforeEach, vi, afterEach } from "vitest";
 import { SystemStatusServer } from "../server.js";
+import { createRequire } from "module";
+const require = createRequire(import.meta.url);
+const { version } = require("../../package.json");
 // Mock axios
 vi.mock("axios");
 describe("SystemStatusServer", () => {
@@ -12,9 +15,7 @@ describe("SystemStatusServer", () => {
             Content: "Critical issue requiring immediate attention",
             OutageStart: "2024-08-27T10:00:00Z",
             OutageEnd: "2024-08-27T11:00:00Z",
-            AffectedResources: [
-                { ResourceName: "Anvil", ResourceID: "anvil-1" }
-            ]
+            AffectedResources: [{ ResourceName: "Anvil", ResourceID: "anvil-1" }],
         },
         {
             id: "2",
@@ -22,10 +23,8 @@ describe("SystemStatusServer", () => {
             Content: "Regular maintenance window",
             OutageStart: "2024-08-27T08:00:00Z",
             OutageEnd: "2024-08-27T08:30:00Z",
-            AffectedResources: [
-                { ResourceName: "Bridges-2", ResourceID: "bridges2-1" }
-            ]
-        }
+            AffectedResources: [{ ResourceName: "Bridges-2", ResourceID: "bridges2-1" }],
+        },
     ];
     const mockFutureOutagesData = [
         {
@@ -34,10 +33,8 @@ describe("SystemStatusServer", () => {
             Content: "Planned maintenance",
             OutageStart: "2024-08-30T10:00:00Z",
             OutageEnd: "2024-08-30T14:00:00Z",
-            AffectedResources: [
-                { ResourceName: "Jetstream", ResourceID: "jetstream-1" }
-            ]
-        }
+            AffectedResources: [{ ResourceName: "Jetstream", ResourceID: "jetstream-1" }],
+        },
     ];
     const mockPastOutagesData = [
         {
@@ -47,10 +44,8 @@ describe("SystemStatusServer", () => {
             OutageStart: new Date(Date.now() - 3 * 24 * 60 * 60 * 1000).toISOString(), // 3 days ago
             OutageEnd: 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" }
-            ]
-        }
+            AffectedResources: [{ ResourceName: "Stampede3", ResourceID: "stampede3-1" }],
+        },
     ];
     beforeEach(() => {
         server = new SystemStatusServer();
@@ -71,7 +66,7 @@ describe("SystemStatusServer", () => {
         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["version"]).toBe(version);
             expect(server["baseURL"]).toBe("https://operations-api.access-ci.org");
         });
         it("should provide correct tools", () => {
@@ -82,11 +77,11 @@ describe("SystemStatusServer", () => {
         it("should provide correct resources", () => {
             const resources = server["getResources"]();
             expect(resources).toHaveLength(4);
-            expect(resources.map(r => r.uri)).toEqual([
+            expect(resources.map((r) => r.uri)).toEqual([
                 "accessci://system-status",
                 "accessci://outages/current",
                 "accessci://outages/scheduled",
-                "accessci://outages/past"
+                "accessci://outages/past",
             ]);
         });
     });
@@ -94,13 +89,15 @@ describe("SystemStatusServer", () => {
         it("should fetch and enhance current outages", async () => {
             mockHttpClient.get.mockResolvedValue({
                 status: 200,
-                data: { results: mockCurrentOutagesData }
+                data: { results: mockCurrentOutagesData },
             });
             const result = await server["handleToolCall"]({
-                params: { name: "get_infrastructure_news", arguments: { time: "current" } }
+                method: "tools/call",
+                params: { name: "get_infrastructure_news", arguments: { time: "current" } },
             });
             expect(mockHttpClient.get).toHaveBeenCalledWith("/wh2/news/v1/affiliation/access-ci.org/current_outages/");
-            const response = JSON.parse(result.content[0].text);
+            const content = result.content[0];
+            const response = JSON.parse(content.text);
             expect(response.total_outages).toBe(2);
             expect(response.affected_resources).toEqual(["Anvil", "Bridges-2"]);
             expect(response.severity_counts).toHaveProperty("high", 1); // Emergency
@@ -110,27 +107,31 @@ describe("SystemStatusServer", () => {
         it("should filter outages by resource", async () => {
             mockHttpClient.get.mockResolvedValue({
                 status: 200,
-                data: { results: mockCurrentOutagesData }
+                data: { results: mockCurrentOutagesData },
             });
             const result = await server["handleToolCall"]({
+                method: "tools/call",
                 params: {
                     name: "get_infrastructure_news",
-                    arguments: { query: "Anvil", time: "current" }
-                }
+                    arguments: { query: "Anvil", time: "current" },
+                },
             });
-            const response = JSON.parse(result.content[0].text);
+            const content = result.content[0];
+            const response = JSON.parse(content.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 }
+                data: { results: mockCurrentOutagesData },
             });
             const result = await server["handleToolCall"]({
-                params: { name: "get_infrastructure_news", arguments: { time: "current" } }
+                method: "tools/call",
+                params: { name: "get_infrastructure_news", arguments: { time: "current" } },
             });
-            const response = JSON.parse(result.content[0].text);
+            const content = result.content[0];
+            const response = JSON.parse(content.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");
@@ -141,12 +142,14 @@ describe("SystemStatusServer", () => {
         it("should fetch and enhance scheduled maintenance", async () => {
             mockHttpClient.get.mockResolvedValue({
                 status: 200,
-                data: { results: mockFutureOutagesData }
+                data: { results: mockFutureOutagesData },
             });
             const result = await server["handleToolCall"]({
-                params: { name: "get_infrastructure_news", arguments: { time: "scheduled" } }
+                method: "tools/call",
+                params: { name: "get_infrastructure_news", arguments: { time: "scheduled" } },
             });
-            const response = JSON.parse(result.content[0].text);
+            const content = result.content[0];
+            const response = JSON.parse(content.text);
             expect(response.total_scheduled).toBe(1);
             expect(response.affected_resources).toEqual(["Jetstream"]);
             expect(response.maintenance[0]).toHaveProperty("hours_until_start");
@@ -154,19 +157,23 @@ describe("SystemStatusServer", () => {
             expect(response.maintenance[0]).toHaveProperty("has_scheduled_time", true);
         });
         it("should handle missing scheduled times", async () => {
-            const dataWithoutSchedule = [{
+            const dataWithoutSchedule = [
+                {
                     ...mockFutureOutagesData[0],
                     OutageStart: null,
-                    OutageEnd: null
-                }];
+                    OutageEnd: null,
+                },
+            ];
             mockHttpClient.get.mockResolvedValue({
                 status: 200,
-                data: { results: dataWithoutSchedule }
+                data: { results: dataWithoutSchedule },
             });
             const result = await server["handleToolCall"]({
-                params: { name: "get_infrastructure_news", arguments: { time: "scheduled" } }
+                method: "tools/call",
+                params: { name: "get_infrastructure_news", arguments: { time: "scheduled" } },
             });
-            const response = JSON.parse(result.content[0].text);
+            const content = result.content[0];
+            const response = JSON.parse(content.text);
             expect(response.maintenance[0].has_scheduled_time).toBe(false);
             expect(response.maintenance[0].duration_hours).toBe(null);
         });
@@ -175,22 +182,24 @@ describe("SystemStatusServer", () => {
                 {
                     ...mockFutureOutagesData[0],
                     OutageStart: "2024-08-31T10:00:00Z", // Later
-                    Subject: "Later maintenance"
+                    Subject: "Later maintenance",
                 },
                 {
                     ...mockFutureOutagesData[0],
                     OutageStart: "2024-08-30T10:00:00Z", // Earlier
-                    Subject: "Earlier maintenance"
-                }
+                    Subject: "Earlier maintenance",
+                },
             ];
             mockHttpClient.get.mockResolvedValue({
                 status: 200,
-                data: { results: multipleMaintenanceData }
+                data: { results: multipleMaintenanceData },
             });
             const result = await server["handleToolCall"]({
-                params: { name: "get_infrastructure_news", arguments: { time: "scheduled" } }
+                method: "tools/call",
+                params: { name: "get_infrastructure_news", arguments: { time: "scheduled" } },
             });
-            const response = JSON.parse(result.content[0].text);
+            const content = result.content[0];
+            const response = JSON.parse(content.text);
             expect(response.maintenance[0].Subject).toBe("Earlier maintenance");
             expect(response.maintenance[1].Subject).toBe("Later maintenance");
         });
@@ -199,12 +208,14 @@ describe("SystemStatusServer", () => {
         it("should fetch and enhance past outages", async () => {
             mockHttpClient.get.mockResolvedValue({
                 status: 200,
-                data: { results: mockPastOutagesData }
+                data: { results: mockPastOutagesData },
             });
             const result = await server["handleToolCall"]({
-                params: { name: "get_infrastructure_news", arguments: { time: "past" } }
+                method: "tools/call",
+                params: { name: "get_infrastructure_news", arguments: { time: "past" } },
             });
-            const response = JSON.parse(result.content[0].text);
+            const content = result.content[0];
+            const response = JSON.parse(content.text);
             expect(response.total_past_outages).toBe(1);
             expect(response.outage_types).toEqual(["Full"]);
             expect(response.average_duration_hours).toBe(6); // 6 hour duration
@@ -212,22 +223,26 @@ describe("SystemStatusServer", () => {
             expect(response.outages[0]).toHaveProperty("days_ago");
         });
         it("should apply limit correctly", async () => {
-            const manyOutages = Array(50).fill(0).map((_, i) => ({
+            const manyOutages = Array(50)
+                .fill(0)
+                .map((_, i) => ({
                 ...mockPastOutagesData[0],
                 id: `past-${i}`,
-                Subject: `Past outage ${i}`
+                Subject: `Past outage ${i}`,
             }));
             mockHttpClient.get.mockResolvedValue({
                 status: 200,
-                data: { results: manyOutages }
+                data: { results: manyOutages },
             });
             const result = await server["handleToolCall"]({
+                method: "tools/call",
                 params: {
                     name: "get_infrastructure_news",
-                    arguments: { time: "past", limit: 10 }
-                }
+                    arguments: { time: "past", limit: 10 },
+                },
             });
-            const response = JSON.parse(result.content[0].text);
+            const content = result.content[0];
+            const response = JSON.parse(content.text);
             expect(response.outages).toHaveLength(10);
         });
     });
@@ -238,10 +253,12 @@ describe("SystemStatusServer", () => {
                 .mockResolvedValueOnce({ status: 200, data: { results: mockFutureOutagesData } })
                 .mockResolvedValueOnce({ status: 200, data: { results: mockPastOutagesData } });
             const result = await server["handleToolCall"]({
-                params: { name: "get_infrastructure_news", arguments: { time: "all" } }
+                method: "tools/call",
+                params: { name: "get_infrastructure_news", arguments: { time: "all" } },
             });
             expect(mockHttpClient.get).toHaveBeenCalledTimes(3);
-            const response = JSON.parse(result.content[0].text);
+            const content = result.content[0];
+            const response = JSON.parse(content.text);
             expect(response.current_outages).toBe(2);
             expect(response.scheduled_maintenance).toBe(1);
             expect(response.recent_past_outages).toBe(1); // Within 30 days
@@ -255,9 +272,11 @@ describe("SystemStatusServer", () => {
                 .mockResolvedValueOnce({ status: 200, data: { results: mockFutureOutagesData } })
                 .mockResolvedValueOnce({ status: 200, data: { results: mockPastOutagesData } });
             const result = await server["handleToolCall"]({
-                params: { name: "get_infrastructure_news", arguments: { time: "all" } }
+                method: "tools/call",
+                params: { name: "get_infrastructure_news", arguments: { time: "all" } },
             });
-            const response = JSON.parse(result.content[0].text);
+            const content = result.content[0];
+            const response = JSON.parse(content.text);
             const firstAnnouncement = response.announcements[0];
             expect(firstAnnouncement.category).toBe("current");
         });
@@ -266,15 +285,17 @@ describe("SystemStatusServer", () => {
         it("should check resource status efficiently (direct method)", async () => {
             mockHttpClient.get.mockResolvedValue({
                 status: 200,
-                data: { results: mockCurrentOutagesData }
+                data: { results: mockCurrentOutagesData },
             });
             const result = await server["handleToolCall"]({
+                method: "tools/call",
                 params: {
                     name: "get_infrastructure_news",
-                    arguments: { ids: ["anvil-1", "unknown-resource"] }
-                }
+                    arguments: { ids: ["anvil-1", "unknown-resource"] },
+                },
             });
-            const response = JSON.parse(result.content[0].text);
+            const content = result.content[0];
+            const response = JSON.parse(content.text);
             expect(response.api_method).toBe("direct_outages_check");
             expect(response.resources_checked).toBe(2);
             expect(response.operational).toBe(1); // unknown-resource
@@ -286,19 +307,21 @@ describe("SystemStatusServer", () => {
         it("should use group API when requested", async () => {
             mockHttpClient.get.mockResolvedValue({
                 status: 200,
-                data: { results: [] } // No outages for this group
+                data: { results: [] }, // No outages for this group
             });
             const result = await server["handleToolCall"]({
+                method: "tools/call",
                 params: {
                     name: "get_infrastructure_news",
                     arguments: {
                         ids: ["anvil"],
-                        use_group_api: true
-                    }
-                }
+                        use_group_api: true,
+                    },
+                },
             });
             expect(mockHttpClient.get).toHaveBeenCalledWith("/wh2/news/v1/info_groupid/anvil/");
-            const response = JSON.parse(result.content[0].text);
+            const content = result.content[0];
+            const response = JSON.parse(content.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");
@@ -306,15 +329,17 @@ describe("SystemStatusServer", () => {
         it("should handle group API failures gracefully", async () => {
             mockHttpClient.get.mockRejectedValue(new Error("API Error"));
             const result = await server["handleToolCall"]({
+                method: "tools/call",
                 params: {
                     name: "get_infrastructure_news",
                     arguments: {
                         ids: ["invalid-resource"],
-                        use_group_api: true
-                    }
-                }
+                        use_group_api: true,
+                    },
+                },
             });
-            const response = JSON.parse(result.content[0].text);
+            const content = result.content[0];
+            const response = JSON.parse(content.text);
             expect(response).toHaveProperty("unknown", 1);
             expect(response.resource_status[0].status).toBe("unknown");
             expect(response.resource_status[0].api_method).toBe("group_specific_failed");
@@ -325,37 +350,45 @@ describe("SystemStatusServer", () => {
         it("should handle API errors gracefully", async () => {
             mockHttpClient.get.mockResolvedValue({
                 status: 500,
-                statusText: "Internal Server Error"
+                statusText: "Internal Server Error",
+                data: null,
             });
             const result = await server["handleToolCall"]({
-                params: { name: "get_infrastructure_news", arguments: { time: "current" } }
+                method: "tools/call",
+                params: { name: "get_infrastructure_news", arguments: { time: "current" } },
             });
-            const response = JSON.parse(result.content[0].text);
+            const content = result.content[0];
+            const response = JSON.parse(content.text);
             expect(response.error).toBeDefined();
         });
         it("should handle network errors", async () => {
             mockHttpClient.get.mockRejectedValue(new Error("Network error"));
             const result = await server["handleToolCall"]({
-                params: { name: "get_infrastructure_news", arguments: { time: "current" } }
+                method: "tools/call",
+                params: { name: "get_infrastructure_news", arguments: { time: "current" } },
             });
-            const response = JSON.parse(result.content[0].text);
+            const content = result.content[0];
+            const response = JSON.parse(content.text);
             expect(response.error).toBe("Network error");
         });
         it("should handle unknown tools", async () => {
             const result = await server["handleToolCall"]({
-                params: { name: "unknown_tool", arguments: {} }
+                method: "tools/call",
+                params: { name: "unknown_tool", arguments: {} },
             });
-            expect(result.content[0].text).toContain("Unknown tool");
+            const content = result.content[0];
+            expect(content.text).toContain("Unknown tool");
         });
     });
     describe("Resource Handling", () => {
         it("should handle resource reads correctly", async () => {
             mockHttpClient.get.mockResolvedValue({
                 status: 200,
-                data: { results: mockCurrentOutagesData }
+                data: { results: mockCurrentOutagesData },
             });
             const result = await server["handleResourceRead"]({
-                params: { uri: "accessci://outages/current" }
+                method: "resources/read",
+                params: { uri: "accessci://outages/current" },
             });
             expect(result.contents[0].mimeType).toBe("application/json");
             expect(result.contents[0].text).toBeDefined();
@@ -363,7 +396,8 @@ describe("SystemStatusServer", () => {
         it("should handle unknown resources", async () => {
             await expect(async () => {
                 await server["handleResourceRead"]({
-                    params: { uri: "accessci://unknown" }
+                    method: "resources/read",
+                    params: { uri: "accessci://unknown" },
                 });
             }).rejects.toThrow("Unknown resource");
         });

package/dist/index.js

@@ -5,7 +5,7 @@ async function main() {
     const port = process.env.PORT ? parseInt(process.env.PORT, 10) : undefined;
     await server.start(port ? { httpPort: port } : undefined);
 }
-main().catch((error) => {
+main().catch(() => {
     // Log errors to a file instead of stderr to avoid interfering with JSON-RPC
     process.exit(1);
 });

package/dist/server.d.ts

@@ -1,66 +1,16 @@
-import { BaseAccessServer } from "@access-mcp/shared";
+import { BaseAccessServer, Tool, Resource, CallToolResult } from "@access-mcp/shared";
+import { CallToolRequest, ReadResourceRequest, ReadResourceResult } from "@modelcontextprotocol/sdk/types.js";
 export declare class SystemStatusServer extends BaseAccessServer {
     constructor();
-    protected getTools(): {
-        name: string;
-        description: string;
-        inputSchema: {
-            type: string;
-            properties: {
-                query: {
-                    type: string;
-                    description: string;
-                };
-                time: {
-                    type: string;
-                    enum: string[];
-                    description: string;
-                    default: string;
-                };
-                ids: {
-                    type: string;
-                    items: {
-                        type: string;
-                    };
-                    description: string;
-                };
-                limit: {
-                    type: string;
-                    description: string;
-                    default: number;
-                };
-                use_group_api: {
-                    type: string;
-                    description: string;
-                    default: boolean;
-                };
-            };
-        };
-    }[];
-    protected getResources(): {
-        uri: string;
-        name: string;
-        description: string;
-        mimeType: string;
-    }[];
-    handleToolCall(request: any): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-    }>;
+    protected getTools(): Tool[];
+    protected getResources(): Resource[];
+    protected handleToolCall(request: CallToolRequest): Promise<CallToolResult>;
     /**
      * Router for consolidated get_infrastructure_news tool
      * Routes to appropriate handler based on parameters
      */
     private getInfrastructureNewsRouter;
-    handleResourceRead(request: any): Promise<{
-        contents: {
-            uri: any;
-            mimeType: string;
-            text: string;
-        }[];
-    }>;
+    protected handleResourceRead(request: ReadResourceRequest): Promise<ReadResourceResult>;
     private getCurrentOutages;
     private getScheduledMaintenance;
     private getPastOutages;

package/dist/server.js

@@ -1,7 +1,10 @@
-import { BaseAccessServer, handleApiError } from "@access-mcp/shared";
+import { BaseAccessServer, handleApiError, } from "@access-mcp/shared";
+import { createRequire } from "module";
+const require = createRequire(import.meta.url);
+const { version } = require("../package.json");
 export class SystemStatusServer extends BaseAccessServer {
     constructor() {
-        super("access-mcp-system-status", "0.4.0", "https://operations-api.access-ci.org");
+        super("access-mcp-system-status", version, "https://operations-api.access-ci.org");
     }
     getTools() {
         return [
@@ -13,30 +16,30 @@ export class SystemStatusServer extends BaseAccessServer {
                     properties: {
                         query: {
                             type: "string",
-                            description: "Filter by resource name (e.g., 'delta', 'bridges2')"
+                            description: "Filter by resource name (e.g., 'delta', 'bridges2')",
                         },
                         time: {
                             type: "string",
                             enum: ["current", "scheduled", "past", "all"],
                             description: "Period: current (active), scheduled (future), past, all",
-                            default: "current"
+                            default: "current",
                         },
                         ids: {
                             type: "array",
                             items: { type: "string" },
-                            description: "Check status for specific resource IDs"
+                            description: "Check status for specific resource IDs",
                         },
                         limit: {
                             type: "number",
                             description: "Max results (default: 50)",
-                            default: 50
+                            default: 50,
                         },
                         use_group_api: {
                             type: "boolean",
                             description: "Use group API for status (with ids only)",
-                            default: false
-                        }
-                    }
+                            default: false,
+                        },
+                    },
                 },
             },
         ];
@@ -71,15 +74,16 @@ export class SystemStatusServer extends BaseAccessServer {
     }
     async handleToolCall(request) {
         const { name, arguments: args = {} } = request.params;
+        const typedArgs = args;
         try {
             switch (name) {
                 case "get_infrastructure_news":
                     return await this.getInfrastructureNewsRouter({
-                        resource: args.query,
-                        time: args.time,
-                        resource_ids: args.ids,
-                        limit: args.limit,
-                        use_group_api: args.use_group_api
+                        resource: typedArgs.query,
+                        time: typedArgs.time,
+                        resource_ids: typedArgs.ids,
+                        limit: typedArgs.limit,
+                        use_group_api: typedArgs.use_group_api,
                     });
                 default:
                     return this.errorResponse(`Unknown tool: ${name}`);
@@ -116,7 +120,7 @@ export class SystemStatusServer extends BaseAccessServer {
     async handleResourceRead(request) {
         const { uri } = request.params;
         switch (uri) {
-            case "accessci://system-status":
+            case "accessci://system-status": {
                 return {
                     contents: [
                         {
@@ -126,39 +130,49 @@ export class SystemStatusServer extends BaseAccessServer {
                         },
                     ],
                 };
-            case "accessci://outages/current":
+            }
+            case "accessci://outages/current": {
                 const currentOutages = await this.getCurrentOutages();
+                const content = currentOutages.content[0];
+                const text = content.type === "text" ? content.text : "";
                 return {
                     contents: [
                         {
                             uri,
                             mimeType: "application/json",
-                            text: currentOutages.content[0].text,
+                            text,
                         },
                     ],
                 };
-            case "accessci://outages/scheduled":
+            }
+            case "accessci://outages/scheduled": {
                 const scheduledMaintenance = await this.getScheduledMaintenance();
+                const content = scheduledMaintenance.content[0];
+                const text = content.type === "text" ? content.text : "";
                 return {
                     contents: [
                         {
                             uri,
                             mimeType: "application/json",
-                            text: scheduledMaintenance.content[0].text,
+                            text,
                         },
                     ],
                 };
-            case "accessci://outages/past":
+            }
+            case "accessci://outages/past": {
                 const pastOutages = await this.getPastOutages();
+                const content = pastOutages.content[0];
+                const text = content.type === "text" ? content.text : "";
                 return {
                     contents: [
                         {
                             uri,
                             mimeType: "application/json",
-                            text: pastOutages.content[0].text,
+                            text,
                         },
                     ],
                 };
+            }
             default:
                 throw new Error(`Unknown resource: ${uri}`);
         }
@@ -178,9 +192,11 @@ export class SystemStatusServer extends BaseAccessServer {
         const severityCounts = { high: 0, medium: 0, low: 0, unknown: 0 };
         // Enhance outages with status summary
         const enhancedOutages = outages.map((outage) => {
-            // Track affected resources
+            // Track affected resources (use ResourceID as fallback if ResourceName is missing)
             outage.AffectedResources?.forEach((resource) => {
-                affectedResources.add(resource.ResourceName);
+                const resourceIdentifier = resource.ResourceName || resource.ResourceID;
+                if (resourceIdentifier)
+                    affectedResources.add(String(resourceIdentifier));
             });
             // Categorize severity (basic heuristic)
             const subject = outage.Subject?.toLowerCase() || "";
@@ -188,8 +204,7 @@ export class SystemStatusServer extends BaseAccessServer {
             if (subject.includes("emergency") || subject.includes("critical")) {
                 severity = "high";
             }
-            else if (subject.includes("maintenance") ||
-                subject.includes("scheduled")) {
+            else if (subject.includes("maintenance") || subject.includes("scheduled")) {
                 severity = "low";
             }
             else {
@@ -228,8 +243,8 @@ export class SystemStatusServer extends BaseAccessServer {
         }
         // Sort by scheduled start time
         maintenance.sort((a, b) => {
-            const dateA = new Date(a.OutageStart);
-            const dateB = new Date(b.OutageStart);
+            const dateA = new Date(a.OutageStart || "");
+            const dateB = new Date(b.OutageStart || "");
             return dateA.getTime() - dateB.getTime();
         });
         // Initialize tracking variables
@@ -239,11 +254,13 @@ export class SystemStatusServer extends BaseAccessServer {
         const enhancedMaintenance = maintenance.map((item) => {
             // Track affected resources
             item.AffectedResources?.forEach((resource) => {
-                affectedResources.add(resource.ResourceName);
+                const resourceIdentifier = resource.ResourceName || resource.ResourceID;
+                if (resourceIdentifier)
+                    affectedResources.add(String(resourceIdentifier));
             });
             // Check timing - use OutageStart for scheduling
             const hasScheduledTime = !!item.OutageStart;
-            const startTime = new Date(item.OutageStart);
+            const startTime = new Date(item.OutageStart || "");
             const now = new Date();
             const hoursUntil = (startTime.getTime() - now.getTime()) / (1000 * 60 * 60);
             if (hoursUntil <= 24)
@@ -256,8 +273,7 @@ export class SystemStatusServer extends BaseAccessServer {
                 scheduled_end: item.OutageEnd,
                 hours_until_start: Math.max(0, Math.round(hoursUntil)),
                 duration_hours: item.OutageEnd && item.OutageStart
-                    ? Math.round((new Date(item.OutageEnd).getTime() -
-                        new Date(item.OutageStart).getTime()) /
+                    ? Math.round((new Date(item.OutageEnd).getTime() - new Date(item.OutageStart).getTime()) /
                         (1000 * 60 * 60))
                     : null,
                 has_scheduled_time: hasScheduledTime,
@@ -291,8 +307,8 @@ export class SystemStatusServer extends BaseAccessServer {
         }
         // Sort by outage end time (most recent first)
         pastOutages.sort((a, b) => {
-            const dateA = new Date(a.OutageEnd);
-            const dateB = new Date(b.OutageEnd);
+            const dateA = new Date(a.OutageEnd || "");
+            const dateB = new Date(b.OutageEnd || "");
             return dateB.getTime() - dateA.getTime();
         });
         // Apply limit
@@ -303,23 +319,25 @@ export class SystemStatusServer extends BaseAccessServer {
         const affectedResources = new Set();
         const outageTypes = new Set();
         const recentOutages = pastOutages.filter((outage) => {
-            const endTime = new Date(outage.OutageEnd);
+            const endTime = new Date(outage.OutageEnd || "");
             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
+            // Track affected resources (use ResourceID as fallback if ResourceName is missing)
             outage.AffectedResources?.forEach((resource) => {
-                affectedResources.add(resource.ResourceName);
+                const resourceIdentifier = resource.ResourceName || resource.ResourceID;
+                if (resourceIdentifier)
+                    affectedResources.add(String(resourceIdentifier));
             });
             // Track outage types
             if (outage.OutageType) {
                 outageTypes.add(outage.OutageType);
             }
             // Calculate duration
-            const startTime = new Date(outage.OutageStart);
-            const endTime = new Date(outage.OutageEnd);
+            const startTime = new Date(outage.OutageStart || "");
+            const endTime = new Date(outage.OutageEnd || "");
             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));
@@ -339,9 +357,9 @@ export class SystemStatusServer extends BaseAccessServer {
             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)
+                    .filter((o) => o.duration_hours && o.duration_hours > 0)
+                    .reduce((sum, o) => sum + (o.duration_hours || 0), 0) /
+                    enhancedOutages.filter((o) => o.duration_hours && o.duration_hours > 0).length)
                 : 0,
             outages: enhancedOutages,
         };
@@ -363,27 +381,30 @@ export class SystemStatusServer extends BaseAccessServer {
         ]);
         const currentOutages = currentResponse.data.results || [];
         const futureOutages = futureResponse.data.results || [];
-        const pastOutages = pastResponse.data.results || [];
+        const pastOutagesData = pastResponse.data.results || [];
         // Filter recent past outages (last 30 days) for announcements
-        const recentPastOutages = pastOutages.filter((outage) => {
-            const endTime = new Date(outage.OutageEnd);
+        const recentPastOutages = pastOutagesData.filter((outage) => {
+            const endTime = new Date(outage.OutageEnd || "");
             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' })),
+            ...currentOutages.map((item) => ({ ...item, category: "current" })),
+            ...futureOutages.map((item) => ({ ...item, category: "scheduled" })),
+            ...recentPastOutages.map((item) => ({
+                ...item,
+                category: "recent_past",
+            })),
         ]
             .sort((a, b) => {
             // Sort by most relevant date: current first, then future by start time, then past by end time
-            if (a.category === 'current' && b.category !== 'current')
+            if (a.category === "current" && b.category !== "current")
                 return -1;
-            if (b.category === 'current' && a.category !== 'current')
+            if (b.category === "current" && a.category !== "current")
                 return 1;
-            const dateA = new Date(a.OutageStart);
-            const dateB = new Date(b.OutageStart);
+            const dateA = new Date(a.OutageStart || "");
+            const dateB = new Date(b.OutageStart || "");
             return dateB.getTime() - dateA.getTime(); // Most recent first
         })
             .slice(0, limit);
@@ -393,9 +414,9 @@ export class SystemStatusServer extends BaseAccessServer {
             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,
+                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,
         };
@@ -464,8 +485,7 @@ export class SystemStatusServer extends BaseAccessServer {
                         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,
+                        affected: resourceStatus.filter((r) => r.status === "affected").length,
                         api_method: "direct_outages_check",
                         resource_status: resourceStatus,
                     }, null, 2),
@@ -494,7 +514,7 @@ export class SystemStatusServer extends BaseAccessServer {
                     api_method: "group_specific",
                 };
             }
-            catch (error) {
+            catch {
                 // Fallback to general check if group API fails
                 return {
                     resource_id: resourceId,
@@ -516,10 +536,8 @@ export class SystemStatusServer extends BaseAccessServer {
                         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,
+                        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/dist/web-server.js

@@ -3,7 +3,7 @@ import path from "path";
 import { SystemStatusServer } from "./server.js";
 export function startWebServer(port = 3000) {
     const app = express();
-    const server = new SystemStatusServer();
+    new SystemStatusServer();
     // Serve static files from public directory
     const publicDir = path.join(__dirname, "../../../public");
     app.use(express.static(publicDir));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@access-mcp/system-status",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "description": "MCP server for ACCESS-CI System Status and Outages API",
   "type": "module",
   "main": "dist/index.js",
@@ -44,7 +44,7 @@
     "node": ">=18.0.0"
   },
   "dependencies": {
-    "@access-mcp/shared": "^0.3.3",
+    "@access-mcp/shared": "^0.6.0",
     "express": "^4.18.0"
   },
   "devDependencies": {