strapi-plugin-mcp-chat 0.1.0

package/server/src/controllers/frontend.ts

@@ -0,0 +1,310 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import JSZip from 'jszip';
+import { stageProvision, getProvisionStatus } from '../provision/orchestrate';
+import { inferManifest } from '../provision/infer';
+import { startFrontend, getRunStatus } from '../provision/runner';
+import { integrateFrontend } from '../provision/integrate';
+import { validateManifest } from '../provision/manifest';
+import type { LinkContext } from '../provision/adapters';
+
+/**
+ * Controller de provisão de frontend. Fluxo em DUAS etapas para o cenário
+ * Figma/Lovable (frontend sem manifest):
+ *
+ *  1) analyze: recebe o .zip → extrai para a pasta irmã → se houver
+ *     strapi.manifest.json usa ele, SENÃO infere via IA a partir do código.
+ *     Devolve o manifest proposto para o usuário REVISAR. Não cria nada ainda.
+ *  2) provision: recebe o manifest confirmado (possivelmente editado) → grava no
+ *     projeto → cria content-types + agenda seed/link → reinicia a Strapi.
+ *
+ * Segurança: dev-only (escrita de schema é dev-only), proteção contra zip-slip,
+ * destino aditivo (não sobrescreve pasta existente) e o frontendDir da etapa 2 é
+ * validado para ficar dentro da pasta-pai da app Strapi. Nunca executa o código.
+ */
+
+const MANIFEST_NAME = 'strapi.manifest.json';
+
+function ensureInside(base: string, target: string): boolean {
+  const n = path.normalize(target);
+  return n === base || n.startsWith(base + path.sep);
+}
+
+/** normaliza um nome livre para o formato kebab exigido pelo manifest. */
+function toKebab(input: string): string {
+  const s = (input || 'frontend')
+    .toLowerCase()
+    .replace(/\.zip$/, '')
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .replace(/^[^a-z]+/, '');
+  return s || 'frontend';
+}
+
+function devOnly(ctx: any): boolean {
+  if (process.env.NODE_ENV !== 'development') {
+    ctx.badRequest(
+      'A provisão de frontend só funciona em desenvolvimento (geração de content-types é dev-only).'
+    );
+    return false;
+  }
+  return true;
+}
+
+export default {
+  /** Etapa 1: extrai e descobre/infere o manifest (sem criar nada). */
+  async analyze(ctx: any) {
+    const strapi = ctx.strapi ?? (global as any).strapi;
+    if (!devOnly(ctx)) return;
+
+    // 1) arquivo enviado
+    const files = ctx.request.files || {};
+    const file = files.frontend || files.file || Object.values(files)[0];
+    if (!file) return ctx.badRequest('Envie o .zip do frontend no campo "frontend".');
+    const filepath = (file as any).filepath || (file as any).path;
+    if (!filepath) return ctx.badRequest('Arquivo inválido.');
+    const originalName = (file as any).originalFilename || (file as any).name || 'frontend';
+
+    // 2) abre o zip
+    let zip: JSZip;
+    try {
+      zip = await JSZip.loadAsync(fs.readFileSync(filepath));
+    } catch (e: any) {
+      return ctx.badRequest(`Zip inválido: ${e?.message ?? e}`);
+    }
+
+    // detecta um prefixo de pasta raiz comum (ex.: "meu-app/") para achatar
+    const entryNames = Object.keys(zip.files);
+    const manifestEntry = entryNames.find(
+      (p) => path.basename(p) === MANIFEST_NAME && !zip.files[p].dir
+    );
+    let rootPrefix = '';
+    if (manifestEntry) {
+      rootPrefix = manifestEntry.slice(0, manifestEntry.length - MANIFEST_NAME.length);
+    } else {
+      // se TODO mundo compartilha a mesma primeira pasta, usa-a como prefixo
+      const tops = new Set(
+        entryNames.filter((n) => n.includes('/')).map((n) => n.slice(0, n.indexOf('/') + 1))
+      );
+      if (tops.size === 1) rootPrefix = [...tops][0];
+    }
+
+    // nome do destino: nome do arquivo enviado (kebab)
+    const name = toKebab(originalName);
+    const strapiAppDir: string = strapi.dirs.app.root;
+    const frontendDir = path.resolve(strapiAppDir, '..', name);
+
+    // 3) destino aditivo
+    if (fs.existsSync(frontendDir) && fs.readdirSync(frontendDir).length > 0) {
+      return ctx.badRequest(
+        `A pasta de destino já existe e não está vazia: ${frontendDir}. Renomeie o .zip ou remova a pasta.`
+      );
+    }
+
+    // 4) extrai (com proteção contra zip-slip)
+    try {
+      fs.mkdirSync(frontendDir, { recursive: true });
+      for (const entryName of entryNames) {
+        const entry = zip.files[entryName];
+        const rel =
+          rootPrefix && entryName.startsWith(rootPrefix)
+            ? entryName.slice(rootPrefix.length)
+            : entryName;
+        if (!rel) continue;
+        const dest = path.join(frontendDir, rel);
+        if (!ensureInside(frontendDir, dest)) {
+          throw new Error(`entrada perigosa no zip bloqueada: ${entryName}`);
+        }
+        if (entry.dir) {
+          fs.mkdirSync(dest, { recursive: true });
+        } else {
+          fs.mkdirSync(path.dirname(dest), { recursive: true });
+          fs.writeFileSync(dest, await entry.async('nodebuffer'));
+        }
+      }
+    } catch (e: any) {
+      return ctx.internalServerError(`Falha ao extrair: ${e?.message ?? e}`);
+    }
+
+    // 5) acha ou INFERE o manifest a partir do código
+    const inf = await inferManifest(strapi, frontendDir, { name });
+
+    ctx.body = {
+      ok: inf.ok,
+      frontendDir,
+      inferred: inf.inferred,
+      framework: inf.framework,
+      filesAnalyzed: inf.filesAnalyzed,
+      // manifest cru (mesmo se inválido, para o usuário revisar/editar)
+      manifest: inf.rawManifest ?? inf.manifest ?? null,
+      warnings: inf.warnings,
+      errors: inf.errors,
+      message: inf.ok
+        ? inf.inferred
+          ? 'Manifest inferido a partir do código. Revise e confirme para provisionar.'
+          : 'Manifest encontrado no projeto. Revise e confirme para provisionar.'
+        : 'Não foi possível obter um manifest válido. Edite-o abaixo e tente provisionar.',
+    };
+  },
+
+  /** Etapa 2: provisiona a partir do manifest confirmado. */
+  async provision(ctx: any) {
+    const strapi = ctx.strapi ?? (global as any).strapi;
+    if (!devOnly(ctx)) return;
+
+    const body = ctx.request.body || {};
+    const rawManifest = body.manifest;
+    const frontendDir: string = body.frontendDir;
+    if (!rawManifest) return ctx.badRequest('Envie o "manifest".');
+    if (!frontendDir || !path.isAbsolute(frontendDir)) {
+      return ctx.badRequest('frontendDir ausente ou inválido.');
+    }
+
+    const strapiAppDir: string = strapi.dirs.app.root;
+    const apiRoot: string = strapi.dirs.app.api;
+    const parent = path.resolve(strapiAppDir, '..');
+
+    // segurança: frontendDir tem que ser uma pasta irmã já existente
+    if (!ensureInside(parent, frontendDir) || frontendDir === parent) {
+      return ctx.badRequest('frontendDir fora da pasta permitida.');
+    }
+    if (!fs.existsSync(frontendDir)) {
+      return ctx.badRequest('frontendDir não existe (rode a análise primeiro).');
+    }
+
+    // valida o manifest confirmado
+    const v = validateManifest(rawManifest);
+    if (!v.ok) {
+      return ctx.badRequest({ message: 'Manifest inválido', errors: v.errors });
+    }
+
+    // persiste o manifest no projeto (fica versionável e reaproveitável)
+    try {
+      fs.writeFileSync(
+        path.join(frontendDir, MANIFEST_NAME),
+        JSON.stringify(v.data, null, 2),
+        'utf8'
+      );
+    } catch (e: any) {
+      return ctx.internalServerError(`Não foi possível gravar o manifest: ${e?.message ?? e}`);
+    }
+
+    const port = strapi.config.get('server.port', 1337);
+    let locales: string[] = [];
+    try {
+      locales = ((await strapi.plugin('i18n').service('locales').find()) || []).map((l: any) => l.code);
+    } catch {
+      /* i18n off — segue sem locales */
+    }
+    const context: LinkContext = { strapiUrl: `http://localhost:${port}`, locales };
+
+    const staged = stageProvision(strapi, {
+      rawManifest: v.data,
+      apiRoot,
+      frontendDir,
+      strapiAppDir,
+      context,
+    });
+
+    if (!staged.ok) {
+      return ctx.badRequest({
+        message: 'Provisão falhou',
+        validation: staged.validation,
+        errors: staged.errors,
+      });
+    }
+
+    ctx.body = {
+      ok: true,
+      frontendDir,
+      contentTypes: staged.write?.written.filter((f) => f.endsWith('schema.json')).length ?? 0,
+      skipped: staged.write?.skipped ?? [],
+      willReload: staged.willReload,
+      message: staged.willReload
+        ? 'Provisão agendada. A Strapi vai reiniciar e então criar o conteúdo e ligar o preview.'
+        : 'Nenhuma content-type nova (já existiam).',
+    };
+
+    // NÃO chamamos strapi.reload() aqui: a provisão é dev-only e, em `develop`, o
+    // próprio file watcher da Strapi reinicia ao detectar os novos schema.json.
+    // Disparar um reload manual junto causava um DOUBLE restart e matava o worker
+    // (EPIPE) na 5.48. O watcher cuida do restart; o pós-restart roda no bootstrap.
+  },
+
+  /** Status da provisão — a UI faz polling após confirmar. */
+  status(ctx: any) {
+    const strapi = ctx.strapi ?? (global as any).strapi;
+    ctx.body = getProvisionStatus(strapi.dirs.app.root);
+  },
+
+  /**
+   * Roda o dev server do frontend provisionado. A UI chama isto ao ligar o
+   * preview pela 1ª vez após o upload. Sem body, usa o último provisionado.
+   */
+  async run(ctx: any) {
+    const strapi = ctx.strapi ?? (global as any).strapi;
+    if (!devOnly(ctx)) return;
+
+    const body = ctx.request.body || {};
+    let dir: string = body.dir;
+    let url: string = body.url;
+    if (!dir || !url) {
+      const st = getProvisionStatus(strapi.dirs.app.root);
+      if (st.done) {
+        dir = dir || st.done.frontendDir;
+        url = url || st.done.previewUrl;
+      }
+    }
+    if (!dir || !url) {
+      return ctx.badRequest('Nenhum frontend provisionado para rodar.');
+    }
+
+    // segurança: só dentro da pasta-pai da app
+    const parent = path.resolve(strapi.dirs.app.root, '..');
+    if (!ensureInside(parent, dir) || !fs.existsSync(dir)) {
+      return ctx.badRequest('Pasta do frontend inválida.');
+    }
+
+    ctx.body = await startFrontend(strapi, { dir, url });
+  },
+
+  /** Status do dev server do frontend (polling da UI). */
+  runStatus(ctx: any) {
+    ctx.body = getRunStatus();
+  },
+
+  /**
+   * Religa o frontend ao Strapi por SNAPSHOT: regenera o(s) arquivo(s) de dados
+   * com o conteúdo do Strapi, mantendo nomes de export e imagens originais.
+   * Usa o último provisionado por padrão.
+   */
+  async integrate(ctx: any) {
+    const strapi = ctx.strapi ?? (global as any).strapi;
+    if (!devOnly(ctx)) return;
+
+    const body = ctx.request.body || {};
+    let frontendDir: string = body.frontendDir;
+    if (!frontendDir) {
+      const st = getProvisionStatus(strapi.dirs.app.root);
+      frontendDir = st.done?.frontendDir || '';
+    }
+    if (!frontendDir) return ctx.badRequest('Nenhum frontend provisionado.');
+
+    const parent = path.resolve(strapi.dirs.app.root, '..');
+    if (!ensureInside(parent, frontendDir) || !fs.existsSync(frontendDir)) {
+      return ctx.badRequest('Pasta do frontend inválida.');
+    }
+
+    // lê o manifest persistido no projeto
+    let manifest: any;
+    try {
+      manifest = JSON.parse(fs.readFileSync(path.join(frontendDir, MANIFEST_NAME), 'utf8'));
+    } catch {
+      return ctx.badRequest('Manifest do projeto não encontrado (rode a provisão primeiro).');
+    }
+    const v = validateManifest(manifest);
+    if (!v.ok) return ctx.badRequest({ message: 'Manifest inválido', errors: v.errors });
+
+    ctx.body = await integrateFrontend(strapi, { frontendDir, manifest: v.data });
+  },
+};

