@strapi/core 5.46.1 → 5.47.1

package/dist/services/mcp/tools/log.d.ts

@@ -0,0 +1,87 @@
+import { z } from '@strapi/utils';
+export declare const logToolDefinition: {
+    name: "log";
+    telemetry?: import("@strapi/types/dist/modules/mcp").McpCapabilityTelemetry | undefined;
+} & {
+    devModeOnly: true;
+    auth?: undefined;
+} & {
+    title: "Strapi Log";
+    description: "Logs a message to the Strapi logger with specified level";
+    resolveInputSchema?: import("@strapi/types/dist/modules/mcp").McpToolSchemaResolver<z.ZodObject<{
+        message: z.ZodString;
+        level: z.ZodDefault<z.ZodEnum<{
+            http: "http";
+            info: "info";
+            error: "error";
+            log: "log";
+            warn: "warn";
+        }>>;
+    }, z.core.$strip>> | undefined;
+    resolveOutputSchema: import("@strapi/types/dist/modules/mcp").McpToolSchemaResolver<z.ZodObject<{
+        status: z.ZodString;
+        message: z.ZodString;
+        level: z.ZodString;
+        timestamp: z.ZodString;
+    }, z.core.$strip>>;
+    createHandler: (strapi: import("@strapi/types/dist/core").Strapi, context: import("@strapi/types/dist/modules/mcp").McpHandlerContext) => import("@strapi/types/dist/modules/mcp").McpToolHandler<NoInfer<z.ZodObject<{
+        message: z.ZodString;
+        level: z.ZodDefault<z.ZodEnum<{
+            http: "http";
+            info: "info";
+            error: "error";
+            log: "log";
+            warn: "warn";
+        }>>;
+    }, z.core.$strip>>, NoInfer<z.ZodObject<{
+        status: z.ZodString;
+        message: z.ZodString;
+        level: z.ZodString;
+        timestamp: z.ZodString;
+    }, z.core.$strip>>>;
+} & {
+    name: "log";
+    title: "Strapi Log";
+    description: "Logs a message to the Strapi logger with specified level";
+    resolveInputSchema: () => z.ZodObject<{
+        message: z.ZodString;
+        level: z.ZodDefault<z.ZodEnum<{
+            http: "http";
+            info: "info";
+            error: "error";
+            log: "log";
+            warn: "warn";
+        }>>;
+    }, z.core.$strip>;
+    resolveOutputSchema: () => z.ZodObject<{
+        status: z.ZodString;
+        message: z.ZodString;
+        level: z.ZodString;
+        timestamp: z.ZodString;
+    }, z.core.$strip>;
+    telemetry: {
+        source: string;
+        name: string;
+    };
+    devModeOnly: true;
+    createHandler: (strapi: import("@strapi/types/dist/core").Strapi) => ({ args }: {
+        extra: import("@modelcontextprotocol/sdk/shared/protocol").RequestHandlerExtra<import("@modelcontextprotocol/sdk/types").ServerRequest, import("@modelcontextprotocol/sdk/types").ServerNotification>;
+    } & {
+        args: {
+            message: string;
+            level: "http" | "info" | "error" | "log" | "warn";
+        };
+    }) => Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        structuredContent: {
+            status: string;
+            message: string;
+            level: "http" | "info" | "error" | "log" | "warn";
+            timestamp: string;
+        };
+    }>;
+};
+//# sourceMappingURL=log.d.ts.map

package/dist/services/mcp/tools/log.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"log.d.ts","sourceRoot":"","sources":["../../../../src/services/mcp/tools/log.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,eAAe,CAAC;AAmBlC,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwE5B,CAAC"}

package/dist/services/mcp/tools/log.js

@@ -0,0 +1,88 @@
+'use strict';
+
+var strapiUtils = require('@strapi/utils');
+var toolRegistry = require('../tool-registry.js');
+
+const inputSchema = strapiUtils.z.object({
+    message: strapiUtils.z.string().describe('Message to log'),
+    level: strapiUtils.z.enum([
+        'info',
+        'http',
+        'warn',
+        'error',
+        'log'
+    ]).default('info').describe('Log level (default: info)')
+});
+const outputSchema = strapiUtils.z.object({
+    status: strapiUtils.z.string(),
+    message: strapiUtils.z.string(),
+    level: strapiUtils.z.string(),
+    timestamp: strapiUtils.z.string()
+});
+const logToolDefinition = toolRegistry.makeMcpToolDefinition({
+    name: 'log',
+    title: 'Strapi Log',
+    description: 'Logs a message to the Strapi logger with specified level',
+    resolveInputSchema: ()=>inputSchema,
+    resolveOutputSchema: ()=>outputSchema,
+    telemetry: {
+        source: 'core',
+        name: 'log'
+    },
+    devModeOnly: true,
+    createHandler: (strapi)=>async ({ args })=>{
+            const { message, level } = args;
+            // Security: Sanitize message to prevent log injection
+            // 1. Limit length to prevent log spam (10KB max)
+            const MAX_MESSAGE_LENGTH = 10 * 1024;
+            let sanitizedMessage = message.length > MAX_MESSAGE_LENGTH ? `${message.substring(0, MAX_MESSAGE_LENGTH)}...[truncated]` : message;
+            // 2. Remove control characters (including ANSI escape codes)
+            // This regex matches: \x00-\x1F (C0 controls), \x7F (DEL), \x80-\x9F (C1 controls)
+            // and ANSI escape sequences (\x1B[ followed by parameters and command)
+            sanitizedMessage = sanitizedMessage// eslint-disable-next-line no-control-regex
+            .replace(/\x1B\[[0-9;]*[A-Za-z]/g, '') // Remove ANSI escape sequences
+            // eslint-disable-next-line no-control-regex
+            .replace(/[\x00-\x1F\x7F-\x9F]/g, ''); // Remove control characters
+            // 3. Replace newlines with spaces to prevent fake log entry injection
+            sanitizedMessage = sanitizedMessage.replace(/[\r\n]+/g, ' ');
+            // 4. Trim whitespace
+            sanitizedMessage = sanitizedMessage.trim();
+            // Map level to appropriate logger method
+            switch(level){
+                case 'http':
+                    strapi.log.http(`[MCP] ${sanitizedMessage}`);
+                    break;
+                case 'warn':
+                    strapi.log.warn(`[MCP] ${sanitizedMessage}`);
+                    break;
+                case 'error':
+                    strapi.log.error(`[MCP] ${sanitizedMessage}`);
+                    break;
+                case 'log':
+                    strapi.log.info(`[MCP] ${sanitizedMessage}`);
+                    break;
+                case 'info':
+                default:
+                    strapi.log.info(`[MCP] ${sanitizedMessage}`);
+                    break;
+            }
+            const result = {
+                status: 'logged',
+                message: sanitizedMessage,
+                level,
+                timestamp: new Date().toISOString()
+            };
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(result, null, 2)
+                    }
+                ],
+                structuredContent: result
+            };
+        }
+});
+
+exports.logToolDefinition = logToolDefinition;
+//# sourceMappingURL=log.js.map

