vendure-mcp-graphql 1.3.1 → 1.5.0

package/dist/index.js

@@ -7,20 +7,22 @@ import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { CallToolRequestSchema, ListToolsRequestSchema, ErrorCode, McpError, } from "@modelcontextprotocol/sdk/types.js";
 import { config } from "dotenv";
-import { resolve } from "path";
+import { resolve, dirname } from "path";
+import { fileURLToPath } from "url";
 import { existsSync } from "fs";
-// Load environment variables from the project root (CWD)
+// Load environment variables
+const __dirname = dirname(fileURLToPath(import.meta.url));
 // 1. Try to load from project root .env.local
-config({ path: resolve(process.cwd(), ".env.local") });
+config({ path: resolve(__dirname, "../../.env.local") });
 // 2. Also try to load from specific vendure-api-key.env if it exists
-const apiKeyPath = resolve(process.cwd(), "vendure-api-key.env");
+const apiKeyPath = resolve(__dirname, "../../vendure-api-key.env");
 if (existsSync(apiKeyPath)) {
     const envConfig = config({ path: apiKeyPath });
     if (envConfig.parsed?.VENDURE_API_KEY) {
         process.env.VENDURE_API_KEY = envConfig.parsed.VENDURE_API_KEY;
     }
 }
-import { adminQuery, adminMutation, adminBatchMutation, getAdminSchema, getAdminOperations, shopQuery, shopMutation, shopBatchMutation, getShopSchema, getShopOperations, } from "./src/tools/index.js";
+import { adminQuery, adminMutation, adminBatchMutation, getAdminSchema, getAdminOperations, shopQuery, shopMutation, shopBatchMutation, getShopSchema, getShopOperations, describeOperation, } from "./src/tools/index.js";
 // Singleton pattern for shared resources
 class SharedResources {
     static instance = null;
@@ -47,7 +49,7 @@ class SharedResources {
 }
 const server = new Server({
     name: "vendure-mcp-graphql",
-    version: "1.3.1",
+    version: "1.0.0",
 }, {
     capabilities: {
         tools: {},
@@ -64,6 +66,10 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
                 properties: {
                     query: { type: "string", description: "The GraphQL query string" },
                     variables: { type: "object", description: "Optional variables" },
+                    channelToken: {
+                        type: "string",
+                        description: "Optional channel token to set channel context (e.g., 'default-channel', 'test-channel')",
+                    },
                 },
                 required: ["query"],
             },
@@ -79,6 +85,10 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
                         description: "The GraphQL mutation string",
                     },
                     variables: { type: "object", description: "Optional variables" },
+                    channelToken: {
+                        type: "string",
+                        description: "Optional channel token to set channel context (e.g., 'default-channel', 'test-channel')",
+                    },
                 },
                 required: ["mutation"],
             },
@@ -112,6 +122,10 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
                         type: "number",
                         description: "Max number of concurrent mutations. Default: 5.",
                     },
+                    channelToken: {
+                        type: "string",
+                        description: "Optional channel token to set channel context (e.g., 'default-channel', 'test-channel')",
+                    },
                 },
                 required: ["mutation", "ids"],
             },
@@ -134,6 +148,10 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
                 properties: {
                     query: { type: "string", description: "The GraphQL query string" },
                     variables: { type: "object", description: "Optional variables" },
+                    channelToken: {
+                        type: "string",
+                        description: "Optional channel token to set channel context (e.g., 'default-channel', 'test-channel')",
+                    },
                 },
                 required: ["query"],
             },
@@ -149,6 +167,10 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
                         description: "The GraphQL mutation string",
                     },
                     variables: { type: "object", description: "Optional variables" },
+                    channelToken: {
+                        type: "string",
+                        description: "Optional channel token to set channel context (e.g., 'default-channel', 'test-channel')",
+                    },
                 },
                 required: ["mutation"],
             },
@@ -182,6 +204,10 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
                         type: "number",
                         description: "Max number of concurrent mutations. Default: 5.",
                     },
+                    channelToken: {
+                        type: "string",
+                        description: "Optional channel token to set channel context (e.g., 'default-channel', 'test-channel')",
+                    },
                 },
                 required: ["mutation", "ids"],
             },
