@ecadlabs/tezosx-mcp 1.0.0

package/dist/worker.d.ts

@@ -0,0 +1,13 @@
+/**
+ * TezosX MCP Server - Cloudflare Workers Entry Point
+ *
+ * This entry point is for Cloudflare Workers deployment.
+ * For local development with Node.js, see index.ts
+ */
+import { type WorkerEnv } from "./adapters/index.js";
+export interface Env extends WorkerEnv {
+}
+declare const _default: {
+    fetch(request: Request, env: Env, ctx: ExecutionContext): Promise<Response>;
+};
+export default _default;

package/dist/worker.js

@@ -0,0 +1,132 @@
+/**
+ * TezosX MCP Server - Cloudflare Workers Entry Point
+ *
+ * This entry point is for Cloudflare Workers deployment.
+ * For local development with Node.js, see index.ts
+ */
+/// <reference types="@cloudflare/workers-types" />
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { createWorkerAdapter, setAdapter } from "./adapters/index.js";
+import { createMcpServer } from "./server.js";
+// Cache the server config to avoid re-initializing on every request
+let serverConfigPromise = null;
+let currentAdapter = null;
+async function getServerConfig(env) {
+    // Create or update the adapter with the current request's env
+    if (!currentAdapter) {
+        currentAdapter = createWorkerAdapter(env);
+        setAdapter(currentAdapter);
+    }
+    else {
+        currentAdapter.setEnv(env);
+    }
+    // Initialize the server if not already done
+    if (!serverConfigPromise) {
+        serverConfigPromise = createMcpServer(currentAdapter);
+    }
+    return serverConfigPromise;
+}
+/**
+ * Handle incoming requests
+ */
+async function handleRequest(request, env, ctx) {
+    const url = new URL(request.url);
+    const { server } = await getServerConfig(env);
+    // Log incoming request
+    console.log(`[tezosx-mcp] ${request.method} ${url.pathname}`);
+    // Handle MCP endpoint
+    if (url.pathname === '/mcp' && request.method === 'POST') {
+        try {
+            const httpTransport = new StreamableHTTPServerTransport({
+                sessionIdGenerator: undefined,
+                enableJsonResponse: true
+            });
+            // Connect the server to this transport
+            await server.connect(httpTransport);
+            // Create a mock request/response for the transport
+            const body = await request.json();
+            // Handle the MCP request and get the response
+            const responsePromise = new Promise((resolve) => {
+                const mockRes = {
+                    statusCode: 200,
+                    headers: {},
+                    body: '',
+                    setHeader(name, value) {
+                        this.headers[name] = value;
+                    },
+                    status(code) {
+                        this.statusCode = code;
+                        return this;
+                    },
+                    json(data) {
+                        this.headers['Content-Type'] = 'application/json';
+                        this.body = JSON.stringify(data);
+                        resolve(new Response(this.body, {
+                            status: this.statusCode,
+                            headers: this.headers
+                        }));
+                    },
+                    send(data) {
+                        this.body = data;
+                        resolve(new Response(this.body, {
+                            status: this.statusCode,
+                            headers: this.headers
+                        }));
+                    },
+                    end(data) {
+                        if (data)
+                            this.body = data;
+                        resolve(new Response(this.body, {
+                            status: this.statusCode,
+                            headers: this.headers
+                        }));
+                    },
+                    on(_event, _handler) {
+                        // No-op for Workers
+                    }
+                };
+                const mockReq = {
+                    method: request.method,
+                    url: url.pathname,
+                    headers: Object.fromEntries(request.headers.entries()),
+                    body
+                };
+                httpTransport.handleRequest(mockReq, mockRes, body);
+            });
+            return await responsePromise;
+        }
+        catch (error) {
+            console.error('[tezosx-mcp] MCP request error:', error);
+            return new Response(JSON.stringify({
+                error: 'Internal server error',
+                message: error instanceof Error ? error.message : 'Unknown error'
+            }), {
+                status: 500,
+                headers: { 'Content-Type': 'application/json' }
+            });
+        }
+    }
+    // Health check endpoint
+    if (url.pathname === '/health' || url.pathname === '/') {
+        return new Response(JSON.stringify({
+            status: 'ok',
+            service: 'tezosx-mcp',
+            version: '1.0.0',
+            environment: 'cloudflare-workers'
+        }), {
+            status: 200,
+            headers: { 'Content-Type': 'application/json' }
+        });
+    }
+    // 404 for unknown routes
+    return new Response(JSON.stringify({ error: 'Not found' }), {
+        status: 404,
+        headers: { 'Content-Type': 'application/json' }
+    });
+}
+// Export the Worker fetch handler
+export default {
+    async fetch(request, env, ctx) {
+        return handleRequest(request, env, ctx);
+    }
+};