strapi-plugin-mcp-chat 0.1.0

package/server/src/mcp-client.ts

@@ -0,0 +1,96 @@
+/**
+ * Cliente MCP minimalista (HTTP streamable). Por padrão fala com o MCP server
+ * NATIVO da Strapi (endpoint /mcp, requer admin token), mas aceita qualquer URL
+ * e token no construtor — usado também para o Playwright MCP (controle de browser).
+ *
+ * O endpoint responde em formato SSE (linhas "data: {json}"), então fazemos
+ * o parse manual e mantemos o mcp-session-id entre as chamadas.
+ */
+
+const MCP_URL = process.env.MCP_URL || 'http://localhost:1337/mcp';
+
+const baseHeaders = {
+  'Content-Type': 'application/json',
+  Accept: 'application/json, text/event-stream',
+};
+
+const parseSse = (text: string): any => {
+  const dataLines = text
+    .split('\n')
+    .filter((l) => l.startsWith('data:'))
+    .map((l) => l.slice(5).trim())
+    .filter(Boolean);
+  const last = dataLines[dataLines.length - 1];
+  return last ? JSON.parse(last) : null;
+};
+
+export class McpClient {
+  private sessionId?: string;
+  private url: string;
+  private token?: string;
+  /** Nome amigável (aparece nos logs). */
+  readonly name: string;
+
+  /**
+   * @param url   endpoint MCP streamable. Default: o /mcp nativo da Strapi.
+   * @param name  rótulo p/ logs (ex.: 'strapi', 'playwright').
+   * @param token Bearer token (admin token, exigido pelo /mcp nativo).
+   */
+  constructor(url: string = MCP_URL, name = 'strapi', token?: string) {
+    this.url = url;
+    this.name = name;
+    this.token = token;
+  }
+
+  private headers() {
+    const h: Record<string, string> = { ...baseHeaders };
+    if (this.token) h['Authorization'] = `Bearer ${this.token}`;
+    if (this.sessionId) h['mcp-session-id'] = this.sessionId;
+    return h;
+  }
+
+  async init(): Promise<void> {
+    const res = await fetch(this.url, {
+      method: 'POST',
+      headers: this.headers(),
+      body: JSON.stringify({
+        jsonrpc: '2.0',
+        id: 1,
+        method: 'initialize',
+        params: {
+          protocolVersion: '2024-11-05',
+          capabilities: {},
+          clientInfo: { name: 'mcp-chat-plugin', version: '0.1.0' },
+        },
+      }),
+    });
+    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, {
+      method: 'POST',
+      headers: this.headers(),
+      body: JSON.stringify({ jsonrpc: '2.0', method: 'notifications/initialized' }),
+    });
+  }
+
+  private async rpc(method: string, params: any, id: number): Promise<any> {
+    const res = await fetch(this.url, {
+      method: 'POST',
+      headers: this.headers(),
+      body: JSON.stringify({ jsonrpc: '2.0', id, method, params }),
+    });
+    const json = parseSse(await res.text());
+    if (json?.error) throw new Error(json.error.message || 'Erro MCP');
+    return json?.result;
+  }
+
+  async listTools(): Promise<any[]> {
+    const result = await this.rpc('tools/list', {}, 2);
+    return result?.tools || [];
+  }
+
+  async callTool(name: string, args: Record<string, any>): Promise<any> {
+    return this.rpc('tools/call', { name, arguments: args || {} }, 3);
+  }
+}

package/server/src/provision/adapters.ts

