@access-mcp/shared 0.3.3 → 0.6.0

package/dist/__tests__/base-server.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/base-server.test.js

@@ -0,0 +1,176 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { BaseAccessServer } from "../base-server.js";
+// Concrete implementation for testing
+class TestServer extends BaseAccessServer {
+    constructor() {
+        super("test-server", "1.0.0", "https://api.example.com");
+    }
+    getTools() {
+        return [
+            {
+                name: "test_tool",
+                description: "A test tool",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        message: { type: "string" },
+                    },
+                },
+            },
+        ];
+    }
+    getResources() {
+        return [
+            {
+                uri: "test://resource",
+                name: "Test Resource",
+                mimeType: "application/json",
+            },
+        ];
+    }
+    async handleToolCall(request) {
+        if (request.params.name === "test_tool") {
+            const args = request.params.arguments;
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({ echo: args.message || "no message" }),
+                    },
+                ],
+            };
+        }
+        return this.errorResponse(`Unknown tool: ${request.params.name}`);
+    }
+}
+describe("BaseAccessServer HTTP Mode", () => {
+    let server;
+    let port;
+    let baseUrl;
+    beforeEach(async () => {
+        server = new TestServer();
+        port = 3100 + Math.floor(Math.random() * 100);
+        baseUrl = `http://localhost:${port}`;
+        await server.start({ httpPort: port });
+    });
+    afterEach(async () => {
+        // Server cleanup handled by process exit
+    });
+    describe("Health endpoint", () => {
+        it("should return health status", async () => {
+            const response = await fetch(`${baseUrl}/health`);
+            const data = await response.json();
+            expect(response.status).toBe(200);
+            expect(data.server).toBe("test-server");
+            expect(data.version).toBe("1.0.0");
+            expect(data.status).toBe("healthy");
+            expect(data.timestamp).toBeDefined();
+        });
+    });
+    describe("Tools endpoint", () => {
+        it("should list available tools", async () => {
+            const response = await fetch(`${baseUrl}/tools`);
+            const data = await response.json();
+            expect(response.status).toBe(200);
+            expect(data.tools).toHaveLength(1);
+            expect(data.tools[0].name).toBe("test_tool");
+        });
+    });
+    describe("Tool execution endpoint", () => {
+        it("should execute a tool via POST", async () => {
+            const response = await fetch(`${baseUrl}/tools/test_tool`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ arguments: { message: "hello" } }),
+            });
+            const data = await response.json();
+            expect(response.status).toBe(200);
+            expect(data.content).toBeDefined();
+            const result = JSON.parse(data.content[0].text);
+            expect(result.echo).toBe("hello");
+        });
+        it("should return 404 for unknown tool", async () => {
+            const response = await fetch(`${baseUrl}/tools/unknown_tool`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ arguments: {} }),
+            });
+            expect(response.status).toBe(404);
+            const data = await response.json();
+            expect(data.error).toContain("not found");
+        });
+    });
+    describe("SSE endpoint", () => {
+        it("should accept SSE connections", async () => {
+            const controller = new AbortController();
+            const timeout = setTimeout(() => controller.abort(), 1000);
+            try {
+                const response = await fetch(`${baseUrl}/sse`, {
+                    signal: controller.signal,
+                });
+                expect(response.status).toBe(200);
+                expect(response.headers.get("content-type")).toContain("text/event-stream");
+            }
+            catch (e) {
+                // AbortError is expected when we timeout
+                if (e instanceof Error && e.name !== "AbortError") {
+                    throw e;
+                }
+            }
+            finally {
+                clearTimeout(timeout);
+            }
+        });
+    });
+});
+describe("BaseAccessServer helper methods", () => {
+    let server;
+    beforeEach(() => {
+        server = new TestServer();
+    });
+    describe("errorResponse", () => {
+        it("should create error response without hint", () => {
+            const result = server["errorResponse"]("Something went wrong");
+            expect(result.isError).toBe(true);
+            const textContent = result.content[0];
+            const content = JSON.parse(textContent.text);
+            expect(content.error).toBe("Something went wrong");
+            expect(content.hint).toBeUndefined();
+        });
+        it("should create error response with hint", () => {
+            const result = server["errorResponse"]("Invalid input", "Try using a number");
+            expect(result.isError).toBe(true);
+            const textContent = result.content[0];
+            const content = JSON.parse(textContent.text);
+            expect(content.error).toBe("Invalid input");
+            expect(content.hint).toBe("Try using a number");
+        });
+    });
+    describe("createJsonResource", () => {
+        it("should create JSON resource response", () => {
+            const result = server["createJsonResource"]("test://data", { foo: "bar" });
+            expect(result.contents).toHaveLength(1);
+            expect(result.contents[0].uri).toBe("test://data");
+            expect(result.contents[0].mimeType).toBe("application/json");
+            expect(JSON.parse(result.contents[0].text)).toEqual({ foo: "bar" });
+        });
+    });
+    describe("createMarkdownResource", () => {
+        it("should create Markdown resource response", () => {
+            const result = server["createMarkdownResource"]("test://doc", "# Hello");
+            expect(result.contents).toHaveLength(1);
+            expect(result.contents[0].uri).toBe("test://doc");
+            expect(result.contents[0].mimeType).toBe("text/markdown");
+            expect(result.contents[0].text).toBe("# Hello");
+        });
+    });
+    describe("createTextResource", () => {
+        it("should create plain text resource response", () => {
+            const result = server["createTextResource"]("test://text", "Hello world");
+            expect(result.contents).toHaveLength(1);
+            expect(result.contents[0].uri).toBe("test://text");
+            expect(result.contents[0].mimeType).toBe("text/plain");
+            expect(result.contents[0].text).toBe("Hello world");
+        });
+    });
+});

