@access-mcp/system-status 0.5.0 → 0.6.0

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");
@@ -97,17 +107,19 @@ describe("SystemStatusServer Integration Tests", () => {
             }
         }, 15000);
         it("should check resource status with direct method", async () => {
-            // Test with common resource names that might exist
+            // Test with human-readable names - these get resolved to full IDs
             const result = await server["handleToolCall"]({
+                method: "tools/call",
                 params: {
                     name: "get_infrastructure_news",
                     arguments: {
-                        ids: ["anvil", "bridges", "jetstream"],
-                        use_group_api: false
-                    }
-                }
+                        ids: ["Anvil", "Delta", "Expanse"],
+                        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");
@@ -115,32 +127,36 @@ describe("SystemStatusServer Integration Tests", () => {
             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
+            // Check resource status structure - IDs should be resolved to full format
             responseData.resource_status.forEach((resource) => {
                 expect(resource).toHaveProperty("resource_id");
+                expect(resource.resource_id).toContain(".access-ci.org"); // Resolved to full 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);
+        }, 15000);
         it("should test group API functionality", async () => {
-            // Test group API with a resource that might have a group ID
+            // Test group API with a human-readable name
             const result = await server["handleToolCall"]({
+                method: "tools/call",
                 params: {
                     name: "get_infrastructure_news",
                     arguments: {
-                        ids: ["anvil"],
-                        use_group_api: true
-                    }
-                }
+                        ids: ["Anvil"],
+                        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);
             const resourceStatus = responseData.resource_status[0];
-            expect(resourceStatus).toHaveProperty("resource_id", "anvil");
+            expect(resourceStatus.resource_id).toContain("anvil"); // Resolved ID contains anvil
+            expect(resourceStatus.resource_id).toContain(".access-ci.org");
             expect(resourceStatus).toHaveProperty("api_method");
             expect(["group_specific", "group_specific_failed"]).toContain(resourceStatus.api_method);
             // If it succeeded, check structure
@@ -153,15 +169,17 @@ describe("SystemStatusServer Integration Tests", () => {
                 expect(resourceStatus.status).toBe("unknown");
                 expect(resourceStatus).toHaveProperty("error");
             }
-        }, 10000);
+        }, 15000);
         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 +196,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);
@@ -190,7 +209,10 @@ describe("SystemStatusServer Integration Tests", () => {
                 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();
+                    const content = result.contents[0];
+                    if ("text" in content) {
+                        expect(() => JSON.parse(content.text)).not.toThrow();
+                    }
                 }
             }
         }, 15000);
@@ -199,24 +221,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);