strapi-plugin-mcp-chat 0.1.0

package/server/src/provision/orchestrate.ts

@@ -0,0 +1,236 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { validateManifest, type Manifest } from './manifest';
+import { generateAll } from './generate';
+import { writeApis, requestReload, type WriteResult } from './write';
+export { requestReload };
+import { seedContent, type SeedResult } from './seed';
+import { linkFrontend, type LinkResult } from './link';
+import { grantPublicRead, type PermissionsResult } from './permissions';
+import { adapterForManifest, type LinkContext } from './adapters';
+import { apiUid } from './generate';
+
+/**
+ * Orquestrador da provisão.
+ *
+ * O ponto delicado: depois de gravar os schema.json, a Strapi precisa
+ * REINICIAR para reconhecer os novos content-types — e só DEPOIS dá pra semear
+ * e ligar o preview (que dependem dos types existindo). Como o reload derruba o
+ * contexto atual, dividimos em dois momentos:
+ *
+ *  1. stageProvision()  — valida, grava src/api, escreve um marcador "pendente"
+ *     que sobrevive ao restart e dispara o reload.
+ *  2. runPendingProvision() — roda no bootstrap após o restart: lê o marcador,
+ *     semeia + linka, apaga o marcador. Idempotente (sem marcador = no-op).
+ */
+
+const MARKER_DIR = '.mcp-chat';
+const MARKER_FILE = 'pending-provision.json';
+const DONE_FILE = 'last-provision.json';
+
+interface PendingMarker {
+  manifest: Manifest;
+  frontendDir: string;
+  strapiAppDir: string;
+  context: LinkContext;
+}
+
+/** Resumo da última provisão concluída — lido pela UI para anunciar "preview pronto". */
+export interface ProvisionDone {
+  name: string;
+  framework: string;
+  frontendDir: string;
+  contentTypes: string[];
+  previewUrl: string;
+  seedCreated: { uid: string; count: number }[];
+  linkErrors: string[];
+  finishedAt: string;
+}
+
+function markerPath(strapiAppDir: string): string {
+  return path.join(strapiAppDir, MARKER_DIR, MARKER_FILE);
+}
+
+function donePath(strapiAppDir: string): string {
+  return path.join(strapiAppDir, MARKER_DIR, DONE_FILE);
+}
+
+export interface ProvisionStatus {
+  /** há uma provisão agendada aguardando o pós-restart. */
+  pending: boolean;
+  /** resumo da última provisão concluída (null se nunca houve). */
+  done: ProvisionDone | null;
+}
+
+/** Lido pelo endpoint de status: a UI faz polling disto após o upload. */
+export function getProvisionStatus(strapiAppDir: string): ProvisionStatus {
+  const pending = fs.existsSync(markerPath(strapiAppDir));
+  let done: ProvisionDone | null = null;
+  try {
+    const dp = donePath(strapiAppDir);
+    if (fs.existsSync(dp)) done = JSON.parse(fs.readFileSync(dp, 'utf8'));
+  } catch {
+    /* ignore */
+  }
+  return { pending, done };
+}
+
+export interface StageInput {
+  rawManifest: unknown;
+  /** src/api absoluto. */
+  apiRoot: string;
+  /** pasta do frontend já instalado. */
+  frontendDir: string;
+  /** raiz da app Strapi. */
+  strapiAppDir: string;
+  context: LinkContext;
+  dryRun?: boolean;
+}
+
+export interface StageResult {
+  ok: boolean;
+  validation: { ok: boolean; errors?: string[] };
+  write?: WriteResult;
+  staged: boolean;
+  willReload: boolean;
+  errors: string[];
+}
+
+/** Etapa 1: valida + grava content-types + agenda o pós-restart. */
+export function stageProvision(strapi: any, input: StageInput): StageResult {
+  const result: StageResult = {
+    ok: false,
+    validation: { ok: false },
+    staged: false,
+    willReload: false,
+    errors: [],
+  };
+
+  const v = validateManifest(input.rawManifest);
+  if (!v.ok) {
+    result.validation = { ok: false, errors: v.errors };
+    result.errors.push('manifest inválido');
+    return result;
+  }
+  result.validation = { ok: true };
+
+  const apis = generateAll(v.data);
+  const write = writeApis(apis, { apiRoot: input.apiRoot, dryRun: input.dryRun });
+  result.write = write;
+  if (!write.ok) {
+    result.errors.push(...write.errors);
+    return result;
+  }
+
+  // grava o marcador para o pós-restart (seed + link)
+  const marker: PendingMarker = {
+    manifest: v.data,
+    frontendDir: input.frontendDir,
+    strapiAppDir: input.strapiAppDir,
+    context: input.context,
+  };
+  if (!input.dryRun) {
+    try {
+      const mp = markerPath(input.strapiAppDir);
+      fs.mkdirSync(path.dirname(mp), { recursive: true });
+      fs.writeFileSync(mp, JSON.stringify(marker, null, 2), 'utf8');
+      // limpa o resumo da provisão anterior: a UI faz polling por um NOVO.
+      try {
+        fs.unlinkSync(donePath(input.strapiAppDir));
+      } catch {
+        /* não existia, tudo bem */
+      }
+      result.staged = true;
+    } catch (e: any) {
+      result.errors.push(`marcador: ${e?.message ?? e}`);
+      return result;
+    }
+  }
+
+  result.ok = true;
+  // só recarrega se houve content-type nova escrita (senão nada mudou).
+  // O reload em si é disparado pelo controller DEPOIS de responder ao HTTP,
+  // senão o restart mata a resposta em voo (a UI não saberia que deu certo).
+  result.willReload = !input.dryRun && write.written.length > 0;
+  return result;
+}
+
+export interface RunPendingResult {
+  ran: boolean;
+  seed?: SeedResult;
+  link?: LinkResult;
+  permissions?: PermissionsResult;
+  errors: string[];
+}
+
+/** Etapa 2: roda no bootstrap após o restart. Idempotente. */
+export async function runPendingProvision(
+  strapi: any,
+  strapiAppDir: string
+): Promise<RunPendingResult> {
+  const result: RunPendingResult = { ran: false, errors: [] };
+  const mp = markerPath(strapiAppDir);
+  if (!fs.existsSync(mp)) return result; // nada pendente
+
+  let marker: PendingMarker;
+  try {
+    marker = JSON.parse(fs.readFileSync(mp, 'utf8'));
+  } catch (e: any) {
+    result.errors.push(`marcador ilegível: ${e?.message ?? e}`);
+    return result;
+  }
+
+  result.ran = true;
+  try {
+    result.seed = await seedContent(strapi, marker.manifest);
+  } catch (e: any) {
+    result.errors.push(`seed: ${e?.message ?? e}`);
+  }
+  try {
+    result.permissions = await grantPublicRead(strapi, marker.manifest);
+    if (result.permissions.errors.length) {
+      result.errors.push(...result.permissions.errors.map((e) => `perm: ${e}`));
+    }
+  } catch (e: any) {
+    result.errors.push(`permissões: ${e?.message ?? e}`);
+  }
+  try {
+    result.link = linkFrontend(marker.manifest, {
+      frontendDir: marker.frontendDir,
+      strapiAppDir: marker.strapiAppDir,
+      context: marker.context,
+    });
+  } catch (e: any) {
+    result.errors.push(`link: ${e?.message ?? e}`);
+  }
+
+  // grava o resumo de conclusão para a UI anunciar "preview pronto".
+  try {
+    const adapter = adapterForManifest(marker.manifest);
+    const previewUrl =
+      marker.context.frontendUrl || `http://localhost:${adapter.defaultPort}`;
+    const done: ProvisionDone = {
+      name: marker.manifest.name,
+      framework: marker.manifest.framework,
+      frontendDir: marker.frontendDir,
+      contentTypes: marker.manifest.contentTypes.map((c) => apiUid(c.singularName)),
+      previewUrl,
+      seedCreated: result.seed?.created ?? [],
+      linkErrors: result.link?.errors ?? [],
+      finishedAt: new Date().toISOString(),
+    };
+    const dp = donePath(strapiAppDir);
+    fs.mkdirSync(path.dirname(dp), { recursive: true });
+    fs.writeFileSync(dp, JSON.stringify(done, null, 2), 'utf8');
+  } catch (e: any) {
+    result.errors.push(`resumo: ${e?.message ?? e}`);
+  }
+
+  // remove o marcador para não repetir (idempotência entre restarts)
+  try {
+    fs.unlinkSync(mp);
+  } catch {
+    /* ignore */
+  }
+  return result;
+}

