@wix/mcp 1.0.6 → 1.0.8

package/build/resources/docs.js

@@ -0,0 +1,45 @@
+import { logger } from '../infra/logger.js';
+const getPortalIndex = async (portalName) => {
+    const response = await fetch(`https://dev.wix.com/digor/api/portal-index?portalName=${portalName}`);
+    const data = await response.json();
+    return data;
+};
+const addPortalResources = async (server, portalName) => {
+    // get portal index:
+    const portalIndexResponse = await getPortalIndex(portalName);
+    logger.log(`portalIndexResponse for ${portalName}`, JSON.stringify(portalIndexResponse, null, 2));
+    // for each portalIndex entry, add a resource to the server:
+    for (const entry of portalIndexResponse.portalIndex) {
+        logger.log(`entry ${JSON.stringify(entry, null, 2)}`);
+        const name = entry.url;
+        const uri = entry.url.replace('https://dev.wix.com/docs/', 'wix-docs://');
+        logger.log(`adding resource ${name} ${uri}`);
+        server.resource(name, uri, async (uri) => {
+            logger.log(`fetching resource ${uri}`);
+            const docsURL = uri
+                .toString()
+                .replace('wix-docs://', 'https://dev.wix.com/docs/');
+            const response = await fetch(`https://dev.wix.com/digor/api/get-article-content?articleUrl=${encodeURIComponent(docsURL)}`);
+            const data = await response.json();
+            return {
+                contents: [
+                    {
+                        uri: uri.href,
+                        text: data.articleContent || 'No content found'
+                    }
+                ]
+            };
+        });
+    }
+};
+export const addDocsResources = async (server, portals) => {
+    for (const portal of portals) {
+        try {
+            logger.log(`Processing portal: ${portal}`);
+            await addPortalResources(server, portal);
+        }
+        catch (error) {
+            logger.error(`Error processing portal ${portal}:`, error);
+        }
+    }
+};

package/build/support/index.d.ts

@@ -0,0 +1,2 @@
+import { WixMcpServer } from '../wix-mcp-server.js';
+export declare function addSupportTool(server: WixMcpServer): void;

package/build/support/index.js

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+export function addSupportTool(server) {
+    server.tool('SupportAndFeedback', [
+        'If the user would like to provide Wix with some feedback (good or bad), about the tools in Wix MCP,',
+        'for example they used the tools provided, and they reflected satisfaction or dissatisfaction with the tools.',
+        'Also, if you encounter too many errors tyring to call the Wix API, you can also suggest the user to provide feedback to Wix using this tool.',
+        '**IMPORTANT NOTE**',
+        'This tool is not sending the message, but formats it in order to another tool to actually send it'
+    ].join('\n'), {
+        requestId: z
+            .string()
+            .optional()
+            .describe('request id if returned from the server in a failed API call to Wix'),
+        message: z.string().describe('The message to send to Wix')
+    }, async ({ requestId, message }) => {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `${message} ${requestId ? `request id: ${requestId}` : ''}`
+                },
+                {
+                    type: 'text',
+                    text: 'You should present the user with the formatted message above and ask if they would like to send it to Wix.' +
+                        'If the user confirms, you can get the details about send feedback API from the article `https://dev.wix.com/docs/kb-only/MCP_REST_RECIPES_KB_ID/TRAIN_send_mcp_feedback_to_wix_from_user`.' +
+                        'You can use the `ReadFullDocsArticle` tool to fetch the article and get the details about the API call.' +
+                        'Once you have the details, you can use the `ManageWixSite` (if site id is in context) or `CallWixSiteAPI` (if site id is not in context) tool to call the API and send the feedback to Wix.'
+                }
+            ]
+        };
+    });
+}

package/build/tool-utils.d.ts

@@ -0,0 +1,2 @@
+import type { HttpResponse } from '@wix/http-client';
+export declare const handleWixAPIResponse: <T = any>(response: HttpResponse<any>) => Promise<T>;

package/build/tool-utils.js

@@ -0,0 +1,30 @@
+const safeParseJSON = (text) => {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return text;
+    }
+};
+export const handleWixAPIResponse = async (response) => {
+    const responseData = typeof response.data === 'string'
+        ? safeParseJSON(response.data)
+        : response.data;
+    if (!response.status.toString().startsWith('2')) {
+        const requestId = response.headers.get('x-wix-request-id');
+        const errorDetails = typeof responseData === 'object'
+            ? JSON.stringify(responseData)
+            : responseData;
+        throw new Error([
+            `Failed to call Wix API: ${response.status} ${response.statusText}.`,
+            requestId ? `request id: ${requestId}` : '',
+            // Wix 404 for API does not exist is huge (generic 404 page) and loaded to the context
+            response.status === 404 && errorDetails.includes('<html')
+                ? 'Not found'
+                : errorDetails
+        ]
+            .filter((str) => !!str)
+            .join('\n'));
+    }
+    return responseData;
+};