package/server/src/index.ts

@@ -0,0 +1,43 @@
+/**
+ * Server entry do plugin mcp-chat.
+ */
+
+import chat from './controllers/chat';
+import audio from './controllers/audio';
+import frontend from './controllers/frontend';
+import chatService from './services/chat';
+import audioService from './services/audio';
+import routes from './routes';
+import register from './register';
+import { runPendingProvision } from './provision/orchestrate';
+import { stopFrontend } from './provision/runner';
+
+export default {
+  register,
+  async bootstrap({ strapi }: { strapi: any }) {
+    // Após um restart causado por um upload de frontend, conclui a provisão:
+    // semeia o conteúdo e liga o preview. Idempotente (no-op se não há pendência).
+    try {
+      const r = await runPendingProvision(strapi, strapi.dirs.app.root);
+      if (r.ran) {
+        strapi.log.info(
+          `[mcp-chat] provisão concluída: seed=${JSON.stringify(r.seed?.created ?? [])} link=${r.link?.previewAction ?? 'n/a'}`
+        );
+        if (r.errors.length) strapi.log.warn(`[mcp-chat] provisão com avisos: ${r.errors.join('; ')}`);
+      }
+    } catch (e: any) {
+      strapi.log.error(`[mcp-chat] runPendingProvision falhou: ${e?.message ?? e}`);
+    }
+  },
+  destroy() {
+    // encerra o dev server do frontend (se foi iniciado pelo preview).
+    stopFrontend();
+  },
+  config: {
+    default: {},
+    validator() {},
+  },
+  controllers: { chat, audio, frontend },
+  routes,
+  services: { chat: chatService, audio: audioService },
+};