package/dist/services/mcp/tools/log.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"log.js","sources":["../../../../src/services/mcp/tools/log.ts"],"sourcesContent":["import { z } from '@strapi/utils';\n\nimport { makeMcpToolDefinition } from '../tool-registry';\n\nconst inputSchema = z.object({\n  message: z.string().describe('Message to log'),\n  level: z\n    .enum(['info', 'http', 'warn', 'error', 'log'])\n    .default('info')\n    .describe('Log level (default: info)'),\n});\n\nconst outputSchema = z.object({\n  status: z.string(),\n  message: z.string(),\n  level: z.string(),\n  timestamp: z.string(),\n});\n\nexport const logToolDefinition = makeMcpToolDefinition({\n  name: 'log',\n  title: 'Strapi Log',\n  description: 'Logs a message to the Strapi logger with specified level',\n  resolveInputSchema: () => inputSchema,\n  resolveOutputSchema: () => outputSchema,\n  telemetry: { source: 'core', name: 'log' },\n  devModeOnly: true,\n  createHandler:\n    (strapi) =>\n    async ({ args }) => {\n      const { message, level } = args;\n\n      // Security: Sanitize message to prevent log injection\n      // 1. Limit length to prevent log spam (10KB max)\n      const MAX_MESSAGE_LENGTH = 10 * 1024;\n      let sanitizedMessage =\n        message.length > MAX_MESSAGE_LENGTH\n          ? `${message.substring(0, MAX_MESSAGE_LENGTH)}...[truncated]`\n          : message;\n\n      // 2. Remove control characters (including ANSI escape codes)\n      // This regex matches: \\x00-\\x1F (C0 controls), \\x7F (DEL), \\x80-\\x9F (C1 controls)\n      // and ANSI escape sequences (\\x1B[ followed by parameters and command)\n      sanitizedMessage = sanitizedMessage\n        // eslint-disable-next-line no-control-regex\n        .replace(/\\x1B\\[[0-9;]*[A-Za-z]/g, '') // Remove ANSI escape sequences\n        // eslint-disable-next-line no-control-regex\n        .replace(/[\\x00-\\x1F\\x7F-\\x9F]/g, ''); // Remove control characters\n\n      // 3. Replace newlines with spaces to prevent fake log entry injection\n      sanitizedMessage = sanitizedMessage.replace(/[\\r\\n]+/g, ' ');\n\n      // 4. Trim whitespace\n      sanitizedMessage = sanitizedMessage.trim();\n\n      // Map level to appropriate logger method\n      switch (level) {\n        case 'http':\n          strapi.log.http(`[MCP] ${sanitizedMessage}`);\n          break;\n        case 'warn':\n          strapi.log.warn(`[MCP] ${sanitizedMessage}`);\n          break;\n        case 'error':\n          strapi.log.error(`[MCP] ${sanitizedMessage}`);\n          break;\n        case 'log':\n          strapi.log.info(`[MCP] ${sanitizedMessage}`);\n          break;\n        case 'info':\n        default:\n          strapi.log.info(`[MCP] ${sanitizedMessage}`);\n          break;\n      }\n\n      const result = {\n        status: 'logged',\n        message: sanitizedMessage,\n        level,\n        timestamp: new Date().toISOString(),\n      };\n      return {\n        content: [\n          {\n            type: 'text' as const,\n            text: JSON.stringify(result, null, 2),\n          },\n        ],\n        structuredContent: result,\n      };\n    },\n});\n"],"names":["inputSchema","z","object","message","string","describe","level","enum","default","outputSchema","status","timestamp","logToolDefinition","makeMcpToolDefinition","name","title","description","resolveInputSchema","resolveOutputSchema","telemetry","source","devModeOnly","createHandler","strapi","args","MAX_MESSAGE_LENGTH","sanitizedMessage","length","substring","replace","trim","log","http","warn","error","info","result","Date","toISOString","content","type","text","JSON","stringify","structuredContent"],"mappings":"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"}

package/dist/services/mcp/tools/log.mjs

@@ -0,0 +1,86 @@
+import { z } from '@strapi/utils';
+import { makeMcpToolDefinition } from '../tool-registry.mjs';
+
+const inputSchema = z.object({
+    message: z.string().describe('Message to log'),
+    level: z.enum([
+        'info',
+        'http',
+        'warn',
+        'error',
+        'log'
+    ]).default('info').describe('Log level (default: info)')
+});
+const outputSchema = z.object({
+    status: z.string(),
+    message: z.string(),
+    level: z.string(),
+    timestamp: z.string()
+});
+const logToolDefinition = makeMcpToolDefinition({
+    name: 'log',
+    title: 'Strapi Log',
+    description: 'Logs a message to the Strapi logger with specified level',
+    resolveInputSchema: ()=>inputSchema,
+    resolveOutputSchema: ()=>outputSchema,
+    telemetry: {
+        source: 'core',
+        name: 'log'
+    },
+    devModeOnly: true,
+    createHandler: (strapi)=>async ({ args })=>{
+            const { message, level } = args;
+            // Security: Sanitize message to prevent log injection
+            // 1. Limit length to prevent log spam (10KB max)
+            const MAX_MESSAGE_LENGTH = 10 * 1024;
+            let sanitizedMessage = message.length > MAX_MESSAGE_LENGTH ? `${message.substring(0, MAX_MESSAGE_LENGTH)}...[truncated]` : message;
+            // 2. Remove control characters (including ANSI escape codes)
+            // This regex matches: \x00-\x1F (C0 controls), \x7F (DEL), \x80-\x9F (C1 controls)
+            // and ANSI escape sequences (\x1B[ followed by parameters and command)
+            sanitizedMessage = sanitizedMessage// eslint-disable-next-line no-control-regex
+            .replace(/\x1B\[[0-9;]*[A-Za-z]/g, '') // Remove ANSI escape sequences
+            // eslint-disable-next-line no-control-regex
+            .replace(/[\x00-\x1F\x7F-\x9F]/g, ''); // Remove control characters
+            // 3. Replace newlines with spaces to prevent fake log entry injection
+            sanitizedMessage = sanitizedMessage.replace(/[\r\n]+/g, ' ');
+            // 4. Trim whitespace
+            sanitizedMessage = sanitizedMessage.trim();
+            // Map level to appropriate logger method
+            switch(level){
+                case 'http':
+                    strapi.log.http(`[MCP] ${sanitizedMessage}`);
+                    break;
+                case 'warn':
+                    strapi.log.warn(`[MCP] ${sanitizedMessage}`);
+                    break;
+                case 'error':
+                    strapi.log.error(`[MCP] ${sanitizedMessage}`);
+                    break;
+                case 'log':
+                    strapi.log.info(`[MCP] ${sanitizedMessage}`);
+                    break;
+                case 'info':
+                default:
+                    strapi.log.info(`[MCP] ${sanitizedMessage}`);
+                    break;
+            }
+            const result = {
+                status: 'logged',
+                message: sanitizedMessage,
+                level,
+                timestamp: new Date().toISOString()
+            };
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(result, null, 2)
+                    }
+                ],
+                structuredContent: result
+            };
+        }
+});
+
+export { logToolDefinition };
+//# sourceMappingURL=log.mjs.map

