@wix/mcp 1.0.5 → 1.0.7

package/build/bin.js

@@ -1,98 +1,681 @@
-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 PUBLIC_TOOLS = [...VALID_DOCS_TOOLS];
-const EXPERIMENTAL_TOOLS = ['WIX_API', 'CLI_COMMAND'];
-export const DEFAULT_TOOLS = [...VALID_DOCS_TOOLS];
-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));
+
+// Shim require if needed.
+import module from 'module';
+if (typeof globalThis.require === "undefined") {
+  globalThis.require = module.createRequire(import.meta.url);
 }
-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];
+
+import {
+  VALID_DOCS_TOOLS,
+  WixMcpServer,
+  addDocsResources,
+  addDocsTools,
+  attachFileLogger,
+  attachMcpServerLogger,
+  attachStdErrLogger,
+  handleWixAPIResponse,
+  logger
+} from "./chunk-QGIZNLF4.js";
+
+// src/sentry.ts
+import * as Sentry from "@sentry/node";
+Sentry.init({
+  dsn: "https://583c5af58c664fd1977d638a693b0ada@sentry-next.wixpress.com/20924",
+  tracesSampleRate: 1,
+  initialScope: {
+    tags: {
+      fullArtifactId: "com.wixpress.spartans.wix-mcp"
+    }
+  }
+});
+
+// src/bin.ts
+import minimist from "minimist";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/cli-tools/cli.ts
+import { z } from "zod";
+
+// src/cli-tools/utils.ts
+import { existsSync, readFileSync } from "fs";
+import { homedir } from "os";
+import path from "path";
+function getCliAuthTokenForSiteId(siteIdOrAccountsFileName) {
+  const apiKeyFileName = path.join(homedir(), `.wix/auth/api-key.json`);
+  const apiKeyFileExists = existsSync(apiKeyFileName);
+  if (apiKeyFileExists) {
+    const apiKeyData = JSON.parse(readFileSync(apiKeyFileName, "utf8"));
+    return apiKeyData.token || apiKeyData.accessToken;
+  }
+  const siteTokenFileName = path.join(
+    homedir(),
+    `.wix/auth/${siteIdOrAccountsFileName}.json`
+  );
+  const siteTokenFileExists = existsSync(siteTokenFileName);
+  if (siteTokenFileExists) {
+    const authData = JSON.parse(readFileSync(siteTokenFileName, "utf8"));
+    return authData.accessToken || authData.token;
+  }
+  throw new Error(
+    "No site token or api key found. You need to authenticate with Wix CLI first."
+  );
+}
+function getSiteIdFromCliAppConfig(appPath) {
+  const appConfig = JSON.parse(
+    readFileSync(path.join(appPath, ".wix/app.config.json"), "utf8")
+  );
+  return appConfig.siteId;
+}
+
+// src/cli-tools/cli.ts
+import { execa } from "execa";
+
+// src/interactive-command-tools/handleStdout.ts
+import stripAnsi from "strip-ansi";
+
+// src/interactive-command-tools/eventually.ts
+import waitForExpect from "wait-for-expect";
+var defaultOptions = {
+  timeout: 1e4,
+  interval: 200
+};
+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));
+  });
+}
+
+// src/interactive-command-tools/handleStdout.ts
+function handleStdout(stdout) {
+  let checkStartIndex = 0;
+  const lines = [];
+  logger.log(`handleStdout: stdout: ${stdout}`);
+  stdout.on("data", (chunk) => {
+    logger.log(`handleStdout: chunk: ${chunk}`);
+    lines.push(...stripAnsi(chunk.toString()).split("\n"));
+  });
+  return {
+    async waitForText(match, { timeout = 2 * 60 * 1e3 } = {}) {
+      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 * 1e3 } = {}) {
+      let stopResolve;
+      const stopPromise = new Promise((resolve) => {
+        stopResolve = resolve;
+      });
+      const processedMatches = /* @__PURE__ */ new Set();
+      const waitPromise = eventually(
+        () => {
+          for (const { match, callback } of matchesAndCallbacks) {
+            if (processedMatches.has(match)) {
+              continue;
+            }
+            if (lines.some((line) => line.includes(match))) {
+              logger.log(`create-cli: found match ${match}`);
+              processedMatches.add(match);
+              callback(() => {
+                logger.log(`create-cli: stopping match loop`);
+                stopResolve();
+              });
+            } else {
+            }
+          }
+          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");
     }
-    const requestedTools = toolsArg.split(',').map((t) => t.trim());
-    const tools = [
-        // Include valid non-experimental tools
-        ...requestedTools.filter((tool) => PUBLIC_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`);
+  };
+}
+
+// src/interactive-command-tools/interactive-command-utils.ts
+var ENTER = "\r";
+var DOWN = "\x1B[B";
+var 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?"
+    );
+    if (extensionType === "DASHBOARD_PAGE") {
+    } 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);
+    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");
+      try {
+        await stdoutHandler.waitForText(
+          "Would you like to install dependencies now?",
+          { timeout: 1e3 }
+        );
+        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: 1e3 });
+      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");
+      } else {
+        throw error;
+      }
+    }
+    return stdoutHandler.getOutput();
+  } catch (error) {
+    logger.error("RunWixCliCommand: error", error);
+    throw error;
+  }
+};
+
+// src/cli-tools/cli.ts
+var VALID_CLI_TOOLS = [
+  "WIX_API",
+  "CLI_COMMAND",
+  "CLI_COMMAND_INTERACTIVE_MODE"
+];
+function addCliTools(server2, allowedTools = [
+  "WIX_API",
+  "CLI_COMMAND",
+  "CLI_COMMAND_INTERACTIVE_MODE"
+], isWixOne2 = false) {
+  if (allowedTools.includes("WIX_API")) {
+    server2.tool(
+      "CallWixAPI",
+      "Call Wix apis on an app. Use this to create, read, update, and delete data and other Wix entities in your Wix app.",
+      {
+        appPath: z.string().describe(
+          "The dir path to the wix backoffice cli app to call the api on behalf of. should have {appPath}/.wix/app.config.json file with a siteId field. if passed, siteId is not required"
+        ).optional(),
+        // should we have appPath or siteId here? (appPath encapsulates this more since we can get the siteId from the appPath then perform the call)
+        siteId: z.string().describe(
+          "The siteId of the wix backoffice cli app to call the api on behalf of. You can find the siteId in the {appPath}/.wix/app.config.json file. You can pass any other siteId if you want to call the api on behalf of a different site. If passed, appPath is not required. if not passed, the appPath must be provided."
+        ).optional(),
+        url: z.string().describe(
+          "The url of the api to call - usually you get this from the Wix REST docs or from the conversation context"
+        ),
+        method: z.string().describe(
+          "The HTTP method to use for the API call (e.g. GET, POST, PUT, DELETE)"
+        ),
+        body: z.string().optional().describe(
+          "A string representing of a valid JSON object to describe the body of the request"
+        )
+      },
+      async ({ method, url, body, appPath, siteId }) => {
+        logger.log(
+          `Calling Wix API: ${appPath} ${siteId} ${method} ${url}, body: ${JSON.stringify(
+            body
+          )}`
+        );
+        if (!siteId && !appPath) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "Either appPath or siteId must be provided"
+              }
+            ]
+          };
+        }
+        let siteIdToUse = siteId;
+        if (!siteIdToUse && appPath) {
+          siteIdToUse = getSiteIdFromCliAppConfig(appPath);
+        }
+        if (!siteIdToUse) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "Either appPath or siteId must be provided"
+              }
+            ]
+          };
         }
-    });
-    return tools;
+        logger.log(`Site ID for Wix API call: ${siteIdToUse}`);
+        const authorization = getCliAuthTokenForSiteId(siteIdToUse);
+        if (!authorization) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "Failed to get authorization token. Please check your siteId and appPath"
+              }
+            ]
+          };
+        }
+        try {
+          const response = await fetch(url, {
+            method,
+            headers: {
+              Authorization: authorization,
+              "wix-site-id": siteIdToUse,
+              ...body ? { "Content-Type": "application/json" } : {}
+            },
+            body
+          });
+          const responseData = await handleWixAPIResponse(response);
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Wix API call successful: ${JSON.stringify(responseData)}`
+              }
+            ]
+          };
+        } catch (error) {
+          logger.error(`Failed to call Wix API: ${error}`);
+          throw new Error(`Failed to call Wix API: ${error}`);
+        }
+      }
+    );
+  }
+  if (allowedTools.includes("CLI_COMMAND_INTERACTIVE_MODE")) {
+    server2.tool(
+      "RunWixCliCommandInteractiveMode",
+      `Executes Wix CLI commands for Wix app development and management.
+    Use this tool to run commands like 'wix app generate' (adds new extensions), 'wix app build' (builds your app), 'wix app preview' (creates shareable preview), 'wix app release' (releases a new version of your app), and more.
+
+    IMPORTANT: Before using this tool, check if the command is mapped in package.json scripts:
+    * Use this tool for npm/yarn scripts that map to Wix CLI commands as well.
+    * Do not use this tool for starting the local development server.
+    
+    Before using this tool, you MUST search the Wix documentation for the command you want to run.
+    
+    DO NOT USE THIS TOOL FOR ANY OTHER PURPOSE. IT IS ONLY FOR WIX CLI COMMANDS.`,
+      {
+        appPath: z.string().describe("The full path to the Wix CLI app to run the command on"),
+        extensionType: z.enum(["DASHBOARD_PAGE", "BACKEND_EVENT"]).optional().describe(
+          "The type of extension to generate. You MUST provide this for commands that generate extensions."
+        ),
+        searchedDocs: z.boolean().describe(
+          "Whether you have already searched the Wix documentation for the command you want to run."
+        ),
+        command: z.string().min(1, "Command cannot be empty").max(1e3, "Command is too long").describe(
+          "The Wix CLI command to execute (e.g. 'wix app generate', 'wix app build', 'wix app preview', 'wix app release', etc.), or a npm/yarn script that maps to a Wix CLI command (e.g. 'npm run generate', 'yarn build', etc.)."
+        )
+      },
+      async ({ command, appPath, extensionType }) => {
+        command = command.replace("wix app generate", "npm run generate");
+        if (command.includes("generate") && !extensionType) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "Error: You must provide an extension type for the 'generate' command."
+              }
+            ],
+            isError: true
+          };
+        }
+        logger.log(
+          `RunWixCliCommand: command: ${command}, appPath: ${appPath}, extensionType: ${extensionType}`
+        );
+        try {
+          logger.log(`Executing Wix CLI command: ${command}`);
+          const commandParts = command.split(" ");
+          const commandName = commandParts[0];
+          const commandArgs = commandParts.slice(1);
+          const subprocess = execa(commandName, commandArgs, {
+            cwd: appPath,
+            extendEnv: true,
+            env: {
+              ...process.env,
+              PATH: process.env.PATH,
+              WIX_CLI_TEST_OVERRIDES: JSON.stringify({
+                inkDebug: true
+              })
+            },
+            timeout: 5 * 60 * 1e3,
+            // 5 minute timeout
+            maxBuffer: 10 * 1024 * 1024
+            // 10MB output limit
+          });
+          logger.log(`RunWixCliCommand: pid: ${subprocess.pid}`);
+          if (!subprocess.pid) {
+            let spawnError;
+            if (!spawnError) {
+              await new Promise((resolve) => {
+                subprocess.on("error", (err) => {
+                  spawnError = err;
+                  resolve({ spawnError });
+                });
+              });
+            }
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `Failed to start the Wix CLI command process. This usually indicates a problem with the command or the environment. Are you sure Wix CLI is installed globally?
+
+Command: ${command}
+
+${spawnError}`
+                }
+              ]
+            };
+          }
+          const { stdin, stdout, stderr } = subprocess;
+          if (extensionType) {
+            const output = await mockInteractiveGenerateCommandTool({
+              extensionType,
+              stdin,
+              stdout
+            });
+            logger.log(`RunWixCliCommand: output: ${output}`);
+            return {
+              content: [{ type: "text", text: output }]
+            };
+          }
+          const stringifyStdout = JSON.stringify(stdout);
+          const stringifyStderr = JSON.stringify(stderr);
+          return {
+            content: [
+              { type: "text", text: stringifyStdout },
+              ...stringifyStderr ? [{ type: "text", text: `Error: ${stringifyStderr}` }] : []
+            ]
+          };
+        } catch (error) {
+          logger.error(`Error executing Wix CLI command: ${error}`);
+          return {
+            content: [{ type: "text", text: `Error: ${error}` }],
+            isError: true
+          };
+        }
+      }
+    );
+  }
+  if (allowedTools.includes("CLI_COMMAND")) {
+    server2.tool(
+      "RunWixCliCommand",
+      `Executes Wix CLI commands for Wix app development and management.
+    Use this tool to run commands like 'wix app generate' (adds new extensions), 'wix app build' (builds your app), 'wix app preview' (creates shareable preview), 'wix app release' (releases a new version of your app), and more.
+
+    IMPORTANT: Before using this tool, check if the command is mapped in package.json scripts:
+    * Use this tool for npm/yarn scripts that map to Wix CLI commands as well.
+    * Do not use this tool for starting the local development server.
+    
+    Before using this tool, you MUST search the Wix documentation for the command you want to run.
+    
+    DO NOT USE THIS TOOL FOR ANY OTHER PURPOSE. IT IS ONLY FOR WIX CLI COMMANDS.`,
+      {
+        appPath: z.string().describe("The full path to the Wix CLI app to run the command on."),
+        extensionType: z.enum([
+          "dashboard-page",
+          "dashboard-plugin",
+          "dashboard-menu-plugin",
+          "dashboard-modal",
+          "web-method",
+          "api-route",
+          "event",
+          "service-plugin"
+        ]).optional().describe(
+          "The type of extension to generate. You MUST provide this for commands that generate extensions."
+        ),
+        extensionName: z.string().optional().describe(
+          "The name of the extension to generate, e.g. My Dashboard Page. You MUST provide this for commands that generate extensions."
+        ),
+        searchedDocs: z.boolean().describe(
+          "Whether you have already searched the Wix documentation for the command you want to run."
+        ),
+        command: z.string().min(1, "Command cannot be empty").max(1e3, "Command is too long").describe(
+          "The Wix CLI command to execute (e.g. 'wix app generate', 'wix app build', 'wix app preview', 'wix app release', etc.), or a script that maps to a Wix CLI command (e.g. 'npm run generate', 'yarn generate', etc.)."
+        )
+      },
+      async ({ command, appPath, extensionType, extensionName }) => {
+        logger.log(
+          `RunWixCliCommand: command: ${command}, appPath: ${appPath}, extensionType: ${extensionType}, extensionName: ${extensionName}`
+        );
+        let commandName = "";
+        let commandArgs = [];
+        if (command.includes("generate")) {
+          if (!extensionType) {
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: "Error: You must provide an extension type for the 'generate' command."
+                }
+              ],
+              isError: true
+            };
+          }
+          if (!extensionName) {
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: "Error: You must provide an extension name for the 'generate' command."
+                }
+              ],
+              isError: true
+            };
+          }
+          commandName = "npx";
+          commandArgs = [
+            isWixOne2 ? "wix-one" : "wix",
+            "app",
+            "generate",
+            "-t",
+            extensionType,
+            "-n",
+            extensionName,
+            "--json"
+          ];
+        } else {
+          const commandParts = command.split(" ");
+          commandName = commandParts[0];
+          commandArgs = commandParts.slice(1);
+        }
+        if (isWixOne2 && commandName === "wix") {
+          commandName = "wix-one";
+        }
+        try {
+          logger.log(
+            `Executing Wix CLI command: ${commandName} ${commandArgs.join(" ")}`
+          );
+          const { stdout, stderr, exitCode } = await execa(
+            commandName,
+            commandArgs,
+            {
+              cwd: appPath,
+              extendEnv: true,
+              env: {
+                ...process.env
+              },
+              timeout: 5 * 60 * 1e3,
+              // 5 minute timeout
+              maxBuffer: 10 * 1024 * 1024
+              // 10MB output limit
+            }
+          );
+          if (exitCode !== 0) {
+            return {
+              content: [{ type: "text", text: `Error: ${stderr}` }],
+              isError: true
+            };
+          }
+          logger.log(`RunWixCliCommand: stdout: ${stdout}`);
+          logger.log(`RunWixCliCommand: stderr: ${stderr}`);
+          return {
+            content: [
+              { type: "text", text: stdout },
+              ...stderr ? [{ type: "text", text: `Error: ${stderr}` }] : []
+            ]
+          };
+        } catch (error) {
+          logger.error(`Error executing Wix CLI command: ${error}`);
+          return {
+            content: [{ type: "text", text: `Error: ${error}` }],
+            isError: true
+          };
+        }
+      }
+    );
+  }
 }