@@ -0,0 +1,91 @@
+import type { Framework, Manifest } from './manifest';
+
+/**
+ * Adapters de framework.
+ *
+ * O contrato e o pipeline são idênticos para Next e TanStack; só mudam os
+ * detalhes de cada ecossistema (nome do arquivo .env, prefixo das vars que vão
+ * pro client, porta padrão). Isolar isso aqui é o que permite suportar os dois
+ * sem ifs espalhados pelo código.
+ *
+ * Regra de segurança das env: a URL do Strapi é pública (prefixo do framework),
+ * mas TOKEN e SECRET nunca recebem prefixo público — ficam só no servidor.
+ */
+
+export interface LinkContext {
+  /** URL base do Strapi, ex.: http://localhost:1337 */
+  strapiUrl: string;
+  /** URL base do frontend, ex.: http://localhost:3000 (default = porta do adapter). */
+  frontendUrl?: string;
+  /** API token para o client (opcional; pode ser preenchido depois). */
+  apiToken?: string;
+  /** segredo do preview (draft mode). */
+  previewSecret?: string;
+  /** locales i18n disponíveis (p/ o seletor de idioma do frontend). */
+  locales?: string[];
+}
+
+export interface FrameworkAdapter {
+  framework: Framework;
+  /** arquivo de env que o framework lê. */
+  envFileName: string;
+  /** porta padrão de dev do framework. */
+  defaultPort: number;
+  /** monta as variáveis de ambiente do frontend. */
+  buildEnv(ctx: LinkContext): Record<string, string>;
+  /** dica de onde montar o PreviewBridge (usada na doc/log). */
+  previewBridgeHint: string;
+}
+
+const nextAdapter: FrameworkAdapter = {
+  framework: 'next',
+  envFileName: '.env.local',
+  defaultPort: 3000,
+  buildEnv: ({ strapiUrl, apiToken, previewSecret, locales }) => {
+    const env: Record<string, string> = {
+      // pública: usada por Server e Client Components
+      NEXT_PUBLIC_STRAPI_URL: strapiUrl,
+    };
+    // pública: lista de idiomas p/ o seletor (CSV)
+    if (locales && locales.length) env.NEXT_PUBLIC_LOCALES = locales.join(',');
+    // server-only (sem NEXT_PUBLIC_): nunca vai pro bundle do client
+    if (apiToken) env.STRAPI_API_TOKEN = apiToken;
+    if (previewSecret) env.PREVIEW_SECRET = previewSecret;
+    return env;
+  },
+  previewBridgeHint:
+    'app/_components/PreviewBridge.tsx montado no layout raiz (postMessage para o admin)',
+};
+
+const tanstackAdapter: FrameworkAdapter = {
+  framework: 'tanstack',
+  envFileName: '.env',
+  defaultPort: 5173,
+  buildEnv: ({ strapiUrl, apiToken, previewSecret, locales }) => {
+    const env: Record<string, string> = {
+      // pública no Vite/TanStack: exposta via import.meta.env
+      VITE_STRAPI_URL: strapiUrl,
+    };
+    // pública: lista de idiomas p/ o seletor (CSV)
+    if (locales && locales.length) env.VITE_LOCALES = locales.join(',');
+    // server-only (sem VITE_): só acessível em loaders/server functions
+    if (apiToken) env.STRAPI_API_TOKEN = apiToken;
+    if (previewSecret) env.PREVIEW_SECRET = previewSecret;
+    return env;
+  },
+  previewBridgeHint:
+    'src/components/PreviewBridge.tsx montado no __root (postMessage para o admin)',
+};
+
+const ADAPTERS: Record<Framework, FrameworkAdapter> = {
+  next: nextAdapter,
+  tanstack: tanstackAdapter,
+};
+
+export function getAdapter(framework: Framework): FrameworkAdapter {
+  return ADAPTERS[framework];
+}
+
+export function adapterForManifest(manifest: Manifest): FrameworkAdapter {
+  return getAdapter(manifest.framework);
+}

package/server/src/provision/enable-i18n.ts