package/dist/__tests__/interserver.integration.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,118 @@
+import { describe, it, expect, beforeAll, afterAll } from "vitest";
+import { spawn } from "child_process";
+import path from "path";
+/**
+ * Integration tests for inter-server HTTP communication
+ * These tests start actual MCP servers and test tool execution via HTTP
+ */
+describe("Inter-server Communication Integration Tests", () => {
+    let nsfServer;
+    const NSF_PORT = 3199;
+    const NSF_URL = `http://localhost:${NSF_PORT}`;
+    beforeAll(async () => {
+        // Start NSF Awards server in HTTP mode
+        const serverPath = path.resolve(process.cwd(), "packages/nsf-awards/dist/index.js");
+        nsfServer = spawn("node", [serverPath], {
+            env: {
+                ...process.env,
+                PORT: String(NSF_PORT),
+                LOG_LEVEL: "info", // Enable info logging to see startup message
+            },
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        // Wait for server to be ready
+        await new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                reject(new Error("Server startup timeout"));
+            }, 10000);
+            // Logger writes to stderr, not stdout
+            nsfServer.stderr?.on("data", (data) => {
+                if (data.toString().includes("HTTP server running")) {
+                    clearTimeout(timeout);
+                    resolve();
+                }
+            });
+            nsfServer.on("error", (err) => {
+                clearTimeout(timeout);
+                reject(err);
+            });
+        });
+    }, 15000);
+    afterAll(async () => {
+        if (nsfServer) {
+            nsfServer.kill("SIGTERM");
+            // Wait for process to exit
+            await new Promise((resolve) => {
+                nsfServer.on("exit", () => resolve());
+                setTimeout(resolve, 1000); // Fallback timeout
+            });
+        }
+    });
+    describe("NSF Awards Server HTTP API", () => {
+        it("should respond to health check", async () => {
+            const response = await fetch(`${NSF_URL}/health`);
+            const data = await response.json();
+            expect(response.status).toBe(200);
+            expect(data.status).toBe("healthy");
+            expect(data.server).toBe("access-mcp-nsf-awards");
+        });
+        it("should list available tools", async () => {
+            const response = await fetch(`${NSF_URL}/tools`);
+            const data = await response.json();
+            expect(response.status).toBe(200);
+            expect(data.tools).toBeDefined();
+            expect(Array.isArray(data.tools)).toBe(true);
+            const toolNames = data.tools.map((t) => t.name);
+            expect(toolNames).toContain("search_nsf_awards");
+        });
+        it("should execute search_nsf_awards tool via HTTP", async () => {
+            const response = await fetch(`${NSF_URL}/tools/search_nsf_awards`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({
+                    arguments: {
+                        keyword: "machine learning",
+                        limit: 5,
+                    },
+                }),
+            });
+            const data = await response.json();
+            expect(response.status).toBe(200);
+            expect(data.content).toBeDefined();
+            expect(data.content[0].type).toBe("text");
+            // Parse the result
+            const result = JSON.parse(data.content[0].text);
+            expect(result).toBeDefined();
+        }, 15000);
+        it("should return 404 for unknown tool", async () => {
+            const response = await fetch(`${NSF_URL}/tools/nonexistent_tool`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ arguments: {} }),
+            });
+            expect(response.status).toBe(404);
+        });
+    });
+    describe("SSE Endpoint", () => {
+        it("should accept SSE connections on /sse", async () => {
+            const controller = new AbortController();
+            const timeout = setTimeout(() => controller.abort(), 2000);
+            try {
+                const response = await fetch(`${NSF_URL}/sse`, {
+                    signal: controller.signal,
+                });
+                expect(response.status).toBe(200);
+                expect(response.headers.get("content-type")).toContain("text/event-stream");
+            }
+            catch (e) {
+                // AbortError is expected
+                if (e instanceof Error && e.name !== "AbortError") {
+                    throw e;
+                }
+            }
+            finally {
+                clearTimeout(timeout);
+            }
+        });
+    });
+});