package/dist/services/mcp/tools/log.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"log.mjs","sources":["../../../../src/services/mcp/tools/log.ts"],"sourcesContent":["import { z } from '@strapi/utils';\n\nimport { makeMcpToolDefinition } from '../tool-registry';\n\nconst inputSchema = z.object({\n  message: z.string().describe('Message to log'),\n  level: z\n    .enum(['info', 'http', 'warn', 'error', 'log'])\n    .default('info')\n    .describe('Log level (default: info)'),\n});\n\nconst outputSchema = z.object({\n  status: z.string(),\n  message: z.string(),\n  level: z.string(),\n  timestamp: z.string(),\n});\n\nexport const logToolDefinition = makeMcpToolDefinition({\n  name: 'log',\n  title: 'Strapi Log',\n  description: 'Logs a message to the Strapi logger with specified level',\n  resolveInputSchema: () => inputSchema,\n  resolveOutputSchema: () => outputSchema,\n  telemetry: { source: 'core', name: 'log' },\n  devModeOnly: true,\n  createHandler:\n    (strapi) =>\n    async ({ args }) => {\n      const { message, level } = args;\n\n      // Security: Sanitize message to prevent log injection\n      // 1. Limit length to prevent log spam (10KB max)\n      const MAX_MESSAGE_LENGTH = 10 * 1024;\n      let sanitizedMessage =\n        message.length > MAX_MESSAGE_LENGTH\n          ? `${message.substring(0, MAX_MESSAGE_LENGTH)}...[truncated]`\n          : message;\n\n      // 2. Remove control characters (including ANSI escape codes)\n      // This regex matches: \\x00-\\x1F (C0 controls), \\x7F (DEL), \\x80-\\x9F (C1 controls)\n      // and ANSI escape sequences (\\x1B[ followed by parameters and command)\n      sanitizedMessage = sanitizedMessage\n        // eslint-disable-next-line no-control-regex\n        .replace(/\\x1B\\[[0-9;]*[A-Za-z]/g, '') // Remove ANSI escape sequences\n        // eslint-disable-next-line no-control-regex\n        .replace(/[\\x00-\\x1F\\x7F-\\x9F]/g, ''); // Remove control characters\n\n      // 3. Replace newlines with spaces to prevent fake log entry injection\n      sanitizedMessage = sanitizedMessage.replace(/[\\r\\n]+/g, ' ');\n\n      // 4. Trim whitespace\n      sanitizedMessage = sanitizedMessage.trim();\n\n      // Map level to appropriate logger method\n      switch (level) {\n        case 'http':\n          strapi.log.http(`[MCP] ${sanitizedMessage}`);\n          break;\n        case 'warn':\n          strapi.log.warn(`[MCP] ${sanitizedMessage}`);\n          break;\n        case 'error':\n          strapi.log.error(`[MCP] ${sanitizedMessage}`);\n          break;\n        case 'log':\n          strapi.log.info(`[MCP] ${sanitizedMessage}`);\n          break;\n        case 'info':\n        default:\n          strapi.log.info(`[MCP] ${sanitizedMessage}`);\n          break;\n      }\n\n      const result = {\n        status: 'logged',\n        message: sanitizedMessage,\n        level,\n        timestamp: new Date().toISOString(),\n      };\n      return {\n        content: [\n          {\n            type: 'text' as const,\n            text: JSON.stringify(result, null, 2),\n          },\n        ],\n        structuredContent: result,\n      };\n    },\n});\n"],"names":["inputSchema","z","object","message","string","describe","level","enum","default","outputSchema","status","timestamp","logToolDefinition","makeMcpToolDefinition","name","title","description","resolveInputSchema","resolveOutputSchema","telemetry","source","devModeOnly","createHandler","strapi","args","MAX_MESSAGE_LENGTH","sanitizedMessage","length","substring","replace","trim","log","http","warn","error","info","result","Date","toISOString","content","type","text","JSON","stringify","structuredContent"],"mappings":"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"}

package/dist/services/mcp/utils/createSafeCapabilityRegistration.d.ts

@@ -0,0 +1,36 @@
+import type { Core } from '@strapi/types';
+import type { RegisteredCapability } from '../internal/McpCapabilityRegistry';
+/**
+ * A no-op registered capability used as fallback when SDK registration fails.
+ *
+ * This prevents one broken capability from aborting the entire registration loop.
+ * The capability will appear as "disabled" and cannot be enabled.
+ */
+export declare const FAILED_REGISTERED_CAPABILITY: RegisteredCapability;
+/**
+ * Configuration for creating a safe capability registration
+ */
+export type SafeCapabilityRegistrationConfig<THandler, TErrorResult, TRegistered> = {
+    strapi: Core.Strapi;
+    capabilityType: string;
+    name: string;
+    createHandler: (strapi: Core.Strapi) => THandler;
+    createFallbackHandler: (errorMessage: string) => NoInfer<THandler>;
+    createErrorResult: (error: Error, args: unknown[]) => TErrorResult;
+    registerWithSdk: (safeHandler: THandler) => TRegistered;
+};
+/**
+ * Creates a safe capability registration that protects Strapi core from user callback errors
+ * at three levels:
+ *
+ * - Level 1: Catch factory invocation errors (createHandler throws)
+ * - Level 2: Catch runtime execution errors (handler throws during invocation)
+ * - Level 3: Catch MCP SDK registration errors (SDK rejects the registration)
+ *
+ * This prevents one broken capability from:
+ * - Aborting the entire registration loop
+ * - Crashing the MCP server
+ * - Leaking unhandled errors to the user
+ */
+export declare const createSafeCapabilityRegistration: <THandler, TErrorResult, TRegistered>(config: SafeCapabilityRegistrationConfig<THandler, TErrorResult, TRegistered>) => TRegistered;
+//# sourceMappingURL=createSafeCapabilityRegistration.d.ts.map