@@ -0,0 +1,129 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+/**
+ * Habilita i18n em content-types JÁ existentes, editando o(s) schema.json:
+ * adiciona `pluginOptions.i18n.localized:true` no nível da CT e nos campos
+ * traduzíveis. Necessário para traduzir conteúdo provisionado sem i18n.
+ *
+ * `uid` omitido (ou "*") → habilita em TODAS as content-types de src/api de uma
+ * vez (um único restart). Senão, só na CT indicada.
+ *
+ * Travas (mesma filosofia do writer):
+ *  - DEV-ONLY: só edita em NODE_ENV=development.
+ *  - ADITIVO: apenas ACRESCENTA pluginOptions; nunca remove campos/altera tipos.
+ *  - Não chama strapi.reload(): em dev, gravar o schema dispara o watcher.
+ */
+
+// Campos cujo conteúdo deve passar a variar por locale. Componentes e dynamic
+// zones entram inteiros (o conteúdo textual aninhado segue o atributo de topo).
+const LOCALIZABLE = ['string', 'text', 'richtext', 'component', 'dynamiczone'];
+const isDev = () => process.env.NODE_ENV === 'development';
+
+function schemaPathFor(apiRoot: string, uid: string): string | null {
+  const m = /^api::([^.]+)\.([^.]+)$/.exec(uid);
+  if (!m) return null;
+  const [, api, ct] = m;
+  return path.join(apiRoot, api, 'content-types', ct, 'schema.json');
+}
+
+/** Lista os uids de todas as content-types em src/api (api::<api>.<ct>). */
+function listAllUids(apiRoot: string): string[] {
+  const out: string[] = [];
+  let apis: string[] = [];
+  try {
+    apis = fs.readdirSync(apiRoot);
+  } catch {
+    return out;
+  }
+  for (const api of apis) {
+    const ctDir = path.join(apiRoot, api, 'content-types');
+    if (!fs.existsSync(ctDir)) continue;
+    for (const ct of fs.readdirSync(ctDir)) {
+      if (fs.existsSync(path.join(ctDir, ct, 'schema.json'))) out.push(`api::${api}.${ct}`);
+    }
+  }
+  return out;
+}
+
+const withLocalized = (obj: any) => ({
+  ...(obj || {}),
+  i18n: { ...((obj || {}).i18n || {}), localized: true },
+});
+
+/** Aplica localized:true (CT + campos) em UM schema.json. */
+function patchOne(file: string, campos?: string[]): { campos: string[] } | { erro: string } {
+  if (!fs.existsSync(file)) return { erro: `schema.json não encontrado (${file})` };
+  let schema: any;
+  try {
+    schema = JSON.parse(fs.readFileSync(file, 'utf8'));
+  } catch (e: any) {
+    return { erro: `schema.json ilegível: ${e?.message ?? e}` };
+  }
+  schema.pluginOptions = withLocalized(schema.pluginOptions);
+  const attrs = schema.attributes || {};
+  const alvos =
+    campos && campos.length
+      ? campos
+      : Object.keys(attrs).filter((k) => LOCALIZABLE.includes(attrs[k]?.type));
+  const changed: string[] = [];
+  for (const name of alvos) {
+    if (!attrs[name]) continue;
+    attrs[name].pluginOptions = withLocalized(attrs[name].pluginOptions);
+    changed.push(name);
+  }
+  try {
+    fs.writeFileSync(file, JSON.stringify(schema, null, 2) + '\n', 'utf8');
+  } catch (e: any) {
+    return { erro: `falha ao gravar schema.json: ${e?.message ?? e}` };
+  }
+  return { campos: changed };
+}
+
+export interface EnableI18nResult {
+  ok?: boolean;
+  uid?: string;
+  campos?: string[];
+  /** quando uid é omitido/"*": resumo por content-type. */
+  contentTypes?: { uid: string; campos: string[] }[];
+  total?: number;
+  restart?: boolean;
+  erro?: string;
+}
+
+export function enableI18n(opts: {
+  strapi: any;
+  uid?: string;
+  campos?: string[];
+  allowOutsideDev?: boolean;
+}): EnableI18nResult {
+  const { strapi, uid, campos, allowOutsideDev } = opts;
+  if (!allowOutsideDev && !isDev()) {
+    return { erro: 'habilitar i18n só é permitido em desenvolvimento (NODE_ENV=development).' };
+  }
+  const srcDir = strapi?.dirs?.app?.src || path.join(process.cwd(), 'src');
+  const apiRoot = path.join(srcDir, 'api');
+
+  // TODAS as content-types (uid omitido ou "*") — um único restart.
+  if (!uid || uid === '*') {
+    const uids = listAllUids(apiRoot);
+    if (!uids.length) return { erro: `nenhuma content-type encontrada em ${apiRoot}` };
+    const done: { uid: string; campos: string[] }[] = [];
+    const errors: string[] = [];
+    for (const u of uids) {
+      const file = schemaPathFor(apiRoot, u)!;
+      const r = patchOne(file, campos);
+      if ('erro' in r) errors.push(`${u}: ${r.erro}`);
+      else done.push({ uid: u, campos: r.campos });
+    }
+    if (!done.length) return { erro: `nada habilitado. ${errors.join('; ')}` };
+    return { ok: true, contentTypes: done, total: done.length, restart: true };
+  }
+
+  // Uma content-type específica.
+  const file = schemaPathFor(apiRoot, uid);
+  if (!file) return { erro: `uid inválido: "${uid}" (esperado api::x.x)` };
+  const r = patchOne(file, campos);
+  if ('erro' in r) return { erro: r.erro };
+  return { ok: true, uid, campos: r.campos, restart: true };
+}

