strapi-plugin-mcp-chat 0.1.0

package/server/src/provision/translate.ts

@@ -0,0 +1,153 @@
+/**
+ * Tradução resiliente a campos longos (a "Dor 1": EN→pt-BR estoura).
+ *
+ * NENHUM campo é enviado inteiro ao LLM. `splitForTranslation` quebra o valor em
+ * pedaços abaixo de um teto de tokens (por parágrafo; parágrafos gigantes caem
+ * para sentenças), cada pedaço é traduzido isolado e remontado na ordem. Assim a
+ * tradução funciona para texto de qualquer tamanho.
+ *
+ * Funções puras (split/join) ficam testáveis sem rede; só `translateChunk` toca
+ * a OpenAI, reusando o mesmo padrão `fetch` do services/chat.ts.
+ */
+
+const OPENAI_URL = 'https://api.openai.com/v1/chat/completions';
+const MODEL = process.env.OPENAI_CHAT_MODEL || 'gpt-4o';
+
+/** Estimativa grosseira de tokens (~4 chars/token) — suficiente para chunking. */
+export const approxTokens = (s: string): number => Math.ceil((s || '').length / 4);
+
+/** Teto de tokens de ENTRADA por pedaço. A saída pode crescer ~2x; o teto já
+ *  deixa folga para isso dentro do limite do modelo. */
+export const MAX_CHUNK_TOKENS = 1200;
+
+const splitParagraphs = (text: string): string[] => text.split(/\n{2,}/);
+
+/** Quebra em sentenças preservando a pontuação. */
+const splitSentences = (text: string): string[] =>
+  text.match(/[^.!?]+(?:[.!?]+|$)/g) || [text];
+
+export interface SplitResult {
+  chunks: string[];
+  /** Remonta os pedaços traduzidos na ordem original. */
+  join: (translated: string[]) => string;
+}
+
+/**
+ * Divide um valor textual em pedaços traduzíveis. Curto → 1 pedaço. Longo →
+ * agrupa parágrafos inteiros sob o teto; parágrafo isolado acima do teto é
+ * subdividido em sentenças. A remontagem junta por linha dupla (fronteira de
+ * parágrafo), preservando a estrutura do texto.
+ */
+export function splitForTranslation(value: string, _type?: string): SplitResult {
+  const text = String(value ?? '');
+  if (approxTokens(text) <= MAX_CHUNK_TOKENS) {
+    return { chunks: [text], join: (t) => t[0] ?? '' };
+  }
+
+  // 1) segmentos = parágrafos; parágrafo grande → sentenças
+  const segs: string[] = [];
+  for (const para of splitParagraphs(text)) {
+    if (approxTokens(para) <= MAX_CHUNK_TOKENS) {
+      segs.push(para);
+      continue;
+    }
+    let buf = '';
+    for (const sent of splitSentences(para)) {
+      if (buf && approxTokens(buf + sent) > MAX_CHUNK_TOKENS) {
+        segs.push(buf);
+        buf = '';
+      }
+      buf += sent;
+    }
+    if (buf) segs.push(buf);
+  }
+
+  // 2) empacota segmentos em pedaços sob o teto (juntando por linha dupla)
+  const chunks: string[] = [];
+  let buf: string[] = [];
+  let bufTok = 0;
+  for (const seg of segs) {
+    const t = approxTokens(seg);
+    if (buf.length && bufTok + t > MAX_CHUNK_TOKENS) {
+      chunks.push(buf.join('\n\n'));
+      buf = [];
+      bufTok = 0;
+    }
+    buf.push(seg);
+    bufTok += t;
+  }
+  if (buf.length) chunks.push(buf.join('\n\n'));
+
+  return { chunks, join: (t) => t.join('\n\n') };
+}
+
+/** Traduz UM pedaço via OpenAI, preservando marcação/placeholders. */
+export async function translateChunk(
+  apiKey: string,
+  text: string,
+  sourceLang: string,
+  targetLang: string
+): Promise<string> {
+  if (!text || !text.trim()) return text;
+  const body = {
+    model: MODEL,
+    temperature: 0,
+    max_tokens: Math.min(4000, approxTokens(text) * 3 + 256),
+    messages: [
+      {
+        role: 'system',
+        content:
+          `You are a professional translator. Translate the user's text from ${sourceLang} to ${targetLang}. ` +
+          'Preserve EXACTLY all markdown, HTML tags, URLs, and placeholders such as {name}, :slug, %s, {{var}}. ' +
+          'Keep line breaks. Do NOT add quotes, notes, or explanations. Return ONLY the translated text.',
+      },
+      { role: 'user', content: text },
+    ],
+  };
+  const res = await fetch(OPENAI_URL, {
+    method: 'POST',
+    headers: { Authorization: `Bearer ${apiKey}`, 'Content-Type': 'application/json' },
+    body: JSON.stringify(body),
+  });
+  if (!res.ok) throw new Error(`OpenAI translate: ${await res.text()}`);
+  const data: any = await res.json();
+  return (data.choices?.[0]?.message?.content ?? '').trim();
+}
+
+/** Executa `fn` sobre `items` com no máximo `limit` em paralelo (resolve
+ *  rate-limit com muitos pedaços/locales). Preserva a ordem na saída. */
+export async function mapPool<T, R>(
+  items: T[],
+  limit: number,
+  fn: (item: T, index: number) => Promise<R>
+): Promise<R[]> {
+  const out = new Array<R>(items.length);
+  let i = 0;
+  const workers = Array.from({ length: Math.max(1, Math.min(limit, items.length)) }, async () => {
+    while (i < items.length) {
+      const idx = i++;
+      out[idx] = await fn(items[idx], idx);
+    }
+  });
+  await Promise.all(workers);
+  return out;
+}
+
+/**
+ * Traduz um valor textual completo: split → traduz pedaços (pool) → remonta.
+ * Retorna o texto traduzido e quantos pedaços foram usados (para métrica).
+ */
+export async function translateText(
+  apiKey: string,
+  value: string,
+  sourceLang: string,
+  targetLang: string,
+  type?: string
+): Promise<{ text: string; chunks: number }> {
+  if (typeof value !== 'string' || !value.trim()) return { text: value, chunks: 0 };
+  const { chunks, join } = splitForTranslation(value, type);
+  const translated = await mapPool(chunks, 4, (c) =>
+    c.trim() ? translateChunk(apiKey, c, sourceLang, targetLang) : Promise.resolve(c)
+  );
+  return { text: join(translated), chunks: chunks.length };
+}