package/server/src/mcp/index.ts

@@ -0,0 +1,24 @@
+/**
+ * Registra as tools de conteúdo do plugin no MCP server NATIVO da Strapi
+ * (>= 5.47.0). Estrutura modular inspirada no padrão do exemplo do Paul
+ * Bratslavsky: cada tool é um módulo em ./tools/*, agregado em ./tools/index.ts,
+ * e aqui passamos por um loop chamando `tool.register(registerTool, strapi)`.
+ *
+ * Deve rodar no `register()` do plugin, ANTES de o MCP server iniciar.
+ */
+import { tools } from './tools';
+
+export const registerMcpTools = (strapi: any) => {
+  const mcp = strapi?.ai?.mcp;
+  const enabled = typeof mcp?.isEnabled === 'function' ? mcp.isEnabled() : !!mcp?.registerTool;
+  if (!mcp || typeof mcp.registerTool !== 'function' || !enabled) {
+    strapi.log.warn(
+      '[mcp-chat] MCP nativo indisponível/desligado — tools NÃO registradas. ' +
+        'Requer Strapi >= 5.47.0 com `mcp: { enabled: true }` em config/server.'
+    );
+    return;
+  }
+  const { registerTool } = mcp;
+  for (const tool of tools) tool.register(registerTool, strapi);
+  strapi.log.info(`[mcp-chat] ${tools.length} tools registradas no MCP nativo (mcp_chat_*).`);
+};