-const loggerType = parsedArgs['logger'] || 'mcp';
-if (loggerType === 'file') {
-    attachFileLogger();
+
+// src/bin.ts
+var PUBLIC_TOOLS = [...VALID_DOCS_TOOLS];
+var EXPERIMENTAL_TOOLS = ["WIX_API", "CLI_COMMAND"];
+var DEFAULT_TOOLS = [...VALID_DOCS_TOOLS];
+var 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) {
+    return [...DEFAULT_TOOLS, ...experimentalTools];
+  }
+  const requestedTools = toolsArg.split(",").map((t) => t.trim());
+  const tools = [
+    // Include valid non-experimental tools
+    ...requestedTools.filter(
+      (tool) => PUBLIC_TOOLS.includes(tool)
+    ),
+    // Include enabled experimental tools
+    ...experimentalTools
+  ];
+  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;
 }
-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();
+var loggerType = parsedArgs["logger"] || "mcp";
+if (loggerType === "file") {
+  attachFileLogger();
+} else {
+  attachStdErrLogger();
 }
-logger.log('--------------------------------');
-logger.log('starting WIX MCP server');
-logger.log('--------------------------------');
-const server = new WixMcpServer({
-    name: 'wix-mcp-server',
-    version: '1.0.0'
-}, {
+logger.log("--------------------------------");
+logger.log("starting WIX MCP server");
+logger.log("--------------------------------");
+var server = new WixMcpServer(
+  {
+    name: "wix-mcp-server",
+    version: "1.0.0"
+  },
+  {
     capabilities: {
-        tools: {},
-        prompts: {},
-        logging: {},
-        resources: {}
+      tools: {},
+      prompts: {},
+      logging: {},
+      resources: {}
     }
-});
-const activeTools = parseToolsArg();
-logger.log('Active tools:', activeTools);
-const docsTools = activeTools.filter((tool) => VALID_DOCS_TOOLS.includes(tool));
+  }
+);
+var activeTools = parseToolsArg();
+logger.log("Active tools:", activeTools);
+var docsTools = activeTools.filter(
+  (tool) => VALID_DOCS_TOOLS.includes(tool)
+);
 if (docsTools.length > 0) {
-    logger.log('Adding docs tools:', docsTools);
-    addDocsTools(server, docsTools);
+  logger.log("Adding docs tools:", docsTools);
+  addDocsTools(server, docsTools);
 }
-const isWixOne = parsedArgs['cli'] === 'wix-one';
-const cliTools = activeTools.filter((tool) => VALID_CLI_TOOLS.includes(tool));
+var isWixOne = parsedArgs["cli"] === "wix-one";
+var cliTools = activeTools.filter(
+  (tool) => VALID_CLI_TOOLS.includes(tool)
+);
 if (cliTools.length > 0) {
-    logger.log('Adding cli tools:', cliTools, 'isWixOne:', isWixOne);
-    addCliTools(server, cliTools, isWixOne);
+  logger.log("Adding cli tools:", cliTools, "isWixOne:", isWixOne);
+  addCliTools(server, cliTools, isWixOne);
 }
 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);
+  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');
+logger.log("Starting server");
+var 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);
+logger.log("Transport connected");
+if (loggerType === "mcp") {
+  attachMcpServerLogger(server);
 }
+export {
+  DEFAULT_TOOLS
+};
+//# sourceMappingURL=bin.js.map