@access-mcp/system-status 0.4.1 → 0.5.1

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", () => {
@@ -10,51 +13,39 @@ 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",
-            AffectedResources: [
-                { ResourceName: "Anvil", ResourceID: "anvil-1" }
-            ]
+            OutageStart: "2024-08-27T10:00:00Z",
+            OutageEnd: "2024-08-27T11:00:00Z",
+            AffectedResources: [{ ResourceName: "Anvil", ResourceID: "anvil-1" }],
         },
         {
             id: "2",
             Subject: "Scheduled maintenance on Bridges-2",
             Content: "Regular maintenance window",
-            CreationTime: "2024-08-27T08:00:00Z",
-            LastModificationTime: "2024-08-27T08:30:00Z",
-            AffectedResources: [
-                { ResourceName: "Bridges-2", ResourceID: "bridges2-1" }
-            ]
-        }
+            OutageStart: "2024-08-27T08:00:00Z",
+            OutageEnd: "2024-08-27T08:30:00Z",
+            AffectedResources: [{ ResourceName: "Bridges-2", ResourceID: "bridges2-1" }],
+        },
     ];
     const mockFutureOutagesData = [
         {
             id: "3",
             Subject: "Scheduled Jetstream maintenance",
             Content: "Planned maintenance",
-            CreationTime: "2024-08-27T09:00:00Z",
-            LastModificationTime: "2024-08-27T09:00:00Z",
-            OutageStartDateTime: "2024-08-30T10:00:00Z",
-            OutageEndDateTime: "2024-08-30T14:00:00Z",
-            AffectedResources: [
-                { ResourceName: "Jetstream", ResourceID: "jetstream-1" }
-            ]
-        }
+            OutageStart: "2024-08-30T10:00:00Z",
+            OutageEnd: "2024-08-30T14:00:00Z",
+            AffectedResources: [{ ResourceName: "Jetstream", ResourceID: "jetstream-1" }],
+        },
     ];
     const mockPastOutagesData = [
         {
             id: "4",
             Subject: "Past maintenance on Stampede3",
             Content: "Completed maintenance",
-            CreationTime: new Date(Date.now() - 5 * 24 * 60 * 60 * 1000).toISOString(), // 5 days ago
-            LastModificationTime: new Date(Date.now() - 2 * 24 * 60 * 60 * 1000).toISOString(), // 2 days ago
-            OutageStartDateTime: new Date(Date.now() - 3 * 24 * 60 * 60 * 1000).toISOString(), // 3 days ago
-            OutageEndDateTime: new Date(Date.now() - 3 * 24 * 60 * 60 * 1000 + 6 * 60 * 60 * 1000).toISOString(), // 3 days ago + 6 hours  
+            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();
@@ -75,28 +66,22 @@ 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", () => {
             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"]();
             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",
             ]);
         });
     });
@@ -104,44 +89,49 @@ 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_current_outages", arguments: {} }
+                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
             expect(response.severity_counts).toHaveProperty("low", 1); // Scheduled maintenance
             expect(response.outages[0]).toHaveProperty("severity");
-            expect(response.outages[0]).toHaveProperty("posted_time");
         });
         it("should filter outages by resource", async () => {
             mockHttpClient.get.mockResolvedValue({
                 status: 200,
-                data: { results: mockCurrentOutagesData }
+                data: { results: mockCurrentOutagesData },
             });
             const result = await server["handleToolCall"]({
+                method: "tools/call",
                 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);
+            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_current_outages", arguments: {} }
+                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");
@@ -152,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_scheduled_maintenance", arguments: {} }
+                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");
@@ -165,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],
-                    OutageStartDateTime: null,
-                    OutageEndDateTime: null
-                }];
+                    OutageStart: null,
+                    OutageEnd: null,
+                },
+            ];
             mockHttpClient.get.mockResolvedValue({
                 status: 200,
-                data: { results: dataWithoutSchedule }
+                data: { results: dataWithoutSchedule },
             });
             const result = await server["handleToolCall"]({
-                params: { name: "get_scheduled_maintenance", arguments: {} }
+                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);
         });
