@wix/mcp 1.0.0

package/build/index.js

@@ -0,0 +1,109 @@
+import './sentry.js';
+import minimist from 'minimist';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { addDocsTools, VALID_DOCS_TOOLS } from './docs/docs.js';
+import { addCliTools, VALID_CLI_TOOLS } from './cli-tools/cli.js';
+import { logger, attachStdErrLogger, attachMcpServerLogger, attachFileLogger } from './logger.js';
+import { WixMcpServer } from './wix-mcp-server.js';
+import { addDocsResources } from './resources/docs.js';
+const VALID_TOOLS = [
+    'WDS',
+    'REST',
+    'SDK',
+    'BUILD_APPS',
+    'WIX_HEADLESS'
+];
+const EXPERIMENTAL_TOOLS = ['WIX_API', 'CLI_COMMAND'];
+export const DEFAULT_TOOLS = [
+    'WDS',
+    'REST',
+    'SDK',
+    'BUILD_APPS',
+    'WIX_HEADLESS'
+];
+const parsedArgs = minimist(process.argv.slice(2));
+function parseExperimentalArg() {
+    const experimentalArg = parsedArgs['experimental'];
+    if (!experimentalArg)
+        return [];
+    return experimentalArg
+        .split(',')
+        .map((t) => t.trim())
+        .filter((tool) => EXPERIMENTAL_TOOLS.includes(tool));
+}
+function parseToolsArg() {
+    const toolsArg = parsedArgs['tools'];
+    const experimentalTools = parseExperimentalArg();
+    if (!toolsArg) {
+        // When no tools specified, return both default and experimental tools
+        return [...DEFAULT_TOOLS, ...experimentalTools];
+    }
+    const requestedTools = toolsArg.split(',').map((t) => t.trim());
+    const tools = [
+        // Include valid non-experimental tools
+        ...requestedTools.filter((tool) => VALID_TOOLS.includes(tool)),
+        // Include enabled experimental tools
+        ...experimentalTools
+    ];
+    // Warn about enabled experimental tools
+    tools.forEach((tool) => {
+        if (EXPERIMENTAL_TOOLS.includes(tool)) {
+            logger.log(`Warning: ${tool} is an experimental tool and may have limited functionality or breaking changes`);
+        }
+    });
+    return tools;
+}
+const loggerType = parsedArgs['logger'] || 'mcp';
+if (loggerType === 'file') {
+    attachFileLogger();
+}
+else {
+    // Initially we log to stderr, because MCP server is not connected yet
+    // When the server is connected, we attach the MCP server logger
+    attachStdErrLogger();
+}
+logger.log('--------------------------------');
+logger.log('starting WIX MCP server');
+logger.log('--------------------------------');
+const server = new WixMcpServer({
+    name: 'wix-mcp-server',
+    version: '1.0.0'
+}, {
+    capabilities: {
+        tools: {},
+        prompts: {},
+        logging: {},
+        resources: {}
+    }
+});
+const activeTools = parseToolsArg();
+logger.log('Active tools:', activeTools);
+const docsTools = activeTools.filter((tool) => VALID_DOCS_TOOLS.includes(tool));
+if (docsTools.length > 0) {
+    logger.log('Adding docs tools:', docsTools);
+    addDocsTools(server, docsTools);
+}
+const cliTools = activeTools.filter((tool) => VALID_CLI_TOOLS.includes(tool));
+if (cliTools.length > 0) {
+    logger.log('Adding cli tools:', cliTools);
+    addCliTools(server, cliTools);
+}
+try {
+    const portals = parsedArgs['portals']?.split(',') || [];
+    if (portals.length > 0) {
+        logger.log('Adding docs resources for portals:', portals);
+        await addDocsResources(server, portals);
+    }
+}
+catch (error) {
+    logger.error('Error adding docs resources:', error);
+}
+logger.log('Starting server');
+const transport = new StdioServerTransport();
+logger.log('Connecting to transport');
+await server.connect(transport);
+logger.log('Transport connected');
+if (loggerType === 'mcp') {
+    // From now on, we log to the MCP server
+    attachMcpServerLogger(server);
+}

package/build/interactive-command-tools/eventually.js