@@ -196,6 +222,25 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
             description: "List all available queries and mutations for the Shop API with descriptions.",
             inputSchema: { type: "object", properties: {}, required: [] },
         },
+        {
+            name: "describe_operation",
+            description: "Describe a GraphQL query or mutation in detail: shows which API(s) it's available on, arguments with input types, and the return type with all its fields. Checks both Admin and Shop APIs by default.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    operation: {
+                        type: "string",
+                        description: "The name of the query or mutation to describe (e.g. productGroups, createProduct)",
+                    },
+                    api: {
+                        type: "string",
+                        enum: ["admin", "shop"],
+                        description: "Optional: restrict lookup to a specific API. If omitted, checks both Admin and Shop APIs.",
+                    },
+                },
+                required: ["operation"],
+            },
+        },
     ],
 }));
 // Handle tool calls
@@ -208,7 +253,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     content: [
                         {
                             type: "text",
-                            text: JSON.stringify(await adminQuery(args?.query, args?.variables), null, 2),
+                            text: JSON.stringify(await adminQuery(args?.query, args?.variables, args?.channelToken), null, 2),
                         },
                     ],
                 };
@@ -217,7 +262,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     content: [
                         {
                             type: "text",
-                            text: JSON.stringify(await adminMutation(args?.mutation, args?.variables), null, 2),
+                            text: JSON.stringify(await adminMutation(args?.mutation, args?.variables, args?.channelToken), null, 2),
                         },
                     ],
                 };
@@ -226,7 +271,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     content: [
                         {
                             type: "text",
-                            text: JSON.stringify(await adminBatchMutation(args?.mutation, args?.ids, args?.variableName || "id", args?.extraVariables, args?.concurrency || 5), null, 2),
+                            text: JSON.stringify(await adminBatchMutation(args?.mutation, args?.ids, args?.variableName || "id", args?.extraVariables, args?.concurrency || 5, args?.channelToken), null, 2),
                         },
                     ],
                 };
@@ -253,7 +298,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     content: [
                         {
                             type: "text",
-                            text: JSON.stringify(await shopQuery(args?.query, args?.variables), null, 2),
+                            text: JSON.stringify(await shopQuery(args?.query, args?.variables, args?.channelToken), null, 2),
                         },
                     ],
                 };
@@ -262,7 +307,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     content: [
                         {
                             type: "text",
-                            text: JSON.stringify(await shopMutation(args?.mutation, args?.variables), null, 2),
+                            text: JSON.stringify(await shopMutation(args?.mutation, args?.variables, args?.channelToken), null, 2),
                         },
                     ],
                 };
@@ -271,7 +316,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     content: [
                         {
                             type: "text",
-                            text: JSON.stringify(await shopBatchMutation(args?.mutation, args?.ids, args?.variableName || "id", args?.extraVariables, args?.concurrency || 5), null, 2),
+                            text: JSON.stringify(await shopBatchMutation(args?.mutation, args?.ids, args?.variableName || "id", args?.extraVariables, args?.concurrency || 5, args?.channelToken), null, 2),
                         },
                     ],
                 };
@@ -293,6 +338,15 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                         },
                     ],
                 };
+            case "describe_operation":
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify(await describeOperation(args?.operation, args?.api), null, 2),
+                        },
+                    ],
+                };
             default:
                 throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
         }

package/dist/src/client.d.ts