package/server/src/provision/types-gen.ts

@@ -0,0 +1,117 @@
+import type {
+  Manifest,
+  ManifestContentType,
+  ManifestAttribute,
+} from './manifest';
+
+/**
+ * Gera tipos TypeScript a partir do manifest, para o frontend consumir o
+ * @strapi/client com type-safety. Determinístico (não precisa do schema vivo),
+ * o que mantém o gerador testável e desacoplado do boot da Strapi.
+ *
+ * Mapeia os tipos do manifest para TS, respeitando required (opcional vs não),
+ * relações (objeto único vs array) e mídia.
+ */
+
+function toPascal(singular: string): string {
+  return singular
+    .split('-')
+    .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
+    .join('');
+}
+
+function scalarToTs(type: string): string {
+  switch (type) {
+    case 'string':
+    case 'text':
+    case 'richtext':
+    case 'blocks':
+    case 'email':
+    case 'uid':
+    case 'date':
+    case 'datetime':
+    case 'time':
+      return 'string';
+    case 'integer':
+    case 'biginteger':
+    case 'float':
+    case 'decimal':
+      return 'number';
+    case 'boolean':
+      return 'boolean';
+    case 'json':
+      return 'unknown';
+    default:
+      return 'unknown';
+  }
+}
+
+/** tipo TS do atributo + se é opcional (sem `required`). */
+function attrToTs(
+  attr: ManifestAttribute,
+  pascalOf: (singular: string) => string
+): { tsType: string; optional: boolean } {
+  switch (attr.type) {
+    case 'enumeration':
+      return {
+        tsType: attr.enum.map((e) => JSON.stringify(e)).join(' | '),
+        optional: !attr.required,
+      };
+    case 'media':
+      return {
+        tsType: attr.multiple ? 'StrapiMedia[]' : 'StrapiMedia',
+        optional: !attr.required,
+      };
+    case 'relation': {
+      const target = pascalOf(attr.target);
+      const many = attr.relation === 'oneToMany' || attr.relation === 'manyToMany';
+      return { tsType: many ? `${target}[]` : target, optional: true };
+    }
+    case 'uid':
+      return { tsType: 'string', optional: !attr.required };
+    default:
+      return {
+        tsType: scalarToTs(attr.type),
+        optional: !(attr as any).required,
+      };
+  }
+}
+
+function buildInterface(ct: ManifestContentType): string {
+  const name = ct.displayName
+    ? toPascal(ct.singularName)
+    : toPascal(ct.singularName);
+  const lines: string[] = [`export interface ${name} {`];
+  // campos padrão da Strapi 5
+  lines.push('  documentId: string;');
+  for (const [key, attr] of Object.entries(ct.attributes)) {
+    const { tsType, optional } = attrToTs(attr, toPascal);
+    lines.push(`  ${key}${optional ? '?' : ''}: ${tsType};`);
+  }
+  lines.push('  createdAt: string;');
+  lines.push('  updatedAt: string;');
+  lines.push('  publishedAt?: string;');
+  lines.push('}');
+  return lines.join('\n');
+}
+
+const PREAMBLE = `// Tipos gerados automaticamente a partir do strapi.manifest.json.
+// NÃO edite à mão — rode o link novamente para regenerar.
+
+export interface StrapiMedia {
+  id: number;
+  documentId: string;
+  url: string;
+  alternativeText?: string;
+  width?: number;
+  height?: number;
+  mime?: string;
+  name?: string;
+}
+`;
+
+/** Gera o conteúdo do arquivo de tipos (ex.: strapi-types.ts) do frontend. */
+export function generateTypes(manifest: Manifest): string {
+  const interfaces = manifest.contentTypes.map(buildInterface).join('\n\n');
+  return `${PREAMBLE}\n${interfaces}\n`;
+}