package/dist/services/mcp/utils/createSafeCapabilityRegistration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createSafeCapabilityRegistration.d.ts","sourceRoot":"","sources":["../../../../src/services/mcp/utils/createSafeCapabilityRegistration.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAC1C,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,mCAAmC,CAAC;AAG9E;;;;;GAKG;AACH,eAAO,MAAM,4BAA4B,EAAE,oBAKzC,CAAC;AAEH;;GAEG;AACH,MAAM,MAAM,gCAAgC,CAAC,QAAQ,EAAE,YAAY,EAAE,WAAW,IAAI;IAClF,MAAM,EAAE,IAAI,CAAC,MAAM,CAAC;IACpB,cAAc,EAAE,MAAM,CAAC;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,aAAa,EAAE,CAAC,MAAM,EAAE,IAAI,CAAC,MAAM,KAAK,QAAQ,CAAC;IACjD,qBAAqB,EAAE,CAAC,YAAY,EAAE,MAAM,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAC;IACnE,iBAAiB,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,YAAY,CAAC;IACnE,eAAe,EAAE,CAAC,WAAW,EAAE,QAAQ,KAAK,WAAW,CAAC;CACzD,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,gCAAgC,gDACnC,iCAAiC,QAAQ,EAAE,YAAY,EAAE,WAAW,CAAC,KAC5E,WA4CF,CAAC"}

package/dist/services/mcp/utils/createSafeCapabilityRegistration.js

@@ -0,0 +1,59 @@
+'use strict';
+
+var safeHandlerWrapper = require('./safeHandlerWrapper.js');
+
+/**
+ * A no-op registered capability used as fallback when SDK registration fails.
+ *
+ * This prevents one broken capability from aborting the entire registration loop.
+ * The capability will appear as "disabled" and cannot be enabled.
+ */ const FAILED_REGISTERED_CAPABILITY = Object.freeze({
+    enabled: false,
+    enable () {},
+    disable () {},
+    remove () {}
+});
+/**
+ * Creates a safe capability registration that protects Strapi core from user callback errors
+ * at three levels:
+ *
+ * - Level 1: Catch factory invocation errors (createHandler throws)
+ * - Level 2: Catch runtime execution errors (handler throws during invocation)
+ * - Level 3: Catch MCP SDK registration errors (SDK rejects the registration)
+ *
+ * This prevents one broken capability from:
+ * - Aborting the entire registration loop
+ * - Crashing the MCP server
+ * - Leaking unhandled errors to the user
+ */ const createSafeCapabilityRegistration = (config)=>{
+    const { strapi, capabilityType, name, createHandler, createFallbackHandler, createErrorResult, registerWithSdk } = config;
+    try {
+        // Level 1: Safe factory invocation — catch errors from user's createHandler
+        let rawHandler;
+        try {
+            rawHandler = createHandler(strapi);
+        } catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            strapi.log.error(`[MCP] ${capabilityType} "${name}" handler factory threw during initialization: ${message}`);
+            // Substitute a fallback handler that always returns an error to the MCP client
+            rawHandler = createFallbackHandler(message);
+        }
+        // Level 2: Safe runtime wrapping — catch errors from user's handler during execution
+        const safeHandler = safeHandlerWrapper.wrapSafeHandler(rawHandler, {
+            strapi,
+            capabilityType,
+            name,
+            createErrorResult
+        });
+        return registerWithSdk(safeHandler);
+    } catch (error) {
+        // Level 3: Catch MCP SDK registration errors — prevent one broken capability from aborting all others
+        const message = error instanceof Error ? error.message : String(error);
+        strapi.log.error(`[MCP] Failed to register ${capabilityType.toLowerCase()} "${name}" with MCP server: ${message}`);
+        return FAILED_REGISTERED_CAPABILITY;
+    }
+};
+
+exports.FAILED_REGISTERED_CAPABILITY = FAILED_REGISTERED_CAPABILITY;
+exports.createSafeCapabilityRegistration = createSafeCapabilityRegistration;
+//# sourceMappingURL=createSafeCapabilityRegistration.js.map