package/server/src/mcp/tools/buscar-texto.ts

@@ -0,0 +1,28 @@
+import { z } from '@strapi/utils';
+import type { StrapiMcpToolModule } from '../types';
+import { createContentTools } from '../../content-tools';
+
+const tool: StrapiMcpToolModule = {
+  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: () => z.object({ termo: z.string() }),
+      resolveOutputSchema: () =>
+        z.object({
+          total: z.number().optional(),
+          resultados: z.array(z.any()).optional(),
+          erro: z.string().optional(),
+        }),
+      auth: { policies: [{ action: 'plugin::content-manager.explorer.read' }] },
+      createHandler: (strapi: any) => async ({ args }: any) => {
+        const r = await createContentTools(strapi).buscarTexto(args?.termo);
+        return { content: [{ type: 'text', text: JSON.stringify(r) }], structuredContent: r };
+      },
+    });
+  },
+};
+
+export default tool;

package/server/src/mcp/tools/criar-locale.ts

@@ -0,0 +1,30 @@
+import { z } from '@strapi/utils';
+import type { StrapiMcpToolModule } from '../types';
+import { createContentTools } from '../../content-tools';
+
+const tool: StrapiMcpToolModule = {
+  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: () => z.object({ code: z.string(), name: z.string().optional() }),
+      resolveOutputSchema: () =>
+        z.object({
+          ok: z.boolean().optional(),
+          code: z.string().optional(),
+          name: z.string().optional(),
+          existed: z.boolean().optional(),
+          erro: z.string().optional(),
+        }),
+      auth: { policies: [{ action: 'plugin::i18n.locale.create' }] },
+      createHandler: (strapi: any) => async ({ args }: any) => {
+        const r = await createContentTools(strapi).criarLocale(args);
+        return { content: [{ type: 'text', text: JSON.stringify(r) }], structuredContent: r };
+      },
+    });
+  },
+};
+
+export default tool;