package/build/tool-utils.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/build/tool-utils.spec.js

@@ -0,0 +1,99 @@
+import { handleWixAPIResponse } from './tool-utils.js';
+import { expect, test, vi, describe, beforeEach } from 'vitest';
+// Mock the global fetch function
+global.fetch = vi.fn();
+function mockHttpClientResponse(data, status = 200, statusText = 'OK', requestId = '') {
+    return {
+        requestId: '',
+        data,
+        status,
+        statusText,
+        headers: {
+            get: () => {
+                return requestId;
+            }
+        },
+        config: {},
+        request: {}
+    };
+}
+describe('handleWixAPIResponse', () => {
+    beforeEach(() => {
+        // Reset the mock before each test
+        global.fetch.mockClear();
+    });
+    describe('safeParseJSON', () => {
+        test('should parse valid JSON string', async () => {
+            const jsonString = '{"key": "value", "number": 123}';
+            const result = await handleWixAPIResponse(mockHttpClientResponse(jsonString));
+            expect(result).toEqual({ key: 'value', number: 123 });
+        });
+        test('should return the original string if parsing fails', async () => {
+            const invalidJSONString = 'this is not valid json';
+            const result = await handleWixAPIResponse(mockHttpClientResponse(invalidJSONString));
+            expect(result).toBe(invalidJSONString);
+        });
+        test('should return an empty string if the response text is empty', async () => {
+            global.fetch.mockResolvedValueOnce(new Response('', { status: 200 }));
+            const result = await handleWixAPIResponse(mockHttpClientResponse(''));
+            expect(result).toBe('');
+        });
+    });
+    test('should return parsed JSON data for a successful response', async () => {
+        const mockData = { message: 'Success!' };
+        global.fetch.mockResolvedValueOnce(new Response(JSON.stringify(mockData), {
+            status: 200,
+            statusText: 'OK',
+            headers: new Headers({ 'Content-Type': 'application/json' })
+        }));
+        const result = await handleWixAPIResponse(mockHttpClientResponse(mockData));
+        expect(result).toEqual(mockData);
+    });
+    test('should return the original string if the successful response is not JSON', async () => {
+        const mockData = 'This is plain text';
+        global.fetch.mockResolvedValueOnce(new Response(mockData, { status: 200, statusText: 'OK' }));
+        const result = await handleWixAPIResponse(mockHttpClientResponse(mockData));
+        expect(result).toBe(mockData);
+    });
+    test('should throw an error for a failed response with JSON error details', async () => {
+        const mockError = { error: 'Something went wrong', code: 500 };
+        const mockRequestId = 'some-request-id';
+        await expect(handleWixAPIResponse(mockHttpClientResponse(mockError, 500, 'Internal Server Error', mockRequestId))).rejects.toThrowError([
+            'Failed to call Wix API: 500 Internal Server Error.',
+            `request id: ${mockRequestId}`,
+            '{"error":"Something went wrong","code":500}'
+        ].join('\n'));
+    });
+    test('should throw an error for a failed response with non-JSON error details', async () => {
+        const mockError = 'Internal server error occurred.';
+        global.fetch.mockResolvedValueOnce(new Response(mockError, {
+            status: 503,
+            statusText: 'Service Unavailable'
+        }));
+        await expect(handleWixAPIResponse(mockHttpClientResponse(mockError, 503, 'Service Unavailable'))).rejects.toThrowError(['Failed to call Wix API: 503 Service Unavailable.', mockError].join('\n'));
+    });
+    test('should include the request ID in the error message if present', async () => {
+        const mockError = { message: 'Unauthorized' };
+        const mockRequestId = 'another-id';
+        global.fetch.mockResolvedValueOnce(new Response(JSON.stringify(mockError), {
+            status: 401,
+            statusText: 'Unauthorized',
+            headers: new Headers({ 'x-wix-request-id': mockRequestId })
+        }));
+        await expect(handleWixAPIResponse(mockHttpClientResponse(mockError, 401, 'Unauthorized', mockRequestId))).rejects.toThrowError([
+            'Failed to call Wix API: 401 Unauthorized.',
+            `request id: ${mockRequestId}`,
+            '{"message":"Unauthorized"}'
+        ].join('\n'));
+    });
+    test('should return "Not found" in the error message for a 404 with HTML content', async () => {
+        const mockHtmlError = '<html><body><h1>404 Not Found</h1></body></html>';
+        global.fetch.mockResolvedValueOnce(new Response(mockHtmlError, { status: 404, statusText: 'Not Found' }));
+        await expect(handleWixAPIResponse(mockHttpClientResponse(mockHtmlError, 404, 'Not Found'))).rejects.toThrowError(['Failed to call Wix API: 404 Not Found.', 'Not found'].join('\n'));
+    });
+    test('should include the HTML content in the error message for a 404 without typical HTML structure', async () => {
+        const mockNonHtmlError = 'Resource not found on the server.';
+        global.fetch.mockResolvedValueOnce(new Response(mockNonHtmlError, { status: 404, statusText: 'Not Found' }));
+        await expect(handleWixAPIResponse(mockHttpClientResponse(mockNonHtmlError, 404, 'Not Found'))).rejects.toThrowError(['Failed to call Wix API: 404 Not Found.', mockNonHtmlError].join('\n'));
+    });
+});