package/server/src/provision/permissions.ts

@@ -0,0 +1,58 @@
+import type { Manifest } from './manifest';
+import { apiUid } from './generate';
+
+/**
+ * Concede leitura pública (find / findOne) ao papel "public" para as content-types
+ * recém-criadas — sem isso o frontend recebe 403 e o preview fica vazio. Faz parte
+ * do "ligar o preview". É idempotente (não duplica permissões já existentes) e
+ * só toca nas content-types do manifest (nunca mexe em outras).
+ *
+ * Single types expõem só `find`; collection types expõem `find` e `findOne`.
+ */
+export interface PermissionsResult {
+  granted: string[];
+  errors: string[];
+}
+
+export async function grantPublicRead(
+  strapi: any,
+  manifest: Manifest
+): Promise<PermissionsResult> {
+  const result: PermissionsResult = { granted: [], errors: [] };
+
+  let publicRole: any;
+  try {
+    publicRole = await strapi
+      .query('plugin::users-permissions.role')
+      .findOne({ where: { type: 'public' } });
+  } catch (e: any) {
+    result.errors.push(`papel public: ${e?.message ?? e}`);
+    return result;
+  }
+  if (!publicRole) {
+    result.errors.push('papel "public" não encontrado (users-permissions ativo?)');
+    return result;
+  }
+
+  for (const ct of manifest.contentTypes) {
+    const uid = apiUid(ct.singularName);
+    const actions = ct.kind === 'singleType' ? ['find'] : ['find', 'findOne'];
+    for (const action of actions) {
+      const actionId = `${uid}.${action}`;
+      try {
+        const existing = await strapi
+          .query('plugin::users-permissions.permission')
+          .findOne({ where: { action: actionId, role: publicRole.id } });
+        if (!existing) {
+          await strapi
+            .query('plugin::users-permissions.permission')
+            .create({ data: { action: actionId, role: publicRole.id } });
+          result.granted.push(actionId);
+        }
+      } catch (e: any) {
+        result.errors.push(`${actionId}: ${e?.message ?? e}`);
+      }
+    }
+  }
+  return result;
+}