package/dist/__tests__/utils.test.js

@@ -38,12 +38,12 @@ describe("Utils", () => {
             };
             expect(handleApiError(error)).toBe("API error: 404 Not Found");
         });
-        test("should handle error message", () => {
-            const error = { message: "Network error" };
+        test("should handle Error instance", () => {
+            const error = new Error("Network error");
             expect(handleApiError(error)).toBe("Network error");
         });
         test("should handle unknown error", () => {
-            const error = {};
+            const error = "some string error";
             expect(handleApiError(error)).toBe("Unknown API error");
         });
     });

package/dist/base-server.d.ts

@@ -1,51 +1,50 @@
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { Tool, Resource, Prompt, CallToolResult, ReadResourceResult, GetPromptResult, CallToolRequest, ReadResourceRequest, GetPromptRequest } from "@modelcontextprotocol/sdk/types.js";
 import { AxiosInstance } from "axios";
+import { Logger } from "./logger.js";
+export type { Tool, Resource, Prompt, CallToolResult, ReadResourceResult, GetPromptResult };
 export declare abstract class BaseAccessServer {
     protected serverName: string;
     protected version: string;
     protected baseURL: string;
     protected server: Server;
     protected transport: StdioServerTransport;
+    protected logger: Logger;
     private _httpClient?;
     private _httpServer?;
     private _httpPort?;
+    private _sseTransports;
     constructor(serverName: string, version: string, baseURL?: string);
     protected get httpClient(): AxiosInstance;
     private setupHandlers;
-    protected abstract getTools(): any[];
-    protected abstract getResources(): any[];
-    protected abstract handleToolCall(request: any): Promise<any>;
+    protected abstract getTools(): Tool[];
+    protected abstract getResources(): Resource[];
+    protected abstract handleToolCall(request: CallToolRequest): Promise<CallToolResult>;
     /**
      * Get available prompts - override in subclasses to provide prompts
      */
-    protected getPrompts(): any[];
+    protected getPrompts(): Prompt[];
     /**
      * Handle resource read requests - override in subclasses
      */
-    protected handleResourceRead(request: any): Promise<any>;
+    protected handleResourceRead(request: ReadResourceRequest): Promise<ReadResourceResult>;
     /**
      * Handle get prompt requests - override in subclasses
      */
-    protected handleGetPrompt(request: any): Promise<any>;
+    protected handleGetPrompt(request: GetPromptRequest): Promise<GetPromptResult>;
     /**
      * Helper method to create a standard error response (MCP 2025 compliant)
      * @param message The error message
      * @param hint Optional suggestion for how to fix the error
      */
-    protected errorResponse(message: string, hint?: string): {
-        content: {
-            type: "text";
-            text: string;
-        }[];
-        isError: boolean;
-    };
+    protected errorResponse(message: string, hint?: string): CallToolResult;
     /**
      * Helper method to create a JSON resource response
      * @param uri The resource URI
      * @param data The data to return as JSON
      */
-    protected createJsonResource(uri: string, data: any): {
+    protected createJsonResource(uri: string, data: unknown): {
         contents: {
             uri: string;
             mimeType: string;
@@ -83,13 +82,17 @@ export declare abstract class BaseAccessServer {
         httpPort?: number;
     }): Promise<void>;
     /**
-     * Start HTTP service layer for inter-server communication
+     * Start HTTP service layer with SSE support for remote MCP connections
      */
     private startHttpService;
+    /**
+     * Set up MCP handlers on a server instance
+     */
+    private setupServerHandlers;
     /**
      * Call a tool on another ACCESS-CI MCP server via HTTP
      */
-    protected callRemoteServer(serviceName: string, toolName: string, args?: Record<string, any>): Promise<any>;
+    protected callRemoteServer(serviceName: string, toolName: string, args?: Record<string, unknown>): Promise<unknown>;
     /**
      * Get service endpoint from environment configuration
      * Expected format: ACCESS_MCP_SERVICES=nsf-awards=http://localhost:3001,xdmod-metrics=http://localhost:3002