package/server/src/provision/write.ts

@@ -0,0 +1,136 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import type { GeneratedApi } from './generate';
+
+/**
+ * Writer: grava no disco os arquivos que o gerador produziu.
+ *
+ * Três travas de segurança, nessa ordem:
+ *  1. DEV-ONLY  — só escreve em NODE_ENV=development (o Content-Type Builder da
+ *     Strapi também só opera em dev; gerar schema em prod é proibido).
+ *  2. ADITIVO   — se a pasta da api já existe, a content-type inteira é PULADA.
+ *     Nunca sobrescrevemos nem alteramos types existentes → zero risco de perda
+ *     de dados.
+ *  3. DRY-RUN   — calcula o plano completo sem tocar no disco.
+ *
+ * A reinicialização (para a Strapi reconhecer os novos types) é responsabilidade
+ * separada — ver requestReload().
+ */
+
+export interface WriteOptions {
+  /** caminho absoluto para src/api da app Strapi. */
+  apiRoot: string;
+  /** se true, não escreve nada — só devolve o plano. */
+  dryRun?: boolean;
+  /**
+   * pula a trava dev-only. Use APENAS em testes; em produção o controller
+   * nunca passa isto.
+   */
+  allowOutsideDev?: boolean;
+}
+
+export interface SkippedApi {
+  singularName: string;
+  reason: string;
+}
+
+export interface WriteResult {
+  ok: boolean;
+  dryRun: boolean;
+  /** caminhos (relativos a apiRoot) que foram/serão escritos. */
+  planned: string[];
+  written: string[];
+  /** content-types puladas por já existirem (proteção aditiva). */
+  skipped: SkippedApi[];
+  errors: string[];
+}
+
+function isDev(): boolean {
+  return process.env.NODE_ENV === 'development';
+}
+
+/**
+ * Escreve as content-types geradas em src/api. Aditivo e idempotente: o que já
+ * existe é preservado e reportado em `skipped`.
+ */
+export function writeApis(
+  apis: GeneratedApi[],
+  opts: WriteOptions
+): WriteResult {
+  const result: WriteResult = {
+    ok: false,
+    dryRun: !!opts.dryRun,
+    planned: [],
+    written: [],
+    skipped: [],
+    errors: [],
+  };
+
+  // Trava 1: dev-only
+  if (!opts.allowOutsideDev && !isDev()) {
+    result.errors.push(
+      'Geração de content-types só é permitida em desenvolvimento (NODE_ENV=development). ' +
+        'Em produção, gere os types em dev e faça deploy do código.'
+    );
+    return result;
+  }
+
+  if (!path.isAbsolute(opts.apiRoot)) {
+    result.errors.push(`apiRoot deve ser um caminho absoluto: ${opts.apiRoot}`);
+    return result;
+  }
+
+  for (const api of apis) {
+    const apiDir = path.join(opts.apiRoot, api.singularName);
+
+    // Trava 2: aditivo — nunca toca em api existente
+    if (fs.existsSync(apiDir)) {
+      result.skipped.push({
+        singularName: api.singularName,
+        reason: `já existe em ${path.relative(opts.apiRoot, apiDir)} — preservado`,
+      });
+      continue;
+    }
+
+    for (const [rel, content] of Object.entries(api.files)) {
+      const full = path.join(opts.apiRoot, rel);
+
+      // defesa extra: o caminho final tem que ficar DENTRO de apiRoot
+      const normalized = path.normalize(full);
+      if (
+        normalized !== opts.apiRoot &&
+        !normalized.startsWith(opts.apiRoot + path.sep)
+      ) {
+        result.errors.push(`caminho fora de apiRoot bloqueado: ${rel}`);
+        continue;
+      }
+
+      result.planned.push(rel);
+
+      if (opts.dryRun) continue;
+
+      try {
+        fs.mkdirSync(path.dirname(full), { recursive: true });
+        fs.writeFileSync(full, content, 'utf8');
+        result.written.push(rel);
+      } catch (e: any) {
+        result.errors.push(`falha ao escrever ${rel}: ${e?.message ?? e}`);
+      }
+    }
+  }
+
+  result.ok = result.errors.length === 0;
+  return result;
+}
+
+/**
+ * Pede para a Strapi recarregar, de modo que os novos content-types passem a
+ * existir. Em dev, escrever em src/ já dispara o watcher; chamar reload() torna
+ * o efeito determinístico. Isolado aqui para o controller decidir quando chamar
+ * (normalmente após responder ao cliente, para não cortar a resposta).
+ */
+export function requestReload(strapi: any): void {
+  if (typeof strapi?.reload === 'function') {
+    strapi.reload();
+  }
+}