@@ -185,23 +181,25 @@ describe("SystemStatusServer", () => {
             const multipleMaintenanceData = [
                 {
                     ...mockFutureOutagesData[0],
-                    OutageStartDateTime: "2024-08-31T10:00:00Z", // Later
-                    Subject: "Later maintenance"
+                    OutageStart: "2024-08-31T10:00:00Z", // Later
+                    Subject: "Later maintenance",
                 },
                 {
                     ...mockFutureOutagesData[0],
-                    OutageStartDateTime: "2024-08-30T10:00:00Z", // Earlier
-                    Subject: "Earlier maintenance"
-                }
+                    OutageStart: "2024-08-30T10:00:00Z", // Earlier
+                    Subject: "Earlier maintenance",
+                },
             ];
             mockHttpClient.get.mockResolvedValue({
                 status: 200,
-                data: { results: multipleMaintenanceData }
+                data: { results: multipleMaintenanceData },
             });
             const result = await server["handleToolCall"]({
-                params: { name: "get_scheduled_maintenance", arguments: {} }
+                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");
         });
@@ -210,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_past_outages", arguments: {} }
+                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
@@ -223,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_past_outages",
-                    arguments: { limit: 10 }
-                }
+                    name: "get_infrastructure_news",
+                    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);
         });
     });
@@ -249,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_system_announcements", arguments: {} }
+                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
@@ -266,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_system_announcements", arguments: {} }
+                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");
         });
@@ -277,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: "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);
+            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
@@ -297,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: "check_resource_status",
+                    name: "get_infrastructure_news",
                     arguments: {
-                        resource_ids: ["anvil"],
-                        use_group_api: true
-                    }
-                }
+                        ids: ["anvil"],
+                        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");
@@ -317,16 +329,18 @@ 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: "check_resource_status",
+                    name: "get_infrastructure_news",
                     arguments: {
-                        resource_ids: ["invalid-resource"],
-                        use_group_api: true
-                    }
-                }
+                        ids: ["invalid-resource"],
+                        use_group_api: true,
+                    },
+                },
             });
-            const response = JSON.parse(result.content[0].text);
-            expect(response.unknown).toBe(1);
+            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");
             expect(response.resource_status[0]).toHaveProperty("error");
@@ -336,35 +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_current_outages", arguments: {} }
+                method: "tools/call",
+                params: { name: "get_infrastructure_news", arguments: { time: "current" } },
             });
-            expect(result.content[0].text).toContain("Error");
+            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_current_outages", arguments: {} }
+                method: "tools/call",
+                params: { name: "get_infrastructure_news", arguments: { time: "current" } },
             });
-            expect(result.content[0].text).toContain("Error");
+            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();
@@ -372,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

@@ -1,19 +1,11 @@
 #!/usr/bin/env node
 import { SystemStatusServer } from "./server.js";
 async function main() {
-    // Check if we should run as HTTP server (for deployment)
-    const port = process.env.PORT;
     const server = new SystemStatusServer();
-    if (port) {
-        // Running in HTTP mode (deployment)
-        await server.start({ httpPort: parseInt(port) });
-    }
-    else {
-        // Running in MCP mode (stdio)
-        await server.start();
-    }
+    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,100 +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: {
-                resource_filter: {
-                    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: {
-                    type: string;
-                    description: string;
-                };
-                limit: {
-                    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;
-                };
-                use_group_api: {
-                    type: string;
-                    description: string;
-                    default: boolean;
-                };
-                resource_filter?: undefined;
-                limit?: undefined;
-            };
-            required: string[];
-        };
-    })[];
-    protected getResources(): {
-        uri: string;
-        name: string;
-        description: string;
-        mimeType: string;
-    }[];
-    handleToolCall(request: any): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-    }>;
-    handleResourceRead(request: any): Promise<{
-        contents: {
-            uri: any;
-            mimeType: 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;
+    protected handleResourceRead(request: ReadResourceRequest): Promise<ReadResourceResult>;
     private getCurrentOutages;
     private getScheduledMaintenance;
     private getPastOutages;