package/dist/services/mcp/utils/createSafeCapabilityRegistration.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createSafeCapabilityRegistration.js","sources":["../../../../src/services/mcp/utils/createSafeCapabilityRegistration.ts"],"sourcesContent":["import type { Core } from '@strapi/types';\nimport type { RegisteredCapability } from '../internal/McpCapabilityRegistry';\nimport { wrapSafeHandler } from './safeHandlerWrapper';\n\n/**\n * A no-op registered capability used as fallback when SDK registration fails.\n *\n * This prevents one broken capability from aborting the entire registration loop.\n * The capability will appear as \"disabled\" and cannot be enabled.\n */\nexport const FAILED_REGISTERED_CAPABILITY: RegisteredCapability = Object.freeze({\n  enabled: false,\n  enable() {},\n  disable() {},\n  remove() {},\n});\n\n/**\n * Configuration for creating a safe capability registration\n */\nexport type SafeCapabilityRegistrationConfig<THandler, TErrorResult, TRegistered> = {\n  strapi: Core.Strapi;\n  capabilityType: string;\n  name: string;\n  createHandler: (strapi: Core.Strapi) => THandler;\n  createFallbackHandler: (errorMessage: string) => NoInfer<THandler>;\n  createErrorResult: (error: Error, args: unknown[]) => TErrorResult;\n  registerWithSdk: (safeHandler: THandler) => TRegistered;\n};\n\n/**\n * Creates a safe capability registration that protects Strapi core from user callback errors\n * at three levels:\n *\n * - Level 1: Catch factory invocation errors (createHandler throws)\n * - Level 2: Catch runtime execution errors (handler throws during invocation)\n * - Level 3: Catch MCP SDK registration errors (SDK rejects the registration)\n *\n * This prevents one broken capability from:\n * - Aborting the entire registration loop\n * - Crashing the MCP server\n * - Leaking unhandled errors to the user\n */\nexport const createSafeCapabilityRegistration = <THandler, TErrorResult, TRegistered>(\n  config: SafeCapabilityRegistrationConfig<THandler, TErrorResult, TRegistered>\n): TRegistered => {\n  const {\n    strapi,\n    capabilityType,\n    name,\n    createHandler,\n    createFallbackHandler,\n    createErrorResult,\n    registerWithSdk,\n  } = config;\n\n  try {\n    // Level 1: Safe factory invocation — catch errors from user's createHandler\n    let rawHandler: THandler;\n\n    try {\n      rawHandler = createHandler(strapi);\n    } catch (error) {\n      const message = error instanceof Error ? error.message : String(error);\n      strapi.log.error(\n        `[MCP] ${capabilityType} \"${name}\" handler factory threw during initialization: ${message}`\n      );\n\n      // Substitute a fallback handler that always returns an error to the MCP client\n      rawHandler = createFallbackHandler(message);\n    }\n\n    // Level 2: Safe runtime wrapping — catch errors from user's handler during execution\n    const safeHandler = wrapSafeHandler(rawHandler as (...args: unknown[]) => Promise<unknown>, {\n      strapi,\n      capabilityType,\n      name,\n      createErrorResult,\n    });\n\n    return registerWithSdk(safeHandler as THandler);\n  } catch (error) {\n    // Level 3: Catch MCP SDK registration errors — prevent one broken capability from aborting all others\n    const message = error instanceof Error ? error.message : String(error);\n    strapi.log.error(\n      `[MCP] Failed to register ${capabilityType.toLowerCase()} \"${name}\" with MCP server: ${message}`\n    );\n    return FAILED_REGISTERED_CAPABILITY as unknown as TRegistered;\n  }\n};\n"],"names":["FAILED_REGISTERED_CAPABILITY","Object","freeze","enabled","enable","disable","remove","createSafeCapabilityRegistration","config","strapi","capabilityType","name","createHandler","createFallbackHandler","createErrorResult","registerWithSdk","rawHandler","error","message","Error","String","log","safeHandler","wrapSafeHandler","toLowerCase"],"mappings":";;;;AAIA;;;;;AAKC,IACM,MAAMA,4BAAAA,GAAqDC,MAAAA,CAAOC,MAAM,CAAC;IAC9EC,OAAAA,EAAS,KAAA;IACTC,MAAAA,CAAAA,GAAAA,CAAU,CAAA;IACVC,OAAAA,CAAAA,GAAAA,CAAW,CAAA;IACXC,MAAAA,CAAAA,GAAAA,CAAU;AACZ,CAAA;AAeA;;;;;;;;;;;;IAaO,MAAMC,gCAAAA,GAAmC,CAC9CC,MAAAA,GAAAA;AAEA,IAAA,MAAM,EACJC,MAAM,EACNC,cAAc,EACdC,IAAI,EACJC,aAAa,EACbC,qBAAqB,EACrBC,iBAAiB,EACjBC,eAAe,EAChB,GAAGP,MAAAA;IAEJ,IAAI;;QAEF,IAAIQ,UAAAA;QAEJ,IAAI;AACFA,YAAAA,UAAAA,GAAaJ,aAAAA,CAAcH,MAAAA,CAAAA;AAC7B,QAAA,CAAA,CAAE,OAAOQ,KAAAA,EAAO;AACd,YAAA,MAAMC,UAAUD,KAAAA,YAAiBE,KAAAA,GAAQF,KAAAA,CAAMC,OAAO,GAAGE,MAAAA,CAAOH,KAAAA,CAAAA;AAChER,YAAAA,MAAAA,CAAOY,GAAG,CAACJ,KAAK,CACd,CAAC,MAAM,EAAEP,cAAAA,CAAe,EAAE,EAAEC,IAAAA,CAAK,+CAA+C,EAAEO,OAAAA,CAAAA,CAAS,CAAA;;AAI7FF,YAAAA,UAAAA,GAAaH,qBAAAA,CAAsBK,OAAAA,CAAAA;AACrC,QAAA;;QAGA,MAAMI,WAAAA,GAAcC,mCAAgBP,UAAAA,EAAwD;AAC1FP,YAAAA,MAAAA;AACAC,YAAAA,cAAAA;AACAC,YAAAA,IAAAA;AACAG,YAAAA;AACF,SAAA,CAAA;AAEA,QAAA,OAAOC,eAAAA,CAAgBO,WAAAA,CAAAA;AACzB,IAAA,CAAA,CAAE,OAAOL,KAAAA,EAAO;;AAEd,QAAA,MAAMC,UAAUD,KAAAA,YAAiBE,KAAAA,GAAQF,KAAAA,CAAMC,OAAO,GAAGE,MAAAA,CAAOH,KAAAA,CAAAA;AAChER,QAAAA,MAAAA,CAAOY,GAAG,CAACJ,KAAK,CACd,CAAC,yBAAyB,EAAEP,cAAAA,CAAec,WAAW,GAAG,EAAE,EAAEb,IAAAA,CAAK,mBAAmB,EAAEO,OAAAA,CAAAA,CAAS,CAAA;QAElG,OAAOlB,4BAAAA;AACT,IAAA;AACF;;;;;"}

package/dist/services/mcp/utils/createSafeCapabilityRegistration.mjs

@@ -0,0 +1,56 @@
+import { wrapSafeHandler } from './safeHandlerWrapper.mjs';
+
+/**
+ * A no-op registered capability used as fallback when SDK registration fails.
+ *
+ * This prevents one broken capability from aborting the entire registration loop.
+ * The capability will appear as "disabled" and cannot be enabled.
+ */ const FAILED_REGISTERED_CAPABILITY = Object.freeze({
+    enabled: false,
+    enable () {},
+    disable () {},
+    remove () {}
+});
+/**
+ * Creates a safe capability registration that protects Strapi core from user callback errors
+ * at three levels:
+ *
+ * - Level 1: Catch factory invocation errors (createHandler throws)
+ * - Level 2: Catch runtime execution errors (handler throws during invocation)
+ * - Level 3: Catch MCP SDK registration errors (SDK rejects the registration)
+ *
+ * This prevents one broken capability from:
+ * - Aborting the entire registration loop
+ * - Crashing the MCP server
+ * - Leaking unhandled errors to the user
+ */ const createSafeCapabilityRegistration = (config)=>{
+    const { strapi, capabilityType, name, createHandler, createFallbackHandler, createErrorResult, registerWithSdk } = config;
+    try {
+        // Level 1: Safe factory invocation — catch errors from user's createHandler
+        let rawHandler;
+        try {
+            rawHandler = createHandler(strapi);
+        } catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            strapi.log.error(`[MCP] ${capabilityType} "${name}" handler factory threw during initialization: ${message}`);
+            // Substitute a fallback handler that always returns an error to the MCP client
+            rawHandler = createFallbackHandler(message);
+        }
+        // Level 2: Safe runtime wrapping — catch errors from user's handler during execution
+        const safeHandler = wrapSafeHandler(rawHandler, {
+            strapi,
+            capabilityType,
+            name,
+            createErrorResult
+        });
+        return registerWithSdk(safeHandler);
+    } catch (error) {
+        // Level 3: Catch MCP SDK registration errors — prevent one broken capability from aborting all others
+        const message = error instanceof Error ? error.message : String(error);
+        strapi.log.error(`[MCP] Failed to register ${capabilityType.toLowerCase()} "${name}" with MCP server: ${message}`);
+        return FAILED_REGISTERED_CAPABILITY;
+    }
+};
+
+export { FAILED_REGISTERED_CAPABILITY, createSafeCapabilityRegistration };
+//# sourceMappingURL=createSafeCapabilityRegistration.mjs.map

package/dist/services/mcp/utils/createSafeCapabilityRegistration.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createSafeCapabilityRegistration.mjs","sources":["../../../../src/services/mcp/utils/createSafeCapabilityRegistration.ts"],"sourcesContent":["import type { Core } from '@strapi/types';\nimport type { RegisteredCapability } from '../internal/McpCapabilityRegistry';\nimport { wrapSafeHandler } from './safeHandlerWrapper';\n\n/**\n * A no-op registered capability used as fallback when SDK registration fails.\n *\n * This prevents one broken capability from aborting the entire registration loop.\n * The capability will appear as \"disabled\" and cannot be enabled.\n */\nexport const FAILED_REGISTERED_CAPABILITY: RegisteredCapability = Object.freeze({\n  enabled: false,\n  enable() {},\n  disable() {},\n  remove() {},\n});\n\n/**\n * Configuration for creating a safe capability registration\n */\nexport type SafeCapabilityRegistrationConfig<THandler, TErrorResult, TRegistered> = {\n  strapi: Core.Strapi;\n  capabilityType: string;\n  name: string;\n  createHandler: (strapi: Core.Strapi) => THandler;\n  createFallbackHandler: (errorMessage: string) => NoInfer<THandler>;\n  createErrorResult: (error: Error, args: unknown[]) => TErrorResult;\n  registerWithSdk: (safeHandler: THandler) => TRegistered;\n};\n\n/**\n * Creates a safe capability registration that protects Strapi core from user callback errors\n * at three levels:\n *\n * - Level 1: Catch factory invocation errors (createHandler throws)\n * - Level 2: Catch runtime execution errors (handler throws during invocation)\n * - Level 3: Catch MCP SDK registration errors (SDK rejects the registration)\n *\n * This prevents one broken capability from:\n * - Aborting the entire registration loop\n * - Crashing the MCP server\n * - Leaking unhandled errors to the user\n */\nexport const createSafeCapabilityRegistration = <THandler, TErrorResult, TRegistered>(\n  config: SafeCapabilityRegistrationConfig<THandler, TErrorResult, TRegistered>\n): TRegistered => {\n  const {\n    strapi,\n    capabilityType,\n    name,\n    createHandler,\n    createFallbackHandler,\n    createErrorResult,\n    registerWithSdk,\n  } = config;\n\n  try {\n    // Level 1: Safe factory invocation — catch errors from user's createHandler\n    let rawHandler: THandler;\n\n    try {\n      rawHandler = createHandler(strapi);\n    } catch (error) {\n      const message = error instanceof Error ? error.message : String(error);\n      strapi.log.error(\n        `[MCP] ${capabilityType} \"${name}\" handler factory threw during initialization: ${message}`\n      );\n\n      // Substitute a fallback handler that always returns an error to the MCP client\n      rawHandler = createFallbackHandler(message);\n    }\n\n    // Level 2: Safe runtime wrapping — catch errors from user's handler during execution\n    const safeHandler = wrapSafeHandler(rawHandler as (...args: unknown[]) => Promise<unknown>, {\n      strapi,\n      capabilityType,\n      name,\n      createErrorResult,\n    });\n\n    return registerWithSdk(safeHandler as THandler);\n  } catch (error) {\n    // Level 3: Catch MCP SDK registration errors — prevent one broken capability from aborting all others\n    const message = error instanceof Error ? error.message : String(error);\n    strapi.log.error(\n      `[MCP] Failed to register ${capabilityType.toLowerCase()} \"${name}\" with MCP server: ${message}`\n    );\n    return FAILED_REGISTERED_CAPABILITY as unknown as TRegistered;\n  }\n};\n"],"names":["FAILED_REGISTERED_CAPABILITY","Object","freeze","enabled","enable","disable","remove","createSafeCapabilityRegistration","config","strapi","capabilityType","name","createHandler","createFallbackHandler","createErrorResult","registerWithSdk","rawHandler","error","message","Error","String","log","safeHandler","wrapSafeHandler","toLowerCase"],"mappings":";;AAIA;;;;;AAKC,IACM,MAAMA,4BAAAA,GAAqDC,MAAAA,CAAOC,MAAM,CAAC;IAC9EC,OAAAA,EAAS,KAAA;IACTC,MAAAA,CAAAA,GAAAA,CAAU,CAAA;IACVC,OAAAA,CAAAA,GAAAA,CAAW,CAAA;IACXC,MAAAA,CAAAA,GAAAA,CAAU;AACZ,CAAA;AAeA;;;;;;;;;;;;IAaO,MAAMC,gCAAAA,GAAmC,CAC9CC,MAAAA,GAAAA;AAEA,IAAA,MAAM,EACJC,MAAM,EACNC,cAAc,EACdC,IAAI,EACJC,aAAa,EACbC,qBAAqB,EACrBC,iBAAiB,EACjBC,eAAe,EAChB,GAAGP,MAAAA;IAEJ,IAAI;;QAEF,IAAIQ,UAAAA;QAEJ,IAAI;AACFA,YAAAA,UAAAA,GAAaJ,aAAAA,CAAcH,MAAAA,CAAAA;AAC7B,QAAA,CAAA,CAAE,OAAOQ,KAAAA,EAAO;AACd,YAAA,MAAMC,UAAUD,KAAAA,YAAiBE,KAAAA,GAAQF,KAAAA,CAAMC,OAAO,GAAGE,MAAAA,CAAOH,KAAAA,CAAAA;AAChER,YAAAA,MAAAA,CAAOY,GAAG,CAACJ,KAAK,CACd,CAAC,MAAM,EAAEP,cAAAA,CAAe,EAAE,EAAEC,IAAAA,CAAK,+CAA+C,EAAEO,OAAAA,CAAAA,CAAS,CAAA;;AAI7FF,YAAAA,UAAAA,GAAaH,qBAAAA,CAAsBK,OAAAA,CAAAA;AACrC,QAAA;;QAGA,MAAMI,WAAAA,GAAcC,gBAAgBP,UAAAA,EAAwD;AAC1FP,YAAAA,MAAAA;AACAC,YAAAA,cAAAA;AACAC,YAAAA,IAAAA;AACAG,YAAAA;AACF,SAAA,CAAA;AAEA,QAAA,OAAOC,eAAAA,CAAgBO,WAAAA,CAAAA;AACzB,IAAA,CAAA,CAAE,OAAOL,KAAAA,EAAO;;AAEd,QAAA,MAAMC,UAAUD,KAAAA,YAAiBE,KAAAA,GAAQF,KAAAA,CAAMC,OAAO,GAAGE,MAAAA,CAAOH,KAAAA,CAAAA;AAChER,QAAAA,MAAAA,CAAOY,GAAG,CAACJ,KAAK,CACd,CAAC,yBAAyB,EAAEP,cAAAA,CAAec,WAAW,GAAG,EAAE,EAAEb,IAAAA,CAAK,mBAAmB,EAAEO,OAAAA,CAAAA,CAAS,CAAA;QAElG,OAAOlB,4BAAAA;AACT,IAAA;AACF;;;;"}

package/dist/services/mcp/utils/jsonRpcErrors.d.ts

@@ -0,0 +1,22 @@
+/**
+ * JSON-RPC error codes and messages
+ * @see https://json-rpc.dev/docs/reference/error-codes
+ */
+export declare const JSON_RPC_ERRORS: {
+    readonly INTERNAL_ERROR: {
+        readonly code: -32603;
+        readonly message: "Internal error";
+        readonly httpStatus: 500;
+    };
+    readonly AUTHENTICATION_REQUIRED: {
+        readonly code: -32000;
+        readonly message: "Authentication required";
+        readonly httpStatus: 401;
+    };
+    readonly METHOD_NOT_ALLOWED: {
+        readonly code: -32601;
+        readonly message: "Method not allowed";
+        readonly httpStatus: 405;
+    };
+};
+//# sourceMappingURL=jsonRpcErrors.d.ts.map

package/dist/services/mcp/utils/jsonRpcErrors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsonRpcErrors.d.ts","sourceRoot":"","sources":["../../../../src/services/mcp/utils/jsonRpcErrors.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;CAgBlB,CAAC"}

package/dist/services/mcp/utils/jsonRpcErrors.js

@@ -0,0 +1,25 @@
+'use strict';
+
+/**
+ * JSON-RPC error codes and messages
+ * @see https://json-rpc.dev/docs/reference/error-codes
+ */ const JSON_RPC_ERRORS = {
+    INTERNAL_ERROR: {
+        code: -32603,
+        message: 'Internal error',
+        httpStatus: 500
+    },
+    AUTHENTICATION_REQUIRED: {
+        code: -32e3,
+        message: 'Authentication required',
+        httpStatus: 401
+    },
+    METHOD_NOT_ALLOWED: {
+        code: -32601,
+        message: 'Method not allowed',
+        httpStatus: 405
+    }
+};
+
+exports.JSON_RPC_ERRORS = JSON_RPC_ERRORS;
+//# sourceMappingURL=jsonRpcErrors.js.map

package/dist/services/mcp/utils/jsonRpcErrors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsonRpcErrors.js","sources":["../../../../src/services/mcp/utils/jsonRpcErrors.ts"],"sourcesContent":["/**\n * JSON-RPC error codes and messages\n * @see https://json-rpc.dev/docs/reference/error-codes\n */\nexport const JSON_RPC_ERRORS = {\n  INTERNAL_ERROR: {\n    code: -32603, // \tInternal error\n    message: 'Internal error',\n    httpStatus: 500,\n  },\n  AUTHENTICATION_REQUIRED: {\n    code: -32000, // Server error\n    message: 'Authentication required',\n    httpStatus: 401,\n  },\n  METHOD_NOT_ALLOWED: {\n    code: -32601, // Method not found\n    message: 'Method not allowed',\n    httpStatus: 405,\n  },\n} as const;\n"],"names":["JSON_RPC_ERRORS","INTERNAL_ERROR","code","message","httpStatus","AUTHENTICATION_REQUIRED","METHOD_NOT_ALLOWED"],"mappings":";;AAAA;;;UAIaA,eAAAA,GAAkB;IAC7BC,cAAAA,EAAgB;AACdC,QAAAA,IAAAA,EAAM,MAAC;QACPC,OAAAA,EAAS,gBAAA;QACTC,UAAAA,EAAY;AACd,KAAA;IACAC,uBAAAA,EAAyB;AACvBH,QAAAA,IAAAA,EAAM,KAAC;QACPC,OAAAA,EAAS,yBAAA;QACTC,UAAAA,EAAY;AACd,KAAA;IACAE,kBAAAA,EAAoB;AAClBJ,QAAAA,IAAAA,EAAM,MAAC;QACPC,OAAAA,EAAS,oBAAA;QACTC,UAAAA,EAAY;AACd;AACF;;;;"}

package/dist/services/mcp/utils/jsonRpcErrors.mjs

@@ -0,0 +1,23 @@
+/**
+ * JSON-RPC error codes and messages
+ * @see https://json-rpc.dev/docs/reference/error-codes
+ */ const JSON_RPC_ERRORS = {
+    INTERNAL_ERROR: {
+        code: -32603,
+        message: 'Internal error',
+        httpStatus: 500
+    },
+    AUTHENTICATION_REQUIRED: {
+        code: -32e3,
+        message: 'Authentication required',
+        httpStatus: 401
+    },
+    METHOD_NOT_ALLOWED: {
+        code: -32601,
+        message: 'Method not allowed',
+        httpStatus: 405
+    }
+};
+
+export { JSON_RPC_ERRORS };
+//# sourceMappingURL=jsonRpcErrors.mjs.map

package/dist/services/mcp/utils/jsonRpcErrors.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsonRpcErrors.mjs","sources":["../../../../src/services/mcp/utils/jsonRpcErrors.ts"],"sourcesContent":["/**\n * JSON-RPC error codes and messages\n * @see https://json-rpc.dev/docs/reference/error-codes\n */\nexport const JSON_RPC_ERRORS = {\n  INTERNAL_ERROR: {\n    code: -32603, // \tInternal error\n    message: 'Internal error',\n    httpStatus: 500,\n  },\n  AUTHENTICATION_REQUIRED: {\n    code: -32000, // Server error\n    message: 'Authentication required',\n    httpStatus: 401,\n  },\n  METHOD_NOT_ALLOWED: {\n    code: -32601, // Method not found\n    message: 'Method not allowed',\n    httpStatus: 405,\n  },\n} as const;\n"],"names":["JSON_RPC_ERRORS","INTERNAL_ERROR","code","message","httpStatus","AUTHENTICATION_REQUIRED","METHOD_NOT_ALLOWED"],"mappings":"AAAA;;;UAIaA,eAAAA,GAAkB;IAC7BC,cAAAA,EAAgB;AACdC,QAAAA,IAAAA,EAAM,MAAC;QACPC,OAAAA,EAAS,gBAAA;QACTC,UAAAA,EAAY;AACd,KAAA;IACAC,uBAAAA,EAAyB;AACvBH,QAAAA,IAAAA,EAAM,KAAC;QACPC,OAAAA,EAAS,yBAAA;QACTC,UAAAA,EAAY;AACd,KAAA;IACAE,kBAAAA,EAAoB;AAClBJ,QAAAA,IAAAA,EAAM,MAAC;QACPC,OAAAA,EAAS,oBAAA;QACTC,UAAAA,EAAY;AACd;AACF;;;;"}

package/dist/services/mcp/utils/safeHandlerWrapper.d.ts

@@ -0,0 +1,18 @@
+import type { Core } from '@strapi/types';
+/**
+ * Wraps an MCP capability handler to catch and log errors from user-provided callbacks.
+ *
+ * This prevents externally-registered capabilities (from plugin developers)
+ * from crashing Strapi core when they throw during execution.
+ *
+ * Errors are:
+ * - Logged with full detail (message + stack) via Strapi's logger
+ * - Returned to the MCP client as a safe error response (no stack trace leak)
+ */
+export declare const wrapSafeHandler: <TArgs extends unknown[], TResult>(handler: (...args: TArgs) => Promise<TResult>, options: {
+    strapi: Core.Strapi;
+    capabilityType: string;
+    name: string;
+    createErrorResult: (error: Error, args: TArgs) => TResult;
+}) => ((...args: TArgs) => Promise<TResult>);
+//# sourceMappingURL=safeHandlerWrapper.d.ts.map

package/dist/services/mcp/utils/safeHandlerWrapper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"safeHandlerWrapper.d.ts","sourceRoot":"","sources":["../../../../src/services/mcp/utils/safeHandlerWrapper.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAE1C;;;;;;;;;GASG;AACH,eAAO,MAAM,eAAe,8CACjB,CAAC,GAAG,IAAI,EAAE,KAAK,KAAK,QAAQ,OAAO,CAAC,WACpC;IACP,MAAM,EAAE,KAAK,MAAM,CAAC;IACpB,cAAc,EAAE,MAAM,CAAC;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,iBAAiB,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,KAAK,OAAO,CAAC;CAC3D,KACA,CAAC,CAAC,GAAG,IAAI,EAAE,KAAK,KAAK,QAAQ,OAAO,CAAC,CAoBvC,CAAC"}

package/dist/services/mcp/utils/safeHandlerWrapper.js

@@ -0,0 +1,29 @@
+'use strict';
+
+/**
+ * Wraps an MCP capability handler to catch and log errors from user-provided callbacks.
+ *
+ * This prevents externally-registered capabilities (from plugin developers)
+ * from crashing Strapi core when they throw during execution.
+ *
+ * Errors are:
+ * - Logged with full detail (message + stack) via Strapi's logger
+ * - Returned to the MCP client as a safe error response (no stack trace leak)
+ */ const wrapSafeHandler = (handler, options)=>{
+    const { strapi, capabilityType, name, createErrorResult } = options;
+    return async (...args)=>{
+        try {
+            return await handler(...args);
+        } catch (error) {
+            const normalized = error instanceof Error ? error : new Error(String(error));
+            strapi.log.error(`[MCP] ${capabilityType} "${name}" threw an error during execution: ${normalized.message}`, {
+                error: normalized.message,
+                stack: normalized.stack
+            });
+            return createErrorResult(normalized, args);
+        }
+    };
+};
+
+exports.wrapSafeHandler = wrapSafeHandler;
+//# sourceMappingURL=safeHandlerWrapper.js.map

package/dist/services/mcp/utils/safeHandlerWrapper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"safeHandlerWrapper.js","sources":["../../../../src/services/mcp/utils/safeHandlerWrapper.ts"],"sourcesContent":["import type { Core } from '@strapi/types';\n\n/**\n * Wraps an MCP capability handler to catch and log errors from user-provided callbacks.\n *\n * This prevents externally-registered capabilities (from plugin developers)\n * from crashing Strapi core when they throw during execution.\n *\n * Errors are:\n * - Logged with full detail (message + stack) via Strapi's logger\n * - Returned to the MCP client as a safe error response (no stack trace leak)\n */\nexport const wrapSafeHandler = <TArgs extends unknown[], TResult>(\n  handler: (...args: TArgs) => Promise<TResult>,\n  options: {\n    strapi: Core.Strapi;\n    capabilityType: string;\n    name: string;\n    createErrorResult: (error: Error, args: TArgs) => TResult;\n  }\n): ((...args: TArgs) => Promise<TResult>) => {\n  const { strapi, capabilityType, name, createErrorResult } = options;\n\n  return async (...args: TArgs): Promise<TResult> => {\n    try {\n      return await handler(...args);\n    } catch (error) {\n      const normalized = error instanceof Error ? error : new Error(String(error));\n\n      strapi.log.error(\n        `[MCP] ${capabilityType} \"${name}\" threw an error during execution: ${normalized.message}`,\n        {\n          error: normalized.message,\n          stack: normalized.stack,\n        }\n      );\n\n      return createErrorResult(normalized, args);\n    }\n  };\n};\n"],"names":["wrapSafeHandler","handler","options","strapi","capabilityType","name","createErrorResult","args","error","normalized","Error","String","log","message","stack"],"mappings":";;AAEA;;;;;;;;;AASC,IACM,MAAMA,eAAAA,GAAkB,CAC7BC,OAAAA,EACAC,OAAAA,GAAAA;IAOA,MAAM,EAAEC,MAAM,EAAEC,cAAc,EAAEC,IAAI,EAAEC,iBAAiB,EAAE,GAAGJ,OAAAA;AAE5D,IAAA,OAAO,OAAO,GAAGK,IAAAA,GAAAA;QACf,IAAI;AACF,YAAA,OAAO,MAAMN,OAAAA,CAAAA,GAAWM,IAAAA,CAAAA;AAC1B,QAAA,CAAA,CAAE,OAAOC,KAAAA,EAAO;AACd,YAAA,MAAMC,aAAaD,KAAAA,YAAiBE,KAAAA,GAAQF,KAAAA,GAAQ,IAAIE,MAAMC,MAAAA,CAAOH,KAAAA,CAAAA,CAAAA;AAErEL,YAAAA,MAAAA,CAAOS,GAAG,CAACJ,KAAK,CACd,CAAC,MAAM,EAAEJ,cAAAA,CAAe,EAAE,EAAEC,KAAK,mCAAmC,EAAEI,UAAAA,CAAWI,OAAO,EAAE,EAC1F;AACEL,gBAAAA,KAAAA,EAAOC,WAAWI,OAAO;AACzBC,gBAAAA,KAAAA,EAAOL,WAAWK;AACpB,aAAA,CAAA;AAGF,YAAA,OAAOR,kBAAkBG,UAAAA,EAAYF,IAAAA,CAAAA;AACvC,QAAA;AACF,IAAA,CAAA;AACF;;;;"}