@access-mcp/system-status 0.5.1 → 0.6.0

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

@@ -107,13 +107,13 @@ describe("SystemStatusServer Integration Tests", () => {
             }
         }, 15000);
         it("should check resource status with direct method", async () => {
-            // Test with common resource names that might exist
+            // Test with human-readable names - these get resolved to full IDs
             const result = await server["handleToolCall"]({
                 method: "tools/call",
                 params: {
                     name: "get_infrastructure_news",
                     arguments: {
-                        ids: ["anvil", "bridges", "jetstream"],
+                        ids: ["Anvil", "Delta", "Expanse"],
                         use_group_api: false,
                     },
                 },
@@ -127,23 +127,24 @@ describe("SystemStatusServer Integration Tests", () => {
             expect(responseData).toHaveProperty("api_method", "direct_outages_check");
             expect(Array.isArray(responseData.resource_status)).toBe(true);
             expect(responseData.resource_status).toHaveLength(3);
-            // Check resource status structure
+            // Check resource status structure - IDs should be resolved to full format
             responseData.resource_status.forEach((resource) => {
                 expect(resource).toHaveProperty("resource_id");
+                expect(resource.resource_id).toContain(".access-ci.org"); // Resolved to full ID
                 expect(resource).toHaveProperty("status");
                 expect(["operational", "affected"]).toContain(resource.status);
                 expect(resource).toHaveProperty("active_outages");
                 expect(Array.isArray(resource.outage_details)).toBe(true);
             });
-        }, 10000);
+        }, 15000);
         it("should test group API functionality", async () => {
-            // Test group API with a resource that might have a group ID
+            // Test group API with a human-readable name
             const result = await server["handleToolCall"]({
                 method: "tools/call",
                 params: {
                     name: "get_infrastructure_news",
                     arguments: {
-                        ids: ["anvil"],
+                        ids: ["Anvil"],
                         use_group_api: true,
                     },
                 },
@@ -154,7 +155,8 @@ describe("SystemStatusServer Integration Tests", () => {
             expect(responseData).toHaveProperty("resources_checked", 1);
             expect(responseData.resource_status).toHaveLength(1);
             const resourceStatus = responseData.resource_status[0];
-            expect(resourceStatus).toHaveProperty("resource_id", "anvil");
+            expect(resourceStatus.resource_id).toContain("anvil"); // Resolved ID contains anvil
+            expect(resourceStatus.resource_id).toContain(".access-ci.org");
             expect(resourceStatus).toHaveProperty("api_method");
             expect(["group_specific", "group_specific_failed"]).toContain(resourceStatus.api_method);
             // If it succeeded, check structure
@@ -167,7 +169,7 @@ describe("SystemStatusServer Integration Tests", () => {
                 expect(resourceStatus.status).toBe("unknown");
                 expect(resourceStatus).toHaveProperty("error");
             }
-        }, 10000);
+        }, 15000);
         it("should filter outages by resource correctly", async () => {
             const result = await server["handleToolCall"]({
                 method: "tools/call",
@@ -207,7 +209,10 @@ describe("SystemStatusServer Integration Tests", () => {
                 expect(result.contents[0]).toHaveProperty("text");
                 if (uri !== "accessci://system-status") {
                     // JSON resources should have valid JSON
-                    expect(() => JSON.parse(result.contents[0].text)).not.toThrow();
+                    const content = result.contents[0];
+                    if ("text" in content) {
+                        expect(() => JSON.parse(content.text)).not.toThrow();
+                    }
                 }
             }
         }, 15000);

package/dist/__tests__/server.test.js

@@ -15,7 +15,7 @@ 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" }],
+            AffectedResources: [{ ResourceName: "Anvil", ResourceID: "anvil-1.purdue.access-ci.org" }],
         },
         {
             id: "2",
@@ -23,7 +23,7 @@ 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" }],
+            AffectedResources: [{ ResourceName: "Bridges-2", ResourceID: "bridges2.psc.access-ci.org" }],
         },
     ];
     const mockFutureOutagesData = [
@@ -287,20 +287,21 @@ describe("SystemStatusServer", () => {
                 status: 200,
                 data: { results: mockCurrentOutagesData },
             });
+            // 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-1.purdue.access-ci.org", "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-1.purdue.access-ci.org
+            const anvilStatus = response.resource_status.find((r) => r.resource_id === "anvil-1.purdue.access-ci.org");
             expect(anvilStatus.status).toBe("affected");
             expect(anvilStatus.severity).toBe("high"); // Emergency maintenance
         });
@@ -309,17 +310,18 @@ describe("SystemStatusServer", () => {
                 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"],
+                        ids: ["anvil.purdue.access-ci.org"],
                         use_group_api: true,
                     },
                 },
             });
-            expect(mockHttpClient.get).toHaveBeenCalledWith("/wh2/news/v1/info_groupid/anvil/");
+            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");
@@ -328,12 +330,13 @@ describe("SystemStatusServer", () => {
         });
         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"],
+                        ids: ["invalid.resource.org"],
                         use_group_api: true,
                     },
                 },
@@ -345,6 +348,66 @@ describe("SystemStatusServer", () => {
             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
+            mockHttpClient.get
+                .mockResolvedValueOnce({
+                status: 200,
+                data: {
+                    results: {
+                        active_groups: [
+                            { info_groupid: "anvil.purdue.access-ci.org", group_descriptive_name: "Anvil" },
+                        ],
+                    },
+                },
+            })
+                .mockResolvedValueOnce({
+                status: 200,
+                data: { results: [] }, // No outages
+            });
+            const result = await server["handleToolCall"]({
+                method: "tools/call",
+                params: {
+                    name: "get_infrastructure_news",
+                    arguments: { ids: ["Anvil"] },
+                },
+            });
+            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");
+        });
+        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: ["Stampede"] },
+                },
+            });
+            const content = result.content[0];
+            const response = JSON.parse(content.text);
+            expect(response.error).toContain("Could not resolve");
+            expect(response.resolution_errors[0].error).toContain("Multiple resources match");
+        });
     });
     describe("Error Handling", () => {
         it("should handle API errors gracefully", async () => {
@@ -391,7 +454,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>;

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,6 +6,26 @@ 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 [
             {
@@ -21,13 +41,13 @@ export class SystemStatusServer extends BaseAccessServer {
                         time: {
                             type: "string",
                             enum: ["current", "scheduled", "past", "all"],
-                            description: "Period: current (active), scheduled (future), past, all",
+                            description: "Time filter. Values: 'current' for active outages, 'scheduled' for future/planned, 'past' for historical, 'all' for everything",
                             default: "current",
                         },
                         ids: {
                             type: "array",
                             items: { type: "string" },
-                            description: "Check status for specific resource IDs",
+                            description: "Check status for specific resources. Accepts names (e.g., 'Anvil', 'Delta') or full IDs (e.g., 'anvil.purdue.access-ci.org')",
                         },
                         limit: {
                             type: "number",
@@ -99,8 +119,8 @@ export class SystemStatusServer extends BaseAccessServer {
      */
     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)) {
+        // 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);
         }
         // Time-based routing
@@ -433,13 +453,43 @@ export class SystemStatusServer extends BaseAccessServer {
         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");
         }
+        // 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 {
+                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),
+                    },
+                ],
+            };
+        }
         if (useGroupApi) {
-            return await this.checkResourceStatusViaGroups(resourceIds);
+            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 = resourceIds.map((resourceId) => {
+        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";
@@ -483,7 +533,7 @@ export class SystemStatusServer extends BaseAccessServer {
                     type: "text",
                     text: JSON.stringify({
                         checked_at: new Date().toISOString(),
-                        resources_checked: resourceIds.length,
+                        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",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@access-mcp/system-status",
-  "version": "0.5.1",
+  "version": "0.6.0",
   "description": "MCP server for ACCESS-CI System Status and Outages API",
   "type": "module",
   "main": "dist/index.js",