package/server/src/provision/generate.ts

@@ -0,0 +1,216 @@
+import type { Manifest, ManifestContentType, ManifestAttribute } from './manifest';
+
+/**
+ * Gerador: manifest -> arquivos que a Strapi 5 espera em src/api/<api>/.
+ *
+ * Funções PURAS, sem efeito colateral: recebem o manifest já validado e
+ * devolvem um mapa { caminho relativo -> conteúdo }. Quem escreve no disco é o
+ * writer (separado), o que torna o gerador 100% testável e o dry-run trivial.
+ *
+ * O formato espelha exatamente o que o Content-Type Builder da Strapi gera
+ * (conferido contra schema.json reais), para nunca produzir um schema que a
+ * Strapi recuse.
+ */
+
+// ---------------------------------------------------------------------------
+// helpers de nome
+// ---------------------------------------------------------------------------
+
+/** Pluralização simples (en/pt). O manifest pode sobrescrever via pluralName. */
+export function toPlural(singular: string): string {
+  if (/[^aeiou]y$/i.test(singular)) return singular.replace(/y$/i, 'ies');
+  if (/(s|x|z|ch|sh)$/i.test(singular)) return `${singular}es`;
+  return `${singular}s`;
+}
+
+/** kebab/hífen -> snake_case (collectionName é snake plural). */
+function toSnake(s: string): string {
+  return s.replace(/-/g, '_');
+}
+
+/** "post-blog" -> "Post Blog" */
+function toTitle(s: string): string {
+  return s
+    .split('-')
+    .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
+    .join(' ');
+}
+
+/** UID Strapi de uma content-type pelo singularName: api::produto.produto */
+export function apiUid(singularName: string): string {
+  return `api::${singularName}.${singularName}`;
+}
+
+// ---------------------------------------------------------------------------
+// atributos
+// ---------------------------------------------------------------------------
+
+/**
+ * pluginOptions.i18n.localized:true para um campo, quando o manifest pediu.
+ * Formato idêntico ao do Content-Type Builder. Relações e uid são localizados
+ * automaticamente pelo i18n, então não recebem este bloco.
+ */
+function i18nField(attr: ManifestAttribute): Record<string, any> {
+  return (attr as any).localized
+    ? { pluginOptions: { i18n: { localized: true } } }
+    : {};
+}
+
+function buildAttribute(attr: ManifestAttribute): Record<string, any> {
+  switch (attr.type) {
+    case 'uid':
+      return clean({
+        type: 'uid',
+        targetField: attr.targetField,
+        required: attr.required,
+      });
+
+    case 'enumeration':
+      return clean({
+        type: 'enumeration',
+        ...i18nField(attr),
+        enum: attr.enum,
+        required: attr.required,
+        unique: attr.unique,
+        private: attr.private,
+        default: attr.default,
+      });
+
+    case 'media':
+      return clean({
+        type: 'media',
+        multiple: attr.multiple ?? false,
+        required: attr.required,
+        allowedTypes: attr.allowedTypes,
+      });
+
+    case 'relation':
+      // Unidirecional de propósito: sem mappedBy/inversedBy. Relações bidirecionais
+      // exigem o campo-par no outro lado e são a causa nº1 de schema quebrado.
+      return {
+        type: 'relation',
+        relation: attr.relation,
+        target: apiUid(attr.target),
+      };
+
+    default:
+      // escalares (string, text, integer, boolean, date, json, ...)
+      return clean({
+        type: attr.type,
+        ...i18nField(attr),
+        required: (attr as any).required,
+        unique: (attr as any).unique,
+        private: (attr as any).private,
+        default: (attr as any).default,
+      });
+  }
+}
+
+/** remove chaves undefined para o JSON ficar limpo como o da Strapi. */
+function clean<T extends Record<string, any>>(obj: T): T {
+  for (const k of Object.keys(obj)) if (obj[k] === undefined) delete obj[k];
+  return obj;
+}
+
+// ---------------------------------------------------------------------------
+// schema.json
+// ---------------------------------------------------------------------------
+
+export function buildSchema(ct: ManifestContentType): Record<string, any> {
+  const pluralName = ct.pluralName ?? toPlural(ct.singularName);
+  const attributes: Record<string, any> = {};
+  for (const [key, attr] of Object.entries(ct.attributes)) {
+    attributes[key] = buildAttribute(attr);
+  }
+  return clean({
+    kind: ct.kind,
+    collectionName: toSnake(pluralName),
+    info: {
+      singularName: ct.singularName,
+      pluralName,
+      displayName: ct.displayName ?? toTitle(ct.singularName),
+      description: ct.description ?? '',
+    },
+    options: {
+      draftAndPublish: ct.draftAndPublish,
+    },
+    // Nível CT é obrigatório p/ o i18n reconhecer a content-type como localizada
+    // (@strapi/i18n: isLocalizedContentType lê pluginOptions.i18n.localized).
+    pluginOptions: (ct as any).localized
+      ? { i18n: { localized: true } }
+      : undefined,
+    attributes,
+  });
+}
+
+// ---------------------------------------------------------------------------
+// arquivos de fábrica (controller / route / service)
+// ---------------------------------------------------------------------------
+
+// O UID é castado para `any` de propósito: no momento em que estes arquivos são
+// gerados e a Strapi reinicia, os tipos gerados (types/generated) ainda podem não
+// conter o novo UID, e o `strapi develop` falharia a compilação TS. O cast desacopla
+// o boot do timing do typegen — "nunca quebra". Em runtime o factory recebe a string
+// normalmente; após o typegen incluir o type, o cast fica inócuo.
+function controllerFile(singular: string): string {
+  return `/**
+ * ${singular} controller
+ */
+import { factories } from '@strapi/strapi';
+
+export default factories.createCoreController('${apiUid(singular)}' as any);
+`;
+}
+
+function routeFile(singular: string): string {
+  return `/**
+ * ${singular} router
+ */
+import { factories } from '@strapi/strapi';
+
+export default factories.createCoreRouter('${apiUid(singular)}' as any);
+`;
+}
+
+function serviceFile(singular: string): string {
+  return `/**
+ * ${singular} service
+ */
+import { factories } from '@strapi/strapi';
+
+export default factories.createCoreService('${apiUid(singular)}' as any);
+`;
+}
+
+// ---------------------------------------------------------------------------
+// saída
+// ---------------------------------------------------------------------------
+
+export interface GeneratedApi {
+  singularName: string;
+  uid: string;
+  /** caminhos relativos a src/api -> conteúdo do arquivo */
+  files: Record<string, string>;
+}
+
+/** Gera os 4 arquivos de uma content-type, com caminhos relativos a src/api. */
+export function generateApi(ct: ManifestContentType): GeneratedApi {
+  const s = ct.singularName;
+  const base = s; // nome da pasta da api = singularName
+  return {
+    singularName: s,
+    uid: apiUid(s),
+    files: {
+      [`${base}/content-types/${s}/schema.json`]:
+        JSON.stringify(buildSchema(ct), null, 2) + '\n',
+      [`${base}/controllers/${s}.ts`]: controllerFile(s),
+      [`${base}/routes/${s}.ts`]: routeFile(s),
+      [`${base}/services/${s}.ts`]: serviceFile(s),
+    },
+  };
+}
+
+/** Gera todas as content-types do manifest. */
+export function generateAll(manifest: Manifest): GeneratedApi[] {
+  return manifest.contentTypes.map(generateApi);
+}