strapi-plugin-mcp-chat 0.3.1 → 0.5.0

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/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

@@ -132,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;
@@ -207,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>;
     };
@@ -254,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;