package/server/src/mcp/tools/editar-campo.ts

@@ -0,0 +1,39 @@
+import { z } from '@strapi/utils';
+import type { StrapiMcpToolModule } from '../types';
+import { createContentTools } from '../../content-tools';
+
+const tool: StrapiMcpToolModule = {
+  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: () =>
+        z.object({
+          uid: z.string(),
+          documentId: z.string(),
+          path: z.array(z.union([z.string(), z.number()])).optional(),
+          campo: z.string().optional(),
+          novo_valor: z.string(),
+          locale: z.string().optional(),
+        }),
+      resolveOutputSchema: () =>
+        z.object({
+          ok: z.boolean().optional(),
+          uid: z.string().optional(),
+          documentId: z.string().optional(),
+          path: z.array(z.any()).optional(),
+          novo_valor: z.string().optional(),
+          erro: z.string().optional(),
+        }),
+      auth: { policies: [{ action: 'plugin::content-manager.explorer.update' }] },
+      createHandler: (strapi: any) => async ({ args }: any) => {
+        const r = await createContentTools(strapi).editarCampo(args);
+        return { content: [{ type: 'text', text: JSON.stringify(r) }], structuredContent: r };
+      },
+    });
+  },
+};
+
+export default tool;

package/server/src/mcp/tools/habilitar-i18n.ts

@@ -0,0 +1,33 @@
+import { z } from '@strapi/utils';
+import type { StrapiMcpToolModule } from '../types';
+import { enableI18n } from '../../provision/enable-i18n';
+
+const tool: StrapiMcpToolModule = {
+  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: () =>
+        z.object({ uid: z.string().optional(), campos: z.array(z.string()).optional() }),
+      resolveOutputSchema: () =>
+        z.object({
+          ok: z.boolean().optional(),
+          uid: z.string().optional(),
+          campos: z.array(z.string()).optional(),
+          contentTypes: z.array(z.any()).optional(),
+          total: z.number().optional(),
+          restart: z.boolean().optional(),
+          erro: z.string().optional(),
+        }),
+      auth: { policies: [{ action: 'plugin::content-type-builder.read' }] },
+      createHandler: (strapi: any) => async ({ args }: any) => {
+        const r = enableI18n({ strapi, uid: args?.uid, campos: args?.campos });
+        return { content: [{ type: 'text', text: JSON.stringify(r) }], structuredContent: r };
+      },
+    });
+  },
+};
+
+export default tool;

package/server/src/mcp/tools/index.ts

