strapi-plugin-mcp-chat 0.1.0 → 0.5.0

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

@@ -1,36 +1,30 @@
 import { z } from '@strapi/utils';
-import type { StrapiMcpToolModule } from '../types';
+import { defineTool } from '../define';
 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 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: () =>
+    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 }) => {
+    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

@@ -1,11 +1,14 @@
 /**
- * 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)`.
+ * Tipos do MCP do plugin. As tools agora são DEFINIÇÕES puras criadas com
+ * `defineTool` (ver ./define.ts) e registradas a partir de um array — alinhado
+ * à direção do PR #26603 (`ai.mcp.defineTool`). Re-exportamos os tipos de
+ * `./define` aqui por conveniência/compatibilidade.
  */
-
-export type RegisterTool = (toolDef: Record<string, any>) => void;
-
-export type StrapiMcpToolModule = {
-  register: (registerTool: RegisterTool, strapi: any) => void;
-};
+export type {
+  McpToolDef,
+  McpResourceDef,
+  McpPromptDef,
+  McpToolResult,
+  McpAuth,
+  RegisterTool,
+} from './define';

package/server/src/mcp-client.ts

@@ -14,6 +14,18 @@ const baseHeaders = {
   Accept: 'application/json, text/event-stream',
 };
 
+/** fetch com timeout (AbortController) — nenhum endpoint MCP pode pendurar uma
+ *  request do Strapi indefinidamente. */
+const fetchT = async (url: string, opts: any, timeoutMs = 8000): Promise<Response> => {
+  const ctrl = new AbortController();
+  const t = setTimeout(() => ctrl.abort(), timeoutMs);
+  try {
+    return await fetch(url, { ...opts, signal: ctrl.signal });
+  } finally {
+    clearTimeout(t);
+  }
+};
+
 const parseSse = (text: string): any => {
   const dataLines = text
     .split('\n')
@@ -50,7 +62,7 @@ export class McpClient {
   }
 
   async init(): Promise<void> {
-    const res = await fetch(this.url, {
+    const res = await fetchT(this.url, {
       method: 'POST',
       headers: this.headers(),
       body: JSON.stringify({
@@ -67,7 +79,7 @@ export class McpClient {
     this.sessionId = res.headers.get('mcp-session-id') || undefined;
     await res.text();
     // Notifica que o handshake terminou (sem corpo de resposta relevante).
-    await fetch(this.url, {
+    await fetchT(this.url, {
       method: 'POST',
       headers: this.headers(),
       body: JSON.stringify({ jsonrpc: '2.0', method: 'notifications/initialized' }),
@@ -75,7 +87,7 @@ export class McpClient {
   }
 
   private async rpc(method: string, params: any, id: number): Promise<any> {
-    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 }),

package/server/src/provision/integrate.ts

@@ -558,6 +558,18 @@ export function __getLocale(): string {
   } catch {}
   return __defaultLocale;
 }
+/** Status ativo: ?preview=1 ou ?status=draft na URL → rascunho (preview do
+ *  mcp-chat em modo Draft). Caso contrário, publicado. Só no cliente; no SSR
+ *  cai para "published" (ver a nota de draft preview no README). */
+export function __getStatus(): "draft" | "published" {
+  try {
+    if (typeof window !== "undefined") {
+      const sp = new URL(window.location.href).searchParams;
+      if (sp.get("preview") === "1" || sp.get("status") === "draft") return "draft";
+    }
+  } catch {}
+  return "published";
+}
 
 ${mapperCode}
 
@@ -565,11 +577,13 @@ const __store: Record<string, any> = {};
 export function hydrate(d: any) { if (d) for (const k of Object.keys(d)) __store[k] = d[k]; }
 
 export async function loadAllData(opts: { locale?: string; status?: "draft" | "published" } = {}) {
+  // Sem status explícito, herda do flag de preview na URL (?preview=1 → draft).
+  const __opts = { locale: opts.locale, status: opts.status || __getStatus() };
   const raw: Record<string, any> = {};
   await Promise.all(
     __cts.map(async (c: any) => {
       try {
-        raw[c.s] = c.k === "singleType" ? await fetchSingle(c.s, opts) : await fetchCollection(c.p, opts);
+        raw[c.s] = c.k === "singleType" ? await fetchSingle(c.s, __opts) : await fetchCollection(c.p, __opts);
       } catch {
         raw[c.s] = c.k === "singleType" ? null : [];
       }

package/server/src/provision/write.ts

@@ -49,6 +49,58 @@ function isDev(): boolean {
   return process.env.NODE_ENV === 'development';
 }
 
+// Tipos de atributo que a Strapi 5 aceita num schema.json. Um type fora desta
+// lista faz a Strapi recusar o boot — então validamos ANTES de escrever.
+const KNOWN_ATTR_TYPES = new Set([
+  'string', 'text', 'richtext', 'blocks', 'email', 'password', 'uid', 'enumeration',
+  'json', 'integer', 'biginteger', 'decimal', 'float', 'date', 'time', 'datetime',
+  'timestamp', 'boolean', 'media', 'relation', 'component', 'dynamiczone',
+]);
+
+/**
+ * Valida o conteúdo de um schema.json gerado contra o formato que a Strapi 5
+ * exige. Retorna a lista de erros (vazia = ok). É a trava que garante que uma
+ * provisão NUNCA escreva um schema que impeça o Strapi de bootar.
+ */
+function validateApi(api: GeneratedApi): string[] {
+  const errs: string[] = [];
+  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: any;
+  try {
+    schema = JSON.parse(api.files[rel]);
+  } catch (e: any) {
+    errs.push(`${api.singularName}: schema.json não é JSON válido (${e?.message ?? e})`);
+    return errs;
+  }
+  if (schema?.kind !== 'collectionType' && schema?.kind !== 'singleType') {
+    errs.push(`${api.singularName}: "kind" inválido (${schema?.kind})`);
+  }
+  if (!schema?.info?.singularName || !schema?.info?.pluralName) {
+    errs.push(`${api.singularName}: info.singularName/pluralName obrigatórios`);
+  }
+  const attrs = schema?.attributes;
+  if (!attrs || typeof attrs !== 'object') {
+    errs.push(`${api.singularName}: "attributes" ausente ou inválido`);
+  } else {
+    for (const [name, a] of Object.entries(attrs) as any[]) {
+      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;
+}
+
 /**
  * Escreve as content-types geradas em src/api. Aditivo e idempotente: o que já
  * existe é preservado e reportado em `skipped`.
@@ -80,6 +132,46 @@ export function writeApis(
     return result;
   }
 
+  // ── Validação ALL-OR-NOTHING (antes de tocar no disco) ──────────────────────
+  // Só serão escritas as apis que ainda não existem (trava aditiva). Validamos
+  // TODAS elas; se UMA for inválida, não escrevemos NENHUMA — assim uma provisão
+  // jamais pode deixar o Strapi com um schema quebrado e sem bootar.
+  const toWrite = apis.filter((api) => !fs.existsSync(path.join(opts.apiRoot, api.singularName)));
+  const knownSingulars = new Set<string>([
+    ...apis.map((a) => a.singularName),
+    ...(fs.existsSync(opts.apiRoot)
+      ? fs.readdirSync(opts.apiRoot, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name)
+      : []),
+  ]);
+  const validationErrors: string[] = [];
+  for (const api of toWrite) {
+    validationErrors.push(...validateApi(api));
+    // relações: o target (api::<s>.<s>) precisa existir (gerado agora ou já no disco)
+    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) as any[]) {
+          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 {
+        /* já reportado por validateApi */
+      }
+    }
+  }
+  if (validationErrors.length) {
+    result.errors.push(
+      'Schema gerado inválido — nada foi escrito (provisão abortada com segurança):',
+      ...validationErrors
+    );
+    return result;
+  }
+
   for (const api of apis) {
     const apiDir = path.join(opts.apiRoot, api.singularName);
 

package/server/src/services/chat.ts

@@ -25,6 +25,12 @@ type ChatInput = {
   lang?: Lang;
   /** URL da página aberta no preview — contexto do "isso aqui". */
   previewUrl?: string | null;
+  /**
+   * Política de publicação. `false` (default) = modo RASCUNHO: o agente edita o
+   * draft e NÃO publica, a menos que o usuário peça explicitamente. `true` =
+   * auto-publicar após cada edição (comportamento "live" antigo).
+   */
+  autoPublish?: boolean;
 };
 
 const MODEL = process.env.OPENAI_CHAT_MODEL || 'gpt-4o';
@@ -42,9 +48,9 @@ Ferramentas de conteúdo:
 Fluxo padrão quando o usuário pede uma mudança no site (por texto, voz ou mostrando a tela):
 1. Use buscar_texto com um trecho distintivo do texto a alterar (sem rótulos de status).
 2. Se houver mais de um resultado, escolha o mais provável pelo contexto (e diga qual escolheu); se ambíguo de verdade, pergunte.
-3. editar_campo passando o mesmo uid, documentId e path do resultado, com o novo valor.
-4. publicar a entrada.
-5. Confirme em 1 frase o que foi alterado e publicado (content-type, campo, antes → depois).
+3. editar_campo passando o mesmo uid, documentId e path do resultado, com o novo valor. Isso salva como RASCUNHO (não publica).
+4. Decida se publica ou não conforme a POLÍTICA DE PUBLICAÇÃO indicada mais abaixo.
+5. Confirme em 1 frase o que foi alterado (content-type, campo, antes → depois) e se ficou como rascunho ou foi publicado.
 
 Ferramentas de tradução / idiomas (i18n):
 - listar_locales(): mostra os idiomas configurados e o default.
@@ -58,6 +64,8 @@ Fluxo quando o usuário pede tradução (ex.: "quero o site todo em pt-BR"):
 3. Após o restart, ao repetir, traduzir funciona e localiza tudo.
 4. Confirme em 1 frase: idiomas, quantos documentos e campos foram traduzidos/publicados (use o resumo retornado, não despeje o conteúdo).
 
+Draft & Publish: cada resultado de buscar_texto traz "draftAndPublish". Se for false, aquele tipo NÃO tem rascunho no Strapi — a edição já é o conteúdo vivo e NÃO há o que publicar; nesse caso, ao confirmar, avise que "esse conteúdo não tem rascunho, a alteração já está no ar" e NÃO chame publicar.
+
 Se o usuário compartilhar a tela, uma imagem é anexada à última mensagem — use-a para entender exatamente o que ele está vendo e qual texto quer trocar.
 
 Seja objetivo e acionável. Responda SEMPRE em português.`,
@@ -71,9 +79,9 @@ Content tools:
 Default flow when the user asks for a site change (by text, voice or by showing their screen):
 1. Use buscar_texto with a distinctive snippet of the text to change (no status labels).
 2. If there is more than one result, pick the most likely from context (and say which); if truly ambiguous, ask.
-3. editar_campo passing the same uid, documentId and path from the result, with the new value.
-4. publicar the entry.
-5. Confirm in one sentence what was changed and published (content-type, field, before → after).
+3. editar_campo passing the same uid, documentId and path from the result, with the new value. This saves a DRAFT (does not publish).
+4. Decide whether to publish based on the PUBLISH POLICY stated below.
+5. Confirm in one sentence what was changed (content-type, field, before → after) and whether it stayed a draft or was published.
 
 Translation / language tools (i18n):
 - listar_locales(): shows configured languages and the default.
@@ -87,13 +95,15 @@ Flow when the user asks for translation (e.g. "I want the whole site in pt-BR"):
 3. After the restart, repeating the request makes traduzir localize everything.
 4. Confirm in one sentence: languages, how many documents and fields were translated/published (use the returned summary, don't dump the content).
 
+Draft & Publish: each buscar_texto result includes "draftAndPublish". If it is false, that type has NO draft in Strapi — the edit IS the live content and there is nothing to publish; in that case, when confirming, warn that "this content has no draft, the change is already live" and do NOT call publicar.
+
 If the user shares their screen, an image is attached to the last message — use it to understand exactly what they see and which text they want to change.
 
 Be concise and actionable. ALWAYS answer in English.`,
 };
 
 export default ({ strapi }: { strapi: any }) => ({
-  async chat({ messages, image, lang = 'pt', previewUrl }: ChatInput) {
+  async chat({ messages, image, lang = 'pt', previewUrl, autoPublish = false }: ChatInput) {
     const apiKey = process.env.OPENAI_API_KEY;
     if (!apiKey) {
       throw new Error(
@@ -122,7 +132,11 @@ export default ({ strapi }: { strapi: any }) => ({
     if (process.env.PLAYWRIGHT_MCP_URL) {
       try {
         const client = new McpClient(process.env.PLAYWRIGHT_MCP_URL, 'playwright');
-        await client.init();
+        // init com timeout: um Playwright MCP fora do ar não pode travar o chat.
+        await Promise.race([
+          client.init(),
+          new Promise((_, rej) => setTimeout(() => rej(new Error('timeout')), 4000)),
+        ]);
         const list = await client.listTools();
         for (const t of list) {
           if (mcpByTool[t.name]) continue;
@@ -156,7 +170,17 @@ export default ({ strapi }: { strapi: any }) => ({
       pt: `\n\nVocê também controla um navegador real via ferramentas browser_* (Playwright), apontado para o ADMIN DA STRAPI em ${adminBase} (o backend — é aqui que o conteúdo muda de verdade, NÃO no site público). Pode navegar (browser_navigate), clicar, digitar, rolar, tirar seus próprios screenshots (browser_take_screenshot) e inspecionar console/erros. Prefira sempre suas ferramentas diretas (buscar_texto/editar_campo/publicar) para alterar conteúdo; use o navegador para VERIFICAR no admin que a edição/publicação ficou correta, ou para fluxos da UI que as ferramentas diretas não cobrem.`,
       en: `\n\nYou also control a real browser via browser_* tools (Playwright), pointed at the STRAPI ADMIN at ${adminBase} (the backend — this is where content actually changes, NOT the public site). You can navigate (browser_navigate), click, type, scroll, take your own screenshots (browser_take_screenshot) and inspect console/errors. Always prefer your direct tools (buscar_texto/editar_campo/publicar) to change content; use the browser to VERIFY in the admin that the edit/publish landed, or for admin UI flows the direct tools don't cover.`,
     };
-    const systemContent = SYSTEM[language] + (hasBrowser ? BROWSER_NOTE[language] : '');
+    // ── Política de publicação (draft-first por padrão) ───────────────────────
+    const PUBLISH_POLICY: Record<Lang, string> = {
+      pt: autoPublish
+        ? `\n\nPOLÍTICA DE PUBLICAÇÃO: AUTO-PUBLICAR está LIGADO. Depois de editar_campo, chame publicar para deixar a mudança no ar. Em traduzir, use publish:true (default).`
+        : `\n\nPOLÍTICA DE PUBLICAÇÃO: MODO RASCUNHO (auto-publicar DESLIGADO). NÃO chame publicar a menos que o usuário peça explicitamente ("publica", "põe no ar", "publish"). Depois de editar_campo, PARE e avise que a alteração foi salva como RASCUNHO para revisão (ela já aparece no preview em modo rascunho, mas ainda não no site público). Em traduzir, passe publish:false. Se o usuário pedir para publicar, aí sim use publicar (ou traduzir com publish:true).`,
+      en: autoPublish
+        ? `\n\nPUBLISH POLICY: AUTO-PUBLISH is ON. After editar_campo, call publicar to make the change live. For traduzir, use publish:true (default).`
+        : `\n\nPUBLISH POLICY: DRAFT MODE (auto-publish OFF). Do NOT call publicar unless the user explicitly asks ("publish", "make it live", "publica"). After editar_campo, STOP and tell them the change was saved as a DRAFT for review (it already shows in the preview when in draft mode, but not on the public site yet). For traduzir, pass publish:false. If the user asks to publish, then use publicar (or traduzir with publish:true).`,
+    };
+    const systemContent =
+      SYSTEM[language] + (hasBrowser ? BROWSER_NOTE[language] : '') + PUBLISH_POLICY[language];
 
     // ── Monta a conversa; anexa imagem da tela à última mensagem do usuário ──
     const convo: any[] = [{ role: 'system', content: systemContent }];
@@ -187,11 +211,23 @@ export default ({ strapi }: { strapi: any }) => ({
     });
 
     const callOpenAI = async (body: any) => {
-      const res = await fetch(OPENAI_URL, {
-        method: 'POST',
-        headers: { Authorization: `Bearer ${apiKey}`, 'Content-Type': 'application/json' },
-        body: JSON.stringify(body),
-      });
+      // Timeout: uma chamada lenta da OpenAI não pode prender a request do admin.
+      const ctrl = new AbortController();
+      const timer = setTimeout(() => ctrl.abort(), 60000);
+      let res: Response;
+      try {
+        res = await fetch(OPENAI_URL, {
+          method: 'POST',
+          headers: { Authorization: `Bearer ${apiKey}`, 'Content-Type': 'application/json' },
+          body: JSON.stringify(body),
+          signal: ctrl.signal,
+        });
+      } catch (e: any) {
+        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() as Promise<any>;
     };
@@ -234,6 +270,12 @@ export default ({ strapi }: { strapi: any }) => ({
           } catch (e: any) {
             content = `Erro ao chamar a tool ${name}: ${e?.message || e}`;
           }
+          // Cap defensivo: um resultado gigante não pode estourar o contexto do
+          // modelo nem inflar memória/latência.
+          const MAX_TOOL_CHARS = 12000;
+          if (content.length > MAX_TOOL_CHARS) {
+            content = content.slice(0, MAX_TOOL_CHARS) + `\n…[resultado truncado: ${content.length} chars]`;
+          }
           convo.push({ role: 'tool', tool_call_id: call.id, content });
         }
         continue;