@access-mcp/system-status 0.5.1 → 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 () => {
-            // Test with common resource names that might exist
+        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", "bridges", "jetstream"],
-                        use_group_api: false,
+                        ids: ["Anvil", "Delta", "Expanse"],
                     },
                 },
             });
@@ -124,56 +124,47 @@ 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
+            // Check resource status structure - IDs should be resolved to full format
             responseData.resource_status.forEach((resource) => {
                 expect(resource).toHaveProperty("resource_id");
+                expect(resource.resource_id).toContain(".access-ci.org"); // Resolved to full ID
                 expect(resource).toHaveProperty("status");
-                expect(["operational", "affected"]).toContain(resource.status);
+                expect(["operational", "affected", "unknown"]).toContain(resource.status);
                 expect(resource).toHaveProperty("active_outages");
                 expect(Array.isArray(resource.outage_details)).toBe(true);
             });
-        }, 10000);
-        it("should test group API functionality", async () => {
-            // Test group API with a resource that might have a group ID
+        }, 15000);
+        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,
+                        ids: ["Anvil"],
                     },
                 },
             });
             const content = result.content[0];
             const responseData = JSON.parse(content.text);
-            expect(responseData).toHaveProperty("api_method", "resource_group_api");
             expect(responseData).toHaveProperty("resources_checked", 1);
             expect(responseData.resource_status).toHaveLength(1);
             const resourceStatus = responseData.resource_status[0];
-            expect(resourceStatus).toHaveProperty("resource_id", "anvil");
-            expect(resourceStatus).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");
-            }
-        }, 10000);
+            expect(resourceStatus.resource_id).toContain("anvil"); // Resolved ID contains anvil
+            expect(resourceStatus.resource_id).toContain(".access-ci.org");
+            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];
@@ -207,7 +198,10 @@ describe("SystemStatusServer Integration Tests", () => {
                 expect(result.contents[0]).toHaveProperty("text");
                 if (uri !== "accessci://system-status") {
                     // JSON resources should have valid JSON
-                    expect(() => JSON.parse(result.contents[0].text)).not.toThrow();
+                    const content = result.contents[0];
+                    if ("text" in content) {
+                        expect(() => JSON.parse(content.text)).not.toThrow();
+                    }
                 }
             }
         }, 15000);
