mcp-meilisearch 1.0.25 → 1.0.26

package/README.md

@@ -110,7 +110,7 @@ The package also exports the MCPClient class for client-side integration:
 import { MCPClient } from "mcp-meilisearch/client";
 
 const client = new MCPClient("mcp-meilisearch-client");
-await client.connectToServer("http://localhost:3000/mcp");
+await client.connectToServer("http://localhost:4995/mcp");
 
 // Call a tool
 const result = await client.callTool("search-across-all-indexes", {

package/dist/azure/index.d.ts

@@ -0,0 +1,4 @@
+import { AzureFunction } from "@azure/functions";
+declare const httpTrigger: AzureFunction;
+export default httpTrigger;
+//# sourceMappingURL=index.d.ts.map

package/dist/azure/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/azure/index.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,aAAa,EAAwB,MAAM,kBAAkB,CAAC;AAsFvE,QAAA,MAAM,WAAW,EAAE,aAgHlB,CAAC;AA8BF,eAAe,WAAW,CAAC"}

package/dist/azure/index.js

@@ -0,0 +1,196 @@
+import { IncomingMessage } from "http";
+import { randomUUID } from "node:crypto";
+import { initServer } from "../server.js";
+import { configHandler } from "../utils/config-handler.js";
+import { createErrorResponse } from "../utils/error-handler.js";
+const SESSION_ID_HEADER_NAME = "mcp-session-id";
+const SESSION_TIMEOUT = Number(process.env.SESSION_TIMEOUT) || 3600000;
+let mcpServer = null;
+const sessions = new Map();
+const baseHeaders = {
+    "Access-Control-Allow-Origin": process.env.ALLOWED_ORIGINS || "*",
+    "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
+    "Access-Control-Allow-Headers": `Origin, X-Requested-With, Content-Type, Accept, ${SESSION_ID_HEADER_NAME}`,
+};
+function adaptRequest(req) {
+    const adaptedReq = Object.create(IncomingMessage.prototype);
+    adaptedReq.headers = req.headers;
+    adaptedReq.method = req.method;
+    adaptedReq.url = req.url;
+    adaptedReq.body = req.body;
+    return adaptedReq;
+}
+function createResponseAdapter(context, extraHeaders = {}) {
+    const res = {
+        headers: new Map(),
+        statusCode: 200,
+        bodyChunks: [],
+        setHeader(name, value) {
+            this.headers.set(name, value);
+            return this;
+        },
+        writeHead(statusCode, headers) {
+            this.statusCode = statusCode;
+            if (headers && !Array.isArray(headers)) {
+                Object.entries(headers).forEach(([k, v]) => this.headers.set(k, v));
+            }
+            return this;
+        },
+        write(chunk) {
+            if (chunk)
+                this.bodyChunks.push(chunk);
+            return this;
+        },
+        end(data) {
+            if (data)
+                this.bodyChunks.push(data);
+            const responseHeaders = {};
+            this.headers.forEach((value, key) => {
+                responseHeaders[key] = value;
+            });
+            context.res = {
+                status: this.statusCode,
+                headers: { ...responseHeaders, ...baseHeaders, ...extraHeaders },
+                body: this.bodyChunks.join(""),
+            };
+            return this;
+        },
+    };
+    return res;
+}
+function sendError(context, status, message) {
+    context.res = {
+        status,
+        headers: { "Content-Type": "application/json", ...baseHeaders },
+        body: JSON.stringify(createErrorResponse(message)),
+    };
+}
+const httpTrigger = async function (context, req) {
+    if (!mcpServer) {
+        try {
+            const options = {
+                httpPort: 0,
+                transport: "http",
+                mcpEndpoint: "/api/mcp",
+                meilisearchApiKey: process.env.MEILISEARCH_API_KEY || "",
+                meilisearchHost: process.env.MEILISEARCH_HOST || "http://localhost:7700",
+            };
+            configHandler.setMeilisearchHost(options.meilisearchHost);
+            configHandler.setMeilisearchApiKey(options.meilisearchApiKey);
+            const server = await initServer("http", options);
+            if (server.mcpServer) {
+                mcpServer = server.mcpServer;
+                context.log("MCP server initialized successfully");
+            }
+            else {
+                throw new Error("Failed to initialize MCP server");
+            }
+        }
+        catch (error) {
+            sendError(context, 503, "Failed to initialize MCP server");
+            return;
+        }
+    }
+    if (req.method === "OPTIONS") {
+        context.res = { status: 200, headers: baseHeaders, body: "" };
+        return;
+    }
+    const sessionId = req.headers[SESSION_ID_HEADER_NAME.toLowerCase()];
+    try {
+        if (req.method === "GET") {
+            if (!sessionId || !sessions.has(sessionId)) {
+                sendError(context, 400, "Bad Request: invalid session ID");
+                return;
+            }
+            const session = sessions.get(sessionId);
+            session.lastActivity = Date.now();
+            try {
+                const res = createResponseAdapter(context);
+                await mcpServer.handleGetRequest(adaptRequest(req), res);
+                if (!context.res)
+                    res.end();
+            }
+            catch (error) {
+                context.log.error(`Error handling GET request: ${error}`);
+                sendError(context, 500, `Error in GET request: ${error}`);
+            }
+            return;
+        }
+        if (req.method === "POST") {
+            if (sessionId && sessions.has(sessionId)) {
+                const session = sessions.get(sessionId);
+                session.lastActivity = Date.now();
+                try {
+                    const res = createResponseAdapter(context);
+                    await mcpServer.handlePostRequest(adaptRequest(req), res, req.body);
+                    if (!context.res)
+                        res.end();
+                }
+                catch (error) {
+                    context.log.error(`Error handling POST request: ${error}`);
+                    sendError(context, 500, `Error in POST request: ${error}`);
+                }
+                return;
+            }
+            if (mcpServer.isInitializeRequest?.(req.body)) {
+                const newSessionId = randomUUID();
+                sessions.set(newSessionId, {
+                    transport: null,
+                    lastActivity: Date.now(),
+                });
+                try {
+                    const res = createResponseAdapter(context, {
+                        [SESSION_ID_HEADER_NAME]: newSessionId,
+                        "Access-Control-Expose-Headers": SESSION_ID_HEADER_NAME,
+                    });
+                    await mcpServer.handlePostRequest(adaptRequest(req), res, req.body);
+                    if (!context.res)
+                        res.end();
+                    context.log(`New session created: ${newSessionId}`);
+                }
+                catch (error) {
+                    context.log.error(`Error initializing session: ${error}`);
+                    sessions.delete(newSessionId);
+                    sendError(context, 500, `Error initializing session: ${error}`);
+                }
+                return;
+            }
+            sendError(context, 400, "Invalid request: missing session ID or not an initialize request");
+            return;
+        }
+        sendError(context, 405, "Method not allowed");
+    }
+    catch (error) {
+        context.log.error(`Error handling MCP request: ${error}`);
+        sendError(context, 500, `Internal server error: ${error}`);
+    }
+};
+const cleanupInterval = setInterval(() => {
+    const now = Date.now();
+    for (const [id, info] of sessions.entries()) {
+        if (now - info.lastActivity > SESSION_TIMEOUT) {
+            try {
+                if (info.transport)
+                    info.transport.close();
+                sessions.delete(id);
+            }
+            catch (error) {
+                console.error(`Error cleaning up session ${id}:`, error);
+            }
+        }
+    }
+}, 60000);
+if (typeof process !== "undefined" && process.env.FUNCTIONS_WORKER_RUNTIME) {
+    process.on("SIGTERM", () => {
+        clearInterval(cleanupInterval);
+        if (mcpServer && typeof mcpServer.shutdown === "function") {
+            try {
+                mcpServer.shutdown();
+            }
+            catch (error) {
+                console.error(`Error shutting down MCP server: ${error}`);
+            }
+        }
+    });
+}
+export default httpTrigger;

package/dist/client.d.ts

@@ -7,14 +7,14 @@ export declare class MCPClient {
     private client;
     private tries;
     private transport;
-    private onToolsUpdatedCallback;
+    private toolsUpdatedCallback;
     constructor(serverName: string);
-    setOnToolsUpdatedCallback(callback: (tools: Array<{
+    onToolsUpdatedCallback(callback: (tools: Array<{
         name: string;
         description: string;
     }>) => void): void;
     connectToServer(serverUrl: string): Promise<void>;
-    listTools(): Promise<void>;
+    private listTools;
     private setUpNotifications;
     callTool(name: string, args?: Record<string, any>): Promise<{
         success: boolean;

package/dist/client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAQA,qBAAa,SAAS;IACpB,WAAW,EAAE,OAAO,CAAS;IAC7B,KAAK,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE,EAAE,CAAM;IAEpD,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,KAAK,CAAa;IAC1B,OAAO,CAAC,SAAS,CAA8C;IAC/D,OAAO,CAAC,sBAAsB,CAEd;gBAEJ,UAAU,EAAE,MAAM;IAIvB,yBAAyB,CAC9B,QAAQ,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE,CAAC,KAAK,IAAI;IAKnE,eAAe,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAsBjD,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC;IAuBhC,OAAO,CAAC,kBAAkB;IAWpB,QAAQ,CACZ,IAAI,EAAE,MAAM,EACZ,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GACzB,OAAO,CAAC;QACT,OAAO,EAAE,OAAO,CAAC;QACjB,IAAI,CAAC,EAAE,GAAG,CAAC;QACX,KAAK,CAAC,EAAE,MAAM,CAAC;KAChB,CAAC;IAoCF,OAAO,CAAC,cAAc;IAKhB,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;CAK/B"}
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAQA,qBAAa,SAAS;IACpB,WAAW,EAAE,OAAO,CAAS;IAC7B,KAAK,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE,EAAE,CAAM;IAEpD,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,KAAK,CAAa;IAC1B,OAAO,CAAC,SAAS,CAA8C;IAC/D,OAAO,CAAC,oBAAoB,CAEZ;gBAEJ,UAAU,EAAE,MAAM;IAIvB,sBAAsB,CAC3B,QAAQ,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE,CAAC,KAAK,IAAI;IAKnE,eAAe,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;YAsBzC,SAAS;IAuBvB,OAAO,CAAC,kBAAkB;IAWpB,QAAQ,CACZ,IAAI,EAAE,MAAM,EACZ,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GACzB,OAAO,CAAC;QACT,OAAO,EAAE,OAAO,CAAC;QACjB,IAAI,CAAC,EAAE,GAAG,CAAC;QACX,KAAK,CAAC,EAAE,MAAM,CAAC;KAChB,CAAC;IAoCF,OAAO,CAAC,cAAc;IAKhB,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;CAK/B"}

package/dist/client.js

@@ -7,12 +7,12 @@ export class MCPClient {
     client;
     tries = 0;
     transport = null;
-    onToolsUpdatedCallback = null;
+    toolsUpdatedCallback = null;
     constructor(serverName) {
         this.client = new Client({ name: serverName, version: "1.0.0" });
     }
-    setOnToolsUpdatedCallback(callback) {
-        this.onToolsUpdatedCallback = callback;
+    onToolsUpdatedCallback(callback) {
+        this.toolsUpdatedCallback = callback;
     }
     async connectToServer(serverUrl) {
         const url = new URL(serverUrl);
@@ -54,8 +54,8 @@ export class MCPClient {
             this.tools = [];
         }
         finally {
-            if (this.onToolsUpdatedCallback) {
-                this.onToolsUpdatedCallback([...this.tools]);
+            if (this.toolsUpdatedCallback) {
+                this.toolsUpdatedCallback([...this.tools]);
             }
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcp-meilisearch",
-  "version": "1.0.25",
+  "version": "1.0.26",
   "description": "Model Context Protocol (MCP) implementation for Meilisearch",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/dist/browser.d.ts

@@ -1,14 +0,0 @@
-/**
- * This file provides browser-compatible exports for the MCP client
- * It avoids importing any Node.js specific modules
- */
-import { ServerOptions } from './types/options.js';
-export { MCPClient } from './client.js';
-export type { ServerOptions } from './types/options.js';
-/**
- * Browser-compatible version of mcpMeilisearchServer
- * In browser environments, this sets up the configuration but doesn't start a server
- */
-export declare const mcpMeilisearchServer: (options?: ServerOptions) => Promise<null>;
-export default mcpMeilisearchServer;
-//# sourceMappingURL=browser.d.ts.map

package/dist/browser.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"browser.d.ts","sourceRoot":"","sources":["../src/browser.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAGnD,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAGxC,YAAY,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAExD;;;GAGG;AACH,eAAO,MAAM,oBAAoB,GAC/B,UAAS,aAGR,KACA,OAAO,CAAC,IAAI,CAOd,CAAC;AAEF,eAAe,oBAAoB,CAAC"}

package/dist/browser.js

@@ -1,22 +0,0 @@
-/**
- * This file provides browser-compatible exports for the MCP client
- * It avoids importing any Node.js specific modules
- */
-import { configHandler } from "./utils/config-handler.js";
-// Export only what's needed for browser clients
-export { MCPClient } from './client.js';
-/**
- * Browser-compatible version of mcpMeilisearchServer
- * In browser environments, this sets up the configuration but doesn't start a server
- */
-export const mcpMeilisearchServer = async (options = {
-    meilisearchApiKey: "",
-    meilisearchHost: "http://localhost:7700",
-}) => {
-    // Still set configuration values for potential client usage
-    configHandler.setMeilisearchHost(options.meilisearchHost);
-    configHandler.setMeilisearchApiKey(options.meilisearchApiKey);
-    console.warn('mcpMeilisearchServer cannot be run in a browser environment. Use MCPClient instead.');
-    return null;
-};
-export default mcpMeilisearchServer;