@malek0512/loopback4-mcp 1.0.0

package/src/registry/tool-registry.ts

@@ -0,0 +1,57 @@
+import {bind, BindingScope, inject} from '@loopback/core';
+import {Tool, JsonSchema} from '../protocol/types';
+import {SchemaGenerator} from './schema-generator';
+
+export interface ToolDescriptor {
+  name: string;
+  description?: string;
+  inputSchema: JsonSchema;
+  controller: Object;
+  methodName: string;
+  handler: Function;
+}
+
+@bind({scope: BindingScope.SINGLETON})
+export class ToolRegistry {
+  private tools = new Map<string, ToolDescriptor>();
+
+  constructor(
+    @inject('mcp.schemaGenerator')
+    private schemaGenerator: SchemaGenerator,
+  ) {}
+
+  register(descriptor: ToolDescriptor): void {
+    if (this.tools.has(descriptor.name)) {
+      throw new Error(`Tool '${descriptor.name}' is already registered`);
+    }
+    this.tools.set(descriptor.name, descriptor);
+  }
+
+  unregister(name: string): boolean {
+    return this.tools.delete(name);
+  }
+
+  get(name: string): ToolDescriptor | undefined {
+    return this.tools.get(name);
+  }
+
+  list(): Tool[] {
+    return Array.from(this.tools.values()).map(descriptor => ({
+      name: descriptor.name,
+      description: descriptor.description,
+      inputSchema: descriptor.inputSchema as any,
+    }));
+  }
+
+  has(name: string): boolean {
+    return this.tools.has(name);
+  }
+
+  clear(): void {
+    this.tools.clear();
+  }
+
+  get size(): number {
+    return this.tools.size;
+  }
+}

package/src/transport/index.ts

@@ -0,0 +1 @@
+export * from './sse.transport';

package/src/transport/sse.transport.ts

@@ -0,0 +1,56 @@
+import {bind, BindingScope, inject} from '@loopback/core';
+import {Request, Response} from '@loopback/rest';
+import {MessageRouter} from '../protocol/message-router';
+import {JsonRpcRequest} from '../protocol/types';
+
+@bind({scope: BindingScope.SINGLETON})
+export class SseTransport {
+  constructor(
+    @inject('mcp.messageRouter')
+    private messageRouter: MessageRouter,
+  ) {}
+
+  async handleConnection(req: Request, res: Response): Promise<void> {
+    // Set SSE headers
+    res.setHeader('Content-Type', 'text/event-stream');
+    res.setHeader('Cache-Control', 'no-cache');
+    res.setHeader('Connection', 'keep-alive');
+    res.setHeader('Access-Control-Allow-Origin', '*');
+
+    // Send initial connection event
+    this.sendEvent(res, 'connected', {message: 'MCP Server connected'});
+
+    // Handle incoming messages
+    req.on('data', async (chunk: Buffer) => {
+      try {
+        const message = JSON.parse(chunk.toString()) as JsonRpcRequest;
+        const response = await this.messageRouter.route(message);
+        this.sendEvent(res, 'message', response);
+      } catch (error) {
+        this.sendEvent(res, 'error', {
+          message: 'Failed to process message',
+          error: error instanceof Error ? error.message : String(error),
+        });
+      }
+    });
+
+    // Handle connection close
+    req.on('close', () => {
+      console.log('SSE connection closed');
+    });
+
+    // Keep connection alive
+    const keepAliveInterval = setInterval(() => {
+      this.sendEvent(res, 'ping', {timestamp: Date.now()});
+    }, 30000);
+
+    req.on('close', () => {
+      clearInterval(keepAliveInterval);
+    });
+  }
+
+  private sendEvent(res: Response, event: string, data: unknown): void {
+    res.write(`event: ${event}\n`);
+    res.write(`data: ${JSON.stringify(data)}\n\n`);
+  }
+}