@@ -12,7 +12,7 @@ export interface GraphQLResponse<T = any> {
 export declare class GraphQLClient {
     private apiKey;
     constructor(apiKey?: string | null);
-    request<T = any>(url: string, queryString: string, variables?: Record<string, any>): Promise<T>;
+    request<T = any>(url: string, queryString: string, variables?: Record<string, any>, channelToken?: string): Promise<T>;
 }
 export declare function getClient(): GraphQLClient;
 export declare function getAdminUrl(): string;

package/dist/src/client.js

@@ -7,13 +7,16 @@ export class GraphQLClient {
     constructor(apiKey = null) {
         this.apiKey = apiKey;
     }
-    async request(url, queryString, variables) {
+    async request(url, queryString, variables, channelToken) {
         const headers = {
             "Content-Type": "application/json",
         };
         if (this.apiKey) {
             headers["vendure-api-key"] = this.apiKey;
         }
+        if (channelToken) {
+            headers["vendure-token"] = channelToken;
+        }
         const response = await fetch(url, {
             method: "POST",
             headers,
@@ -33,8 +36,15 @@ export class GraphQLClient {
         return result.data;
     }
 }
+// Singleton instance
+let clientInstance = null;
 export function getClient() {
-    return new GraphQLClient(process.env.VENDURE_API_KEY || null);
+    if (clientInstance) {
+        return clientInstance;
+    }
+    const apiKey = process.env.VENDURE_API_KEY || null;
+    clientInstance = new GraphQLClient(apiKey);
+    return clientInstance;
 }
 export function getAdminUrl() {
     return process.env.ADMIN_API_URL || "http://localhost:3000/admin-api";

package/dist/src/tools/graphql-operations.d.ts

@@ -1,19 +1,19 @@
 /**
  * Execute a GraphQL query on the Admin API
  */
-export declare function adminQuery(queryString: string, variables?: Record<string, any>): Promise<any>;
+export declare function adminQuery(queryString: string, variables?: Record<string, any>, channelToken?: string): Promise<any>;
 /**
  * Execute a GraphQL mutation on the Admin API
  */
-export declare function adminMutation(mutationString: string, variables?: Record<string, any>): Promise<any>;
+export declare function adminMutation(mutationString: string, variables?: Record<string, any>, channelToken?: string): Promise<any>;
 /**
  * Execute a GraphQL query on the Shop API
  */
-export declare function shopQuery(queryString: string, variables?: Record<string, any>): Promise<any>;
+export declare function shopQuery(queryString: string, variables?: Record<string, any>, channelToken?: string): Promise<any>;
 /**
  * Execute a GraphQL mutation on the Shop API
  */
-export declare function shopMutation(mutationString: string, variables?: Record<string, any>): Promise<any>;
+export declare function shopMutation(mutationString: string, variables?: Record<string, any>, channelToken?: string): Promise<any>;
 /**
  * Fetch the Admin GraphQL schema introspection
  */
@@ -22,6 +22,14 @@ export declare function getAdminSchema(): Promise<any>;
  * Fetch the Shop GraphQL schema introspection
  */
 export declare function getShopSchema(): Promise<any>;
+/**
+ * Fetch details for a single type from the Admin API schema
+ */
+export declare function getAdminTypeDetails(name: string): Promise<any>;
+/**
+ * Fetch details for a single type from the Shop API schema
+ */
+export declare function getShopTypeDetails(name: string): Promise<any>;
 /**
  * Fetch a summary of available queries and mutations for the Admin API
  */
@@ -30,6 +38,16 @@ export declare function getAdminOperations(): Promise<any>;
  * Fetch a summary of available queries and mutations for the Shop API
  */
 export declare function getShopOperations(): Promise<any>;
+/**
+ * Describe a GraphQL operation (query or mutation) with full details.
+ *
+ * Checks both Admin and Shop APIs (or just one if `api` is specified).
+ * Returns the operation's arguments with input types, and its return type with fields.
+ *
+ * @param operationName - The name of the query or mutation
+ * @param api - Optional: restrict to "admin" or "shop" only
+ */
+export declare function describeOperation(operationName: string, api?: "admin" | "shop"): Promise<any>;
 export interface BatchResult {
     total: number;
     succeeded: number;
@@ -45,9 +63,9 @@ export interface BatchResult {
  * Execute a GraphQL mutation in batch for multiple IDs on the Admin API.
  * Runs mutations concurrently with configurable concurrency.
  */
-export declare function adminBatchMutation(mutationString: string, ids: string[], variableName?: string, extraVariables?: Record<string, any>, concurrency?: number): Promise<BatchResult>;
+export declare function adminBatchMutation(mutationString: string, ids: string[], variableName?: string, extraVariables?: Record<string, any>, concurrency?: number, channelToken?: string): Promise<BatchResult>;
 /**
  * Execute a GraphQL mutation in batch for multiple IDs on the Shop API.
  * Runs mutations concurrently with configurable concurrency.
  */
-export declare function shopBatchMutation(mutationString: string, ids: string[], variableName?: string, extraVariables?: Record<string, any>, concurrency?: number): Promise<BatchResult>;
+export declare function shopBatchMutation(mutationString: string, ids: string[], variableName?: string, extraVariables?: Record<string, any>, concurrency?: number, channelToken?: string): Promise<BatchResult>;

package/dist/src/tools/graphql-operations.js

@@ -2,30 +2,30 @@ import { getClient, getAdminUrl, getShopUrl } from "../client.js";
 /**
  * Execute a GraphQL query on the Admin API
  */
-export async function adminQuery(queryString, variables) {
+export async function adminQuery(queryString, variables, channelToken) {
     const client = getClient();
-    return client.request(getAdminUrl(), queryString, variables);
+    return client.request(getAdminUrl(), queryString, variables, channelToken);
 }
 /**
  * Execute a GraphQL mutation on the Admin API
  */
-export async function adminMutation(mutationString, variables) {
+export async function adminMutation(mutationString, variables, channelToken) {
     const client = getClient();
-    return client.request(getAdminUrl(), mutationString, variables);
+    return client.request(getAdminUrl(), mutationString, variables, channelToken);
 }
 /**
  * Execute a GraphQL query on the Shop API
  */
-export async function shopQuery(queryString, variables) {
+export async function shopQuery(queryString, variables, channelToken) {
     const client = getClient();
-    return client.request(getShopUrl(), queryString, variables);
+    return client.request(getShopUrl(), queryString, variables, channelToken);
 }
 /**
  * Execute a GraphQL mutation on the Shop API
  */
-export async function shopMutation(mutationString, variables) {
+export async function shopMutation(mutationString, variables, channelToken) {
     const client = getClient();
-    return client.request(getShopUrl(), mutationString, variables);
+    return client.request(getShopUrl(), mutationString, variables, channelToken);
 }
 const introspectionQuery = `
   query IntrospectionQuery {
@@ -138,6 +138,102 @@ const operationsSummaryQuery = `
     }
   }
 `;
+/**
+ * Query that fetches all operations with their return type chain and args.
+ * Used by describeOperation to find a specific operation's details.
+ */
+const allOperationsWithTypesQuery = `
+  query AllOperationsWithTypes {
+    __schema {
+      queryType {
+        fields {
+          name
+          description
+          args {
+            name
+            description
+            defaultValue
+            type {
+              name
+              kind
+              ofType {
+                name
+                kind
+                ofType {
+                  name
+                  kind
+                  ofType {
+                    name
+                    kind
+                  }
+                }
+              }
+            }
+          }
+          type {
+            name
+            kind
+            ofType {
+              name
+              kind
+              ofType {
+                name
+                kind
+                ofType {
+                  name
+                  kind
+                }
+              }
+            }
+          }
+        }
+      }
+      mutationType {
+        fields {
+          name
+          description
+          args {
+            name
+            description
+            defaultValue
+            type {
+              name
+              kind
+              ofType {
+                name
+                kind
+                ofType {
+                  name
+                  kind
+                  ofType {
+                    name
+                    kind
+                  }
+                }
+              }
+            }
+          }
+          type {
+            name
+            kind
+            ofType {
+              name
+              kind
+              ofType {
+                name
+                kind
+                ofType {
+                  name
+                  kind
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+`;
 /**
  * Fetch the Admin GraphQL schema introspection
  */
@@ -152,6 +248,93 @@ export async function getShopSchema() {
     const client = getClient();
     return client.request(getShopUrl(), introspectionQuery);
 }
+/**
+ * Fetch a summary of available queries and mutations for the Admin API
+ */
+const typeDetailsQuery = `
+  query GetTypeDetails($name: String!) {
+    __type(name: $name) {
+      kind
+      name
+      description
+      fields(includeDeprecated: false) {
+        name
+        description
+        args {
+          name
+          description
+          type {
+            name
+            kind
+            ofType {
+              name
+              kind
+              ofType {
+                name
+                kind
+              }
+            }
+          }
+          defaultValue
+        }
+        type {
+          name
+          kind
+          ofType {
+            name
+            kind
+            ofType {
+              name
+              kind
+              ofType {
+                name
+                kind
+              }
+            }
+          }
+        }
+      }
+      inputFields {
+        name
+        description
+        type {
+          name
+          kind
+          ofType {
+            name
+            kind
+            ofType {
+              name
+              kind
+            }
+          }
+        }
+        defaultValue
+      }
+      enumValues(includeDeprecated: false) {
+        name
+        description
+      }
+      interfaces {
+        name
+      }
+    }
+  }
+`;
+/**
+ * Fetch details for a single type from the Admin API schema
+ */
+export async function getAdminTypeDetails(name) {
+    const client = getClient();
+    return client.request(getAdminUrl(), typeDetailsQuery, { name });
+}
+/**
+ * Fetch details for a single type from the Shop API schema
+ */
+export async function getShopTypeDetails(name) {
+    const client = getClient();
+    return client.request(getShopUrl(), typeDetailsQuery, { name });
+}
 /**
  * Fetch a summary of available queries and mutations for the Admin API
  */
@@ -166,21 +349,165 @@ export async function getShopOperations() {
     const client = getClient();
     return client.request(getShopUrl(), operationsSummaryQuery);
 }
+// ─── Helpers for describeOperation ───────────────────────────────
+/**
+ * Extract the named type name from a type chain (through NonNull/List wrappers).
+ * e.g., `[ProductGroup!]!` → `ProductGroup`
+ */
+function extractNamedTypeName(type) {
+    if (!type)
+        return null;
+    if (type.kind !== "NON_NULL" && type.kind !== "LIST") {
+        return type.name || null;
+    }
+    return extractNamedTypeName(type.ofType);
+}
+/**
+ * Format a GraphQL type chain into a readable string like `[ProductGroup!]!`
+ */
+function formatTypeString(type) {
+    if (!type)
+        return "unknown";
+    switch (type.kind) {
+        case "NON_NULL":
+            return `${formatTypeString(type.ofType)}!`;
+        case "LIST":
+            return `[${formatTypeString(type.ofType)}]`;
+        default:
+            return type.name || "unknown";
+    }
+}
+/**
+ * Describe a GraphQL operation (query or mutation) with full details.
+ *
+ * Checks both Admin and Shop APIs (or just one if `api` is specified).
+ * Returns the operation's arguments with input types, and its return type with fields.
+ *
+ * @param operationName - The name of the query or mutation
+ * @param api - Optional: restrict to "admin" or "shop" only
+ */
+export async function describeOperation(operationName, api) {
+    const apisToCheck = api ? [api] : ["admin", "shop"];
+    const client = getClient();
+    const details = [];
+    for (const targetApi of apisToCheck) {
+        const url = targetApi === "admin" ? getAdminUrl() : getShopUrl();
+        try {
+            // Step 1: Fetch all operations with type chains to find the one we need
+            const schemaData = await client.request(url, allOperationsWithTypesQuery);
+            const queryFields = schemaData.__schema.queryType.fields;
+            const mutationFields = schemaData.__schema.mutationType.fields;
+            const queryField = queryFields.find((f) => f.name === operationName);
+            const mutationField = mutationFields.find((f) => f.name === operationName);
+            if (!queryField && !mutationField)
+                continue;
+            const field = queryField || mutationField;
+            const kind = queryField ? "query" : "mutation";
+            // Step 2: Resolve the return type's fields
+            const returnTypeName = extractNamedTypeName(field.type);
+            let returnType = {
+                name: formatTypeString(field.type),
+                namedType: returnTypeName,
+            };
+            if (returnTypeName) {
+                try {
+                    const result = await client.request(url, typeDetailsQuery, {
+                        name: returnTypeName,
+                    });
+                    if (result.__type) {
+                        returnType = {
+                            name: returnTypeName,
+                            kind: result.__type.kind,
+                            description: result.__type.description,
+                            fields: (result.__type.fields || []).map((f) => ({
+                                name: f.name,
+                                type: formatTypeString(f.type),
+                                description: f.description,
+                                args: f.args?.length
+                                    ? f.args.map((a) => ({
+                                        name: a.name,
+                                        type: formatTypeString(a.type),
+                                        description: a.description,
+                                        defaultValue: a.defaultValue,
+                                    }))
+                                    : undefined,
+                            })),
+                            enumValues: result.__type.enumValues,
+                            inputFields: result.__type.inputFields,
+                        };
+                    }
+                }
+                catch {
+                    // Type might be a built-in scalar - skip
+                }
+            }
+            // Step 3: Resolve argument input types
+            const argDetails = await Promise.all((field.args || []).map(async (arg) => {
+                const argTypeName = extractNamedTypeName(arg.type);
+                const detail = {
+                    name: arg.name,
+                    type: formatTypeString(arg.type),
+                    description: arg.description,
+                    defaultValue: arg.defaultValue,
+                };
+                if (argTypeName) {
+                    try {
+                        const result = await client.request(url, typeDetailsQuery, {
+                            name: argTypeName,
+                        });
+                        if (result.__type) {
+                            detail.inputFields = (result.__type.inputFields || []).map((f) => ({
+                                name: f.name,
+                                type: formatTypeString(f.type),
+                                description: f.description,
+                                defaultValue: f.defaultValue,
+                            }));
+                            detail.inputKind = result.__type.kind;
+                            detail.inputDescription = result.__type.description;
+                        }
+                    }
+                    catch {
+                        // ignore
+                    }
+                }
+                return detail;
+            }));
+            details.push({
+                api: targetApi,
+                kind,
+                description: field.description,
+                arguments: argDetails,
+                returnType,
+            });
+        }
+        catch (error) {
+            details.push({
+                api: targetApi,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    return {
+        operation: operationName,
+        availableOn: details.filter((d) => !d.error).map((d) => d.api),
+        details,
+    };
+}
 /**
  * Execute a GraphQL mutation in batch for multiple IDs on the Admin API.
  * Runs mutations concurrently with configurable concurrency.
  */
-export async function adminBatchMutation(mutationString, ids, variableName = "id", extraVariables, concurrency = 5) {
-    return executeBatch(getAdminUrl(), mutationString, ids, variableName, extraVariables, concurrency);
+export async function adminBatchMutation(mutationString, ids, variableName = "id", extraVariables, concurrency = 5, channelToken) {
+    return executeBatch(getAdminUrl(), mutationString, ids, variableName, extraVariables, concurrency, channelToken);
 }
 /**
  * Execute a GraphQL mutation in batch for multiple IDs on the Shop API.
  * Runs mutations concurrently with configurable concurrency.
  */
-export async function shopBatchMutation(mutationString, ids, variableName = "id", extraVariables, concurrency = 5) {
-    return executeBatch(getShopUrl(), mutationString, ids, variableName, extraVariables, concurrency);
+export async function shopBatchMutation(mutationString, ids, variableName = "id", extraVariables, concurrency = 5, channelToken) {
+    return executeBatch(getShopUrl(), mutationString, ids, variableName, extraVariables, concurrency, channelToken);
 }
-async function executeBatch(url, mutationString, ids, variableName, extraVariables, concurrency) {
+async function executeBatch(url, mutationString, ids, variableName, extraVariables, concurrency, channelToken) {
     const client = getClient();
     const results = [];
     const queue = [...ids];
@@ -191,7 +518,7 @@ async function executeBatch(url, mutationString, ids, variableName, extraVariabl
             const id = queue.shift();
             const variables = { ...extraVariables, [variableName]: id };
             try {
-                const data = await client.request(url, mutationString, variables);
+                const data = await client.request(url, mutationString, variables, channelToken);
                 succeeded++;
                 results.push({ id, success: true, data });
             }

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "vendure-mcp-graphql",
-  "version": "1.3.1",
+  "version": "1.5.0",
   "description": "MCP server for Vendure Admin and Shop GraphQL APIs",
   "type": "module",
   "bin": {
-    "vendure-mcp-graphql": "dist/index.js"
+    "vendure-mcp-graphql": "./dist/index.js"
   },
   "main": "dist/index.js",
   "files": [