@access-mcp/system-status 0.4.0 → 0.5.0

package/README.md

@@ -1,79 +1,67 @@
 # 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
-
-This server provides critical operational information about ACCESS-CI systems, including current outages, scheduled maintenance, and system-wide announcements.
-
-## Tools
-
-### get_current_outages
-
-Get current system outages and issues affecting ACCESS-CI resources.
-
-**Parameters:**
-
-- `resource_filter` (string, optional): Filter by specific resource name or ID
-
-**Returns:**
-- Total outages count and severity breakdown
-- Affected resources list
-- Enhanced outage details with severity levels
+## Usage Examples
 
-### get_scheduled_maintenance
+### **Current Status**
 
-Get scheduled maintenance and future outages for ACCESS-CI resources.
+```
+"Current ACCESS-CI outages"
+"Delta operational status"
+"Systems experiencing issues"
+"GPU systems status check"
+```
 
-**Parameters:**
+### **Maintenance & Incidents**
 
-- `resource_filter` (string, optional): Filter by specific resource name or ID
+```
+"Scheduled maintenance this week"
+"Next Expanse maintenance window"
+"Past outages for Bridges-2"
+"All infrastructure news for Delta"
+```
 
-**Returns:**
-- Scheduled maintenance sorted by start time
-- Time until maintenance starts
-- Duration calculations for planned windows
+## Tools
 
-### get_past_outages
+### get_infrastructure_news
 
-Get historical outages and past incidents affecting ACCESS-CI resources.
+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.
 
 **Parameters:**
 
-- `resource_filter` (string, optional): Filter by specific resource name or ID
-- `limit` (number, optional): Maximum number of past outages to return (default: 100)
+- `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)
 
-**Returns:**
-- Historical outage data with duration analysis
-- Recent outages (last 30 days) summary
-- Outage type categorization
+**Examples:**
 
-### get_system_announcements
-
-Get comprehensive system announcements combining current, scheduled, and recent past outages.
-
-**Parameters:**
-
-- `limit` (number, optional): Maximum number of announcements to return (default: 50)
+```typescript
+// Get current outages across all resources
+get_infrastructure_news({})
 
-**Returns:**
-- Unified view of current outages, scheduled maintenance, and recent past incidents
-- Categorized announcements for better organization
-- Timeline-based sorting
+// Get scheduled maintenance
+get_infrastructure_news({ time: "scheduled" })
 
-### check_resource_status
+// Get comprehensive overview of all infrastructure news
+get_infrastructure_news({ time: "all" })
 
-Check the operational status of specific ACCESS-CI resources.
+// Check current status for specific resource
+get_infrastructure_news({ resource: "delta", time: "current" })
 
-**Parameters:**
+// Get all news for specific resource
+get_infrastructure_news({ resource: "delta", time: "all" })
 
-- `resource_ids` (array): List of resource IDs or names to check status for
-- `use_group_api` (boolean, optional): Use resource group API for more efficient querying (default: false)
+// Check operational status of specific resources
+get_infrastructure_news({
+  resource_ids: ["delta.ncsa.access-ci.org", "bridges2.psc.access-ci.org"]
+})
 
-**Returns:**
-- Operational status for each requested resource
-- Active outage details with severity levels
-- API method used (direct vs group-specific)
+// Get past outages with limit
+get_infrastructure_news({ time: "past", limit: 50 })
+```
 
 ## Resources
 
@@ -133,74 +121,73 @@ Add to your Claude Desktop configuration:
 **Natural Language**: "Are there any systems down right now?"
 
 **Tool Call**:
-
 ```typescript
-const outages = await get_current_outages();
+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
-- Workaround information if available
+- Summary statistics (total outages, affected resources)
 
 ### Finding Scheduled Maintenance
 
 **Natural Language**: "When is Delta scheduled for maintenance?"
 
 **Tool Call**:
-
 ```typescript
-const maintenance = await get_scheduled_maintenance({
-  resource_filter: "delta",
+const maintenance = await get_infrastructure_news({
+  resource: "delta",
+  time: "scheduled"
 });
 ```
 
 **Returns**: Upcoming maintenance windows including:
-
 - Scheduled start and end times
 - Systems affected
-- Type of maintenance
-- Expected impact on users
+- Duration in hours
+- Hours until maintenance starts
+- Summary (upcoming in 24h, upcoming this week)
 
-### Getting System Announcements
+### Getting Comprehensive System Overview
 
 **Natural Language**: "What are the latest announcements?"
 
 **Tool Call**:
-
 ```typescript
-const announcements = await get_system_announcements({
-  limit: 10,
+const announcements = await get_infrastructure_news({
+  time: "all",
+  limit: 10
 });
 ```
 
-**Returns**: Recent announcements about:
-
-- Policy changes
-- New features or services
-- Important deadlines
-- System-wide updates
+**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_resource_status({
-  resource_id: "expanse.sdsc.xsede.org",
+const status = await get_infrastructure_news({
+  resource_ids: ["expanse.sdsc.access-ci.org"]
 });
 ```
 
 **Returns**: Current operational status:
-
-- Overall system health
-- Service availability
-- Performance metrics
-- Any active issues or limitations
+- Overall status ("operational" or "affected")
+- Severity level if affected
+- Number of active outages
+- Outage details with subjects
+- Timestamp of status check
 
 ## API Endpoints
 

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

@@ -9,8 +9,8 @@ describe("SystemStatusServer Integration Tests", () => {
         it("should fetch current outages from real API", async () => {
             const result = await server["handleToolCall"]({
                 params: {
-                    name: "get_current_outages",
-                    arguments: { limit: 5 }
+                    name: "get_infrastructure_news",
+                    arguments: { time: "current", limit: 5 }
                 }
             });
             const responseData = JSON.parse(result.content[0].text);
@@ -26,15 +26,14 @@ describe("SystemStatusServer Integration Tests", () => {
             if (responseData.outages.length > 0) {
                 const outage = responseData.outages[0];
                 expect(outage).toHaveProperty("severity");
-                expect(outage).toHaveProperty("posted_time");
-                expect(outage).toHaveProperty("last_updated");
+                // The API response includes original fields like Subject, OutageStart, OutageEnd, etc.
+                expect(outage).toHaveProperty("Subject");
             }
         }, 10000);
         it("should fetch scheduled maintenance from real API", async () => {
             const result = await server["handleToolCall"]({
                 params: {
-                    name: "get_scheduled_maintenance",
-                    arguments: { limit: 5 }
+                    name: "get_infrastructure_news", arguments: { time: "scheduled", limit: 5 }
                 }
             });
             const responseData = JSON.parse(result.content[0].text);
@@ -54,8 +53,7 @@ describe("SystemStatusServer Integration Tests", () => {
         it("should fetch past outages from real API", async () => {
             const result = await server["handleToolCall"]({
                 params: {
-                    name: "get_past_outages",
-                    arguments: { limit: 10 }
+                    name: "get_infrastructure_news", arguments: { time: "past", limit: 5 }
                 }
             });
             const responseData = JSON.parse(result.content[0].text);
@@ -77,8 +75,8 @@ describe("SystemStatusServer Integration Tests", () => {
         it("should get comprehensive system announcements", async () => {
             const result = await server["handleToolCall"]({
                 params: {
-                    name: "get_system_announcements",
-                    arguments: { limit: 20 }
+                    name: "get_infrastructure_news",
+                    arguments: { time: "all", limit: 20 }
                 }
             });
             const responseData = JSON.parse(result.content[0].text);
@@ -102,9 +100,9 @@ describe("SystemStatusServer Integration Tests", () => {
             // Test with common resource names that might exist
             const result = await server["handleToolCall"]({
                 params: {
-                    name: "check_resource_status",
+                    name: "get_infrastructure_news",
                     arguments: {
-                        resource_ids: ["anvil", "bridges", "jetstream"],
+                        ids: ["anvil", "bridges", "jetstream"],
                         use_group_api: false
                     }
                 }
@@ -130,9 +128,9 @@ describe("SystemStatusServer Integration Tests", () => {
             // Test group API with a resource that might have a group ID
             const result = await server["handleToolCall"]({
                 params: {
-                    name: "check_resource_status",
+                    name: "get_infrastructure_news",
                     arguments: {
-                        resource_ids: ["anvil"],
+                        ids: ["anvil"],
                         use_group_api: true
                     }
                 }
@@ -159,19 +157,21 @@ describe("SystemStatusServer Integration Tests", () => {
         it("should filter outages by resource correctly", async () => {
             const result = await server["handleToolCall"]({
                 params: {
-                    name: "get_current_outages",
-                    arguments: { resource_filter: "anvil" }
+                    name: "get_infrastructure_news",
+                    arguments: { time: "current", query: "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);
-            });
+            if (responseData.outages.length > 0) {
+                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 = [
@@ -200,8 +200,8 @@ describe("SystemStatusServer Integration Tests", () => {
             // 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" }
+                    name: "get_infrastructure_news",
+                    arguments: { time: "current", query: "nonexistent-resource-xyz-12345" }
                 }
             });
             const responseData = JSON.parse(result.content[0].text);
@@ -212,8 +212,8 @@ describe("SystemStatusServer Integration Tests", () => {
         it("should handle large limit values gracefully", async () => {
             const result = await server["handleToolCall"]({
                 params: {
-                    name: "get_past_outages",
-                    arguments: { limit: 1000 }
+                    name: "get_infrastructure_news",
+                    arguments: { time: "past", limit: 1000 }
                 }
             });
             const responseData = JSON.parse(result.content[0].text);

package/dist/__tests__/server.test.js

@@ -10,8 +10,8 @@ describe("SystemStatusServer", () => {
             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",
+            OutageStart: "2024-08-27T10:00:00Z",
+            OutageEnd: "2024-08-27T11:00:00Z",
             AffectedResources: [
                 { ResourceName: "Anvil", ResourceID: "anvil-1" }
             ]
@@ -20,8 +20,8 @@ describe("SystemStatusServer", () => {
             id: "2",
             Subject: "Scheduled maintenance on Bridges-2",
             Content: "Regular maintenance window",
-            CreationTime: "2024-08-27T08:00:00Z",
-            LastModificationTime: "2024-08-27T08:30:00Z",
+            OutageStart: "2024-08-27T08:00:00Z",
+            OutageEnd: "2024-08-27T08:30:00Z",
             AffectedResources: [
                 { ResourceName: "Bridges-2", ResourceID: "bridges2-1" }
             ]
@@ -32,10 +32,8 @@ describe("SystemStatusServer", () => {
             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",
+            OutageStart: "2024-08-30T10:00:00Z",
+            OutageEnd: "2024-08-30T14:00:00Z",
             AffectedResources: [
                 { ResourceName: "Jetstream", ResourceID: "jetstream-1" }
             ]
@@ -46,10 +44,8 @@ describe("SystemStatusServer", () => {
             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  
+            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" }
@@ -80,14 +76,8 @@ describe("SystemStatusServer", () => {
         });
         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"
-            ]);
+            expect(tools).toHaveLength(1);
+            expect(tools[0].name).toBe("get_infrastructure_news");
         });
         it("should provide correct resources", () => {
             const resources = server["getResources"]();
@@ -107,7 +97,7 @@ describe("SystemStatusServer", () => {
                 data: { results: mockCurrentOutagesData }
             });
             const result = await server["handleToolCall"]({
-                params: { name: "get_current_outages", arguments: {} }
+                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);
@@ -116,7 +106,6 @@ describe("SystemStatusServer", () => {
             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({
@@ -125,8 +114,8 @@ describe("SystemStatusServer", () => {
             });
             const result = await server["handleToolCall"]({
                 params: {
-                    name: "get_current_outages",
-                    arguments: { resource_filter: "Anvil" }
+                    name: "get_infrastructure_news",
+                    arguments: { query: "Anvil", time: "current" }
                 }
             });
             const response = JSON.parse(result.content[0].text);
@@ -139,7 +128,7 @@ describe("SystemStatusServer", () => {
                 data: { results: mockCurrentOutagesData }
             });
             const result = await server["handleToolCall"]({
-                params: { name: "get_current_outages", arguments: {} }
+                params: { name: "get_infrastructure_news", arguments: { time: "current" } }
             });
             const response = JSON.parse(result.content[0].text);
             const emergencyOutage = response.outages.find((o) => o.Subject.includes("Emergency"));
@@ -155,7 +144,7 @@ describe("SystemStatusServer", () => {
                 data: { results: mockFutureOutagesData }
             });
             const result = await server["handleToolCall"]({
-                params: { name: "get_scheduled_maintenance", arguments: {} }
+                params: { name: "get_infrastructure_news", arguments: { time: "scheduled" } }
             });
             const response = JSON.parse(result.content[0].text);
             expect(response.total_scheduled).toBe(1);
@@ -167,15 +156,15 @@ describe("SystemStatusServer", () => {
         it("should handle missing scheduled times", async () => {
             const dataWithoutSchedule = [{
                     ...mockFutureOutagesData[0],
-                    OutageStartDateTime: null,
-                    OutageEndDateTime: null
+                    OutageStart: null,
+                    OutageEnd: null
                 }];
             mockHttpClient.get.mockResolvedValue({
                 status: 200,
                 data: { results: dataWithoutSchedule }
             });
             const result = await server["handleToolCall"]({
-                params: { name: "get_scheduled_maintenance", arguments: {} }
+                params: { name: "get_infrastructure_news", arguments: { time: "scheduled" } }
             });
             const response = JSON.parse(result.content[0].text);
             expect(response.maintenance[0].has_scheduled_time).toBe(false);
@@ -185,12 +174,12 @@ describe("SystemStatusServer", () => {
             const multipleMaintenanceData = [
                 {
                     ...mockFutureOutagesData[0],
-                    OutageStartDateTime: "2024-08-31T10:00:00Z", // Later
+                    OutageStart: "2024-08-31T10:00:00Z", // Later
                     Subject: "Later maintenance"
                 },
                 {
                     ...mockFutureOutagesData[0],
-                    OutageStartDateTime: "2024-08-30T10:00:00Z", // Earlier
+                    OutageStart: "2024-08-30T10:00:00Z", // Earlier
                     Subject: "Earlier maintenance"
                 }
             ];
@@ -199,7 +188,7 @@ describe("SystemStatusServer", () => {
                 data: { results: multipleMaintenanceData }
             });
             const result = await server["handleToolCall"]({
-                params: { name: "get_scheduled_maintenance", arguments: {} }
+                params: { name: "get_infrastructure_news", arguments: { time: "scheduled" } }
             });
             const response = JSON.parse(result.content[0].text);
             expect(response.maintenance[0].Subject).toBe("Earlier maintenance");
@@ -213,7 +202,7 @@ describe("SystemStatusServer", () => {
                 data: { results: mockPastOutagesData }
             });
             const result = await server["handleToolCall"]({
-                params: { name: "get_past_outages", arguments: {} }
+                params: { name: "get_infrastructure_news", arguments: { time: "past" } }
             });
             const response = JSON.parse(result.content[0].text);
             expect(response.total_past_outages).toBe(1);
@@ -234,8 +223,8 @@ describe("SystemStatusServer", () => {
             });
             const result = await server["handleToolCall"]({
                 params: {
-                    name: "get_past_outages",
-                    arguments: { limit: 10 }
+                    name: "get_infrastructure_news",
+                    arguments: { time: "past", limit: 10 }
                 }
             });
             const response = JSON.parse(result.content[0].text);
@@ -249,7 +238,7 @@ describe("SystemStatusServer", () => {
                 .mockResolvedValueOnce({ status: 200, data: { results: mockFutureOutagesData } })
                 .mockResolvedValueOnce({ status: 200, data: { results: mockPastOutagesData } });
             const result = await server["handleToolCall"]({
-                params: { name: "get_system_announcements", arguments: {} }
+                params: { name: "get_infrastructure_news", arguments: { time: "all" } }
             });
             expect(mockHttpClient.get).toHaveBeenCalledTimes(3);
             const response = JSON.parse(result.content[0].text);
@@ -266,7 +255,7 @@ describe("SystemStatusServer", () => {
                 .mockResolvedValueOnce({ status: 200, data: { results: mockFutureOutagesData } })
                 .mockResolvedValueOnce({ status: 200, data: { results: mockPastOutagesData } });
             const result = await server["handleToolCall"]({
-                params: { name: "get_system_announcements", arguments: {} }
+                params: { name: "get_infrastructure_news", arguments: { time: "all" } }
             });
             const response = JSON.parse(result.content[0].text);
             const firstAnnouncement = response.announcements[0];
@@ -281,8 +270,8 @@ describe("SystemStatusServer", () => {
             });
             const result = await server["handleToolCall"]({
                 params: {
-                    name: "check_resource_status",
-                    arguments: { resource_ids: ["anvil-1", "unknown-resource"] }
+                    name: "get_infrastructure_news",
+                    arguments: { ids: ["anvil-1", "unknown-resource"] }
                 }
             });
             const response = JSON.parse(result.content[0].text);
@@ -301,9 +290,9 @@ describe("SystemStatusServer", () => {
             });
             const result = await server["handleToolCall"]({
                 params: {
-                    name: "check_resource_status",
+                    name: "get_infrastructure_news",
                     arguments: {
-                        resource_ids: ["anvil"],
+                        ids: ["anvil"],
                         use_group_api: true
                     }
                 }
@@ -318,15 +307,15 @@ describe("SystemStatusServer", () => {
             mockHttpClient.get.mockRejectedValue(new Error("API Error"));
             const result = await server["handleToolCall"]({
                 params: {
-                    name: "check_resource_status",
+                    name: "get_infrastructure_news",
                     arguments: {
-                        resource_ids: ["invalid-resource"],
+                        ids: ["invalid-resource"],
                         use_group_api: true
                     }
                 }
             });
             const response = JSON.parse(result.content[0].text);
-            expect(response.unknown).toBe(1);
+            expect(response).toHaveProperty("unknown", 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");
@@ -339,16 +328,18 @@ describe("SystemStatusServer", () => {
                 statusText: "Internal Server Error"
             });
             const result = await server["handleToolCall"]({
-                params: { name: "get_current_outages", arguments: {} }
+                params: { name: "get_infrastructure_news", arguments: { time: "current" } }
             });
-            expect(result.content[0].text).toContain("Error");
+            const response = JSON.parse(result.content[0].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_current_outages", arguments: {} }
+                params: { name: "get_infrastructure_news", arguments: { time: "current" } }
             });
-            expect(result.content[0].text).toContain("Error");
+            const response = JSON.parse(result.content[0].text);
+            expect(response.error).toBe("Network error");
         });
         it("should handle unknown tools", async () => {
             const result = await server["handleToolCall"]({

package/dist/index.js

@@ -1,18 +1,9 @@
 #!/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)
-    const port = process.env.PORT;
-    if (port) {
-        // Running in web mode (deployment)
-        startWebServer(parseInt(port));
-    }
-    else {
-        // Running in MCP mode (stdio)
-        const server = new SystemStatusServer();
-        await server.start();
-    }
+    const server = new SystemStatusServer();
+    const port = process.env.PORT ? parseInt(process.env.PORT, 10) : undefined;
+    await server.start(port ? { httpPort: port } : undefined);
 }
 main().catch((error) => {
     // Log errors to a file instead of stderr to avoid interfering with JSON-RPC

package/dist/server.d.ts

@@ -1,81 +1,42 @@
 import { BaseAccessServer } from "@access-mcp/shared";
 export declare class SystemStatusServer extends BaseAccessServer {
     constructor();
-    protected getTools(): ({
+    protected getTools(): {
         name: string;
         description: string;
         inputSchema: {
             type: string;
             properties: {
-                resource_filter: {
+                query: {
                     type: string;
                     description: string;
                 };
-                limit?: undefined;
-                resource_ids?: undefined;
-                use_group_api?: undefined;
-            };
-            required: never[];
-        };
-    } | {
-        name: string;
-        description: string;
-        inputSchema: {
-            type: string;
-            properties: {
-                resource_filter: {
+                time: {
                     type: string;
+                    enum: string[];
                     description: string;
+                    default: string;
                 };
-                limit: {
+                ids: {
                     type: string;
+                    items: {
+                        type: string;
+                    };
                     description: string;
                 };
-                resource_ids?: undefined;
-                use_group_api?: undefined;
-            };
-            required: never[];
-        };
-    } | {
-        name: string;
-        description: string;
-        inputSchema: {
-            type: string;
-            properties: {
                 limit: {
                     type: string;
                     description: string;
-                };
-                resource_filter?: undefined;
-                resource_ids?: undefined;
-                use_group_api?: undefined;
-            };
-            required: never[];
-        };
-    } | {
-        name: string;
-        description: string;
-        inputSchema: {
-            type: string;
-            properties: {
-                resource_ids: {
-                    type: string;
-                    items: {
-                        type: string;
-                    };
-                    description: string;
+                    default: number;
                 };
                 use_group_api: {
                     type: string;
                     description: string;
                     default: boolean;
                 };
-                resource_filter?: undefined;
-                limit?: undefined;
             };
-            required: string[];
         };
-    })[];
+    }[];
     protected getResources(): {
         uri: string;
         name: string;
@@ -88,6 +49,11 @@ export declare class SystemStatusServer extends BaseAccessServer {
             text: string;
         }[];
     }>;
+    /**
+     * Router for consolidated get_infrastructure_news tool
+     * Routes to appropriate handler based on parameters
+     */
+    private getInfrastructureNewsRouter;
     handleResourceRead(request: any): Promise<{
         contents: {
             uri: any;

package/dist/server.js

@@ -6,83 +6,37 @@ export class SystemStatusServer extends BaseAccessServer {
     getTools() {
         return [
             {
-                name: "get_current_outages",
-                description: "Get current system outages and issues affecting ACCESS-CI resources",
+                name: "get_infrastructure_news",
+                description: "Get ACCESS-CI infrastructure status (outages, maintenance, incidents). Returns {total, items}.",
                 inputSchema: {
                     type: "object",
                     properties: {
-                        resource_filter: {
+                        query: {
                             type: "string",
-                            description: "Optional: filter by specific resource name or ID",
+                            description: "Filter by resource name (e.g., 'delta', 'bridges2')"
                         },
-                    },
-                    required: [],
-                },
-            },
-            {
-                name: "get_scheduled_maintenance",
-                description: "Get scheduled maintenance and future outages for ACCESS-CI resources",
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        resource_filter: {
+                        time: {
                             type: "string",
-                            description: "Optional: filter by specific resource name or ID",
+                            enum: ["current", "scheduled", "past", "all"],
+                            description: "Period: current (active), scheduled (future), past, all",
+                            default: "current"
                         },
-                    },
-                    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",
+                        ids: {
+                            type: "array",
+                            items: { type: "string" },
+                            description: "Check status for specific resource IDs"
                         },
                         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)",
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        limit: {
-                            type: "number",
-                            description: "Maximum number of announcements to return (default: 50)",
-                        },
-                    },
-                    required: [],
-                },
-            },
-            {
-                name: "check_resource_status",
-                description: "Check the operational status of specific ACCESS-CI resources",
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        resource_ids: {
-                            type: "array",
-                            items: { type: "string" },
-                            description: "List of resource IDs or names to check status for",
+                            description: "Max results (default: 50)",
+                            default: 50
                         },
                         use_group_api: {
                             type: "boolean",
-                            description: "Use resource group API for more efficient querying (default: false)",
-                            default: false,
-                        },
-                    },
-                    required: ["resource_ids"],
+                            description: "Use group API for status (with ids only)",
+                            default: false
+                        }
+                    }
                 },
             },
         ];
@@ -119,29 +73,44 @@ export class SystemStatusServer extends BaseAccessServer {
         const { name, arguments: args = {} } = request.params;
         try {
             switch (name) {
-                case "get_current_outages":
-                    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, args.use_group_api);
+                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
+                    });
                 default:
-                    throw new Error(`Unknown tool: ${name}`);
+                    return this.errorResponse(`Unknown tool: ${name}`);
             }
         }
         catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Error: ${handleApiError(error)}`,
-                    },
-                ],
-            };
+            return this.errorResponse(handleApiError(error));
+        }
+    }
+    /**
+     * Router for consolidated get_infrastructure_news tool
+     * Routes to appropriate handler based on parameters
+     */
+    async getInfrastructureNewsRouter(args) {
+        const { resource, time = "current", resource_ids, limit, use_group_api = false } = args;
+        // Check resource status (returns operational/affected)
+        if (resource_ids && Array.isArray(resource_ids)) {
+            return await this.checkResourceStatus(resource_ids, use_group_api);
+        }
+        // Time-based routing
+        switch (time) {
+            case "current":
+                return await this.getCurrentOutages(resource);
+            case "scheduled":
+                return await this.getScheduledMaintenance(resource);
+            case "past":
+                return await this.getPastOutages(resource, limit || 100);
+            case "all":
+                return await this.getSystemAnnouncements(limit || 50);
+            default:
+                throw new Error(`Invalid time parameter: ${time}. Must be one of: current, scheduled, past, all`);
         }
     }
     async handleResourceRead(request) {
@@ -230,8 +199,6 @@ export class SystemStatusServer extends BaseAccessServer {
             return {
                 ...outage,
                 severity,
-                posted_time: outage.CreationTime,
-                last_updated: outage.LastModificationTime,
             };
         });
         const summary = {
@@ -261,8 +228,8 @@ export class SystemStatusServer extends BaseAccessServer {
         }
         // Sort by scheduled start time
         maintenance.sort((a, b) => {
-            const dateA = new Date(a.OutageStartDateTime || a.CreationTime);
-            const dateB = new Date(b.OutageStartDateTime || b.CreationTime);
+            const dateA = new Date(a.OutageStart);
+            const dateB = new Date(b.OutageStart);
             return dateA.getTime() - dateB.getTime();
         });
         // Initialize tracking variables
@@ -274,9 +241,9 @@ export class SystemStatusServer extends BaseAccessServer {
             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);
+            // Check timing - use OutageStart for scheduling
+            const hasScheduledTime = !!item.OutageStart;
+            const startTime = new Date(item.OutageStart);
             const now = new Date();
             const hoursUntil = (startTime.getTime() - now.getTime()) / (1000 * 60 * 60);
             if (hoursUntil <= 24)
@@ -285,12 +252,12 @@ export class SystemStatusServer extends BaseAccessServer {
                 upcomingWeek++; // 7 days * 24 hours
             return {
                 ...item,
-                scheduled_start: item.OutageStartDateTime,
-                scheduled_end: item.OutageEndDateTime,
+                scheduled_start: item.OutageStart,
+                scheduled_end: item.OutageEnd,
                 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()) /
+                duration_hours: item.OutageEnd && item.OutageStart
+                    ? Math.round((new Date(item.OutageEnd).getTime() -
+                        new Date(item.OutageStart).getTime()) /
                         (1000 * 60 * 60))
                     : null,
                 has_scheduled_time: hasScheduledTime,
@@ -324,8 +291,8 @@ export class SystemStatusServer extends BaseAccessServer {
         }
         // 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);
+            const dateA = new Date(a.OutageEnd);
+            const dateB = new Date(b.OutageEnd);
             return dateB.getTime() - dateA.getTime();
         });
         // Apply limit
