strapi-plugin-mcp-chat 0.3.1 → 0.6.0

package/server/src/provision/runner.ts

@@ -32,6 +32,44 @@ export interface RunInfo {
 let info: RunInfo = { state: 'idle', dir: null, url: null, pm: null, error: null, log: [] };
 let child: ChildProcess | null = null;
 let pollTimer: ReturnType<typeof setInterval> | null = null;
+let appRootForPid: string | null = null;
+
+// ── pidfile: rastreia o PID do dev server p/ matá-lo no shutdown e limpar
+//    órfãos no boot (ex.: após um crash/SIGKILL onde o destroy não rodou). ──
+function pidFilePath(appRoot: string): string {
+  return path.join(appRoot, '.mcp-chat', 'frontend.pid');
+}
+function writePid(pid: number): void {
+  try {
+    if (!appRootForPid) return;
+    const pf = pidFilePath(appRootForPid);
+    fs.mkdirSync(path.dirname(pf), { recursive: true });
+    fs.writeFileSync(pf, String(pid), 'utf8');
+  } catch { /* best-effort */ }
+}
+function clearPid(): void {
+  try {
+    if (appRootForPid) fs.unlinkSync(pidFilePath(appRootForPid));
+  } catch { /* não existia */ }
+}
+function isAlive(pid: number): boolean {
+  try { process.kill(pid, 0); return true; } catch { return false; }
+}
+/**
+ * Mata um dev server órfão deixado por uma execução anterior (crash/SIGKILL não
+ * roda o destroy()). Chamado no bootstrap do plugin — garante "limpar ao
+ * desligar" mesmo quando o shutdown não foi limpo, e evita o EADDRINUSE.
+ */
+export function cleanupStaleFrontend(appRoot: string): void {
+  appRootForPid = appRoot;
+  try {
+    const pf = pidFilePath(appRoot);
+    if (!fs.existsSync(pf)) return;
+    const pid = parseInt(fs.readFileSync(pf, 'utf8').trim(), 10);
+    if (pid && isAlive(pid)) { try { process.kill(pid, 'SIGTERM'); } catch { /* já morto */ } }
+    fs.unlinkSync(pf);
+  } catch { /* best-effort */ }
+}
 
 function detectPM(dir: string): string {
   if (fs.existsSync(path.join(dir, 'bun.lockb')) || fs.existsSync(path.join(dir, 'bun.lock'))) return 'bun';
@@ -55,7 +93,7 @@ function detectFramework(dir: string): 'vite' | 'next' | 'other' {
  *  - 3000 (Next default) e 1337 (Strapi).
  * Evita colisão com o admin do Strapi (que responde 426 a requests não-WS).
  */
-const FRONTEND_BASE_PORT = 4321;
+export const FRONTEND_BASE_PORT = 4321;
 
 /** Acha uma porta TCP livre a partir de `start`, testando em 0.0.0.0 (pega
  *  ocupações em `*:porta` de qualquer interface IPv4). */
@@ -101,11 +139,14 @@ export function stopFrontend(): void {
     try { child.kill('SIGTERM'); } catch { /* ignore */ }
     child = null;
   }
+  clearPid(); // limpa ao desligar — não deixa órfão
   if (info.state !== 'error') info.state = 'idle';
 }
 
 export async function startFrontend(_strapi: any, opts: { dir: string; url: string }): Promise<RunInfo> {
   const { dir } = opts;
+  // raiz da app p/ o pidfile (limpeza de órfãos no boot / shutdown).
+  if (_strapi?.dirs?.app?.root) appRootForPid = _strapi.dirs.app.root;
 
   // idempotente: já rodando/subindo para o mesmo dir
   if (child && info.dir === dir && ['installing', 'starting', 'running'].includes(info.state)) {
@@ -138,12 +179,14 @@ export async function startFrontend(_strapi: any, opts: { dir: string; url: stri
   const startDev = () => {
     info.state = 'starting';
     child = spawnIn(pm, devArgs);
+    if (child.pid) writePid(child.pid); // rastreia p/ limpar no shutdown/boot
     child.stdout?.on('data', (d) => pushLog(d));
     child.stderr?.on('data', (d) => pushLog(d));
     child.on('exit', (code) => {
       // processo morreu → frontend DOWN. Zera o child e libera o estado p/ que
       // apertar Preview de novo reinicie (em vez de ficar preso em "running").
       child = null;
+      clearPid();
       if (pollTimer) { clearInterval(pollTimer); pollTimer = null; }
       if (info.state === 'running') info.state = 'idle';
       else { info.state = 'error'; info.error = `dev encerrou (código ${code}). Veja o log.`; }

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;
+  /**
+   * Status do preview atual: 'draft' (toggle de rascunho ligado) ou 'published'
+   * (live). A busca de texto segue ESTE modo — acha rascunho quando em draft, e
+   * o conteúdo no ar quando em live. Default 'draft'.
+   */
+  previewStatus?: 'draft' | 'published';
   /**
    * 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` =
@@ -103,7 +109,7 @@ Be concise and actionable. ALWAYS answer in English.`,
 };
 
 export default ({ strapi }: { strapi: any }) => ({
-  async chat({ messages, image, lang = 'pt', previewUrl, autoPublish = false }: ChatInput) {
+  async chat({ messages, image, lang = 'pt', previewUrl, previewStatus = 'draft', autoPublish = false }: ChatInput) {
     const apiKey = process.env.OPENAI_API_KEY;
     if (!apiKey) {
       throw new Error(
@@ -116,7 +122,7 @@ export default ({ strapi }: { strapi: any }) => ({
     const { buscarTexto, editarCampo, publicar, listarLocales, criarLocale, traduzir } =
       createContentTools(strapi);
     const LOCAL_TOOLS: Record<string, (args: any) => Promise<any>> = {
-      buscar_texto: (a) => buscarTexto(a?.termo),
+      buscar_texto: (a) => buscarTexto(a?.termo, previewStatus),
       editar_campo: (a) => editarCampo(a),
       publicar: (a) => publicar(a),
       listar_locales: () => listarLocales(),
@@ -132,7 +138,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 +217,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 +276,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;