opc-agent 4.1.2 → 4.1.4

package/src/protocols/mcp/server.ts

@@ -1,262 +0,0 @@
-import { createServer, type IncomingMessage, type ServerResponse } from 'http';
-import { createInterface } from 'readline';
-import type {
-  MCPServerConfig, MCPServerToolDefinition, MCPResourceDefinition,
-  MCPPromptDefinition, JsonRpcRequest, JsonRpcResponse,
-} from './types';
-import { MCP_ERRORS } from './types';
-
-export class MCPServer {
-  private config: MCPServerConfig;
-  private tools: Map<string, MCPServerToolDefinition> = new Map();
-  private resources: Map<string, MCPResourceDefinition> = new Map();
-  private prompts: Map<string, MCPPromptDefinition> = new Map();
-  private sseClients: Set<ServerResponse> = new Set();
-  private httpServer: ReturnType<typeof createServer> | null = null;
-
-  constructor(config: MCPServerConfig) {
-    this.config = config;
-    for (const t of config.tools ?? []) this.addTool(t);
-    for (const r of config.resources ?? []) this.addResource(r);
-    for (const p of config.prompts ?? []) this.addPrompt(p);
-  }
-
-  addTool(tool: MCPServerToolDefinition): void {
-    this.tools.set(tool.name, tool);
-  }
-
-  removeTool(name: string): void {
-    this.tools.delete(name);
-  }
-
-  addResource(resource: MCPResourceDefinition): void {
-    this.resources.set(resource.uri, resource);
-  }
-
-  removeResource(uri: string): void {
-    this.resources.delete(uri);
-  }
-
-  addPrompt(prompt: MCPPromptDefinition): void {
-    this.prompts.set(prompt.name, prompt);
-  }
-
-  getToolCount(): number { return this.tools.size; }
-  getResourceCount(): number { return this.resources.size; }
-  getPromptCount(): number { return this.prompts.size; }
-  getConnectedClients(): number { return this.sseClients.size; }
-
-  /** Serve over stdio — one JSON-RPC message per line */
-  async serveStdio(): Promise<void> {
-    const rl = createInterface({ input: process.stdin, terminal: false });
-    rl.on('line', async (line) => {
-      const trimmed = line.trim();
-      if (!trimmed) return;
-      try {
-        const msg = JSON.parse(trimmed) as JsonRpcRequest;
-        const response = await this.handleMessage(msg);
-        if (response) {
-          process.stdout.write(JSON.stringify(response) + '\n');
-        }
-      } catch {
-        const err: JsonRpcResponse = {
-          jsonrpc: '2.0', id: null,
-          error: MCP_ERRORS.PARSE_ERROR,
-        };
-        process.stdout.write(JSON.stringify(err) + '\n');
-      }
-    });
-  }
-
-  /** Serve over HTTP + SSE */
-  async serveHTTP(port: number): Promise<void> {
-    this.httpServer = createServer((req, res) => this.handleHTTP(req, res));
-    return new Promise((resolve) => {
-      this.httpServer!.listen(port, () => resolve());
-    });
-  }
-
-  /** Mount on existing HTTP server at a path prefix */
-  mount(server: any, path = '/mcp'): void {
-    const orig = server.listeners('request')[0] as any;
-    server.removeAllListeners('request');
-    server.on('request', (req: IncomingMessage, res: ServerResponse) => {
-      if (req.url?.startsWith(path)) {
-        // Rewrite URL to strip prefix
-        req.url = req.url.slice(path.length) || '/';
-        this.handleHTTP(req, res);
-      } else if (orig) {
-        orig(req, res);
-      }
-    });
-  }
-
-  stop(): void {
-    this.httpServer?.close();
-    for (const client of this.sseClients) {
-      client.end();
-    }
-    this.sseClients.clear();
-  }
-
-  private handleHTTP(req: IncomingMessage, res: ServerResponse): void {
-    res.setHeader('Access-Control-Allow-Origin', '*');
-    res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
-    res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
-
-    if (req.method === 'OPTIONS') {
-      res.writeHead(204);
-      res.end();
-      return;
-    }
-
-    const url = new URL(req.url || '/', `http://${req.headers.host || 'localhost'}`);
-
-    if (url.pathname === '/sse' && req.method === 'GET') {
-      // SSE endpoint
-      res.writeHead(200, {
-        'Content-Type': 'text/event-stream',
-        'Cache-Control': 'no-cache',
-        'Connection': 'keep-alive',
-      });
-      this.sseClients.add(res);
-      // Send endpoint info
-      res.write(`data: ${JSON.stringify({ type: 'endpoint', url: '/message' })}\n\n`);
-      req.on('close', () => this.sseClients.delete(res));
-      return;
-    }
-
-    if (url.pathname === '/message' && req.method === 'POST') {
-      let body = '';
-      req.on('data', (chunk) => { body += chunk; });
-      req.on('end', async () => {
-        try {
-          const msg = JSON.parse(body) as JsonRpcRequest;
-          const response = await this.handleMessage(msg);
-          if (response) {
-            // Send via SSE to all clients
-            for (const client of this.sseClients) {
-              client.write(`data: ${JSON.stringify(response)}\n\n`);
-            }
-            res.writeHead(200, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify(response));
-          } else {
-            res.writeHead(202);
-            res.end();
-          }
-        } catch {
-          res.writeHead(400, { 'Content-Type': 'application/json' });
-          res.end(JSON.stringify({ jsonrpc: '2.0', id: null, error: MCP_ERRORS.PARSE_ERROR }));
-        }
-      });
-      return;
-    }
-
-    res.writeHead(404);
-    res.end('Not Found');
-  }
-
-  async handleMessage(msg: JsonRpcRequest): Promise<JsonRpcResponse | null> {
-    // Notifications (no id) don't get responses
-    if (msg.id === undefined) return null;
-
-    const id = msg.id;
-    try {
-      switch (msg.method) {
-        case 'initialize':
-          return this.rpcResult(id, {
-            protocolVersion: '2024-11-05',
-            capabilities: {
-              tools: this.tools.size > 0 ? { listChanged: true } : undefined,
-              resources: this.resources.size > 0 ? { subscribe: false, listChanged: true } : undefined,
-              prompts: this.prompts.size > 0 ? { listChanged: true } : undefined,
-            },
-            serverInfo: { name: this.config.name, version: this.config.version },
-          });
-
-        case 'tools/list':
-          return this.rpcResult(id, {
-            tools: Array.from(this.tools.values()).map(t => ({
-              name: t.name,
-              description: t.description,
-              inputSchema: t.inputSchema,
-            })),
-          });
-
-        case 'tools/call': {
-          const { name, arguments: args } = msg.params ?? {};
-          const tool = this.tools.get(name);
-          if (!tool) return this.rpcError(id, MCP_ERRORS.TOOL_NOT_FOUND);
-          // Validate required fields
-          const schema = tool.inputSchema;
-          if (schema?.required && Array.isArray(schema.required)) {
-            for (const field of schema.required) {
-              if (args?.[field] === undefined) {
-                return this.rpcError(id, { code: -32602, message: `Missing required parameter: ${field}` });
-              }
-            }
-          }
-          try {
-            const result = await tool.handler(args ?? {});
-            return this.rpcResult(id, {
-              content: [{ type: 'text', text: typeof result === 'string' ? result : JSON.stringify(result) }],
-            });
-          } catch (err: any) {
-            return this.rpcResult(id, {
-              content: [{ type: 'text', text: err.message || 'Tool execution failed' }],
-              isError: true,
-            });
-          }
-        }
-
-        case 'resources/list':
-          return this.rpcResult(id, {
-            resources: Array.from(this.resources.values()).map(r => ({
-              uri: r.uri, name: r.name, description: r.description, mimeType: r.mimeType,
-            })),
-          });
-
-        case 'resources/read': {
-          const { uri } = msg.params ?? {};
-          const resource = this.resources.get(uri);
-          if (!resource) return this.rpcError(id, MCP_ERRORS.RESOURCE_NOT_FOUND);
-          const content = await resource.handler();
-          return this.rpcResult(id, {
-            contents: [{ uri, mimeType: resource.mimeType || 'text/plain', text: content }],
-          });
-        }
-
-        case 'prompts/list':
-          return this.rpcResult(id, {
-            prompts: Array.from(this.prompts.values()).map(p => ({
-              name: p.name, description: p.description,
-              arguments: p.arguments,
-            })),
-          });
-
-        case 'prompts/get': {
-          const { name, arguments: promptArgs } = msg.params ?? {};
-          const prompt = this.prompts.get(name);
-          if (!prompt) return this.rpcError(id, MCP_ERRORS.PROMPT_NOT_FOUND);
-          const messages = prompt.handler
-            ? await prompt.handler(promptArgs ?? {})
-            : [{ role: 'user' as const, content: { type: 'text' as const, text: prompt.description || '' } }];
-          return this.rpcResult(id, { description: prompt.description, messages });
-        }
-
-        default:
-          return this.rpcError(id, MCP_ERRORS.METHOD_NOT_FOUND);
-      }
-    } catch (err: any) {
-      return this.rpcError(id, { ...MCP_ERRORS.INTERNAL_ERROR, data: err.message });
-    }
-  }
-
-  private rpcResult(id: number | string, result: any): JsonRpcResponse {
-    return { jsonrpc: '2.0', id, result };
-  }
-
-  private rpcError(id: number | string, error: { code: number; message: string; data?: any }): JsonRpcResponse {
-    return { jsonrpc: '2.0', id, error };
-  }
-}