package/server/src/register.ts

@@ -0,0 +1,17 @@
+import { registerMcpTools } from './mcp';
+
+/**
+ * register() do plugin: estende o MCP nativo da Strapi registrando as tools
+ * de conteúdo. Precisa rodar antes de o MCP server iniciar (ordem de boot:
+ * register → bootstrap → MCP start).
+ */
+export default ({ strapi }: { strapi: any }) => {
+  // Blindado: a API do MCP nativo ainda evolui entre versões da Strapi. Uma
+  // mudança de assinatura aqui NÃO pode derrubar o boot do plugin (a provisão de
+  // frontend não depende do MCP). Se falhar, só avisamos.
+  try {
+    registerMcpTools(strapi);
+  } catch (e: any) {
+    strapi.log.warn(`[mcp-chat] registro do MCP falhou (seguindo sem ele): ${e?.message ?? e}`);
+  }
+};

package/server/src/routes/index.ts

@@ -0,0 +1,66 @@
+/**
+ * Rotas do plugin (tipo admin: exigem um admin autenticado).
+ * Ficam montadas sob /mcp-chat.
+ */
+
+export default {
+  admin: {
+    type: 'admin',
+    routes: [
+      {
+        method: 'POST',
+        path: '/message',
+        handler: 'chat.message',
+        config: { policies: [] },
+      },
+      {
+        method: 'POST',
+        path: '/stt',
+        handler: 'audio.stt',
+        config: { policies: [] },
+      },
+      {
+        method: 'POST',
+        path: '/tts',
+        handler: 'audio.tts',
+        config: { policies: [] },
+      },
+      {
+        method: 'POST',
+        path: '/frontend/analyze',
+        handler: 'frontend.analyze',
+        config: { policies: [] },
+      },
+      {
+        method: 'POST',
+        path: '/frontend/provision',
+        handler: 'frontend.provision',
+        config: { policies: [] },
+      },
+      {
+        method: 'GET',
+        path: '/frontend/status',
+        handler: 'frontend.status',
+        config: { policies: [] },
+      },
+      {
+        method: 'POST',
+        path: '/frontend/run',
+        handler: 'frontend.run',
+        config: { policies: [] },
+      },
+      {
+        method: 'GET',
+        path: '/frontend/run-status',
+        handler: 'frontend.runStatus',
+        config: { policies: [] },
+      },
+      {
+        method: 'POST',
+        path: '/frontend/integrate',
+        handler: 'frontend.integrate',
+        config: { policies: [] },
+      },
+    ],
+  },
+};