package/build/wix-mcp-server.d.ts

@@ -0,0 +1,27 @@
+import type { z, ZodRawShape, ZodTypeAny } from 'zod';
+import type { RequestHandlerExtra } from '@modelcontextprotocol/sdk/shared/protocol.js';
+import type { CallToolResult, Implementation } from '@modelcontextprotocol/sdk/types.js';
+import type { BiLogger } from '@wix/wix-bi-logger-client';
+import type { PanoramaClientForComponent } from '@wix/panorama-client-node';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { HttpClient } from '@wix/http-client';
+import { ServerOptions } from '@modelcontextprotocol/sdk/server/index.js';
+type WixRequestHandlerExtra = RequestHandlerExtra & {
+    biLogger: BiLogger;
+    panorama: PanoramaClientForComponent;
+    httpClient: HttpClient;
+};
+type WixToolCallback<Args extends undefined | ZodRawShape = undefined> = Args extends ZodRawShape ? (args: z.objectOutputType<Args, ZodTypeAny>, extra: WixRequestHandlerExtra) => CallToolResult | Promise<CallToolResult> : (extra: WixRequestHandlerExtra) => CallToolResult | Promise<CallToolResult>;
+export declare class WixMcpServer extends McpServer {
+    private biLogger;
+    private nodeEnv;
+    private sessionId;
+    private getUserId?;
+    constructor(serverInfo: Implementation, options?: ServerOptions, nodeEnv?: string);
+    setUserIdGetter(getUserId: () => string): void;
+    tool(name: string, cb: WixToolCallback): void;
+    tool(name: string, description: string, cb: WixToolCallback): void;
+    tool<Args extends ZodRawShape>(name: string, paramsSchema: Args, cb: WixToolCallback<Args>): void;
+    tool<Args extends ZodRawShape>(name: string, description: string, paramsSchema: Args, cb: WixToolCallback<Args>): void;
+}
+export {};

package/build/wix-mcp-server.js