@@ -215,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,7 +15,8 @@ describe("SystemStatusServer", () => {
             Content: "Critical issue requiring immediate attention",
             OutageStart: "2024-08-27T10:00:00Z",
             OutageEnd: "2024-08-27T11:00:00Z",
-            AffectedResources: [{ ResourceName: "Anvil", ResourceID: "anvil-1" }],
+            OutageType: "Full",
+            AffectedResources: [{ ResourceName: "Anvil", ResourceID: "anvil-1.purdue.access-ci.org" }],
         },
         {
             id: "2",
@@ -23,7 +24,8 @@ describe("SystemStatusServer", () => {
             Content: "Regular maintenance window",
             OutageStart: "2024-08-27T08:00:00Z",
             OutageEnd: "2024-08-27T08:30:00Z",
-            AffectedResources: [{ ResourceName: "Bridges-2", ResourceID: "bridges2-1" }],
+            OutageType: "Partial",
+            AffectedResources: [{ ResourceName: "Bridges-2", ResourceID: "bridges2.psc.access-ci.org" }],
         },
     ];
     const mockFutureOutagesData = [
@@ -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,68 +337,122 @@ 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", "unknown-resource"] },
+                    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
-            expect(response.affected).toBe(1); // anvil-1
-            const anvilStatus = response.resource_status.find((r) => r.resource_id === "anvil-1");
+            expect(response.operational).toBe(1); // unknown.resource.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
+            expect(anvilStatus.severity).toBe("high"); // Full outage = high
+            expect(anvilStatus.outage_details[0].outage_type).toBe("Full");
         });
-        it("should use group API when requested", async () => {
-            mockHttpClient.get.mockResolvedValue({
+        it("should handle group API failures gracefully", async () => {
+            mockHttpClient.get.mockRejectedValue(new Error("API Error"));
+            const result = await server["handleToolCall"]({
+                method: "tools/call",
+                params: {
+                    name: "get_infrastructure_news",
+                    arguments: { ids: ["failing.resource.org"] },
+                },
+            });
+            const content = result.content[0];
+            const response = JSON.parse(content.text);
+            expect(response.unknown).toBe(1);
+            expect(response.resource_status[0].status).toBe("unknown");
+            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: group API for the resolved resource ID
+            mockHttpClient.get
+                .mockResolvedValueOnce({
                 status: 200,
-                data: { results: [] }, // No outages for this group
+                data: {
+                    results: {
+                        active_groups: [
+                            { info_groupid: "anvil.purdue.access-ci.org", group_descriptive_name: "Anvil" },
+                        ],
+                    },
+                },
+            })
+                .mockResolvedValueOnce({
+                status: 200,
+                data: { results: [] }, // No outages from group API
             });
             const result = await server["handleToolCall"]({
                 method: "tools/call",
                 params: {
                     name: "get_infrastructure_news",
-                    arguments: {
-                        ids: ["anvil"],
-                        use_group_api: true,
-                    },
+                    arguments: { ids: ["Anvil"] },
                 },
             });
-            expect(mockHttpClient.get).toHaveBeenCalledWith("/wh2/news/v1/info_groupid/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.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(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 handle group API failures gracefully", async () => {
-            mockHttpClient.get.mockRejectedValue(new Error("API Error"));
+        it("should return error when resource name is ambiguous", async () => {
+            mockHttpClient.get.mockResolvedValueOnce({
+                status: 200,
+                data: {
+                    results: {
+                        active_groups: [
+                            {
+                                info_groupid: "stampede2.tacc.access-ci.org",
+                                group_descriptive_name: "Stampede 2",
+                            },
+                            {
+                                info_groupid: "stampede3.tacc.access-ci.org",
+                                group_descriptive_name: "Stampede 3",
+                            },
+                        ],
+                    },
+                },
+            });
             const result = await server["handleToolCall"]({
                 method: "tools/call",
                 params: {
                     name: "get_infrastructure_news",
-                    arguments: {
-                        ids: ["invalid-resource"],
-                        use_group_api: true,
-                    },
+                    arguments: { ids: ["Stampede"] },
                 },
             });
             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");
+            expect(response.error).toContain("Could not resolve");
+            expect(response.resolution_errors[0].error).toContain("Multiple resources match");
         });
     });
     describe("Error Handling", () => {
@@ -391,7 +500,7 @@ describe("SystemStatusServer", () => {
                 params: { uri: "accessci://outages/current" },
             });
             expect(result.contents[0].mimeType).toBe("application/json");
-            expect(result.contents[0].text).toBeDefined();
+            expect("text" in result.contents[0] && result.contents[0].text).toBeDefined();
         });
         it("should handle unknown resources", async () => {
             await expect(async () => {

package/dist/server.d.ts

@@ -2,6 +2,11 @@ import { BaseAccessServer, Tool, Resource, CallToolResult } from "@access-mcp/sh
 import { CallToolRequest, ReadResourceRequest, ReadResourceResult } from "@modelcontextprotocol/sdk/types.js";
 export declare class SystemStatusServer extends BaseAccessServer {
     constructor();
+    /**
+     * Search for resources by name to resolve human-readable names to full IDs.
+     * Used by resolveResourceId callback.
+     */
+    private searchResourcesByName;
     protected getTools(): Tool[];
     protected getResources(): Resource[];
     protected handleToolCall(request: CallToolRequest): Promise<CallToolResult>;
@@ -16,5 +21,4 @@ export declare class SystemStatusServer extends BaseAccessServer {
     private getPastOutages;
     private getSystemAnnouncements;
     private checkResourceStatus;
-    private checkResourceStatusViaGroups;
 }

package/dist/server.js

@@ -1,4 +1,4 @@
-import { BaseAccessServer, handleApiError, } from "@access-mcp/shared";
+import { BaseAccessServer, handleApiError, resolveResourceId, } from "@access-mcp/shared";
 import { createRequire } from "module";
 const require = createRequire(import.meta.url);
 const { version } = require("../package.json");
@@ -6,39 +6,59 @@ export class SystemStatusServer extends BaseAccessServer {
     constructor() {
         super("access-mcp-system-status", version, "https://operations-api.access-ci.org");
     }
+    /**
+     * Search for resources by name to resolve human-readable names to full IDs.
+     * Used by resolveResourceId callback.
+     */
+    async searchResourcesByName(query) {
+        try {
+            const response = await this.httpClient.get("/wh2/cider/v1/access-active-groups/type/resource-catalog.access-ci.org/");
+            const groups = response.data.results?.active_groups || [];
+            const queryLower = query.toLowerCase();
+            return groups
+                .filter((g) => g.group_descriptive_name?.toLowerCase().includes(queryLower))
+                .map((g) => ({
+                id: g.info_groupid || "",
+                name: g.group_descriptive_name || "",
+            }));
+        }
+        catch {
+            return [];
+        }
+    }
     getTools() {
         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: "Period: current (active), scheduled (future), past, all",
+                            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 resource IDs",
+                            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,
-                        },
                     },
                 },
             },
@@ -79,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}`);
@@ -98,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;
-        // Check resource status (returns operational/affected)
-        if (resource_ids && Array.isArray(resource_ids)) {
-            return await this.checkResourceStatus(resource_ids, use_group_api);
+        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);
         }
         // 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`);
         }
@@ -177,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();
@@ -231,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();
@@ -295,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();
@@ -372,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 || "");
@@ -429,101 +468,84 @@ 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");
         }
-        if (useGroupApi) {
-            return await this.checkResourceStatusViaGroups(resourceIds);
-        }
-        // 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 = resourceIds.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";
+        // Resolve all resource names to IDs first
+        const resolvedIds = [];
+        const resolutionErrors = [];
+        for (const inputId of resourceIds) {
+            const resolved = await resolveResourceId(inputId, (query) => this.searchResourcesByName(query));
+            if (resolved.success) {
+                resolvedIds.push(resolved.id);
+            }
+            else {
+                resolutionErrors.push({ input: inputId, error: resolved.error });
             }
+        }
+        // If any resolutions failed, return errors
+        if (resolutionErrors.length > 0) {
             return {
-                resource_id: resourceId,
-                status,
-                severity,
-                active_outages: affectedOutages.length,
-                outage_details: affectedOutages.map((outage) => ({
-                    subject: outage.Subject,
-                    severity,
-                })),
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            error: "Could not resolve some resource names",
+                            resolution_errors: resolutionErrors,
+                            suggestions: [
+                                "Use full resource IDs (e.g., 'anvil.purdue.access-ci.org')",
+                                "Or use exact resource names (e.g., 'Anvil', 'Delta')",
+                            ],
+                        }, null, 2),
+                    },
+                ],
             };
-        });
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: JSON.stringify({
-                        checked_at: new Date().toISOString(),
-                        resources_checked: resourceIds.length,
-                        operational: resourceStatus.filter((r) => r.status === "operational").length,
-                        affected: resourceStatus.filter((r) => r.status === "affected").length,
-                        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}`,
                 };
             }
         });
@@ -533,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.5.1",
+  "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": {