@@ -0,0 +1,17 @@
+import buscarTexto from './buscar-texto';
+import editarCampo from './editar-campo';
+import publicar from './publicar';
+import listarLocales from './listar-locales';
+import criarLocale from './criar-locale';
+import traduzir from './traduzir';
+import habilitarI18n from './habilitar-i18n';
+
+export const tools = [
+  buscarTexto,
+  editarCampo,
+  publicar,
+  listarLocales,
+  criarLocale,
+  traduzir,
+  habilitarI18n,
+];

package/server/src/mcp/tools/listar-locales.ts

@@ -0,0 +1,27 @@
+import { z } from '@strapi/utils';
+import type { StrapiMcpToolModule } from '../types';
+import { createContentTools } from '../../content-tools';
+
+const tool: StrapiMcpToolModule = {
+  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: () => z.object({}),
+      resolveOutputSchema: () =>
+        z.object({
+          default: z.string().optional(),
+          locales: z.array(z.any()).optional(),
+          erro: z.string().optional(),
+        }),
+      auth: { policies: [{ action: 'plugin::content-manager.explorer.read' }] },
+      createHandler: (strapi: any) => async () => {
+        const r = await createContentTools(strapi).listarLocales();
+        return { content: [{ type: 'text', text: JSON.stringify(r) }], structuredContent: r };
+      },
+    });
+  },
+};
+
+export default tool;

package/server/src/mcp/tools/publicar.ts

@@ -0,0 +1,31 @@
+import { z } from '@strapi/utils';
+import type { StrapiMcpToolModule } from '../types';
+import { createContentTools } from '../../content-tools';
+
+const tool: StrapiMcpToolModule = {
+  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: () =>
+        z.object({ uid: z.string(), documentId: z.string(), locale: z.string().optional() }),
+      resolveOutputSchema: () =>
+        z.object({
+          ok: z.boolean().optional(),
+          uid: z.string().optional(),
+          documentId: z.string().optional(),
+          status: z.string().optional(),
+          locale: z.string().optional(),
+        }),
+      auth: { policies: [{ action: 'plugin::content-manager.explorer.publish' }] },
+      createHandler: (strapi: any) => async ({ args }: any) => {
+        const r = await createContentTools(strapi).publicar(args);
+        return { content: [{ type: 'text', text: JSON.stringify(r) }], structuredContent: r };
+      },
+    });
+  },
+};
+
+export default tool;

package/server/src/mcp/tools/traduzir.ts

@@ -0,0 +1,36 @@
+import { z } from '@strapi/utils';
+import type { StrapiMcpToolModule } from '../types';
+import { createContentTools } from '../../content-tools';
+
+const tool: StrapiMcpToolModule = {
+  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: () =>
+        z.object({
+          target_locales: z.array(z.string()).min(1),
+          source_locale: z.string().optional(),
+          uid: z.string().optional(),
+          documentId: z.string().optional(),
+          publish: z.boolean().optional(),
+        }),
+      resolveOutputSchema: () =>
+        z.object({
+          ok: z.boolean().optional(),
+          source: z.string().optional(),
+          por_locale: z.array(z.any()).optional(),
+          erro: z.string().optional(),
+        }),
+      auth: { policies: [{ action: 'plugin::content-manager.explorer.update' }] },
+      createHandler: (strapi: any) => async ({ args }: any) => {
+        const r = await createContentTools(strapi).traduzir(args);
+        return { content: [{ type: 'text', text: JSON.stringify(r) }], structuredContent: r };
+      },
+    });
+  },
+};
+
+export default tool;

package/server/src/mcp/types.ts

@@ -0,0 +1,11 @@
+/**
+ * Tipos para os módulos de tool do MCP (padrão inspirado no exemplo do Paul
+ * Bratslavsky: github.com/PaulBratslavsky/strapi-mcp-demo-and-tool-extension).
+ * Cada tool é um módulo com um `register(registerTool, strapi)`.
+ */
+
+export type RegisterTool = (toolDef: Record<string, any>) => void;
+
+export type StrapiMcpToolModule = {
+  register: (registerTool: RegisterTool, strapi: any) => void;
+};