@access-mcp/system-status 0.6.0 → 0.7.0

package/README.md

@@ -29,11 +29,11 @@ Get infrastructure status, outages, and maintenance information for ACCESS-CI re
 **Parameters:**
 | 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 |
+| `resource` | string | Filter by resource name (e.g., "delta", "bridges2", "anvil") |
+| `outage_type` | enum | Filter by type: `Full`, `Partial`, `Degraded`, `Reconfiguration` |
+| `ids` | array | Check operational status for specific resources by name or ID |
 | `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:**
 ```javascript
@@ -46,12 +46,20 @@ get_infrastructure_news({ time: "scheduled" })
 // Get comprehensive overview
 get_infrastructure_news({ time: "all" })
 
-// Check current status for specific resource
+// Filter to a specific resource
 get_infrastructure_news({ resource: "delta", time: "current" })
 
-// Check operational status of specific resources
+// Filter by outage type
+get_infrastructure_news({ outage_type: "Full" })
+
+// Check operational status of specific resources (by name or ID)
+get_infrastructure_news({
+  ids: ["Anvil", "Delta", "Bridges-2"]
+})
+
+// Or using full resource IDs
 get_infrastructure_news({
-  resource_ids: ["delta.ncsa.access-ci.org", "bridges2.psc.access-ci.org"]
+  ids: ["delta.ncsa.access-ci.org", "bridges2.psc.access-ci.org"]
 })
 
 // Get past outages with limit
@@ -80,3 +88,6 @@ npm install -g @access-mcp/system-status
 ## Resources
 
 - `accessci://system-status` - Current operational status of all ACCESS-CI resources
+- `accessci://outages/current` - Currently active outages
+- `accessci://outages/scheduled` - Upcoming scheduled maintenance
+- `accessci://outages/past` - Historical outages

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

@@ -106,15 +106,15 @@ describe("SystemStatusServer Integration Tests", () => {
                 expect(["current", "scheduled", "recent_past"]).toContain(announcement.category);
             }
         }, 15000);