package/server/src/services/audio.ts

@@ -0,0 +1,53 @@
+/**
+ * Serviço de áudio: STT (Whisper) e TTS (OpenAI), via fetch (Node 18+ tem
+ * FormData/Blob/fetch globais).
+ * Usa OPENAI_API_KEY (a mesma chave usada no chat).
+ */
+
+export default ({ strapi }: { strapi: any }) => ({
+  async transcribe(buffer: Buffer, mimetype: string, language?: string) {
+    const key = process.env.OPENAI_API_KEY;
+    if (!key) throw new Error('OPENAI_API_KEY não configurada no .env (necessária p/ áudio).');
+
+    const ext = mimetype.includes('mp4')
+      ? 'mp4'
+      : mimetype.includes('ogg')
+        ? 'ogg'
+        : mimetype.includes('wav')
+          ? 'wav'
+          : 'webm';
+
+    const form = new FormData();
+    form.append('file', new Blob([buffer], { type: mimetype }), `audio.${ext}`);
+    form.append('model', 'whisper-1');
+    // Só aceita um código válido (en|pt). Forçar o idioma ERRADO faz o Whisper
+    // transcrever no idioma errado; em caso de dúvida, deixa em branco para
+    // auto-detecção (confiável para áudios claros).
+    const raw = Array.isArray(language) ? language[0] : language;
+    const lang = raw === 'en' || raw === 'pt' ? raw : undefined;
+    if (lang) form.append('language', lang);
+
+    const res = await fetch('https://api.openai.com/v1/audio/transcriptions', {
+      method: 'POST',
+      headers: { Authorization: `Bearer ${key}` },
+      body: form,
+    });
+    if (!res.ok) throw new Error(`OpenAI STT: ${await res.text()}`);
+    const data: any = await res.json();
+    return { text: data.text as string };
+  },
+
+  async synthesize(text: string, voice = 'echo') {
+    const key = process.env.OPENAI_API_KEY;
+    if (!key) throw new Error('OPENAI_API_KEY não configurada no .env (necessária p/ áudio).');
+
+    const res = await fetch('https://api.openai.com/v1/audio/speech', {
+      method: 'POST',
+      headers: { Authorization: `Bearer ${key}`, 'Content-Type': 'application/json' },
+      body: JSON.stringify({ model: 'tts-1', input: text, voice, response_format: 'mp3' }),
+    });
+    if (!res.ok) throw new Error(`OpenAI TTS: ${await res.text()}`);
+    const buffer = Buffer.from(await res.arrayBuffer());
+    return { audio_base64: buffer.toString('base64'), content_type: 'audio/mpeg' };
+  },
+});