@@ -0,0 +1,15 @@
+import waitForExpect from 'wait-for-expect';
+const defaultOptions = {
+    timeout: 10000,
+    interval: 200
+};
+export default async function eventually(expectation, options) {
+    return new Promise((resolve, reject) => {
+        waitForExpect
+            .default(async () => {
+            const ret = await expectation();
+            resolve(ret);
+        }, options?.timeout ?? defaultOptions.timeout, options?.interval ?? defaultOptions.interval)
+            .catch((error) => reject(error));
+    });
+}

package/build/interactive-command-tools/handleStdout.js

@@ -0,0 +1,75 @@
+import stripAnsi from 'strip-ansi';
+import eventually from './eventually.js';
+import { logger } from '../logger.js';
+export function handleStdout(stdout) {
+    let checkStartIndex = 0;
+    const lines = [];
+    logger.log(`handleStdout: stdout: ${stdout}`);
+    stdout.on('data', (chunk) => {
+        logger.log(`handleStdout: chunk: ${chunk}`);
+        // log(`create-cli: chunk: ${chunk}`);
+        lines.push(...stripAnsi(chunk.toString()).split('\n'));
+    });
+    return {
+        async waitForText(match, { timeout = 2 * 60 * 1000 } = {}) {
+            return eventually(() => {
+                const matchedIndex = lines.findIndex((line, index) => {
+                    if (index < checkStartIndex) {
+                        return false;
+                    }
+                    if (typeof match === 'string') {
+                        return line.includes(match);
+                    }
+                    return line.match(match);
+                });
+                checkStartIndex = matchedIndex >= 0 ? matchedIndex + 1 : lines.length;
+                if (matchedIndex !== -1) {
+                    return lines[matchedIndex];
+                }
+                const message = `Could not match text in output: ${match}`;
+                throw new Error(message);
+            }, { timeout });
+        },
+        async waitForAndCallback(matchesAndCallbacks, { timeout = 2 * 60 * 1000 } = {}) {
+            let stopResolve;
+            const stopPromise = new Promise((resolve) => {
+                stopResolve = resolve;
+            });
+            // Keep track of matches we've already processed
+            const processedMatches = new Set();
+            const waitPromise = eventually(() => {
+                //log(`create-cli: waiting for ${matchesAndCallbacks.length - processedMatches.size} matches`);
+                for (const { match, callback } of matchesAndCallbacks) {
+                    // Skip if we've already processed this match
+                    if (processedMatches.has(match)) {
+                        continue;
+                    }
+                    if (lines.some((line) => line.includes(match))) {
+                        logger.log(`create-cli: found match ${match}`);
+                        // Add to processed matches so we don't match it again
+                        processedMatches.add(match);
+                        callback(() => {
+                            logger.log(`create-cli: stopping match loop`);
+                            stopResolve();
+                        });
+                    }
+                    else {
+                        // log(`create-cli: waiting for ${match}`);
+                    }
+                }
+                // If we've processed all matches, we're done
+                if (processedMatches.size === matchesAndCallbacks.length) {
+                    return true;
+                }
+                throw new Error(`Could not find any of the remaining matches: ${matchesAndCallbacks
+                    .filter((m) => !processedMatches.has(m.match))
+                    .map((m) => m.match)
+                    .join(', ')}`);
+            }, { timeout });
+            return Promise.race([waitPromise, stopPromise]);
+        },
+        async getOutput() {
+            return lines.join('\n');
+        }
+    };
+}

package/build/interactive-command-tools/interactive-command-utils.js