-        it("should check resource status with direct method", async () => {
+        it("should check resource status using group API", async () => {
             // Test with human-readable names - these get resolved to full IDs
+            // The group API is used automatically for efficient per-resource queries
             const result = await server["handleToolCall"]({
                 method: "tools/call",
                 params: {
                     name: "get_infrastructure_news",
                     arguments: {
                         ids: ["Anvil", "Delta", "Expanse"],
-                        use_group_api: false,
                     },
                 },
             });
@@ -124,7 +124,6 @@ describe("SystemStatusServer Integration Tests", () => {
             expect(responseData).toHaveProperty("resources_checked", 3);
             expect(responseData).toHaveProperty("operational");
             expect(responseData).toHaveProperty("affected");
-            expect(responseData).toHaveProperty("api_method", "direct_outages_check");
             expect(Array.isArray(responseData.resource_status)).toBe(true);
             expect(responseData.resource_status).toHaveLength(3);
             // Check resource status structure - IDs should be resolved to full format
@@ -132,50 +131,40 @@ describe("SystemStatusServer Integration Tests", () => {
                 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(["operational", "affected", "unknown"]).toContain(resource.status);
                 expect(resource).toHaveProperty("active_outages");
                 expect(Array.isArray(resource.outage_details)).toBe(true);
             });
         }, 15000);
-        it("should test group API functionality", async () => {
-            // Test group API with a human-readable name
+        it("should check single resource status", async () => {
+            // Test with a single human-readable name
             const result = await server["handleToolCall"]({
                 method: "tools/call",
                 params: {
                     name: "get_infrastructure_news",
                     arguments: {
                         ids: ["Anvil"],
-                        use_group_api: true,
                     },
                 },
             });
             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.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
-            if (resourceStatus.api_method === "group_specific") {
-                expect(resourceStatus).toHaveProperty("status");
-                expect(["operational", "affected"]).toContain(resourceStatus.status);
-            }
-            // If it failed, check error handling
-            if (resourceStatus.api_method === "group_specific_failed") {
-                expect(resourceStatus.status).toBe("unknown");
-                expect(resourceStatus).toHaveProperty("error");
-            }
+            expect(resourceStatus).toHaveProperty("status");
+            expect(["operational", "affected", "unknown"]).toContain(resourceStatus.status);
+            expect(resourceStatus).toHaveProperty("active_outages");
+            expect(resourceStatus).toHaveProperty("outage_details");
         }, 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", resource: "anvil" },
                 },
             });
             const content = result.content[0];
@@ -220,11 +209,12 @@ describe("SystemStatusServer Integration Tests", () => {
     describe("Edge Cases and Error Handling", () => {
         it("should handle empty API responses", async () => {
             // This tests the robustness of our logic with potentially empty responses
+            // Using a resource filter that won't match anything
             const result = await server["handleToolCall"]({
                 method: "tools/call",
                 params: {
                     name: "get_infrastructure_news",
-                    arguments: { time: "current", query: "nonexistent-resource-xyz-12345" },
+                    arguments: { time: "current", resource: "nonexistent-resource-xyz-12345" },
                 },
             });
             const content = result.content[0];

package/dist/__tests__/server.test.js

@@ -15,6 +15,7 @@ describe("SystemStatusServer", () => {
             Content: "Critical issue requiring immediate attention",
             OutageStart: "2024-08-27T10:00:00Z",
             OutageEnd: "2024-08-27T11:00:00Z",
+            OutageType: "Full",
             AffectedResources: [{ ResourceName: "Anvil", ResourceID: "anvil-1.purdue.access-ci.org" }],
         },
         {
@@ -23,6 +24,7 @@ describe("SystemStatusServer", () => {
             Content: "Regular maintenance window",
             OutageStart: "2024-08-27T08:00:00Z",
             OutageEnd: "2024-08-27T08:30:00Z",
+            OutageType: "Partial",
             AffectedResources: [{ ResourceName: "Bridges-2", ResourceID: "bridges2.psc.access-ci.org" }],
         },
     ];
@@ -113,7 +115,7 @@ describe("SystemStatusServer", () => {
                 method: "tools/call",
                 params: {
                     name: "get_infrastructure_news",
-                    arguments: { query: "Anvil", time: "current" },
+                    arguments: { resource: "Anvil", time: "current" },
                 },
             });
             const content = result.content[0];
@@ -121,6 +123,59 @@ describe("SystemStatusServer", () => {
             expect(response.total_outages).toBe(1);
             expect(response.outages[0].Subject).toContain("Anvil");
         });
+        it("should filter outages by outage_type", async () => {
+            mockHttpClient.get.mockResolvedValue({
+                status: 200,
+                data: { results: mockCurrentOutagesData },
+            });
+            const result = await server["handleToolCall"]({
+                method: "tools/call",
+                params: {
+                    name: "get_infrastructure_news",
+                    arguments: { outage_type: "Full", time: "current" },
+                },
+            });
+            const content = result.content[0];
+            const response = JSON.parse(content.text);
+            expect(response.total_outages).toBe(1);
+            expect(response.outages[0].OutageType).toBe("Full");
+            expect(response.outages[0].Subject).toContain("Anvil");
+        });
+        it("should filter by both resource and outage_type", async () => {
+            mockHttpClient.get.mockResolvedValue({
+                status: 200,
+                data: { results: mockCurrentOutagesData },
+            });
+            // Filter for Partial outages on Bridges-2
+            const result = await server["handleToolCall"]({
+                method: "tools/call",
+                params: {
+                    name: "get_infrastructure_news",
+                    arguments: { resource: "Bridges", outage_type: "Partial", time: "current" },
+                },
+            });
+            const content = result.content[0];
+            const response = JSON.parse(content.text);
+            expect(response.total_outages).toBe(1);
+            expect(response.outages[0].OutageType).toBe("Partial");
+        });
+        it("should return empty when outage_type filter matches nothing", async () => {
+            mockHttpClient.get.mockResolvedValue({
+                status: 200,
+                data: { results: mockCurrentOutagesData },
+            });
+            const result = await server["handleToolCall"]({
+                method: "tools/call",
+                params: {
+                    name: "get_infrastructure_news",
+                    arguments: { outage_type: "Degraded", time: "current" },
+                },
+            });
+            const content = result.content[0];
+            const response = JSON.parse(content.text);
+            expect(response.total_outages).toBe(0);
+            expect(response.outages).toHaveLength(0);
+        });
         it("should categorize severity correctly", async () => {
             mockHttpClient.get.mockResolvedValue({
                 status: 200,
@@ -282,75 +337,62 @@ describe("SystemStatusServer", () => {
         });
     });
     describe("checkResourceStatus", () => {
-        it("should check resource status efficiently (direct method)", async () => {
-            mockHttpClient.get.mockResolvedValue({
+        it("should check resource status using group API", async () => {
+            // Mock group API responses for each resource
+            const now = new Date();
+            const activeOutage = {
+                Subject: "Current outage on Anvil",
+                OutageStart: new Date(now.getTime() - 3600000).toISOString(), // 1 hour ago
+                OutageEnd: null, // Still active
+                OutageType: "Full",
+            };
+            mockHttpClient.get
+                .mockResolvedValueOnce({
                 status: 200,
-                data: { results: mockCurrentOutagesData },
+                data: { results: [activeOutage] }, // anvil has active outage
+            })
+                .mockResolvedValueOnce({
+                status: 200,
+                data: { results: [] }, // unknown resource has no outages
             });
             // Use full IDs with dots to skip resolution lookup
             const result = await server["handleToolCall"]({
                 method: "tools/call",
                 params: {
                     name: "get_infrastructure_news",
-                    arguments: { ids: ["anvil-1.purdue.access-ci.org", "unknown.resource.org"] },
+                    arguments: { ids: ["anvil.purdue.access-ci.org", "unknown.resource.org"] },
                 },
             });
+            expect(mockHttpClient.get).toHaveBeenCalledWith("/wh2/news/v1/info_groupid/anvil.purdue.access-ci.org/");
+            expect(mockHttpClient.get).toHaveBeenCalledWith("/wh2/news/v1/info_groupid/unknown.resource.org/");
             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.org
-            expect(response.affected).toBe(1); // anvil-1.purdue.access-ci.org
-            const anvilStatus = response.resource_status.find((r) => r.resource_id === "anvil-1.purdue.access-ci.org");
+            expect(response.affected).toBe(1); // anvil.purdue.access-ci.org
+            const anvilStatus = response.resource_status.find((r) => r.resource_id === "anvil.purdue.access-ci.org");
             expect(anvilStatus.status).toBe("affected");
-            expect(anvilStatus.severity).toBe("high"); // Emergency maintenance
-        });
-        it("should use group API when requested", async () => {
-            mockHttpClient.get.mockResolvedValue({
-                status: 200,
-                data: { results: [] }, // No outages for this group
-            });
-            // Use full ID with dots to skip resolution lookup
-            const result = await server["handleToolCall"]({
-                method: "tools/call",
-                params: {
-                    name: "get_infrastructure_news",
-                    arguments: {
-                        ids: ["anvil.purdue.access-ci.org"],
-                        use_group_api: true,
-                    },
-                },
-            });
-            expect(mockHttpClient.get).toHaveBeenCalledWith("/wh2/news/v1/info_groupid/anvil.purdue.access-ci.org/");
-            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");
+            expect(anvilStatus.severity).toBe("high"); // Full outage = high
+            expect(anvilStatus.outage_details[0].outage_type).toBe("Full");
         });
         it("should handle group API failures gracefully", async () => {
             mockHttpClient.get.mockRejectedValue(new Error("API Error"));
-            // Use full ID with dots to skip resolution lookup
             const result = await server["handleToolCall"]({
                 method: "tools/call",
                 params: {
                     name: "get_infrastructure_news",
-                    arguments: {
-                        ids: ["invalid.resource.org"],
-                        use_group_api: true,
-                    },
+                    arguments: { ids: ["failing.resource.org"] },
                 },
             });
             const content = result.content[0];
             const response = JSON.parse(content.text);
-            expect(response).toHaveProperty("unknown", 1);
+            expect(response.unknown).toBe(1);
             expect(response.resource_status[0].status).toBe("unknown");
-            expect(response.resource_status[0].api_method).toBe("group_specific_failed");
             expect(response.resource_status[0]).toHaveProperty("error");
         });
         it("should resolve human-readable name to resource ID", async () => {
             // First call: resource search for name resolution
-            // Second call: current outages
+            // Second call: group API for the resolved resource ID
             mockHttpClient.get
                 .mockResolvedValueOnce({
                 status: 200,
@@ -364,7 +406,7 @@ describe("SystemStatusServer", () => {
             })
                 .mockResolvedValueOnce({
                 status: 200,
-                data: { results: [] }, // No outages
+                data: { results: [] }, // No outages from group API
             });
             const result = await server["handleToolCall"]({
                 method: "tools/call",
@@ -373,10 +415,14 @@ describe("SystemStatusServer", () => {
                     arguments: { ids: ["Anvil"] },
                 },
             });
+            // Should have called resource search first, then group API
+            expect(mockHttpClient.get).toHaveBeenCalledWith("/wh2/cider/v1/access-active-groups/type/resource-catalog.access-ci.org/");
+            expect(mockHttpClient.get).toHaveBeenCalledWith("/wh2/news/v1/info_groupid/anvil.purdue.access-ci.org/");
             const content = result.content[0];
             const response = JSON.parse(content.text);
             expect(response.resources_checked).toBe(1);
             expect(response.resource_status[0].resource_id).toBe("anvil.purdue.access-ci.org");
+            expect(response.resource_status[0].status).toBe("operational"); // No current outages
         });
         it("should return error when resource name is ambiguous", async () => {
             mockHttpClient.get.mockResolvedValueOnce({

package/dist/server.d.ts

@@ -21,5 +21,4 @@ export declare class SystemStatusServer extends BaseAccessServer {
     private getPastOutages;
     private getSystemAnnouncements;
     private checkResourceStatus;
-    private checkResourceStatusViaGroups;
 }

package/dist/server.js

@@ -30,35 +30,35 @@ export class SystemStatusServer extends BaseAccessServer {
         return [
             {
                 name: "get_infrastructure_news",
-                description: "Get ACCESS-CI infrastructure status (outages, maintenance, incidents). Returns {total, items}.",
+                description: "Get ACCESS-CI infrastructure status including outages, maintenance, and incidents. With no parameters, returns current active outages. Use 'time' to get scheduled/past outages, 'resource' to filter to a specific system, or 'ids' to check status of specific resources.",
                 inputSchema: {
                     type: "object",
                     properties: {
-                        query: {
-                            type: "string",
-                            description: "Filter by resource name (e.g., 'delta', 'bridges2')",
-                        },
                         time: {
                             type: "string",
                             enum: ["current", "scheduled", "past", "all"],
-                            description: "Time filter. Values: 'current' for active outages, 'scheduled' for future/planned, 'past' for historical, 'all' for everything",
+                            description: "Time period: 'current' (active now), 'scheduled' (planned/future), 'past' (historical), 'all' (combined view)",
                             default: "current",
                         },
+                        resource: {
+                            type: "string",
+                            description: "Filter to a specific resource by name (e.g., 'delta', 'bridges2', 'anvil')",
+                        },
+                        outage_type: {
+                            type: "string",
+                            enum: ["Full", "Partial", "Degraded", "Reconfiguration"],
+                            description: "Filter by severity: 'Full' (complete outage), 'Partial' (some services affected), 'Degraded' (reduced performance), 'Reconfiguration' (system changes)",
+                        },
                         ids: {
                             type: "array",
                             items: { type: "string" },
-                            description: "Check status for specific resources. Accepts names (e.g., 'Anvil', 'Delta') or full IDs (e.g., 'anvil.purdue.access-ci.org')",
+                            description: "Check operational status for specific resources. Returns 'operational' or 'affected' for each. Accepts names ('Anvil') or IDs ('anvil.purdue.access-ci.org')",
                         },
                         limit: {
                             type: "number",
-                            description: "Max results (default: 50)",
+                            description: "Max results to return",
                             default: 50,
                         },
-                        use_group_api: {
-                            type: "boolean",
-                            description: "Use group API for status (with ids only)",
-                            default: false,
-                        },
                     },
                 },
             },
@@ -99,11 +99,11 @@ export class SystemStatusServer extends BaseAccessServer {
             switch (name) {
                 case "get_infrastructure_news":
                     return await this.getInfrastructureNewsRouter({
-                        resource: typedArgs.query,
+                        resource: typedArgs.resource,
                         time: typedArgs.time,
+                        outage_type: typedArgs.outage_type,
                         resource_ids: typedArgs.ids,
                         limit: typedArgs.limit,
-                        use_group_api: typedArgs.use_group_api,
                     });
                 default:
                     return this.errorResponse(`Unknown tool: ${name}`);
@@ -118,21 +118,21 @@ export class SystemStatusServer extends BaseAccessServer {
      * Routes to appropriate handler based on parameters
      */
     async getInfrastructureNewsRouter(args) {
-        const { resource, time = "current", resource_ids, limit, use_group_api = false } = args;
+        const { resource, time = "current", outage_type, resource_ids, limit } = args;
         // Check resource status (returns operational/affected) - only if IDs provided
         if (resource_ids && Array.isArray(resource_ids) && resource_ids.length > 0) {
-            return await this.checkResourceStatus(resource_ids, use_group_api);
+            return await this.checkResourceStatus(resource_ids);
         }
         // Time-based routing
         switch (time) {
             case "current":
-                return await this.getCurrentOutages(resource);
+                return await this.getCurrentOutages(resource, outage_type);
             case "scheduled":
-                return await this.getScheduledMaintenance(resource);
+                return await this.getScheduledMaintenance(resource, outage_type);
             case "past":
-                return await this.getPastOutages(resource, limit || 100);
+                return await this.getPastOutages(resource, outage_type, limit || 100);
             case "all":
-                return await this.getSystemAnnouncements(limit || 50);
+                return await this.getSystemAnnouncements(outage_type, limit || 50);
             default:
                 throw new Error(`Invalid time parameter: ${time}. Must be one of: current, scheduled, past, all`);
         }
@@ -197,9 +197,13 @@ export class SystemStatusServer extends BaseAccessServer {
                 throw new Error(`Unknown resource: ${uri}`);
         }
     }
-    async getCurrentOutages(resourceFilter) {
+    async getCurrentOutages(resourceFilter, outageTypeFilter) {
         const response = await this.httpClient.get("/wh2/news/v1/affiliation/access-ci.org/current_outages/");
         let outages = response.data.results || [];
+        // Filter by outage type if specified
+        if (outageTypeFilter) {
+            outages = outages.filter((outage) => outage.OutageType?.toLowerCase() === outageTypeFilter.toLowerCase());
+        }
         // Filter by resource if specified
         if (resourceFilter) {
             const filter = resourceFilter.toLowerCase();
@@ -251,9 +255,13 @@ export class SystemStatusServer extends BaseAccessServer {
             ],
         };
     }
-    async getScheduledMaintenance(resourceFilter) {
+    async getScheduledMaintenance(resourceFilter, outageTypeFilter) {
         const response = await this.httpClient.get("/wh2/news/v1/affiliation/access-ci.org/future_outages/");
         let maintenance = response.data.results || [];
+        // Filter by outage type if specified
+        if (outageTypeFilter) {
+            maintenance = maintenance.filter((item) => item.OutageType?.toLowerCase() === outageTypeFilter.toLowerCase());
+        }
         // Filter by resource if specified
         if (resourceFilter) {
             const filter = resourceFilter.toLowerCase();
@@ -315,9 +323,13 @@ export class SystemStatusServer extends BaseAccessServer {
             ],
         };
     }
-    async getPastOutages(resourceFilter, limit = 100) {
+    async getPastOutages(resourceFilter, outageTypeFilter, limit = 100) {
         const response = await this.httpClient.get("/wh2/news/v1/affiliation/access-ci.org/past_outages/");
         let pastOutages = response.data.results || [];
+        // Filter by outage type if specified
+        if (outageTypeFilter) {
+            pastOutages = pastOutages.filter((outage) => outage.OutageType?.toLowerCase() === outageTypeFilter.toLowerCase());
+        }
         // Filter by resource if specified
         if (resourceFilter) {
             const filter = resourceFilter.toLowerCase();
@@ -392,16 +404,23 @@ export class SystemStatusServer extends BaseAccessServer {
             ],
         };
     }
-    async getSystemAnnouncements(limit = 50) {
+    async getSystemAnnouncements(outageTypeFilter, limit = 50) {
         // Get current, future, and recent past announcements for comprehensive view
         const [currentResponse, futureResponse, pastResponse] = await Promise.all([
             this.httpClient.get("/wh2/news/v1/affiliation/access-ci.org/current_outages/"),
             this.httpClient.get("/wh2/news/v1/affiliation/access-ci.org/future_outages/"),
             this.httpClient.get("/wh2/news/v1/affiliation/access-ci.org/past_outages/"),
         ]);
-        const currentOutages = currentResponse.data.results || [];
-        const futureOutages = futureResponse.data.results || [];
-        const pastOutagesData = pastResponse.data.results || [];
+        let currentOutages = currentResponse.data.results || [];
+        let futureOutages = futureResponse.data.results || [];
+        let pastOutagesData = pastResponse.data.results || [];
+        // Filter by outage type if specified
+        if (outageTypeFilter) {
+            const typeFilter = outageTypeFilter.toLowerCase();
+            currentOutages = currentOutages.filter((o) => o.OutageType?.toLowerCase() === typeFilter);
+            futureOutages = futureOutages.filter((o) => o.OutageType?.toLowerCase() === typeFilter);
+            pastOutagesData = pastOutagesData.filter((o) => o.OutageType?.toLowerCase() === typeFilter);
+        }
         // Filter recent past outages (last 30 days) for announcements
         const recentPastOutages = pastOutagesData.filter((outage) => {
             const endTime = new Date(outage.OutageEnd || "");
@@ -449,7 +468,7 @@ export class SystemStatusServer extends BaseAccessServer {
             ],
         };
     }
-    async checkResourceStatus(resourceIds, useGroupApi = false) {
+    async checkResourceStatus(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");
         }
@@ -483,97 +502,50 @@ export class SystemStatusServer extends BaseAccessServer {
                 ],
             };
         }
-        if (useGroupApi) {
-            return await this.checkResourceStatusViaGroups(resolvedIds);
-        }
-        // Efficient approach: fetch raw current outages data once
-        const response = await this.httpClient.get("/wh2/news/v1/affiliation/access-ci.org/current_outages/");
-        const rawOutages = response.data.results || [];
-        const resourceStatus = resolvedIds.map((resourceId) => {
-            const affectedOutages = rawOutages.filter((outage) => outage.AffectedResources?.some((resource) => resource.ResourceID?.toString() === resourceId ||
-                resource.ResourceName?.toLowerCase().includes(resourceId.toLowerCase())));
-            let status = "operational";
-            let severity = null;
-            if (affectedOutages.length > 0) {
-                status = "affected";
-                // Get highest severity using same logic as getCurrentOutages
-                const severities = affectedOutages.map((outage) => {
-                    const subject = outage.Subject?.toLowerCase() || "";
-                    if (subject.includes("emergency") || subject.includes("critical")) {
-                        return "high";
-                    }
-                    else if (subject.includes("maintenance") || subject.includes("scheduled")) {
-                        return "low";
-                    }
-                    else {
-                        return "medium";
-                    }
-                });
-                if (severities.includes("high"))
-                    severity = "high";
-                else if (severities.includes("medium"))
-                    severity = "medium";
-                else
-                    severity = "low";
-            }
-            return {
-                resource_id: resourceId,
-                status,
-                severity,
-                active_outages: affectedOutages.length,
-                outage_details: affectedOutages.map((outage) => ({
-                    subject: outage.Subject,
-                    severity,
-                })),
-            };
-        });
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: JSON.stringify({
-                        checked_at: new Date().toISOString(),
-                        resources_checked: resolvedIds.length,
-                        operational: resourceStatus.filter((r) => r.status === "operational").length,
-                        affected: resourceStatus.filter((r) => r.status === "affected").length,
-                        api_method: "direct_outages_check",
-                        resource_status: resourceStatus,
-                    }, null, 2),
-                },
-            ],
-        };
-    }
-    async checkResourceStatusViaGroups(resourceIds) {
-        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) => {
+        // Use group API for efficient per-resource queries
+        const now = new Date();
+        const statusPromises = resolvedIds.map(async (resourceId) => {
             try {
                 const response = await this.httpClient.get(`/wh2/news/v1/info_groupid/${resourceId}/`);
-                const groupData = response.data.results || [];
-                const hasOutages = groupData.length > 0;
+                const allOutages = response.data.results || [];
+                // Filter to current outages only (started and not ended)
+                const currentOutages = allOutages.filter((outage) => {
+                    const start = outage.OutageStart ? new Date(outage.OutageStart) : null;
+                    const end = outage.OutageEnd ? new Date(outage.OutageEnd) : null;
+                    return start && start <= now && (!end || end > now);
+                });
+                let status = "operational";
+                let severity = null;
+                if (currentOutages.length > 0) {
+                    status = "affected";
+                    // Determine severity from OutageType
+                    const types = currentOutages.map((o) => o.OutageType?.toLowerCase());
+                    if (types.includes("full"))
+                        severity = "high";
+                    else if (types.includes("degraded") || types.includes("partial"))
+                        severity = "medium";
+                    else
+                        severity = "low";
+                }
                 return {
                     resource_id: resourceId,
-                    status: hasOutages ? "affected" : "operational",
-                    severity: hasOutages ? "medium" : null,
-                    active_outages: groupData.length,
-                    outage_details: groupData.map((outage) => ({
+                    status,
+                    severity,
+                    active_outages: currentOutages.length,
+                    outage_details: currentOutages.map((outage) => ({
                         subject: outage.Subject,
+                        outage_type: outage.OutageType,
                     })),
-                    api_method: "group_specific",
                 };
             }
             catch {
-                // Fallback to general check if group API fails
                 return {
                     resource_id: resourceId,
                     status: "unknown",
                     severity: null,
                     active_outages: 0,
                     outage_details: [],
-                    error: `Group API failed for ${resourceId}`,
-                    api_method: "group_specific_failed",
+                    error: `Failed to fetch status for ${resourceId}`,
                 };
             }
         });
@@ -583,12 +555,11 @@ export class SystemStatusServer extends BaseAccessServer {
                 {
                     type: "text",
                     text: JSON.stringify({
-                        checked_at: new Date().toISOString(),
-                        resources_checked: resourceIds.length,
+                        checked_at: now.toISOString(),
+                        resources_checked: resolvedIds.length,
                         operational: resourceStatus.filter((r) => r.status === "operational").length,
                         affected: resourceStatus.filter((r) => r.status === "affected").length,
                         unknown: resourceStatus.filter((r) => r.status === "unknown").length,
-                        api_method: "resource_group_api",
                         resource_status: resourceStatus,
                     }, null, 2),
                 },

package/package.json

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