@@ -336,7 +303,7 @@ export class SystemStatusServer extends BaseAccessServer {
         const affectedResources = new Set();
         const outageTypes = new Set();
         const recentOutages = pastOutages.filter((outage) => {
-            const endTime = new Date(outage.OutageEndDateTime || outage.LastModificationTime);
+            const endTime = new Date(outage.OutageEnd);
             const daysAgo = (Date.now() - endTime.getTime()) / (1000 * 60 * 60 * 24);
             return daysAgo <= 30; // Last 30 days
         });
@@ -351,20 +318,18 @@ export class SystemStatusServer extends BaseAccessServer {
                 outageTypes.add(outage.OutageType);
             }
             // Calculate duration
-            const startTime = new Date(outage.OutageStartDateTime);
-            const endTime = new Date(outage.OutageEndDateTime);
+            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));
             return {
                 ...outage,
-                outage_start: outage.OutageStartDateTime,
-                outage_end: outage.OutageEndDateTime,
+                outage_start: outage.OutageStart,
+                outage_end: outage.OutageEnd,
                 duration_hours: durationHours,
                 days_ago: daysAgo,
                 outage_type: outage.OutageType,
-                posted_time: outage.CreationTime,
-                last_updated: outage.LastModificationTime,
             };
         });
         const summary = {
@@ -401,7 +366,7 @@ export class SystemStatusServer extends BaseAccessServer {
         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 endTime = new Date(outage.OutageEnd);
             const daysAgo = (Date.now() - endTime.getTime()) / (1000 * 60 * 60 * 24);
             return daysAgo <= 30;
         });