@@ -0,0 +1,75 @@
+import { handleStdout } from './handleStdout.js';
+import { logger } from '../logger.js';
+export const ENTER = '\r';
+const DOWN = '\u001b[B';
+export const mockInteractiveGenerateCommandTool = async ({ extensionType, stdin, stdout }) => {
+    try {
+        logger.log('RunWixCliCommand: handle stdout');
+        const stdoutHandler = handleStdout(stdout);
+        logger.log('RunWixCliCommand: waiting for text');
+        await stdoutHandler.waitForText('What kind of extension would you like to generate?');
+        // Enter the extension type
+        if (extensionType === 'DASHBOARD_PAGE') {
+            // No need to press enter
+        }
+        else if (extensionType === 'BACKEND_EVENT') {
+            logger.log('RunWixCliCommand: writing DOWN 9 times');
+            for (let i = 0; i < 9; i++) {
+                stdin.write(DOWN);
+                await new Promise((resolve) => setTimeout(resolve, 10));
+            }
+        }
+        logger.log('RunWixCliCommand: writing ENTER 1');
+        stdin.write(ENTER);
+        // Wait for next step
+        if (extensionType === 'DASHBOARD_PAGE') {
+            await stdoutHandler.waitForText('Page title');
+            logger.log('RunWixCliCommand: writing ENTER 2');
+            stdin.write(ENTER);
+            await stdoutHandler.waitForText('Enter the route for the new page');
+            logger.log('RunWixCliCommand: writing ENTER 3');
+            stdin.write(ENTER);
+        }
+        else if (extensionType === 'BACKEND_EVENT') {
+            await stdoutHandler.waitForText('Event folder');
+            logger.log('RunWixCliCommand: writing ENTER 2');
+            stdin.write(ENTER);
+            logger.log('RunWixCliCommand: waiting for text');
+            // Check if the text is "Would you like to install dependencies now?", if dependencies are already installed, it will not be printed
+            try {
+                await stdoutHandler.waitForText('Would you like to install dependencies now?', { timeout: 1000 });
+                logger.log('RunWixCliCommand: writing ENTER 3');
+                stdin.write(ENTER);
+            }
+            catch (error) {
+                if (error instanceof Error &&
+                    error.message.includes('Could not match text in output')) {
+                    logger.log('RunWixCliCommand: dependencies are already installed, skipping install');
+                    logger.log(await stdoutHandler.getOutput());
+                }
+                else {
+                    throw error;
+                }
+            }
+        }
+        logger.log('RunWixCliCommand: waiting for success message');
+        try {
+            await stdoutHandler.waitForText('Successfully', { timeout: 1000 });
+            logger.log('RunWixCliCommand: success message found');
+        }
+        catch (error) {
+            if (error instanceof Error &&
+                error.message.includes('Could not match text in output')) {
+                logger.log('RunWixCliCommand: success message not found, skipping'); // just skip and try to continue by returning the output
+            }
+            else {
+                throw error;
+            }
+        }
+        return stdoutHandler.getOutput();
+    }
+    catch (error) {
+        logger.error('RunWixCliCommand: error', error);
+        throw error;
+    }
+};

package/build/logger.js

@@ -0,0 +1,61 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { homedir } from 'os';
+const createNullLogger = () => {
+    return {
+        log: () => { },
+        error: () => { }
+    };
+};
+const createStdErrLogger = () => {
+    return {
+        log: (data) => {
+            console.error(data);
+        },
+        error: (data) => {
+            console.error(data);
+        }
+    };
+};
+const createMcpServerLogger = (server) => {
+    return {
+        log: (data) => {
+            server.server.sendLoggingMessage({ level: 'info', data });
+        },
+        error: (data) => {
+            server.server.sendLoggingMessage({ level: 'error', data });
+        }
+    };
+};
+const createFileLogger = () => {
+    const filePath = path.join(homedir(), 'wix-mcp-log.txt');
+    const date = new Date()
+        .toLocaleString('en-US', { timeZone: 'Asia/Jerusalem' })
+        .replace(/,/g, '');
+    return {
+        log: (...data) => {
+            const message = `[info] ${date} - ${data.join(' ')}`;
+            fs.appendFile(filePath, `${message}\n`);
+        },
+        error: (...data) => {
+            const message = `[error] ${date} - ${data.join(' ')}`;
+            fs.appendFile(filePath, `${message}\n`);
+        }
+    };
+};
+export const logger = createNullLogger();
+export const attachMcpServerLogger = (server) => {
+    const mcpLogger = createMcpServerLogger(server);
+    logger.log = mcpLogger.log;
+    logger.error = mcpLogger.error;
+};
+export const attachStdErrLogger = () => {
+    const stdErrLogger = createStdErrLogger();
+    logger.log = stdErrLogger.log;
+    logger.error = stdErrLogger.error;
+};
+export const attachFileLogger = () => {
+    const fileLogger = createFileLogger();
+    logger.log = fileLogger.log;
+    logger.error = fileLogger.error;
+};

package/build/panorama.js

