@wix/mcp 1.0.6 → 1.0.8

package/build/index.d.ts

@@ -1,30 +1,7 @@
-import { ZodRawShape, z, ZodTypeAny } from 'zod';
-import { RequestHandlerExtra } from '@modelcontextprotocol/sdk/shared/protocol.js';
-import { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
-import { PanoramaClientForComponent } from '@wix/panorama-client-node';
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-
-type WixRequestHandlerExtra = RequestHandlerExtra & {
-    panorama: PanoramaClientForComponent;
-};
-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>;
-declare class WixMcpServer extends McpServer {
-    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;
-}
-
-declare const VALID_DOCS_TOOLS: readonly ["WDS", "REST", "SDK", "BUILD_APPS", "WIX_HEADLESS", "BUSINESS_SOLUTIONS"];
-type DocsTool = (typeof VALID_DOCS_TOOLS)[number];
-declare const addDocsTools: (server: WixMcpServer, allowedTools?: DocsTool[]) => void;
-
-declare function addApiCallTool(server: WixMcpServer, getSiteAccessToken: (siteId: string) => Promise<string>, getAccountAccessToken: () => Promise<string>): void;
-
-declare const handleWixAPIResponse: <T = any>(response: Response) => Promise<T>;
-
-declare const addDocsResources: (server: McpServer, portals: string[]) => Promise<void>;
-
-declare function addSupportTool(server: WixMcpServer): void;
-
-export { type DocsTool, VALID_DOCS_TOOLS, WixMcpServer, addApiCallTool, addDocsResources, addDocsTools, addSupportTool, handleWixAPIResponse };
+export { WixMcpServer } from './wix-mcp-server.js';
+export { addDocsTools, DocsTool, VALID_DOCS_TOOLS } from './docs/docs.js';
+export { addApiCallTool } from './api-call/index.js';
+export { handleWixAPIResponse } from './tool-utils.js';
+export { addDocsResources } from './resources/docs.js';
+export { addSupportTool } from './support/index.js';
+export { McpAuthenticationStrategy, McpHeaders } from './auth/index.js';

package/build/index.js

@@ -1,193 +1,6 @@
-import {
-  VALID_DOCS_TOOLS,
-  WixMcpServer,
-  addDocsResources,
-  addDocsTools,
-  handleWixAPIResponse,
-  logger
-} from "./chunk-YRLMZUQM.js";
-
-// src/api-call/index.ts
-import { z } from "zod";
-function addApiCallTool(server, getSiteAccessToken, getAccountAccessToken) {
-  server.tool(
-    "CallWixSiteAPI",
-    [
-      "Call Wix apis on a business or site. Use this to create, read, update, and delete data and other Wix entities in your Wix site,",
-      `You should ALWAYS check the rest docs - "SearchWixRESTDocumentation" for the specific API you want to call, don't just call it without knowing what it does, CHECK THE DOCS`,
-      "Error Handling:",
-      'If the error is related to missing installed app or "WDE0110: Wix Code not enabled", you should install the missing app by using ReadFullDocsArticle tool to fetch the article - https://dev.wix.com/docs/kb-only/MCP_REST_RECIPES_KB_ID/TRAIN_wix.devcenter.apps.installer.v1.AppsInstallerService.InstallApp',
-      "**Note:** there is no need to check if an app is installed/ Wix Code enabled in advance, just call the API and handle the error if it occurs, the API error message will state it clearly.",
-      "For any other error, use your default error handling mechanism"
-    ].join("\n"),
-    {
-      siteId: z.string().describe("The id of the site selected using site selection tool"),
-      url: z.string().describe(
-        "The url of the api to call - ALWAYS get the information from the Wix REST docs or from the conversation context, the URL MUST BE ABSOLUTE URL"
-      ),
-      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 ({ url, body, method, siteId }) => {
-      logger.log(
-        `Calling Wix Site API: ${siteId} ${url}, body: ${JSON.stringify(body)}`
-      );
-      const authorization = await getSiteAccessToken(siteId);
-      try {
-        const response = await fetch(url, {
-          method,
-          headers: {
-            Authorization: authorization,
-            ...body ? { "Content-Type": "application/json" } : {}
-          },
-          body: method === "GET" ? void 0 : body
-        });
-        const responseData = await handleWixAPIResponse(response);
-        return {
-          content: [
-            {
-              type: "text",
-              text: `Wix Site API call successful: ${JSON.stringify(responseData)}`
-            }
-          ]
-        };
-      } catch (error) {
-        logger.error(`Failed to call Wix Site API: ${error}`);
-        throw new Error(`Failed to call Wix Site API: ${error}`);
-      }
-    }
-  );
-  server.tool(
-    "ListWixSites",
-    "List Wix sites for the current user",
-    async () => {
-      const sitesRes = await fetch(
-        "https://www.wixapis.com/site-list/v2/sites/query",
-        {
-          method: "POST",
-          headers: {
-            "Content-Type": "application/json",
-            Accept: "application/json, text/plain, */*",
-            Authorization: await getAccountAccessToken()
-          },
-          body: JSON.stringify({
-            query: {
-              cursorPaging: { limit: 50 }
-            }
-          })
-        }
-      );
-      const result = await sitesRes.json().then(
-        ({ sites }) => sites?.map(({ id, displayName }) => ({
-          id,
-          name: displayName
-        })) ?? []
-      );
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify(result)
-          },
-          {
-            type: "text",
-            text: "if there is more than one site returned, the user should pick one from a list, list the sites (only name) for the user and ask them to pick one"
-          }
-        ]
-      };
-    }
-  );
-  server.tool(
-    "ManageWixSite",
-    `Use account level API in order to create a site, update a site and publish site.
-    ALWAYS use "SearchWixRESTDocumentation" to search for the API you should invoke, NEVER GUESS THE SITE API URL
-    You should ALWAYS check the rest docs - "SearchWixRESTDocumentation" for the specific API you want to call, don't just call it without knowing what it does, CHECK THE DOCS`,
-    {
-      url: z.string().describe(
-        "The url of the api to call - ALWAYS get the information from the Wix REST docs DONT GUESS IT, the URL MUST BE ABSOLUTE URL"
-      ),
-      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 ({ url, body, method }) => {
-      logger.log(
-        `Calling Wix Account level API: ${url}, body: ${JSON.stringify(body)}`
-      );
-      const authorization = await getAccountAccessToken();
-      try {
-        const response = await fetch(url, {
-          method,
-          headers: {
-            Authorization: authorization,
-            ...body ? { "Content-Type": "application/json" } : {}
-          },
-          body: method === "GET" ? void 0 : body
-        });
-        const responseData = await handleWixAPIResponse(response);
-        return {
-          content: [
-            {
-              type: "text",
-              text: `Wix Account API call successful: ${JSON.stringify(responseData)}`
-            }
-          ]
-        };
-      } catch (error) {
-        logger.error(`Failed to call Wix Account API: ${error}`);
-        throw new Error(`Failed to call Wix Account API: ${error}`);
-      }
-    }
-  );
-}
-
-// src/support/index.ts
-import { z as z2 } from "zod";
-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: z2.string().optional().describe(
-        "request id if returned from the server in a failed API call to Wix"
-      ),
-      message: z2.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."
-          }
-        ]
-      };
-    }
-  );
-}
-export {
-  VALID_DOCS_TOOLS,
-  WixMcpServer,
-  addApiCallTool,
-  addDocsResources,
-  addDocsTools,
-  addSupportTool,
-  handleWixAPIResponse
-};
+export { WixMcpServer } from './wix-mcp-server.js';
+export { addDocsTools, VALID_DOCS_TOOLS } from './docs/docs.js';
+export { addApiCallTool } from './api-call/index.js';
+export { handleWixAPIResponse } from './tool-utils.js';
+export { addDocsResources } from './resources/docs.js';
+export { addSupportTool } from './support/index.js';