@@ -417,8 +382,8 @@ export class SystemStatusServer extends BaseAccessServer {
                 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);
+            const dateA = new Date(a.OutageStart);
+            const dateB = new Date(b.OutageStart);
             return dateB.getTime() - dateA.getTime(); // Most recent first
         })
             .slice(0, limit);
@@ -444,6 +409,9 @@ export class SystemStatusServer extends BaseAccessServer {
         };
     }
     async checkResourceStatus(resourceIds, useGroupApi = false) {
+        if (!resourceIds || !Array.isArray(resourceIds) || resourceIds.length === 0) {
+            throw new Error("resource_ids parameter is required and must be a non-empty array of resource IDs");
+        }
         if (useGroupApi) {
             return await this.checkResourceStatusViaGroups(resourceIds);
         }
@@ -485,8 +453,6 @@ export class SystemStatusServer extends BaseAccessServer {
                 outage_details: affectedOutages.map((outage) => ({
                     subject: outage.Subject,
                     severity,
-                    posted: outage.CreationTime,
-                    last_updated: outage.LastModificationTime,
                 })),
             };
         });
@@ -508,6 +474,9 @@ export class SystemStatusServer extends BaseAccessServer {
         };
     }
     async checkResourceStatusViaGroups(resourceIds) {
+        if (!resourceIds || !Array.isArray(resourceIds) || resourceIds.length === 0) {
+            throw new Error("resource_ids parameter is required and must be a non-empty array of resource IDs");
+        }
         // Try to use the more efficient group-based API
         const statusPromises = resourceIds.map(async (resourceId) => {
             try {
@@ -521,8 +490,6 @@ export class SystemStatusServer extends BaseAccessServer {
                     active_outages: groupData.length,
                     outage_details: groupData.map((outage) => ({
                         subject: outage.Subject,
-                        posted: outage.CreationTime,
-                        last_updated: outage.LastModificationTime,
                     })),
                     api_method: "group_specific",
                 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@access-mcp/system-status",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "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.0",
+    "@access-mcp/shared": "^0.3.3",
     "express": "^4.18.0"
   },
   "devDependencies": {