package/src/protocols/mcp/types.ts

@@ -1,69 +0,0 @@
-/**
- * MCP Server types — JSON-RPC 2.0 based Model Context Protocol
- */
-
-export interface MCPServerConfig {
-  name: string;
-  version: string;
-  tools?: MCPServerToolDefinition[];
-  resources?: MCPResourceDefinition[];
-  prompts?: MCPPromptDefinition[];
-}
-
-export interface MCPServerToolDefinition {
-  name: string;
-  description: string;
-  inputSchema: Record<string, any>;
-  handler: (args: any) => Promise<any>;
-}
-
-export interface MCPResourceDefinition {
-  uri: string;
-  name: string;
-  description?: string;
-  mimeType?: string;
-  handler: () => Promise<string>;
-}
-
-export interface MCPPromptDefinition {
-  name: string;
-  description?: string;
-  arguments?: MCPPromptArgument[];
-  handler?: (args: Record<string, string>) => Promise<MCPPromptMessage[]>;
-}
-
-export interface MCPPromptArgument {
-  name: string;
-  description?: string;
-  required?: boolean;
-}
-
-export interface MCPPromptMessage {
-  role: 'user' | 'assistant';
-  content: { type: 'text'; text: string };
-}
-
-export interface JsonRpcRequest {
-  jsonrpc: '2.0';
-  id?: number | string;
-  method: string;
-  params?: any;
-}
-
-export interface JsonRpcResponse {
-  jsonrpc: '2.0';
-  id: number | string | null;
-  result?: any;
-  error?: { code: number; message: string; data?: any };
-}
-
-export const MCP_ERRORS = {
-  PARSE_ERROR: { code: -32700, message: 'Parse error' },
-  INVALID_REQUEST: { code: -32600, message: 'Invalid Request' },
-  METHOD_NOT_FOUND: { code: -32601, message: 'Method not found' },
-  INVALID_PARAMS: { code: -32602, message: 'Invalid params' },
-  INTERNAL_ERROR: { code: -32603, message: 'Internal error' },
-  TOOL_NOT_FOUND: { code: -32001, message: 'Tool not found' },
-  RESOURCE_NOT_FOUND: { code: -32002, message: 'Resource not found' },
-  PROMPT_NOT_FOUND: { code: -32003, message: 'Prompt not found' },
-} as const;