@@ -0,0 +1,18 @@
+import { createRequire } from 'module';
+import { createGlobalConfig, panoramaClientFactory, PanoramaPlatform } from '@wix/panorama-client-node';
+const require = createRequire(import.meta.url);
+const packageJson = require('../package.json');
+export const globalConfig = createGlobalConfig();
+export const panoramaFactory = panoramaClientFactory({
+    baseParams: {
+        platform: PanoramaPlatform.Standalone,
+        fullArtifactId: 'com.wixpress.spartans.wix-mcp',
+        artifactVersion: packageJson.version
+    },
+    data: {
+        packageVersion: packageJson.version,
+        versions: process.versions,
+        platform: process.platform,
+        arch: process.arch
+    }
+}).withGlobalConfig(globalConfig);

package/build/resources/docs.js

@@ -0,0 +1,45 @@
+import { logger } from '../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/sentry.js

@@ -0,0 +1,10 @@
+import * as Sentry from '@sentry/node';
+Sentry.init({
+    dsn: 'https://583c5af58c664fd1977d638a693b0ada@sentry-next.wixpress.com/20924',
+    tracesSampleRate: 1.0,
+    initialScope: {
+        tags: {
+            fullArtifactId: 'com.wixpress.spartans.wix-mcp'
+        }
+    }
+});

package/build/wix-mcp-server.js

@@ -0,0 +1,50 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { globalConfig, panoramaFactory } from './panorama.js';
+import { captureException, setTags } from '@sentry/node';
+export class WixMcpServer extends McpServer {
+    tool(...args) {
+        const cbIndex = args.findIndex((arg) => typeof arg === 'function');
+        if (cbIndex !== -1) {
+            const originalCb = args[cbIndex];
+            const toolName = args[0];
+            const panoramaComponentId = toolName;
+            const panorama = panoramaFactory.client({
+                baseParams: {
+                    componentId: panoramaComponentId
+                }
+            });
+            setTags({
+                panoramaSessionId: globalConfig.getSessionId()
+            });
+            const wrappedCb = async (...cbArgs) => {
+                const argsBeforeExtra = cbArgs.slice(0, cbArgs.length - 1);
+                const extra = cbArgs[cbArgs.length - 1];
+                const wrappedExtra = {
+                    ...extra,
+                    panorama: panorama.createClientForComponent()
+                };
+                panorama.transaction(toolName).start();
+                try {
+                    const cbResult = await originalCb(...argsBeforeExtra, wrappedExtra);
+                    panorama.transaction(toolName).finish();
+                    return cbResult;
+                }
+                catch (e) {
+                    panorama.errorMonitor().reportError(e);
+                    captureException(e, {
+                        tags: {
+                            componentId: panoramaComponentId,
+                            toolName
+                        }
+                    });
+                    return {
+                        isError: true,
+                        content: [{ type: 'text', text: e.message }]
+                    };
+                }
+            };
+            args[cbIndex] = wrappedCb;
+        }
+        return super.tool.apply(this, args);
+    }
+}

package/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "@wix/mcp",
+  "version": "1.0.0",
+  "description": "A Model Context Protocol server for Wix AI tools",
+  "type": "module",
+  "bin": "./bin.js",
+  "files": [
+    "build"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "start": "npm run build && node ./build/index.js",
+    "watch": "tsc --watch",
+    "lint": "eslint .",
+    "inspector": "npx @modelcontextprotocol/inspector build/index.js"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.9.0",
+    "@sentry/node": "^9.12.0",
+    "@wix/panorama-client-node": "^3.227.0",
+    "execa": "^9.5.2",
+    "minimist": "^1.2.8",
+    "strip-ansi": "^7.1.0",
+    "uuid": "^11.1.0",
+    "wait-for-expect": "^3.0.2",
+    "zod": "^3.24.2"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.24.0",
+    "@types/express": "^5.0.1",
+    "@types/minimist": "^1.2.5",
+    "@types/node": "^20.17.30",
+    "eslint": "^9.24.0",
+    "eslint-config-prettier": "^10.1.2",
+    "eslint-plugin-prettier": "^5.2.6",
+    "globals": "^16.0.0",
+    "prettier": "^3.5.3",
+    "typescript": "^5.8.3",
+    "typescript-eslint": "^8.30.1",
+    "vitest": "^3.1.1"
+  },
+  "exports": {
+    ".": {
+      "import": "./build/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "wix": {
+    "artifact": {
+      "artifactId": "wix-mcp",
+      "groupId": "com.wixpress.spartans"
+    },
+    "validations": {
+      "source": [
+        "lint"
+      ]
+    }
+  },
+  "falconPackageHash": "bf847433e48397ca724ff50a4883a0a7a5aedc5c5cb6af9048001461"
+}