strapi-plugin-mcp-chat 0.3.1 → 0.5.0

package/dist/server/index.js

@@ -412,6 +412,68 @@ var import_node_path = __toESM(require("node:path"));
 function isDev() {
   return process.env.NODE_ENV === "development";
 }
+var KNOWN_ATTR_TYPES = /* @__PURE__ */ new Set([
+  "string",
+  "text",
+  "richtext",
+  "blocks",
+  "email",
+  "password",
+  "uid",
+  "enumeration",
+  "json",
+  "integer",
+  "biginteger",
+  "decimal",
+  "float",
+  "date",
+  "time",
+  "datetime",
+  "timestamp",
+  "boolean",
+  "media",
+  "relation",
+  "component",
+  "dynamiczone"
+]);
+function validateApi(api) {
+  const errs = [];
+  const rel = Object.keys(api.files).find((r) => r.endsWith("schema.json"));
+  if (!rel) {
+    errs.push(`${api.singularName}: schema.json ausente nos arquivos gerados`);
+    return errs;
+  }
+  let schema;
+  try {
+    schema = JSON.parse(api.files[rel]);
+  } catch (e) {
+    errs.push(`${api.singularName}: schema.json n\xE3o \xE9 JSON v\xE1lido (${e?.message ?? e})`);
+    return errs;
+  }
+  if (schema?.kind !== "collectionType" && schema?.kind !== "singleType") {
+    errs.push(`${api.singularName}: "kind" inv\xE1lido (${schema?.kind})`);
+  }
+  if (!schema?.info?.singularName || !schema?.info?.pluralName) {
+    errs.push(`${api.singularName}: info.singularName/pluralName obrigat\xF3rios`);
+  }
+  const attrs = schema?.attributes;
+  if (!attrs || typeof attrs !== "object") {
+    errs.push(`${api.singularName}: "attributes" ausente ou inv\xE1lido`);
+  } else {
+    for (const [name, a] of Object.entries(attrs)) {
+      if (!a || typeof a !== "object" || !a.type) {
+        errs.push(`${api.singularName}.${name}: atributo sem "type"`);
+      } else if (!KNOWN_ATTR_TYPES.has(a.type)) {
+        errs.push(`${api.singularName}.${name}: type desconhecido "${a.type}"`);
+      } else if (a.type === "relation" && !a.target) {
+        errs.push(`${api.singularName}.${name}: relation sem "target"`);
+      } else if (a.type === "component" && !a.component) {
+        errs.push(`${api.singularName}.${name}: component sem "component"`);
+      }
+    }
+  }
+  return errs;
+}
 function writeApis(apis, opts) {
   const result = {
     ok: false,
@@ -431,6 +493,37 @@ function writeApis(apis, opts) {
     result.errors.push(`apiRoot deve ser um caminho absoluto: ${opts.apiRoot}`);
     return result;
   }
+  const toWrite = apis.filter((api) => !import_node_fs.default.existsSync(import_node_path.default.join(opts.apiRoot, api.singularName)));
+  const knownSingulars = /* @__PURE__ */ new Set([
+    ...apis.map((a) => a.singularName),
+    ...import_node_fs.default.existsSync(opts.apiRoot) ? import_node_fs.default.readdirSync(opts.apiRoot, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name) : []
+  ]);
+  const validationErrors = [];
+  for (const api of toWrite) {
+    validationErrors.push(...validateApi(api));
+    const rel = Object.keys(api.files).find((r) => r.endsWith("schema.json"));
+    if (rel) {
+      try {
+        const attrs = JSON.parse(api.files[rel])?.attributes || {};
+        for (const [name, a] of Object.entries(attrs)) {
+          if (a?.type === "relation" && typeof a.target === "string") {
+            const tgt = a.target.split("::")[1]?.split(".")[0];
+            if (tgt && !knownSingulars.has(tgt)) {
+              validationErrors.push(`${api.singularName}.${name}: relation aponta para "${a.target}" inexistente`);
+            }
+          }
+        }
+      } catch {
+      }
+    }
+  }
+  if (validationErrors.length) {
+    result.errors.push(
+      "Schema gerado inv\xE1lido \u2014 nada foi escrito (provis\xE3o abortada com seguran\xE7a):",
+      ...validationErrors
+    );
+    return result;
+  }
   for (const api of apis) {
     const apiDir = import_node_path.default.join(opts.apiRoot, api.singularName);
     if (import_node_fs.default.existsSync(apiDir)) {
@@ -2088,8 +2181,11 @@ async function integrateFrontend(strapi, opts) {
 // server/src/controllers/frontend.ts
 var MANIFEST_NAME = "strapi.manifest.json";
 function ensureInside2(base, target) {
-  const n = import_node_path7.default.normalize(target);
-  return n === base || n.startsWith(base + import_node_path7.default.sep);
+  const b = import_node_path7.default.resolve(base);
+  const t = import_node_path7.default.resolve(target);
+  if (t === b) return true;
+  const rel = import_node_path7.default.relative(b, t);
+  return !!rel && !rel.startsWith("..") && !import_node_path7.default.isAbsolute(rel);
 }
 function toKebab(input) {
   const s = (input || "frontend").toLowerCase().replace(/\.zip$/, "").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").replace(/^[^a-z]+/, "");
@@ -2311,6 +2407,15 @@ var baseHeaders = {
   "Content-Type": "application/json",
   Accept: "application/json, text/event-stream"
 };
+var fetchT = async (url, opts, timeoutMs = 8e3) => {
+  const ctrl = new AbortController();
+  const t = setTimeout(() => ctrl.abort(), timeoutMs);
+  try {
+    return await fetch(url, { ...opts, signal: ctrl.signal });
+  } finally {
+    clearTimeout(t);
+  }
+};
 var parseSse = (text) => {
   const dataLines = text.split("\n").filter((l) => l.startsWith("data:")).map((l) => l.slice(5).trim()).filter(Boolean);
   const last = dataLines[dataLines.length - 1];
@@ -2334,7 +2439,7 @@ var McpClient = class {
     return h;
   }
   async init() {
-    const res = await fetch(this.url, {
+    const res = await fetchT(this.url, {
       method: "POST",
       headers: this.headers(),
       body: JSON.stringify({
@@ -2350,14 +2455,14 @@ var McpClient = class {
     });
     this.sessionId = res.headers.get("mcp-session-id") || void 0;
     await res.text();
-    await fetch(this.url, {
+    await fetchT(this.url, {
       method: "POST",
       headers: this.headers(),
       body: JSON.stringify({ jsonrpc: "2.0", method: "notifications/initialized" })
     });
   }
   async rpc(method, params, id) {
-    const res = await fetch(this.url, {
+    const res = await fetchT(this.url, {
       method: "POST",
       headers: this.headers(),
       body: JSON.stringify({ jsonrpc: "2.0", id, method, params })
@@ -2473,16 +2578,18 @@ function createContentTools(strapi) {
   );
   const attrsOf = (uid) => strapi.contentTypes?.[uid]?.attributes || strapi.components?.[uid]?.attributes || {};
   const hasDraftAndPublish = (uid) => strapi.contentTypes?.[uid]?.options?.draftAndPublish === true;
-  const buildPopulate = (attributes, seen = /* @__PURE__ */ new Set()) => {
+  const MAX_DEPTH = 8;
+  const buildPopulate = (attributes, seen = /* @__PURE__ */ new Set(), depth = 0) => {
+    if (depth >= MAX_DEPTH) return {};
     const populate = {};
     for (const [name, a] of Object.entries(attributes)) {
       if (a.type === "component" && a.component) {
-        const sub = seen.has(a.component) ? {} : buildPopulate(attrsOf(a.component), new Set(seen).add(a.component));
+        const sub = seen.has(a.component) ? {} : buildPopulate(attrsOf(a.component), new Set(seen).add(a.component), depth + 1);
         populate[name] = Object.keys(sub).length ? { populate: sub } : true;
       } else if (a.type === "dynamiczone") {
         const on = {};
         for (const comp of a.components || []) {
-          const sub = seen.has(comp) ? {} : buildPopulate(attrsOf(comp), new Set(seen).add(comp));
+          const sub = seen.has(comp) ? {} : buildPopulate(attrsOf(comp), new Set(seen).add(comp), depth + 1);
           on[comp] = Object.keys(sub).length ? { populate: sub } : true;
         }
         populate[name] = { on };
@@ -2494,6 +2601,7 @@ function createContentTools(strapi) {
   };
   const walkFind = (node, attributes, basePath, needle, collect) => {
     if (!node || typeof node !== "object") return;
+    if (basePath.length > 24) return;
     for (const [name, a] of Object.entries(attributes)) {
       const v = node[name];
       if (v == null) continue;
@@ -2518,11 +2626,13 @@ function createContentTools(strapi) {
       }
     }
   };
+  const MAX_MATCHES = 100;
   const buscarTexto = async (termo) => {
     const needle = String(termo || "").toLowerCase().trim();
     if (!needle) return { erro: "termo vazio" };
     const matches = [];
     for (const ct of apiContentTypes()) {
+      if (matches.length >= MAX_MATCHES) break;
       const attributes = ct.attributes || {};
       const populate = buildPopulate(attributes);
       let entries = [];
@@ -2549,7 +2659,12 @@ function createContentTools(strapi) {
         });
       }
     }
-    return { total: matches.length, resultados: matches };
+    const truncated = matches.length > MAX_MATCHES;
+    return {
+      total: matches.length,
+      resultados: matches.slice(0, MAX_MATCHES),
+      ...truncated ? { truncado: true, nota: `mostrando ${MAX_MATCHES} de ${matches.length} resultados; refine o termo` } : {}
+    };
   };
   const sanitizeNode = (node, attributes) => {
     if (node == null) return node;
@@ -3061,7 +3176,10 @@ var chat_default2 = ({ strapi }) => ({
     if (process.env.PLAYWRIGHT_MCP_URL) {
       try {
         const client = new McpClient(process.env.PLAYWRIGHT_MCP_URL, "playwright");
-        await client.init();
+        await Promise.race([
+          client.init(),
+          new Promise((_, rej) => setTimeout(() => rej(new Error("timeout")), 4e3))
+        ]);
         const list = await client.listTools();
         for (const t of list) {
           if (mcpByTool[t.name]) continue;
@@ -3133,11 +3251,22 @@ PUBLISH POLICY: DRAFT MODE (auto-publish OFF). Do NOT call publicar unless the u
       }
     });
     const callOpenAI = async (body) => {
-      const res = await fetch(OPENAI_URL4, {
-        method: "POST",
-        headers: { Authorization: `Bearer ${apiKey}`, "Content-Type": "application/json" },
-        body: JSON.stringify(body)
-      });
+      const ctrl = new AbortController();
+      const timer = setTimeout(() => ctrl.abort(), 6e4);
+      let res;
+      try {
+        res = await fetch(OPENAI_URL4, {
+          method: "POST",
+          headers: { Authorization: `Bearer ${apiKey}`, "Content-Type": "application/json" },
+          body: JSON.stringify(body),
+          signal: ctrl.signal
+        });
+      } catch (e) {
+        if (e?.name === "AbortError") throw new Error("OpenAI chat: tempo limite excedido (60s).");
+        throw e;
+      } finally {
+        clearTimeout(timer);
+      }
       if (!res.ok) throw new Error(`OpenAI chat: ${await res.text()}`);
       return res.json();
     };
@@ -3176,6 +3305,11 @@ PUBLISH POLICY: DRAFT MODE (auto-publish OFF). Do NOT call publicar unless the u
           } catch (e) {
             content = `Erro ao chamar a tool ${name}: ${e?.message || e}`;
           }
+          const MAX_TOOL_CHARS = 12e3;
+          if (content.length > MAX_TOOL_CHARS) {
+            content = content.slice(0, MAX_TOOL_CHARS) + `
+\u2026[resultado truncado: ${content.length} chars]`;
+          }
           convo.push({ role: "tool", tool_call_id: call.id, content });
         }
         continue;
@@ -3299,196 +3433,166 @@ var routes_default = {
 
 // server/src/mcp/tools/buscar-texto.ts
 var import_utils2 = require("@strapi/utils");
-var tool = {
-  register(registerTool) {
-    registerTool({
-      name: "mcp_chat_buscar_texto",
-      title: "Search text across content (deep)",
-      description: 'Search a phrase across ALL content-types, single types, components and dynamic zones (recursive, substring). Returns matches with a `path` (e.g. ["dynamic_zone",2,"heading"]) to pass to mcp_chat_editar_campo.',
-      resolveInputSchema: () => import_utils2.z.object({ termo: import_utils2.z.string() }),
-      resolveOutputSchema: () => import_utils2.z.object({
-        total: import_utils2.z.number().optional(),
-        resultados: import_utils2.z.array(import_utils2.z.any()).optional(),
-        erro: import_utils2.z.string().optional()
-      }),
-      auth: { policies: [{ action: "plugin::content-manager.explorer.read" }] },
-      createHandler: (strapi) => async ({ args }) => {
-        const r = await createContentTools(strapi).buscarTexto(args?.termo);
-        return { content: [{ type: "text", text: JSON.stringify(r) }], structuredContent: r };
-      }
-    });
+
+// server/src/mcp/define.ts
+var defineTool = (def) => def;
+
+// server/src/mcp/tools/buscar-texto.ts
+var buscar_texto_default = defineTool({
+  name: "mcp_chat_buscar_texto",
+  title: "Search text across content (deep)",
+  description: 'Search a phrase across ALL content-types, single types, components and dynamic zones (recursive, substring). Returns matches with a `path` (e.g. ["dynamic_zone",2,"heading"]) to pass to mcp_chat_editar_campo.',
+  resolveInputSchema: () => import_utils2.z.object({ termo: import_utils2.z.string() }),
+  resolveOutputSchema: () => import_utils2.z.object({
+    total: import_utils2.z.number().optional(),
+    resultados: import_utils2.z.array(import_utils2.z.any()).optional(),
+    erro: import_utils2.z.string().optional()
+  }),
+  auth: { policies: [{ action: "plugin::content-manager.explorer.read" }] },
+  createHandler: (strapi) => async ({ args }) => {
+    const r = await createContentTools(strapi).buscarTexto(args.termo);
+    return { content: [{ type: "text", text: JSON.stringify(r) }], structuredContent: r };
   }
-};
-var buscar_texto_default = tool;
+});
 
 // server/src/mcp/tools/editar-campo.ts
 var import_utils3 = require("@strapi/utils");
-var tool2 = {
-  register(registerTool) {
-    registerTool({
-      name: "mcp_chat_editar_campo",
-      title: "Edit a (possibly nested) field",
-      description: "Edit a field value (saved as draft), including text nested in components/dynamic zones. Pass the `path` exactly as returned by mcp_chat_buscar_texto; for a simple top-level field you may use `campo`.",
-      resolveInputSchema: () => import_utils3.z.object({
-        uid: import_utils3.z.string(),
-        documentId: import_utils3.z.string(),
-        path: import_utils3.z.array(import_utils3.z.union([import_utils3.z.string(), import_utils3.z.number()])).optional(),
-        campo: import_utils3.z.string().optional(),
-        novo_valor: import_utils3.z.string(),
-        locale: import_utils3.z.string().optional()
-      }),
-      resolveOutputSchema: () => import_utils3.z.object({
-        ok: import_utils3.z.boolean().optional(),
-        uid: import_utils3.z.string().optional(),
-        documentId: import_utils3.z.string().optional(),
-        path: import_utils3.z.array(import_utils3.z.any()).optional(),
-        novo_valor: import_utils3.z.string().optional(),
-        erro: import_utils3.z.string().optional()
-      }),
-      auth: { policies: [{ action: "plugin::content-manager.explorer.update" }] },
-      createHandler: (strapi) => async ({ args }) => {
-        const r = await createContentTools(strapi).editarCampo(args);
-        return { content: [{ type: "text", text: JSON.stringify(r) }], structuredContent: r };
-      }
-    });
+var editar_campo_default = defineTool({
+  name: "mcp_chat_editar_campo",
+  title: "Edit a (possibly nested) field",
+  description: "Edit a field value (saved as draft), including text nested in components/dynamic zones. Pass the `path` exactly as returned by mcp_chat_buscar_texto; for a simple top-level field you may use `campo`.",
+  resolveInputSchema: () => import_utils3.z.object({
+    uid: import_utils3.z.string(),
+    documentId: import_utils3.z.string(),
+    path: import_utils3.z.array(import_utils3.z.union([import_utils3.z.string(), import_utils3.z.number()])).optional(),
+    campo: import_utils3.z.string().optional(),
+    novo_valor: import_utils3.z.string(),
+    locale: import_utils3.z.string().optional()
+  }),
+  resolveOutputSchema: () => import_utils3.z.object({
+    ok: import_utils3.z.boolean().optional(),
+    uid: import_utils3.z.string().optional(),
+    documentId: import_utils3.z.string().optional(),
+    path: import_utils3.z.array(import_utils3.z.any()).optional(),
+    novo_valor: import_utils3.z.string().optional(),
+    erro: import_utils3.z.string().optional()
+  }),
+  auth: { policies: [{ action: "plugin::content-manager.explorer.update" }] },
+  createHandler: (strapi) => async ({ args }) => {
+    const r = await createContentTools(strapi).editarCampo(args);
+    return { content: [{ type: "text", text: JSON.stringify(r) }], structuredContent: r };
   }
-};
-var editar_campo_default = tool2;
+});
 
 // server/src/mcp/tools/publicar.ts
 var import_utils4 = require("@strapi/utils");
-var tool3 = {
-  register(registerTool) {
-    registerTool({
-      name: "mcp_chat_publicar",
-      title: "Publish an entry",
-      description: 'Publish an entry by uid + documentId, making the change visible on the site. Pass `locale` to publish a specific language, or "*" for all.',
-      resolveInputSchema: () => import_utils4.z.object({ uid: import_utils4.z.string(), documentId: import_utils4.z.string(), locale: import_utils4.z.string().optional() }),
-      resolveOutputSchema: () => import_utils4.z.object({
-        ok: import_utils4.z.boolean().optional(),
-        uid: import_utils4.z.string().optional(),
-        documentId: import_utils4.z.string().optional(),
-        status: import_utils4.z.string().optional(),
-        locale: import_utils4.z.string().optional()
-      }),
-      auth: { policies: [{ action: "plugin::content-manager.explorer.publish" }] },
-      createHandler: (strapi) => async ({ args }) => {
-        const r = await createContentTools(strapi).publicar(args);
-        return { content: [{ type: "text", text: JSON.stringify(r) }], structuredContent: r };
-      }
-    });
+var publicar_default = defineTool({
+  name: "mcp_chat_publicar",
+  title: "Publish an entry",
+  description: 'Publish an entry by uid + documentId, making the change visible on the site. Pass `locale` to publish a specific language, or "*" for all. For content-types without Draft & Publish there is nothing to publish (returns status "no-draft-publish") \u2014 the edit is already live.',
+  resolveInputSchema: () => import_utils4.z.object({ uid: import_utils4.z.string(), documentId: import_utils4.z.string(), locale: import_utils4.z.string().optional() }),
+  resolveOutputSchema: () => import_utils4.z.object({
+    ok: import_utils4.z.boolean().optional(),
+    uid: import_utils4.z.string().optional(),
+    documentId: import_utils4.z.string().optional(),
+    status: import_utils4.z.string().optional(),
+    locale: import_utils4.z.string().optional()
+  }),
+  auth: { policies: [{ action: "plugin::content-manager.explorer.publish" }] },
+  createHandler: (strapi) => async ({ args }) => {
+    const r = await createContentTools(strapi).publicar(args);
+    return { content: [{ type: "text", text: JSON.stringify(r) }], structuredContent: r };
   }
-};
-var publicar_default = tool3;
+});
 
 // server/src/mcp/tools/listar-locales.ts
 var import_utils5 = require("@strapi/utils");
-var tool4 = {
-  register(registerTool) {
-    registerTool({
-      name: "mcp_chat_listar_locales",
-      title: "List i18n locales",
-      description: "List the configured locales (languages) and which one is the default.",
-      resolveInputSchema: () => import_utils5.z.object({}),
-      resolveOutputSchema: () => import_utils5.z.object({
-        default: import_utils5.z.string().optional(),
-        locales: import_utils5.z.array(import_utils5.z.any()).optional(),
-        erro: import_utils5.z.string().optional()
-      }),
-      auth: { policies: [{ action: "plugin::content-manager.explorer.read" }] },
-      createHandler: (strapi) => async () => {
-        const r = await createContentTools(strapi).listarLocales();
-        return { content: [{ type: "text", text: JSON.stringify(r) }], structuredContent: r };
-      }
-    });
+var listar_locales_default = defineTool({
+  name: "mcp_chat_listar_locales",
+  title: "List i18n locales",
+  description: "List the configured locales (languages) and which one is the default.",
+  resolveInputSchema: () => import_utils5.z.object({}),
+  resolveOutputSchema: () => import_utils5.z.object({
+    default: import_utils5.z.string().optional(),
+    locales: import_utils5.z.array(import_utils5.z.any()).optional(),
+    erro: import_utils5.z.string().optional()
+  }),
+  auth: { policies: [{ action: "plugin::content-manager.explorer.read" }] },
+  createHandler: (strapi) => async () => {
+    const r = await createContentTools(strapi).listarLocales();
+    return { content: [{ type: "text", text: JSON.stringify(r) }], structuredContent: r };
   }
-};
-var listar_locales_default = tool4;
+});
 
 // server/src/mcp/tools/criar-locale.ts
 var import_utils6 = require("@strapi/utils");
-var tool5 = {
-  register(registerTool) {
-    registerTool({
-      name: "mcp_chat_criar_locale",
-      title: "Create an i18n locale",
-      description: 'Create a locale (language). `code` must be a valid ISO code (e.g. "pt-BR", "es"). Idempotent: returns ok if it already exists.',
-      resolveInputSchema: () => import_utils6.z.object({ code: import_utils6.z.string(), name: import_utils6.z.string().optional() }),
-      resolveOutputSchema: () => import_utils6.z.object({
-        ok: import_utils6.z.boolean().optional(),
-        code: import_utils6.z.string().optional(),
-        name: import_utils6.z.string().optional(),
-        existed: import_utils6.z.boolean().optional(),
-        erro: import_utils6.z.string().optional()
-      }),
-      auth: { policies: [{ action: "plugin::i18n.locale.create" }] },
-      createHandler: (strapi) => async ({ args }) => {
-        const r = await createContentTools(strapi).criarLocale(args);
-        return { content: [{ type: "text", text: JSON.stringify(r) }], structuredContent: r };
-      }
-    });
+var criar_locale_default = defineTool({
+  name: "mcp_chat_criar_locale",
+  title: "Create an i18n locale",
+  description: 'Create a locale (language). `code` must be a valid ISO code (e.g. "pt-BR", "es"). Idempotent: returns ok if it already exists.',
+  resolveInputSchema: () => import_utils6.z.object({ code: import_utils6.z.string(), name: import_utils6.z.string().optional() }),
+  resolveOutputSchema: () => import_utils6.z.object({
+    ok: import_utils6.z.boolean().optional(),
+    code: import_utils6.z.string().optional(),
+    name: import_utils6.z.string().optional(),
+    existed: import_utils6.z.boolean().optional(),
+    erro: import_utils6.z.string().optional()
+  }),
+  auth: { policies: [{ action: "plugin::i18n.locale.create" }] },
+  createHandler: (strapi) => async ({ args }) => {
+    const r = await createContentTools(strapi).criarLocale(args);
+    return { content: [{ type: "text", text: JSON.stringify(r) }], structuredContent: r };
   }
-};
-var criar_locale_default = tool5;
+});
 
 // server/src/mcp/tools/traduzir.ts
 var import_utils7 = require("@strapi/utils");
-var tool6 = {
-  register(registerTool) {
-    registerTool({
-      name: "mcp_chat_traduzir",
-      title: "Translate localized content",
-      description: "Translate localized content into one or more languages. Creates missing locales, translates field by field (long text is split and reassembled, never overflows) and publishes. Without uid/documentId, translates ALL localized content-types. Handles many locales at once.",
-      resolveInputSchema: () => import_utils7.z.object({
-        target_locales: import_utils7.z.array(import_utils7.z.string()).min(1),
-        source_locale: import_utils7.z.string().optional(),
-        uid: import_utils7.z.string().optional(),
-        documentId: import_utils7.z.string().optional(),
-        publish: import_utils7.z.boolean().optional()
-      }),
-      resolveOutputSchema: () => import_utils7.z.object({
-        ok: import_utils7.z.boolean().optional(),
-        source: import_utils7.z.string().optional(),
-        por_locale: import_utils7.z.array(import_utils7.z.any()).optional(),
-        erro: import_utils7.z.string().optional()
-      }),
-      auth: { policies: [{ action: "plugin::content-manager.explorer.update" }] },
-      createHandler: (strapi) => async ({ args }) => {
-        const r = await createContentTools(strapi).traduzir(args);
-        return { content: [{ type: "text", text: JSON.stringify(r) }], structuredContent: r };
-      }
-    });
+var traduzir_default = defineTool({
+  name: "mcp_chat_traduzir",
+  title: "Translate localized content",
+  description: "Translate localized content into one or more languages. Creates missing locales, translates field by field (long text is split and reassembled, never overflows) and publishes (only on content-types with Draft & Publish). Without uid/documentId, translates ALL localized content-types. Handles many locales at once.",
+  resolveInputSchema: () => import_utils7.z.object({
+    target_locales: import_utils7.z.array(import_utils7.z.string()).min(1),
+    source_locale: import_utils7.z.string().optional(),
+    uid: import_utils7.z.string().optional(),
+    documentId: import_utils7.z.string().optional(),
+    publish: import_utils7.z.boolean().optional()
+  }),
+  resolveOutputSchema: () => import_utils7.z.object({
+    ok: import_utils7.z.boolean().optional(),
+    source: import_utils7.z.string().optional(),
+    por_locale: import_utils7.z.array(import_utils7.z.any()).optional(),
+    erro: import_utils7.z.string().optional()
+  }),
+  auth: { policies: [{ action: "plugin::content-manager.explorer.update" }] },
+  createHandler: (strapi) => async ({ args }) => {
+    const r = await createContentTools(strapi).traduzir(args);
+    return { content: [{ type: "text", text: JSON.stringify(r) }], structuredContent: r };
   }
-};
-var traduzir_default = tool6;
+});
 
 // server/src/mcp/tools/habilitar-i18n.ts
 var import_utils8 = require("@strapi/utils");
-var tool7 = {
-  register(registerTool) {
-    registerTool({
-      name: "mcp_chat_habilitar_i18n",
-      title: "Enable i18n on a content-type",
-      description: 'Enable translation on content-types not localized yet: marks the content-type and its textual fields/components as localized. Required before translating content provisioned without i18n. Omit `uid` (or pass "*") to enable ALL content-types at once. Edits the schema (dev-only); Strapi restarts.',
-      resolveInputSchema: () => import_utils8.z.object({ uid: import_utils8.z.string().optional(), campos: import_utils8.z.array(import_utils8.z.string()).optional() }),
-      resolveOutputSchema: () => import_utils8.z.object({
-        ok: import_utils8.z.boolean().optional(),
-        uid: import_utils8.z.string().optional(),
-        campos: import_utils8.z.array(import_utils8.z.string()).optional(),
-        contentTypes: import_utils8.z.array(import_utils8.z.any()).optional(),
-        total: import_utils8.z.number().optional(),
-        restart: import_utils8.z.boolean().optional(),
-        erro: import_utils8.z.string().optional()
-      }),
-      auth: { policies: [{ action: "plugin::content-type-builder.read" }] },
-      createHandler: (strapi) => async ({ args }) => {
-        const r = enableI18n({ strapi, uid: args?.uid, campos: args?.campos });
-        return { content: [{ type: "text", text: JSON.stringify(r) }], structuredContent: r };
-      }
-    });
+var habilitar_i18n_default = defineTool({
+  name: "mcp_chat_habilitar_i18n",
+  title: "Enable i18n on a content-type",
+  description: 'Enable translation on content-types not localized yet: marks the content-type and its textual fields/components as localized. Required before translating content provisioned without i18n. Omit `uid` (or pass "*") to enable ALL content-types at once. Edits the schema (dev-only); Strapi restarts.',
+  resolveInputSchema: () => import_utils8.z.object({ uid: import_utils8.z.string().optional(), campos: import_utils8.z.array(import_utils8.z.string()).optional() }),
+  resolveOutputSchema: () => import_utils8.z.object({
+    ok: import_utils8.z.boolean().optional(),
+    uid: import_utils8.z.string().optional(),
+    campos: import_utils8.z.array(import_utils8.z.string()).optional(),
+    contentTypes: import_utils8.z.array(import_utils8.z.any()).optional(),
+    total: import_utils8.z.number().optional(),
+    restart: import_utils8.z.boolean().optional(),
+    erro: import_utils8.z.string().optional()
+  }),
+  auth: { policies: [{ action: "plugin::content-type-builder.read" }] },
+  createHandler: (strapi) => async ({ args }) => {
+    const r = enableI18n({ strapi, uid: args.uid, campos: args.campos });
+    return { content: [{ type: "text", text: JSON.stringify(r) }], structuredContent: r };
   }
-};
-var habilitar_i18n_default = tool7;
+});
 
 // server/src/mcp/tools/index.ts
 var tools = [
@@ -3511,9 +3615,16 @@ var registerMcpTools = (strapi) => {
     );
     return;
   }
-  const { registerTool } = mcp;
-  for (const tool8 of tools) tool8.register(registerTool, strapi);
-  strapi.log.info(`[mcp-chat] ${tools.length} tools registradas no MCP nativo (mcp_chat_*).`);
+  let registered = 0;
+  for (const tool of tools) {
+    try {
+      mcp.registerTool(tool);
+      registered += 1;
+    } catch (e) {
+      strapi.log.warn(`[mcp-chat] tool "${tool?.name}" falhou ao registrar: ${e?.message ?? e}`);
+    }
+  }
+  strapi.log.info(`[mcp-chat] ${registered}/${tools.length} tools registradas no MCP nativo (mcp_chat_*).`);
 };
 
 // server/src/register.ts
@@ -3542,7 +3653,10 @@ var index_default = {
     }
   },
   destroy() {
-    stopFrontend();
+    try {
+      stopFrontend();
+    } catch {
+    }
   },
   config: {
     default: {},

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "strapi-plugin-mcp-chat",
-  "version": "0.3.1",
+  "version": "0.5.0",
   "description": "AI chat inside the Strapi 5 admin that reads and edits your content (incl. components & dynamic zones) via MCP, with voice and a side-by-side live preview.",
   "keywords": [
     "strapi",