package/build/infra/bi-logger.d.ts

@@ -0,0 +1,2 @@
+import type { BiEvent, BiLogger } from '@wix/wix-bi-logger-client';
+export declare function createBiLogger(defaultFields?: BiEvent): BiLogger;

package/build/infra/bi-logger.js

@@ -0,0 +1,10 @@
+import { StandaloneNodeLogger } from '@wix/standalone-node-bi-logger';
+export function createBiLogger(defaultFields) {
+    return new StandaloneNodeLogger()
+        .factory({})
+        .updateDefaults({
+        localTime: () => Date.now(),
+        ...defaultFields
+    })
+        .logger();
+}

package/build/infra/environment.d.ts

@@ -0,0 +1,9 @@
+export declare enum ENV {
+    DEV = "DEV",
+    TEST = "TEST",
+    LOCAL = "LOCAL",
+    REMOTE = "REMOTE",
+    PICASSO = "PICASSO"
+}
+export declare const DEV_ENVIRONMENTS: ENV[];
+export declare function getEnvironment(nodeEnv?: string): ENV;

package/build/infra/environment.js

@@ -0,0 +1,27 @@
+export var ENV;
+(function (ENV) {
+    ENV["DEV"] = "DEV";
+    ENV["TEST"] = "TEST";
+    ENV["LOCAL"] = "LOCAL";
+    ENV["REMOTE"] = "REMOTE";
+    ENV["PICASSO"] = "PICASSO";
+})(ENV || (ENV = {}));
+const DEFAULT_ENV = ENV.LOCAL;
+export const DEV_ENVIRONMENTS = [ENV.DEV, ENV.TEST];
+export function getEnvironment(nodeEnv) {
+    const env = nodeEnv || process.env.NODE_ENV;
+    switch (env?.toUpperCase()) {
+        case 'DEV':
+            return ENV.DEV;
+        case 'TEST':
+            return ENV.TEST;
+        case 'LOCAL':
+            return ENV.LOCAL;
+        case 'REMOTE':
+            return ENV.REMOTE;
+        case 'PICASSO':
+            return ENV.PICASSO;
+        default:
+            return DEFAULT_ENV;
+    }
+}