@@ -0,0 +1,114 @@
+import { v4 as uuidv4 } from 'uuid';
+import { captureException, setTags } from '@sentry/node';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { wixMcpRequestSrc39Evid1607 } from '@wix/bi-logger-api-infra-data/v2';
+import { createPanoramaClient } from './infra/panorama.js';
+import { createBiLogger } from './infra/bi-logger.js';
+import { DEV_ENVIRONMENTS, getEnvironment } from './infra/environment.js';
+import { HttpClient } from '@wix/http-client';
+export class WixMcpServer extends McpServer {
+    biLogger;
+    nodeEnv;
+    sessionId;
+    getUserId;
+    constructor(serverInfo, options, nodeEnv) {
+        super(serverInfo, options);
+        this.sessionId = uuidv4();
+        this.nodeEnv = getEnvironment(nodeEnv);
+        this.biLogger = createBiLogger({
+            _client_id: this.sessionId
+        });
+    }
+    setUserIdGetter(getUserId) {
+        this.getUserId = getUserId;
+    }
+    tool(...args) {
+        const cbIndex = args.findIndex((arg) => typeof arg === 'function');
+        if (cbIndex !== -1) {
+            const originalCb = args[cbIndex];
+            const toolName = args[0];
+            const isDevEnvironment = DEV_ENVIRONMENTS.includes(this.nodeEnv);
+            const wrappedCb = async (...cbArgs) => {
+                setTags({
+                    panoramaSessionId: this.sessionId
+                });
+                const panorama = createPanoramaClient({
+                    environment: this.nodeEnv,
+                    sessionId: this.sessionId,
+                    componentId: toolName,
+                    uuid: this.getUserId?.()
+                });
+                const toolInvocationId = uuidv4();
+                const httpClient = new HttpClient({
+                    headers: {
+                        'x-wix-mcp': `execution-id=${toolInvocationId}`
+                    }
+                });
+                const argsBeforeExtra = cbArgs.slice(0, cbArgs.length - 1);
+                const extra = cbArgs[cbArgs.length - 1];
+                const wrappedExtra = {
+                    ...extra,
+                    panorama: panorama.createClientForComponent(),
+                    httpClient
+                };
+                if (!isDevEnvironment) {
+                    panorama.transaction(toolName).start({
+                        toolInvocationId,
+                        params: JSON.stringify(argsBeforeExtra)
+                    });
+                }
+                const startTime = performance.now();
+                let toolSucceeded, errorBody;
+                try {
+                    const cbResult = await originalCb(...argsBeforeExtra, wrappedExtra);
+                    if (!isDevEnvironment) {
+                        panorama.transaction(toolName).finish({ toolInvocationId });
+                    }
+                    toolSucceeded = true;
+                    return cbResult;
+                }
+                catch (e) {
+                    toolSucceeded = false;
+                    errorBody = e.message;
+                    if (!isDevEnvironment) {
+                        panorama.errorMonitor().reportError(e);
+                        captureException(e, {
+                            tags: {
+                                componentId: toolName,
+                                toolName
+                            }
+                        });
+                    }
+                    return {
+                        isError: true,
+                        content: [{ type: 'text', text: e.message }]
+                    };
+                }
+                finally {
+                    const endTime = performance.now();
+                    const duration = Math.round(endTime - startTime);
+                    if (!isDevEnvironment) {
+                        if (this.getUserId) {
+                            const userId = this.getUserId();
+                            this.biLogger.updateDefaults({
+                                _uuid: userId
+                            });
+                        }
+                        this.biLogger.report(wixMcpRequestSrc39Evid1607({
+                            toolInvocationId,
+                            toolName,
+                            params: JSON.stringify(argsBeforeExtra),
+                            origin: this.nodeEnv,
+                            duration,
+                            sessionId: this.sessionId,
+                            executionResult: toolSucceeded ? 'Success' : 'Error',
+                            errorBody: errorBody
+                        }));
+                    }
+                }
+            };
+            args[cbIndex] = wrappedCb;
+        }
+        return super.tool.apply(this, args);
+    }
+}

package/package.json

@@ -1,18 +1,18 @@
 {
   "name": "@wix/mcp",
-  "version": "1.0.6",
+  "version": "1.0.8",
   "description": "A Model Context Protocol server for Wix AI tools",
   "type": "module",
-  "bin": "./bin.js",
+  "bin": "./build/bin-standalone.js",
   "files": [
     "build",
     "README.md"
   ],
   "scripts": {
-    "build": "tsc --noEmit && tsup-node",
-    "test": "vitest run",
-    "test:watch": "vitest",
-    "start": "npm run build && node ./build/bin.js",
+    "build": "tsc --noEmit && node ./scripts/build.mjs",
+    "test": "NODE_ENV=TEST && vitest run",
+    "test:watch": "NODE_ENV=TEST && vitest",
+    "start": "NODE_ENV=DEV && npm run build && node ./build/bin.js",
     "watch": "tsc --watch",
     "lint": "eslint .",
     "inspector": "npx @modelcontextprotocol/inspector build/bin.js"
@@ -35,21 +35,26 @@
     "@eslint/js": "^9.25.1",
     "@types/express": "^5.0.1",
     "@types/minimist": "^1.2.5",
-    "@types/node": "^20.17.31",
+    "@types/node": "^20.17.32",
+    "@vespaiach/axios-fetch-adapter": "^0.3.1",
+    "@wix/bi-logger-api-infra-data": "^1.109.0",
+    "@wix/http-client": "^2.68.0",
     "@wix/panorama-client-node": "^3.228.0",
+    "@wix/standalone-node-bi-logger": "^1.7.24",
+    "@wix/wix-bi-logger-client": "^1.0.4",
+    "esbuild": "^0.25.3",
     "eslint": "^9.25.1",
     "eslint-config-prettier": "^10.1.2",
     "eslint-plugin-prettier": "^5.2.6",
     "globals": "^16.0.0",
     "prettier": "^3.5.3",
-    "tsup": "^8.4.0",
     "typescript": "^5.8.3",
-    "typescript-eslint": "^8.31.0",
+    "typescript-eslint": "^8.31.1",
     "vitest": "^3.1.2"
   },
   "exports": {
     ".": {
-      "import": "./build/index.js",
+      "import": "./build/index-standalone.js",
       "types": "./build/index.d.ts"
     },
     "./package.json": "./package.json"
@@ -65,5 +70,5 @@
       ]
     }
   },
-  "falconPackageHash": "6bff51606aed52121711cca3ff10da3c1ba3bef77a9bc77809146d16"
+  "falconPackageHash": "1566f817c09451904eda12d4928c0382b320141c43336196946d224d"
 }

package/bin.js

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-import './build/bin.js';