@access-mcp/shared 0.2.3 → 0.3.1

package/dist/base-server.d.ts

@@ -8,12 +8,32 @@ export declare abstract class BaseAccessServer {
     protected server: Server;
     protected transport: StdioServerTransport;
     private _httpClient?;
+    private _httpServer?;
+    private _httpPort?;
     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 handleResourceRead(request: any): Promise<any>;
-    start(): Promise<void>;
+    protected handleResourceRead(request: any): Promise<any>;
+    /**
+     * Start the MCP server with optional HTTP service layer for inter-server communication
+     */
+    start(options?: {
+        httpPort?: number;
+    }): Promise<void>;
+    /**
+     * Start HTTP service layer for inter-server communication
+     */
+    private startHttpService;
+    /**
+     * Call a tool on another ACCESS-CI MCP server via HTTP
+     */
+    protected callRemoteServer(serviceName: string, toolName: string, args?: Record<string, any>): Promise<any>;
+    /**
+     * Get service endpoint from environment configuration
+     * Expected format: ACCESS_MCP_SERVICES=nsf-awards=http://localhost:3001,xdmod-metrics=http://localhost:3002
+     */
+    private getServiceEndpoint;
 }

package/dist/base-server.js

@@ -2,6 +2,7 @@ import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { CallToolRequestSchema, ListResourcesRequestSchema, ListToolsRequestSchema, ReadResourceRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
 import axios from "axios";
+import express from "express";
 export class BaseAccessServer {
     serverName;
     version;
@@ -9,6 +10,8 @@ export class BaseAccessServer {
     server;
     transport;
     _httpClient;
+    _httpServer;
+    _httpPort;
     constructor(serverName, version, baseURL = "https://support.access-ci.org/api") {
         this.serverName = serverName;
         this.version = version;
@@ -99,9 +102,120 @@ export class BaseAccessServer {
             }
         });
     }
-    async start() {
-        await this.server.connect(this.transport);
-        // MCP servers should not output anything to stderr/stdout when running
-        // as it interferes with JSON-RPC communication
+    async handleResourceRead(request) {
+        throw new Error("Resource reading not supported by this server");
+    }
+    /**
+     * Start the MCP server with optional HTTP service layer for inter-server communication
+     */
+    async start(options) {
+        // Start HTTP service layer if port is specified
+        if (options?.httpPort) {
+            this._httpPort = options.httpPort;
+            await this.startHttpService();
+            console.log(`${this.serverName} HTTP server running on port ${this._httpPort}`);
+        }
+        else {
+            // Only connect stdio transport when NOT in HTTP mode
+            await this.server.connect(this.transport);
+            // MCP servers should not output anything to stderr/stdout when running
+            // as it interferes with JSON-RPC communication
+        }
+    }
+    /**
+     * Start HTTP service layer for inter-server communication
+     */
+    async startHttpService() {
+        if (!this._httpPort)
+            return;
+        this._httpServer = express();
+        this._httpServer.use(express.json());
+        // Health check endpoint
+        this._httpServer.get('/health', (req, res) => {
+            res.json({
+                server: this.serverName,
+                version: this.version,
+                status: 'healthy',
+                timestamp: new Date().toISOString()
+            });
+        });
+        // List available tools endpoint
+        this._httpServer.get('/tools', (req, res) => {
+            try {
+                const tools = this.getTools();
+                res.json({ tools });
+            }
+            catch (error) {
+                res.status(500).json({ error: 'Failed to list tools' });
+            }
+        });
+        // Tool execution endpoint
+        this._httpServer.post('/tools/:toolName', async (req, res) => {
+            try {
+                const { toolName } = req.params;
+                const { arguments: args = {} } = req.body;
+                // Validate that the tool exists
+                const tools = this.getTools();
+                const tool = tools.find(t => t.name === toolName);
+                if (!tool) {
+                    return res.status(404).json({ error: `Tool '${toolName}' not found` });
+                }
+                // Execute the tool
+                const request = {
+                    params: {
+                        name: toolName,
+                        arguments: args
+                    }
+                };
+                const result = await this.handleToolCall(request);
+                res.json(result);
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                res.status(500).json({ error: errorMessage });
+            }
+        });
+        // Start HTTP server
+        return new Promise((resolve, reject) => {
+            this._httpServer.listen(this._httpPort, '0.0.0.0', () => {
+                resolve();
+            }).on('error', reject);
+        });
+    }
+    /**
+     * Call a tool on another ACCESS-CI MCP server via HTTP
+     */
+    async callRemoteServer(serviceName, toolName, args = {}) {
+        const serviceUrl = this.getServiceEndpoint(serviceName);
+        if (!serviceUrl) {
+            throw new Error(`Service '${serviceName}' not found. Check ACCESS_MCP_SERVICES environment variable.`);
+        }
+        const response = await axios.post(`${serviceUrl}/tools/${toolName}`, {
+            arguments: args
+        }, {
+            timeout: 30000,
+            validateStatus: () => true
+        });
+        if (response.status !== 200) {
+            throw new Error(`Remote server call failed: ${response.status} ${response.data?.error || response.statusText}`);
+        }
+        return response.data;
+    }
+    /**
+     * Get service endpoint from environment configuration
+     * Expected format: ACCESS_MCP_SERVICES=nsf-awards=http://localhost:3001,xdmod-metrics=http://localhost:3002
+     */
+    getServiceEndpoint(serviceName) {
+        const services = process.env.ACCESS_MCP_SERVICES;
+        if (!services)
+            return null;
+        const serviceMap = {};
+        services.split(',').forEach(service => {
+            const [name, url] = service.split('=');
+            if (name && url) {
+                serviceMap[name.trim()] = url.trim();
+            }
+        });
+        return serviceMap[serviceName] || null;
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@access-mcp/shared",
-  "version": "0.2.3",
+  "version": "0.3.1",
   "description": "Shared utilities for ACCESS-CI MCP servers",
   "type": "module",
   "main": "dist/index.js",
@@ -34,6 +34,10 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.16.0",
     "axios": "^1.6.0",
+    "express": "^5.1.0",
     "zod": "^3.22.0"
+  },
+  "devDependencies": {
+    "@types/express": "^5.0.0"
   }
 }