package/build/infra/logger.d.ts

@@ -0,0 +1,10 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+interface Logger {
+    log(...data: unknown[]): void;
+    error(...data: unknown[]): void;
+}
+export declare const logger: Logger;
+export declare const attachMcpServerLogger: (server: McpServer) => void;
+export declare const attachStdErrLogger: () => void;
+export declare const attachFileLogger: () => void;
+export {};

package/build/infra/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/infra/panorama.d.ts

@@ -0,0 +1,7 @@
+import type { ENV } from './environment.js';
+export declare const createPanoramaClient: (opts: {
+    environment: ENV;
+    sessionId: string;
+    componentId: string;
+    uuid?: string;
+}) => import("@wix/panorama-client-node").PanoramaClient;

package/build/infra/panorama.js

@@ -0,0 +1,35 @@
+// import { createRequire } from 'module';
+import { createGlobalConfig, panoramaClientFactory, PanoramaPlatform } from '@wix/panorama-client-node';
+// const require = createRequire(import.meta.url);
+// const packageJson = require('../package.json');
+// TODO: use real package.json
+// I temporarily disabled this because it's not working in the remote server
+const packageJson = {
+    version: '1.0.0'
+};
+export const createPanoramaClient = (opts) => {
+    const globalPanoramaConfig = createGlobalConfig();
+    globalPanoramaConfig.setSessionId(opts.sessionId);
+    const panoramaFactory = panoramaClientFactory({
+        reporterOptions: {
+            silent: true
+        },
+        baseParams: {
+            uuid: opts.uuid,
+            componentId: opts.componentId,
+            platform: PanoramaPlatform.Standalone,
+            fullArtifactId: 'com.wixpress.spartans.wix-mcp',
+            artifactVersion: packageJson.version
+        },
+        data: {
+            environment: opts.environment,
+            runtime: {
+                packageVersion: packageJson.version,
+                versions: process.versions,
+                platform: process.platform,
+                arch: process.arch
+            }
+        }
+    }).withGlobalConfig(globalPanoramaConfig);
+    return panoramaFactory.client();
+};

package/build/infra/sentry.d.ts

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

package/build/infra/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/interactive-command-tools/eventually.d.ts

@@ -0,0 +1,6 @@
+interface Options {
+    timeout?: number;
+    interval?: number;
+}
+export default function eventually<ReturnType = void>(expectation: () => ReturnType | Promise<ReturnType>, options?: Options): Promise<ReturnType>;
+export {};

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.d.ts

@@ -0,0 +1,13 @@
+import Stream from 'node:stream';
+export declare function handleStdout(stdout: Stream.Readable): {
+    waitForText(match: string | RegExp, { timeout }?: {
+        timeout?: number | undefined;
+    }): Promise<string | undefined>;
+    waitForAndCallback(matchesAndCallbacks: {
+        match: string;
+        callback: (stop: () => void) => void;
+    }[], { timeout }?: {
+        timeout?: number | undefined;
+    }): Promise<unknown>;
+    getOutput(): Promise<string>;
+};

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

@@ -0,0 +1,75 @@
+import stripAnsi from 'strip-ansi';
+import eventually from './eventually.js';
+import { logger } from '../infra/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.d.ts

@@ -0,0 +1,7 @@
+import Stream from 'node:stream';
+export declare const ENTER = "\r";
+export declare const mockInteractiveGenerateCommandTool: ({ extensionType, stdin, stdout }: {
+    extensionType: string;
+    stdin: Stream.Writable;
+    stdout: Stream.Readable;
+}) => Promise<string>;

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

@@ -0,0 +1,75 @@
+import { handleStdout } from './handleStdout.js';
+import { logger } from '../infra/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/resources/docs.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare const addDocsResources: (server: McpServer, portals: string[]) => Promise<void>;