package/server/src/provision/runner.ts

@@ -0,0 +1,176 @@
+import { spawn, type ChildProcess } from 'node:child_process';
+import net from 'node:net';
+import fs from 'node:fs';
+import path from 'node:path';
+
+/**
+ * Roda o dev server do frontend provisionado, a pedido da UI (quando o usuário
+ * liga o preview). Detecta o gerenciador de pacotes, instala se preciso e sobe
+ * `dev`, reportando o estado para a UI mostrar o "carregando" até subir.
+ *
+ * ROBUSTEZ DE PORTA/HOST (evita o 426 "Upgrade Required" e iframe em branco):
+ *  - Escolhe uma porta LIVRE em 127.0.0.1 (pula qualquer outro app que já ocupe
+ *    a porta padrão do framework — ex.: outro Vite na 5173).
+ *  - Sobe o dev server fixado em 127.0.0.1 (IPv4 explícito) com a flag de porta
+ *    do framework, e o preview usa EXATAMENTE essa URL — sem depender da
+ *    resolução ambígua de "localhost" (IPv4 vs IPv6).
+ *
+ * Só roda em dev; o controller valida o caminho. O filho morre com a Strapi.
+ */
+
+export type RunState = 'idle' | 'installing' | 'starting' | 'running' | 'error';
+
+export interface RunInfo {
+  state: RunState;
+  dir: string | null;
+  url: string | null;
+  pm: string | null;
+  error: string | null;
+  log: string[];
+}
+
+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;
+
+function detectPM(dir: string): string {
+  if (fs.existsSync(path.join(dir, 'bun.lockb')) || fs.existsSync(path.join(dir, 'bun.lock'))) return 'bun';
+  if (fs.existsSync(path.join(dir, 'pnpm-lock.yaml'))) return 'pnpm';
+  if (fs.existsSync(path.join(dir, 'yarn.lock'))) return 'yarn';
+  return 'npm';
+}
+
+const has = (dir: string, ...names: string[]) => names.some((n) => fs.existsSync(path.join(dir, n)));
+
+/** Detecta o framework pelo arquivo de config, p/ passar a flag de porta certa. */
+function detectFramework(dir: string): 'vite' | 'next' | 'other' {
+  if (has(dir, 'next.config.js', 'next.config.ts', 'next.config.mjs')) return 'next';
+  if (has(dir, 'vite.config.js', 'vite.config.ts', 'vite.config.mjs')) return 'vite';
+  return 'other';
+}
+
+/**
+ * Porta-base do dev server do FRONTEND no preview. Propositalmente longe de:
+ *  - 5173 (Vite do PAINEL ADMIN do próprio Strapi 5 em `strapi develop`),
+ *  - 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;
+
+/** Acha uma porta TCP livre a partir de `start`, testando em 0.0.0.0 (pega
+ *  ocupações em `*:porta` de qualquer interface IPv4). */
+function findFreePort(start: number): Promise<number> {
+  return new Promise((resolve) => {
+    const tryPort = (p: number) => {
+      if (p > start + 200) return resolve(start); // desistência improvável
+      const srv = net.createServer();
+      srv.once('error', () => tryPort(p + 1));
+      srv.once('listening', () => srv.close(() => resolve(p)));
+      srv.listen(p, '0.0.0.0');
+    };
+    tryPort(start);
+  });
+}
+
+function pushLog(s: string) {
+  for (const line of String(s).split('\n')) {
+    const t = line.trim();
+    if (t) info.log.push(t);
+  }
+  if (info.log.length > 60) info.log = info.log.slice(-60);
+}
+
+async function urlUp(url: string): Promise<boolean> {
+  try {
+    const res = await fetch(url, { method: 'GET' });
+    // 2xx/3xx = app de verdade. 426 (Upgrade Required) e 5xx = servidor errado
+    // ou não pronto → NÃO considerar no ar.
+    return res.status >= 200 && res.status < 400;
+  } catch {
+    return false;
+  }
+}
+
+export function getRunStatus(): RunInfo {
+  return { ...info, log: info.log.slice(-15) };
+}
+
+export function stopFrontend(): void {
+  if (pollTimer) { clearInterval(pollTimer); pollTimer = null; }
+  if (child) {
+    try { child.kill('SIGTERM'); } catch { /* ignore */ }
+    child = null;
+  }
+  if (info.state !== 'error') info.state = 'idle';
+}
+
+export async function startFrontend(_strapi: any, opts: { dir: string; url: string }): Promise<RunInfo> {
+  const { dir } = opts;
+
+  // idempotente: já rodando/subindo para o mesmo dir
+  if (child && info.dir === dir && ['installing', 'starting', 'running'].includes(info.state)) {
+    return getRunStatus();
+  }
+  stopFrontend(); // troca de projeto / reinício limpo
+
+  const pm = detectPM(dir);
+  const framework = detectFramework(dir);
+  // porta livre numa faixa dedicada (longe de 5173/3000/1337) — evita colidir
+  // com o Vite do admin do Strapi e outros servidores.
+  const port = await findFreePort(FRONTEND_BASE_PORT);
+  const url = `http://127.0.0.1:${port}`;
+
+  info = { state: 'installing', dir, url, pm, error: null, log: [] };
+
+  const spawnIn = (cmd: string, args: string[]) =>
+    spawn(cmd, args, { cwd: dir, env: { ...process.env }, stdio: ['ignore', 'pipe', 'pipe'] });
+
+  // flags p/ fixar host+porta por framework
+  const fwArgs =
+    framework === 'next'
+      ? ['-H', '127.0.0.1', '-p', String(port)]
+      : framework === 'vite'
+        ? ['--host', '127.0.0.1', '--port', String(port), '--strictPort']
+        : ['--port', String(port)];
+  // yarn repassa args direto; os demais precisam do separador "--"
+  const devArgs = pm === 'yarn' ? ['dev', ...fwArgs] : ['run', 'dev', '--', ...fwArgs];
+
+  const startDev = () => {
+    info.state = 'starting';
+    child = spawnIn(pm, devArgs);
+    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;
+      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.`; }
+    });
+    // confirma que subiu fazendo polling no próprio URL (127.0.0.1:porta)
+    pollTimer = setInterval(async () => {
+      if (await urlUp(url)) {
+        info.state = 'running';
+        if (pollTimer) { clearInterval(pollTimer); pollTimer = null; }
+      }
+    }, 1500);
+  };
+
+  const needInstall = !fs.existsSync(path.join(dir, 'node_modules'));
+  if (needInstall) {
+    pushLog(`Instalando dependências com ${pm}…`);
+    const installArgs = pm === 'npm' ? ['install', '--no-audit', '--no-fund'] : ['install'];
+    const inst = spawnIn(pm, installArgs);
+    inst.stdout?.on('data', (d) => pushLog(d));
+    inst.stderr?.on('data', (d) => pushLog(d));
+    inst.on('exit', (code) => {
+      if (code === 0) startDev();
+      else { info.state = 'error'; info.error = `instalação falhou (código ${code}). Veja o log.`; }
+    });
+  } else {
+    startDev();
+  }
+
+  return getRunStatus();
+}

package/server/src/provision/seed.ts

@@ -0,0 +1,115 @@
+import type { Manifest } from './manifest';
+import { apiUid } from './generate';
+
+/**
+ * Seed: popula o conteúdo declarado em `manifest.seed` usando o Document Service
+ * da Strapi 5 (a API correta no v5 — nada de entityService legado).
+ *
+ * Roda DEPOIS do restart, quando os content-types já existem. Princípios:
+ *  - Idempotente: só semeia se ainda estiver VAZIO. Re-rodar não duplica.
+ *  - Aditivo: nunca apaga nem altera conteúdo existente.
+ *  - Publica por padrão (status 'published') para o frontend já enxergar o
+ *    conteúdo — mas só se o type tiver draftAndPublish; senão cria direto.
+ *  - Cobre collectionType (vários) e singleType (a única entrada).
+ */
+
+export interface SeedResult {
+  ok: boolean;
+  created: { uid: string; count: number }[];
+  skipped: { uid: string; reason: string }[];
+  errors: string[];
+}
+
+export async function seedContent(
+  strapi: any,
+  manifest: Manifest
+): Promise<SeedResult> {
+  const result: SeedResult = {
+    ok: false,
+    created: [],
+    skipped: [],
+    errors: [],
+  };
+
+  if (!manifest.seed?.length) {
+    result.ok = true;
+    return result;
+  }
+
+  // índice singularName -> definição da content-type (para saber kind/D&P)
+  const byName = new Map(
+    manifest.contentTypes.map((ct) => [ct.singularName, ct])
+  );
+
+  for (const group of manifest.seed) {
+    const uid = apiUid(group.singularName);
+    const def = byName.get(group.singularName);
+
+    if (!def) {
+      result.skipped.push({
+        uid,
+        reason: 'singularName não consta em contentTypes',
+      });
+      continue;
+    }
+
+    if (!strapi.contentTypes?.[uid]) {
+      result.skipped.push({
+        uid,
+        reason: 'content-type ainda não registrada (faltou restart?)',
+      });
+      continue;
+    }
+
+    // cria uma entrada e publica (publish() é o passo confiável na 5.47.1;
+    // create({status:'published'}) não publica de fato nesta versão).
+    const createOne = async (data: any) => {
+      const doc = await strapi.documents(uid).create({ data });
+      if (def.draftAndPublish && doc?.documentId) {
+        await strapi.documents(uid).publish({ documentId: doc.documentId });
+      }
+    };
+
+    try {
+      if (def.kind === 'singleType') {
+        // single type: só a primeira entrada; pula se já existir conteúdo.
+        const current = await strapi.documents(uid).findFirst();
+        if (current) {
+          result.skipped.push({ uid, reason: 'single type já tem conteúdo' });
+          continue;
+        }
+        if (group.entries[0]) {
+          await createOne(group.entries[0]);
+          result.created.push({ uid, count: 1 });
+        }
+        continue;
+      }
+
+      // collection: idempotente — só semeia se vazia
+      const existing = await strapi.documents(uid).findMany({ limit: 1 });
+      if (Array.isArray(existing) && existing.length > 0) {
+        result.skipped.push({ uid, reason: 'coleção já tem conteúdo' });
+        continue;
+      }
+      // resiliente: uma entrada ruim não derruba as outras
+      let count = 0;
+      let failed = 0;
+      for (const data of group.entries) {
+        try {
+          await createOne(data);
+          count++;
+        } catch (e: any) {
+          failed++;
+          if (failed === 1) result.errors.push(`seed ${uid} (entrada): ${e?.message ?? e}`);
+        }
+      }
+      result.created.push({ uid, count });
+      if (failed) result.skipped.push({ uid, reason: `${failed} entrada(s) falharam` });
+    } catch (e: any) {
+      result.errors.push(`seed ${uid}: ${e?.message ?? e}`);
+    }
+  }
+
+  result.ok = result.errors.length === 0;
+  return result;
+}