strapi-plugin-mcp-chat 0.3.1 → 0.6.0

package/dist/server/index.js

@@ -36,12 +36,12 @@ module.exports = __toCommonJS(index_exports);
 // server/src/controllers/chat.ts
 var chat_default = ({ strapi }) => ({
   async message(ctx) {
-    const { messages, image, lang, previewUrl, autoPublish } = ctx.request.body || {};
+    const { messages, image, lang, previewUrl, previewStatus, autoPublish } = ctx.request.body || {};
     if (!Array.isArray(messages) || messages.length === 0) {
       return ctx.badRequest('Campo "messages" (array) \xE9 obrigat\xF3rio.');
     }
     try {
-      const result = await strapi.plugin("mcp-chat").service("chat").chat({ messages, image, lang, previewUrl, autoPublish });
+      const result = await strapi.plugin("mcp-chat").service("chat").chat({ messages, image, lang, previewUrl, previewStatus, autoPublish });
       ctx.body = result;
     } catch (e) {
       strapi.log.error(`[mcp-chat] ${e?.message || e}`);
@@ -88,8 +88,8 @@ var import_node_path7 = __toESM(require("node:path"));
 var import_jszip = __toESM(require("jszip"));
 
 // server/src/provision/orchestrate.ts
-var import_node_fs3 = __toESM(require("node:fs"));
-var import_node_path3 = __toESM(require("node:path"));
+var import_node_fs4 = __toESM(require("node:fs"));
+var import_node_path4 = __toESM(require("node:path"));
 
 // server/src/provision/manifest.ts
 var import_utils = require("@strapi/utils");
@@ -412,6 +412,68 @@ var import_node_path = __toESM(require("node:path"));
 function isDev() {
   return process.env.NODE_ENV === "development";
 }
+var KNOWN_ATTR_TYPES = /* @__PURE__ */ new Set([
+  "string",
+  "text",
+  "richtext",
+  "blocks",
+  "email",
+  "password",
+  "uid",
+  "enumeration",
+  "json",
+  "integer",
+  "biginteger",
+  "decimal",
+  "float",
+  "date",
+  "time",
+  "datetime",
+  "timestamp",
+  "boolean",
+  "media",
+  "relation",
+  "component",
+  "dynamiczone"
+]);
+function validateApi(api) {
+  const errs = [];
+  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;
+  try {
+    schema = JSON.parse(api.files[rel]);
+  } catch (e) {
+    errs.push(`${api.singularName}: schema.json n\xE3o \xE9 JSON v\xE1lido (${e?.message ?? e})`);
+    return errs;
+  }
+  if (schema?.kind !== "collectionType" && schema?.kind !== "singleType") {
+    errs.push(`${api.singularName}: "kind" inv\xE1lido (${schema?.kind})`);
+  }
+  if (!schema?.info?.singularName || !schema?.info?.pluralName) {
+    errs.push(`${api.singularName}: info.singularName/pluralName obrigat\xF3rios`);
+  }
+  const attrs = schema?.attributes;
+  if (!attrs || typeof attrs !== "object") {
+    errs.push(`${api.singularName}: "attributes" ausente ou inv\xE1lido`);
+  } else {
+    for (const [name, a] of Object.entries(attrs)) {
+      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;
+}
 function writeApis(apis, opts) {
   const result = {
     ok: false,
@@ -431,6 +493,37 @@ function writeApis(apis, opts) {
     result.errors.push(`apiRoot deve ser um caminho absoluto: ${opts.apiRoot}`);
     return result;
   }
+  const toWrite = apis.filter((api) => !import_node_fs.default.existsSync(import_node_path.default.join(opts.apiRoot, api.singularName)));
+  const knownSingulars = /* @__PURE__ */ new Set([
+    ...apis.map((a) => a.singularName),
+    ...import_node_fs.default.existsSync(opts.apiRoot) ? import_node_fs.default.readdirSync(opts.apiRoot, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name) : []
+  ]);
+  const validationErrors = [];
+  for (const api of toWrite) {
+    validationErrors.push(...validateApi(api));
+    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)) {
+          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 {
+      }
+    }
+  }
+  if (validationErrors.length) {
+    result.errors.push(
+      "Schema gerado inv\xE1lido \u2014 nada foi escrito (provis\xE3o abortada com seguran\xE7a):",
+      ...validationErrors
+    );
+    return result;
+  }
   for (const api of apis) {
     const apiDir = import_node_path.default.join(opts.apiRoot, api.singularName);
     if (import_node_fs.default.existsSync(apiDir)) {
@@ -540,8 +633,8 @@ async function seedContent(strapi, manifest) {
 }
 
 // server/src/provision/link.ts
-var import_node_fs2 = __toESM(require("node:fs"));
-var import_node_path2 = __toESM(require("node:path"));
+var import_node_fs3 = __toESM(require("node:fs"));
+var import_node_path3 = __toESM(require("node:path"));
 
 // server/src/provision/adapters.ts
 var nextAdapter = {
@@ -677,6 +770,179 @@ ${interfaces}
 `;
 }
 
+// server/src/provision/runner.ts
+var import_node_child_process = require("node:child_process");
+var import_node_net = __toESM(require("node:net"));
+var import_node_fs2 = __toESM(require("node:fs"));
+var import_node_path2 = __toESM(require("node:path"));
+var info = { state: "idle", dir: null, url: null, pm: null, error: null, log: [] };
+var child = null;
+var pollTimer = null;
+var appRootForPid = null;
+function pidFilePath(appRoot) {
+  return import_node_path2.default.join(appRoot, ".mcp-chat", "frontend.pid");
+}
+function writePid(pid) {
+  try {
+    if (!appRootForPid) return;
+    const pf = pidFilePath(appRootForPid);
+    import_node_fs2.default.mkdirSync(import_node_path2.default.dirname(pf), { recursive: true });
+    import_node_fs2.default.writeFileSync(pf, String(pid), "utf8");
+  } catch {
+  }
+}
+function clearPid() {
+  try {
+    if (appRootForPid) import_node_fs2.default.unlinkSync(pidFilePath(appRootForPid));
+  } catch {
+  }
+}
+function isAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function cleanupStaleFrontend(appRoot) {
+  appRootForPid = appRoot;
+  try {
+    const pf = pidFilePath(appRoot);
+    if (!import_node_fs2.default.existsSync(pf)) return;
+    const pid = parseInt(import_node_fs2.default.readFileSync(pf, "utf8").trim(), 10);
+    if (pid && isAlive(pid)) {
+      try {
+        process.kill(pid, "SIGTERM");
+      } catch {
+      }
+    }
+    import_node_fs2.default.unlinkSync(pf);
+  } catch {
+  }
+}
+function detectPM(dir) {
+  if (import_node_fs2.default.existsSync(import_node_path2.default.join(dir, "bun.lockb")) || import_node_fs2.default.existsSync(import_node_path2.default.join(dir, "bun.lock"))) return "bun";
+  if (import_node_fs2.default.existsSync(import_node_path2.default.join(dir, "pnpm-lock.yaml"))) return "pnpm";
+  if (import_node_fs2.default.existsSync(import_node_path2.default.join(dir, "yarn.lock"))) return "yarn";
+  return "npm";
+}
+var has = (dir, ...names) => names.some((n) => import_node_fs2.default.existsSync(import_node_path2.default.join(dir, n)));
+function detectFramework(dir) {
+  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";
+}
+var FRONTEND_BASE_PORT = 4321;
+function findFreePort(start) {
+  return new Promise((resolve) => {
+    const tryPort = (p) => {
+      if (p > start + 200) return resolve(start);
+      const srv = import_node_net.default.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) {
+  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) {
+  try {
+    const res = await fetch(url, { method: "GET" });
+    return res.status >= 200 && res.status < 400;
+  } catch {
+    return false;
+  }
+}
+function getRunStatus() {
+  return { ...info, log: info.log.slice(-15) };
+}
+function stopFrontend() {
+  if (pollTimer) {
+    clearInterval(pollTimer);
+    pollTimer = null;
+  }
+  if (child) {
+    try {
+      child.kill("SIGTERM");
+    } catch {
+    }
+    child = null;
+  }
+  clearPid();
+  if (info.state !== "error") info.state = "idle";
+}
+async function startFrontend(_strapi, opts) {
+  const { dir } = opts;
+  if (_strapi?.dirs?.app?.root) appRootForPid = _strapi.dirs.app.root;
+  if (child && info.dir === dir && ["installing", "starting", "running"].includes(info.state)) {
+    return getRunStatus();
+  }
+  stopFrontend();
+  const pm = detectPM(dir);
+  const framework = detectFramework(dir);
+  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, args) => (0, import_node_child_process.spawn)(cmd, args, { cwd: dir, env: { ...process.env }, stdio: ["ignore", "pipe", "pipe"] });
+  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)];
+  const devArgs = pm === "yarn" ? ["dev", ...fwArgs] : ["run", "dev", "--", ...fwArgs];
+  const startDev = () => {
+    info.state = "starting";
+    child = spawnIn(pm, devArgs);
+    if (child.pid) writePid(child.pid);
+    child.stdout?.on("data", (d) => pushLog(d));
+    child.stderr?.on("data", (d) => pushLog(d));
+    child.on("exit", (code) => {
+      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\xF3digo ${code}). Veja o log.`;
+      }
+    });
+    pollTimer = setInterval(async () => {
+      if (await urlUp(url)) {
+        info.state = "running";
+        if (pollTimer) {
+          clearInterval(pollTimer);
+          pollTimer = null;
+        }
+      }
+    }, 1500);
+  };
+  const needInstall = !import_node_fs2.default.existsSync(import_node_path2.default.join(dir, "node_modules"));
+  if (needInstall) {
+    pushLog(`Instalando depend\xEAncias com ${pm}\u2026`);
+    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\xE7\xE3o falhou (c\xF3digo ${code}). Veja o log.`;
+      }
+    });
+  } else {
+    startDev();
+  }
+  return getRunStatus();
+}
+
 // server/src/provision/link.ts
 function parseEnv(content) {
   const out = {};
@@ -706,48 +972,120 @@ function mergeEnv(existing, next) {
   }
   return { content, added, preserved };
 }
-function buildPreviewConfig(manifest) {
+var PREVIEW_MARKER = "mcp-chat:preview-merged";
+var PREVIEW_MODULE = "mcp-chat-preview";
+function buildPreviewConfig(manifest, framework = manifest.framework) {
   const routes = {};
   for (const ct of manifest.contentTypes) {
-    if (ct.preview?.route) routes[apiUid(ct.singularName)] = ct.preview.route;
+    routes[apiUid(ct.singularName)] = ct.preview?.route ?? "/";
   }
   const routesJson = JSON.stringify(routes, null, 2);
-  return `// Preview gerado pelo mcp-chat a partir do strapi.manifest.json.
+  const isNext = framework === "next";
+  const urlBranch = isNext ? `        // Next.js: rota de draft mode que seta o cookie e redireciona p/ \`path\`.
+        const qs = new URLSearchParams({ secret, status: status ?? 'draft', path: pathname });
+        return \`\${clientUrl}/api/preview?\${qs.toString()}\`;` : `        // SPA (Vite/TanStack): abre a p\xE1gina direta; o front l\xEA ?preview/status.
+        const qs = new URLSearchParams({ preview: '1', status: status ?? 'draft', secret });
+        return \`\${clientUrl}\${pathname}?\${qs.toString()}\`;`;
+  return `// Preview gerado pelo mcp-chat a partir do strapi.manifest.json (framework: ${framework}).
 // Mapa uid -> rota do frontend (placeholders :campo s\xE3o preenchidos pelo doc).
+// Este arquivo \xE9 mesclado em config/admin.ts \u2014 n\xE3o precisa edit\xE1-lo \xE0 m\xE3o.
 const PREVIEW_ROUTES: Record<string, string> = ${routesJson};
 
-export default ({ env }) => ({
-  auth: {
-    secret: env('ADMIN_JWT_SECRET'),
-  },
-  apiToken: { salt: env('API_TOKEN_SALT') },
-  transfer: { token: { salt: env('TRANSFER_TOKEN_SALT') } },
+export default ({ env }: { env: any }) => ({
   preview: {
     enabled: true,
     config: {
       allowedOrigins: [env('CLIENT_URL', 'http://localhost:3000')],
       async handler(uid: string, { documentId, locale, status }: any) {
-        const route = PREVIEW_ROUTES[uid];
-        if (!route) return null;
-        const doc = await strapi.documents(uid as any).findOne({ documentId, locale });
-        if (!doc) return null;
-        // substitui :campo pelos valores do documento (ex.: :slug)
-        const pathname = route.replace(/:([a-zA-Z0-9_]+)/g, (_m, f) =>
-          encodeURIComponent(String((doc as any)[f] ?? ''))
-        );
+        const route = PREVIEW_ROUTES[uid] ?? '/';
         const clientUrl = env('CLIENT_URL', 'http://localhost:3000');
         const secret = env('PREVIEW_SECRET', '');
-        const qs = new URLSearchParams({ secret, status: status ?? 'draft', path: pathname });
-        return \`\${clientUrl}/api/preview?\${qs.toString()}\`;
+
+        // s\xF3 busca o doc se a rota tiver placeholders (ex.: :slug) a preencher.
+        let pathname = route;
+        if (pathname.includes(':')) {
+          const doc = await strapi.documents(uid as any).findOne({ documentId, locale });
+          if (!doc) return null;
+          pathname = pathname.replace(/:([a-zA-Z0-9_]+)/g, (_m, f) =>
+            encodeURIComponent(String((doc as any)[f] ?? ''))
+          );
+        }
+
+${urlBranch}
       },
     },
   },
 });
 `;
 }
+function buildStandaloneAdmin() {
+  return `// ${PREVIEW_MARKER} \u2014 admin.ts gerado pelo mcp-chat (preview inclu\xEDdo).
+import previewConfig from './${PREVIEW_MODULE}';
+
+export default ({ env }: { env: any }) => ({
+  auth: { secret: env('ADMIN_JWT_SECRET') },
+  apiToken: { salt: env('API_TOKEN_SALT') },
+  transfer: { token: { salt: env('TRANSFER_TOKEN_SALT') } },
+  secrets: { encryptionKey: env('ENCRYPTION_KEY') },
+  flags: {
+    nps: env.bool('FLAG_NPS', true),
+    promoteEE: env.bool('FLAG_PROMOTE_EE', true),
+  },
+  ...previewConfig({ env }),
+});
+`;
+}
+function buildAdminWrapper() {
+  return `// ${PREVIEW_MARKER} \u2014 preview do mcp-chat mesclado sobre o admin original.
+// Sua config original est\xE1 preservada em ./admin.base \u2014 edite l\xE1, n\xE3o aqui.
+import base from './admin.base';
+import previewConfig from './${PREVIEW_MODULE}';
+
+export default (ctx: any) => {
+  const b = typeof base === 'function' ? (base as any)(ctx) : (base ?? {});
+  return { ...b, ...previewConfig(ctx) };
+};
+`;
+}
+var CSP_MARKER = "mcp-chat:csp-frame";
+function securityBlock() {
+  return `  // ${CSP_MARKER} \u2014 libera o frame-src p/ o admin embutir o preview do frontend
+  // (dev server local em qualquer porta). Sem isto a CSP padr\xE3o (default-src 'self')
+  // bloqueia o iframe e o preview fica em branco.
+  {
+    name: 'strapi::security',
+    config: {
+      contentSecurityPolicy: {
+        useDefaults: true,
+        directives: {
+          'connect-src': ["'self'", 'https:', 'http:'],
+          'frame-src': ["'self'", 'http://localhost:*', 'http://127.0.0.1:*'],
+          'img-src': ["'self'", 'data:', 'blob:', 'market-assets.strapi.io'],
+          'media-src': ["'self'", 'data:', 'blob:'],
+          upgradeInsecureRequests: null,
+        },
+      },
+    },
+  },`;
+}
+function patchSecurityMiddleware(strapiAppDir, dryRun) {
+  const configDir = import_node_path3.default.join(strapiAppDir, "config");
+  const file = ["middlewares.ts", "middlewares.js"].find(
+    (f) => import_node_fs3.default.existsSync(import_node_path3.default.join(configDir, f))
+  );
+  if (!file) return "skipped";
+  const p = import_node_path3.default.join(configDir, file);
+  const content = import_node_fs3.default.readFileSync(p, "utf8");
+  if (content.includes(CSP_MARKER) || content.includes("'frame-src'")) return "already";
+  const m = content.match(/^[ \t]*['"]strapi::security['"]\s*,/m);
+  if (!m) return "manual";
+  const next = content.replace(m[0], securityBlock());
+  if (!dryRun) import_node_fs3.default.writeFileSync(p, next, "utf8");
+  return "patched";
+}
 function ensureInside(base, target) {
-  const n = import_node_path2.default.normalize(target);
-  return n === base || n.startsWith(base + import_node_path2.default.sep);
+  const n = import_node_path3.default.normalize(target);
+  return n === base || n.startsWith(base + import_node_path3.default.sep);
 }
 function linkFrontend(manifest, opts) {
   const adapter = adapterForManifest(manifest);
@@ -759,49 +1097,90 @@ function linkFrontend(manifest, opts) {
     typesFile: "strapi-types.ts",
     previewFile: "config/admin.ts",
     previewAction: "skipped",
+    backendEnvAdded: [],
+    cspAction: "skipped",
     errors: []
   };
-  if (!import_node_path2.default.isAbsolute(opts.frontendDir) || !import_node_path2.default.isAbsolute(opts.strapiAppDir)) {
+  if (!import_node_path3.default.isAbsolute(opts.frontendDir) || !import_node_path3.default.isAbsolute(opts.strapiAppDir)) {
     result.errors.push("frontendDir e strapiAppDir devem ser absolutos");
     return result;
   }
   try {
-    const envPath = import_node_path2.default.join(opts.frontendDir, adapter.envFileName);
+    const envPath = import_node_path3.default.join(opts.frontendDir, adapter.envFileName);
     if (!ensureInside(opts.frontendDir, envPath)) throw new Error("env fora do frontendDir");
-    const existing = import_node_fs2.default.existsSync(envPath) ? import_node_fs2.default.readFileSync(envPath, "utf8") : "";
+    const existing = import_node_fs3.default.existsSync(envPath) ? import_node_fs3.default.readFileSync(envPath, "utf8") : "";
     const vars = adapter.buildEnv(opts.context);
     const { content, added, preserved } = mergeEnv(existing, vars);
     result.envAdded = added;
     result.envPreserved = preserved;
-    if (!opts.dryRun && added.length) import_node_fs2.default.writeFileSync(envPath, content, "utf8");
+    if (!opts.dryRun && added.length) import_node_fs3.default.writeFileSync(envPath, content, "utf8");
   } catch (e) {
     result.errors.push(`env: ${e?.message ?? e}`);
   }
   try {
-    const typesPath = import_node_path2.default.join(opts.frontendDir, result.typesFile);
+    const typesPath = import_node_path3.default.join(opts.frontendDir, result.typesFile);
     if (!ensureInside(opts.frontendDir, typesPath)) throw new Error("types fora do frontendDir");
-    if (!opts.dryRun) import_node_fs2.default.writeFileSync(typesPath, generateTypes(manifest), "utf8");
+    if (!opts.dryRun) import_node_fs3.default.writeFileSync(typesPath, generateTypes(manifest), "utf8");
   } catch (e) {
     result.errors.push(`types: ${e?.message ?? e}`);
   }
   try {
-    const adminPath = import_node_path2.default.join(opts.strapiAppDir, "config", "admin.ts");
-    const content = buildPreviewConfig(manifest);
-    if (import_node_fs2.default.existsSync(adminPath)) {
-      result.previewFile = "config/admin.mcp-chat-preview.ts";
-      const sidecar = import_node_path2.default.join(opts.strapiAppDir, "config", "admin.mcp-chat-preview.ts");
-      if (!opts.dryRun) import_node_fs2.default.writeFileSync(sidecar, content, "utf8");
-      result.previewAction = "sidecar";
-    } else {
-      if (!opts.dryRun) {
-        import_node_fs2.default.mkdirSync(import_node_path2.default.dirname(adminPath), { recursive: true });
-        import_node_fs2.default.writeFileSync(adminPath, content, "utf8");
+    const configDir = import_node_path3.default.join(opts.strapiAppDir, "config");
+    if (!ensureInside(opts.strapiAppDir, configDir)) throw new Error("config fora do strapiAppDir");
+    const adminPath = import_node_path3.default.join(configDir, "admin.ts");
+    const adminBasePath = import_node_path3.default.join(configDir, "admin.base.ts");
+    const modulePath = import_node_path3.default.join(configDir, `${PREVIEW_MODULE}.ts`);
+    if (!opts.dryRun) {
+      import_node_fs3.default.mkdirSync(configDir, { recursive: true });
+      import_node_fs3.default.writeFileSync(modulePath, buildPreviewConfig(manifest, adapter.framework), "utf8");
+      try {
+        import_node_fs3.default.unlinkSync(import_node_path3.default.join(configDir, "admin.mcp-chat-preview.ts"));
+      } catch {
       }
+    }
+    result.previewFile = `config/${PREVIEW_MODULE}.ts`;
+    if (!import_node_fs3.default.existsSync(adminPath)) {
+      if (!opts.dryRun) import_node_fs3.default.writeFileSync(adminPath, buildStandaloneAdmin(), "utf8");
       result.previewAction = "created";
+    } else {
+      const adminContent = import_node_fs3.default.readFileSync(adminPath, "utf8");
+      if (!adminContent.includes(PREVIEW_MARKER)) {
+        if (!opts.dryRun) {
+          if (!import_node_fs3.default.existsSync(adminBasePath)) {
+            import_node_fs3.default.writeFileSync(adminBasePath, adminContent, "utf8");
+          }
+          import_node_fs3.default.writeFileSync(adminPath, buildAdminWrapper(), "utf8");
+        }
+      }
+      result.previewAction = "merged";
     }
   } catch (e) {
     result.errors.push(`preview: ${e?.message ?? e}`);
   }
+  try {
+    const clientUrl = opts.context.frontendUrl || `http://localhost:${FRONTEND_BASE_PORT}`;
+    const backendVars = { CLIENT_URL: clientUrl };
+    if (opts.context.previewSecret) backendVars.PREVIEW_SECRET = opts.context.previewSecret;
+    const backendEnvPath = import_node_path3.default.join(opts.strapiAppDir, ".env");
+    if (ensureInside(opts.strapiAppDir, backendEnvPath)) {
+      const existing = import_node_fs3.default.existsSync(backendEnvPath) ? import_node_fs3.default.readFileSync(backendEnvPath, "utf8") : "";
+      const { content, added } = mergeEnv(existing, backendVars);
+      result.backendEnvAdded = added;
+      if (!opts.dryRun && added.length) import_node_fs3.default.writeFileSync(backendEnvPath, content, "utf8");
+    }
+  } catch (e) {
+    result.errors.push(`backend env: ${e?.message ?? e}`);
+  }
+  try {
+    result.cspAction = patchSecurityMiddleware(opts.strapiAppDir, opts.dryRun);
+    if (result.cspAction === "manual") {
+      result.errors.push(
+        "CSP: config/middlewares j\xE1 tem strapi::security customizado \u2014 adicione manualmente frame-src 'self' http://localhost:* http://127.0.0.1:* para o preview embutir o frontend."
+      );
+    }
+  } catch (e) {
+    result.errors.push(`csp: ${e?.message ?? e}`);
+  }
   result.ok = result.errors.length === 0;
   return result;
 }
@@ -844,17 +1223,17 @@ var MARKER_DIR = ".mcp-chat";
 var MARKER_FILE = "pending-provision.json";
 var DONE_FILE = "last-provision.json";
 function markerPath(strapiAppDir) {
-  return import_node_path3.default.join(strapiAppDir, MARKER_DIR, MARKER_FILE);
+  return import_node_path4.default.join(strapiAppDir, MARKER_DIR, MARKER_FILE);
 }
 function donePath(strapiAppDir) {
-  return import_node_path3.default.join(strapiAppDir, MARKER_DIR, DONE_FILE);
+  return import_node_path4.default.join(strapiAppDir, MARKER_DIR, DONE_FILE);
 }
 function getProvisionStatus(strapiAppDir) {
-  const pending = import_node_fs3.default.existsSync(markerPath(strapiAppDir));
+  const pending = import_node_fs4.default.existsSync(markerPath(strapiAppDir));
   let done = null;
   try {
     const dp = donePath(strapiAppDir);
-    if (import_node_fs3.default.existsSync(dp)) done = JSON.parse(import_node_fs3.default.readFileSync(dp, "utf8"));
+    if (import_node_fs4.default.existsSync(dp)) done = JSON.parse(import_node_fs4.default.readFileSync(dp, "utf8"));
   } catch {
   }
   return { pending, done };
@@ -890,10 +1269,10 @@ function stageProvision(strapi, input) {
   if (!input.dryRun) {
     try {
       const mp = markerPath(input.strapiAppDir);
-      import_node_fs3.default.mkdirSync(import_node_path3.default.dirname(mp), { recursive: true });
-      import_node_fs3.default.writeFileSync(mp, JSON.stringify(marker, null, 2), "utf8");
+      import_node_fs4.default.mkdirSync(import_node_path4.default.dirname(mp), { recursive: true });
+      import_node_fs4.default.writeFileSync(mp, JSON.stringify(marker, null, 2), "utf8");
       try {
-        import_node_fs3.default.unlinkSync(donePath(input.strapiAppDir));
+        import_node_fs4.default.unlinkSync(donePath(input.strapiAppDir));
       } catch {
       }
       result.staged = true;
@@ -909,10 +1288,10 @@ function stageProvision(strapi, input) {
 async function runPendingProvision(strapi, strapiAppDir) {
   const result = { ran: false, errors: [] };
   const mp = markerPath(strapiAppDir);
-  if (!import_node_fs3.default.existsSync(mp)) return result;
+  if (!import_node_fs4.default.existsSync(mp)) return result;
   let marker;
   try {
-    marker = JSON.parse(import_node_fs3.default.readFileSync(mp, "utf8"));
+    marker = JSON.parse(import_node_fs4.default.readFileSync(mp, "utf8"));
   } catch (e) {
     result.errors.push(`marcador ileg\xEDvel: ${e?.message ?? e}`);
     return result;
@@ -941,8 +1320,7 @@ async function runPendingProvision(strapi, strapiAppDir) {
     result.errors.push(`link: ${e?.message ?? e}`);
   }
   try {
-    const adapter = adapterForManifest(marker.manifest);
-    const previewUrl = marker.context.frontendUrl || `http://localhost:${adapter.defaultPort}`;
+    const previewUrl = marker.context.frontendUrl || `http://localhost:${FRONTEND_BASE_PORT}`;
     const done = {
       name: marker.manifest.name,
       framework: marker.manifest.framework,
@@ -954,21 +1332,21 @@ async function runPendingProvision(strapi, strapiAppDir) {
       finishedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
     const dp = donePath(strapiAppDir);
-    import_node_fs3.default.mkdirSync(import_node_path3.default.dirname(dp), { recursive: true });
-    import_node_fs3.default.writeFileSync(dp, JSON.stringify(done, null, 2), "utf8");
+    import_node_fs4.default.mkdirSync(import_node_path4.default.dirname(dp), { recursive: true });
+    import_node_fs4.default.writeFileSync(dp, JSON.stringify(done, null, 2), "utf8");
   } catch (e) {
     result.errors.push(`resumo: ${e?.message ?? e}`);
   }
   try {
-    import_node_fs3.default.unlinkSync(mp);
+    import_node_fs4.default.unlinkSync(mp);
   } catch {
   }
   return result;
 }
 
 // server/src/provision/infer.ts
-var import_node_fs4 = __toESM(require("node:fs"));
-var import_node_path4 = __toESM(require("node:path"));
+var import_node_fs5 = __toESM(require("node:fs"));
+var import_node_path5 = __toESM(require("node:path"));
 var OPENAI_URL = "https://api.openai.com/v1/chat/completions";
 var MODEL = process.env.OPENAI_CHAT_MODEL || "gpt-4o";
 var SKIP_DIRS = /* @__PURE__ */ new Set([
@@ -1001,38 +1379,53 @@ function score(rel) {
 function walk(dir, base, out) {
   let entries;
   try {
-    entries = import_node_fs4.default.readdirSync(dir, { withFileTypes: true });
+    entries = import_node_fs5.default.readdirSync(dir, { withFileTypes: true });
   } catch {
     return;
   }
   for (const e of entries) {
     if (e.name.startsWith(".") && e.name !== ".") continue;
-    const full = import_node_path4.default.join(dir, e.name);
+    const full = import_node_path5.default.join(dir, e.name);
     if (e.isDirectory()) {
       if (SKIP_DIRS.has(e.name)) continue;
       walk(full, base, out);
-    } else if (CODE_EXT.has(import_node_path4.default.extname(e.name))) {
-      out.push(import_node_path4.default.relative(base, full));
+    } else if (CODE_EXT.has(import_node_path5.default.extname(e.name))) {
+      out.push(import_node_path5.default.relative(base, full));
     }
   }
 }
+function hasInlineDataArray(content) {
+  return /(?:export\s+)?const\s+\w+\s*(?::[^=\n]+)?=\s*\[\s*\{/.test(content);
+}
 function collectFiles(frontendDir) {
   const all = [];
   walk(frontendDir, frontendDir, all);
   const tree = all.slice().sort();
-  const ranked = all.map((rel) => ({ rel, s: score(rel) })).filter((x) => x.s > 0).sort((a, b) => b.s - a.s);
-  const files = [];
-  let total = 0;
-  for (const { rel } of ranked) {
-    if (files.length >= MAX_FILES || total >= MAX_TOTAL_CHARS) break;
+  const scored = [];
+  for (const rel of all) {
+    let content;
     try {
-      let content = import_node_fs4.default.readFileSync(import_node_path4.default.join(frontendDir, rel), "utf8");
-      if (!/export\s+(const|default|type|interface)/.test(content)) continue;
-      if (content.length > MAX_FILE_CHARS) content = content.slice(0, MAX_FILE_CHARS) + "\n/* \u2026truncado\u2026 */";
-      files.push({ rel, content });
-      total += content.length;
+      content = import_node_fs5.default.readFileSync(import_node_path5.default.join(frontendDir, rel), "utf8");
     } catch {
+      continue;
     }
+    const dataArray = hasInlineDataArray(content);
+    const hasExport = /export\s+(const|default|type|interface)/.test(content);
+    if (!hasExport && !dataArray) continue;
+    let s = score(rel);
+    if (dataArray) s += 8;
+    if (s <= 0) continue;
+    scored.push({ rel, content, s });
+  }
+  scored.sort((a, b) => b.s - a.s);
+  const files = [];
+  let total = 0;
+  for (const it of scored) {
+    if (files.length >= MAX_FILES || total >= MAX_TOTAL_CHARS) break;
+    let content = it.content;
+    if (content.length > MAX_FILE_CHARS) content = content.slice(0, MAX_FILE_CHARS) + "\n/* \u2026truncado\u2026 */";
+    files.push({ rel: it.rel, content });
+    total += content.length;
   }
   return { files, tree };
 }
@@ -1067,7 +1460,7 @@ function collectPageTexts(frontendDir) {
   for (const rel of ranked) {
     if (out.length >= MAX_TEXT_FILES) break;
     try {
-      const texts = extractTexts(import_node_fs4.default.readFileSync(import_node_path4.default.join(frontendDir, rel), "utf8"));
+      const texts = extractTexts(import_node_fs5.default.readFileSync(import_node_path5.default.join(frontendDir, rel), "utf8"));
       if (texts.length) out.push({ rel, texts });
     } catch {
     }
@@ -1155,9 +1548,9 @@ function buildPageContentTypes(pageTexts, budget) {
   }
   return { contentTypes, seed };
 }
-function detectFramework(frontendDir) {
+function detectFramework2(frontendDir) {
   try {
-    const pkg = JSON.parse(import_node_fs4.default.readFileSync(import_node_path4.default.join(frontendDir, "package.json"), "utf8"));
+    const pkg = JSON.parse(import_node_fs5.default.readFileSync(import_node_path5.default.join(frontendDir, "package.json"), "utf8"));
     const deps = { ...pkg.dependencies || {}, ...pkg.devDependencies || {} };
     if (deps.next) return "next";
     if (deps["@tanstack/react-start"]) return "tanstack";
@@ -1201,13 +1594,15 @@ Gere um JSON "strapi.manifest.json" com ESTE formato:
 
 REGRAS:
 - Crie uma content-type para cada COLE\xC7\xC3O de dados (arrays de objetos). Use os MESMOS nomes de campo do c\xF3digo.
+- IMPORTANTE: muitos frontends guardam os dados em arrays declarados INLINE dentro de componentes (.tsx/.jsx), ex.: \`const services = [{ name, price, desc }]\`, \`const reviews = [...]\`, \`const hours = [...]\`. TRATE esses arrays como cole\xE7\xF5es e modele cada um como um collectionType, mesmo que estejam dentro de um componente de UI.
+- Ao modelar um array desses, inclua SOMENTE os campos que s\xE3o dados/texto (ex.: name, price, desc, label, href, value). IGNORE props que s\xE3o c\xF3digo/apresenta\xE7\xE3o: componentes de \xEDcone (ex.: \`icon: Scissors\`), elementos React, fun\xE7\xF5es, classes CSS, imports de imagem.
 - Dados de "configura\xE7\xE3o do site" (objeto \xFAnico: nome, telefone, etc.) \u2192 singleType.
 - Campos string longos/descri\xE7\xF5es \u2192 "text" ou "richtext". Listas de strings \u2192 "json".
 - Use "date"/"datetime" SOMENTE para datas ISO completas (YYYY-MM-DD). Datas parciais como "2025-04" ou textos livres \u2192 use "string" (sen\xE3o o seed falha).
 - Imagens (imports de assets ou caminhos) \u2192 "media" (N\xC3O coloque o valor da imagem no seed; omita o campo no seed).
-- Em "seed", extraia o conte\xFAdo REAL hardcoded no c\xF3digo, omitindo campos de m\xEDdia e rela\xE7\xF5es.
+- Em "seed", copie o conte\xFAdo REAL hardcoded no c\xF3digo, VERBATIM (exatamente como est\xE1, sem reescrever, traduzir ou inventar), omitindo campos de m\xEDdia e rela\xE7\xF5es. Todo valor de seed TEM que existir literalmente no c\xF3digo fornecido.
 - Foque APENAS em cole\xE7\xF5es/objetos de dados \u2014 N\xC3O precisa modelar textos soltos de UI (isso \xE9 tratado \xE0 parte).
-- N\xC3O invente. singularName kebab-case, sem repetir. Rela\xE7\xF5es s\xF3 apontam para types definidos por voc\xEA.
+- N\xC3O invente NADA. Se n\xE3o tiver certeza de um valor, omita-o. singularName kebab-case, sem repetir. Rela\xE7\xF5es s\xF3 apontam para types definidos por voc\xEA.
 - Se n\xE3o houver cole\xE7\xF5es de dados, devolva contentTypes: [] e seed: [].
 - Responda APENAS com o JSON, nada de markdown.
 
@@ -1218,7 +1613,7 @@ Arquivos de dados (cole\xE7\xF5es):
 ${filesBlock}`;
 }
 async function inferManifest(strapi, frontendDir, opts) {
-  const framework = detectFramework(frontendDir);
+  const framework = detectFramework2(frontendDir);
   const result = {
     ok: false,
     inferred: true,
@@ -1227,10 +1622,10 @@ async function inferManifest(strapi, frontendDir, opts) {
     warnings: [],
     errors: []
   };
-  const existing = import_node_path4.default.join(frontendDir, "strapi.manifest.json");
-  if (import_node_fs4.default.existsSync(existing)) {
+  const existing = import_node_path5.default.join(frontendDir, "strapi.manifest.json");
+  if (import_node_fs5.default.existsSync(existing)) {
     try {
-      const raw = JSON.parse(import_node_fs4.default.readFileSync(existing, "utf8"));
+      const raw = JSON.parse(import_node_fs5.default.readFileSync(existing, "utf8"));
       const v2 = validateManifest(raw);
       result.inferred = false;
       result.rawManifest = raw;
@@ -1313,6 +1708,48 @@ async function inferManifest(strapi, frontendDir, opts) {
   } else if (!apiKey) {
     result.warnings.push("Sem OPENAI_API_KEY: modelando os TEXTOS (determin\xEDstico); cole\xE7\xF5es de dados n\xE3o inferidas.");
   }
+  if (dataCts.length && dataSeed.length) {
+    const parts = [];
+    for (const f of collected.files) {
+      try {
+        parts.push(import_node_fs5.default.readFileSync(import_node_path5.default.join(frontendDir, f.rel), "utf8"));
+      } catch {
+        parts.push(f.content);
+      }
+    }
+    const norm = (x) => String(x).toLowerCase().replace(/[^a-z0-9]+/g, "");
+    const hay = norm(parts.join("\n"));
+    const present = (v2) => {
+      if (typeof v2 !== "string") return false;
+      const n = norm(v2);
+      return n.length >= 4 && hay.includes(n);
+    };
+    const keep = /* @__PURE__ */ new Set();
+    const verifiedSeed = [];
+    let droppedEntries = 0;
+    for (const grp of dataSeed) {
+      const entries = (grp.entries ?? []).filter((e) => {
+        const ok = Object.values(e).some(present);
+        if (!ok) droppedEntries++;
+        return ok;
+      });
+      if (entries.length) {
+        verifiedSeed.push({ ...grp, entries });
+        keep.add(grp.singularName);
+      }
+    }
+    const verifiedCts = dataCts.filter(
+      (ct) => ct.kind === "singleType" || keep.has(ct.singularName)
+    );
+    const droppedCts = dataCts.length - verifiedCts.length;
+    if (droppedEntries || droppedCts) {
+      result.warnings.push(
+        `Anti-alucina\xE7\xE3o: descartei ${droppedEntries} entrada(s) e ${droppedCts} content-type(s) cujos valores n\xE3o batiam com o c\xF3digo.`
+      );
+    }
+    dataCts = verifiedCts;
+    dataSeed = verifiedSeed;
+  }
   const budget = 60 - dataCts.length - 1;
   const page = buildPageContentTypes(pageTexts, budget);
   const finalManifest = {
@@ -1341,132 +1778,6 @@ async function inferManifest(strapi, frontendDir, opts) {
   return result;
 }
 
-// server/src/provision/runner.ts
-var import_node_child_process = require("node:child_process");
-var import_node_net = __toESM(require("node:net"));
-var import_node_fs5 = __toESM(require("node:fs"));
-var import_node_path5 = __toESM(require("node:path"));
-var info = { state: "idle", dir: null, url: null, pm: null, error: null, log: [] };
-var child = null;
-var pollTimer = null;
-function detectPM(dir) {
-  if (import_node_fs5.default.existsSync(import_node_path5.default.join(dir, "bun.lockb")) || import_node_fs5.default.existsSync(import_node_path5.default.join(dir, "bun.lock"))) return "bun";
-  if (import_node_fs5.default.existsSync(import_node_path5.default.join(dir, "pnpm-lock.yaml"))) return "pnpm";
-  if (import_node_fs5.default.existsSync(import_node_path5.default.join(dir, "yarn.lock"))) return "yarn";
-  return "npm";
-}
-var has = (dir, ...names) => names.some((n) => import_node_fs5.default.existsSync(import_node_path5.default.join(dir, n)));
-function detectFramework2(dir) {
-  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";
-}
-var FRONTEND_BASE_PORT = 4321;
-function findFreePort(start) {
-  return new Promise((resolve) => {
-    const tryPort = (p) => {
-      if (p > start + 200) return resolve(start);
-      const srv = import_node_net.default.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) {
-  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) {
-  try {
-    const res = await fetch(url, { method: "GET" });
-    return res.status >= 200 && res.status < 400;
-  } catch {
-    return false;
-  }
-}
-function getRunStatus() {
-  return { ...info, log: info.log.slice(-15) };
-}
-function stopFrontend() {
-  if (pollTimer) {
-    clearInterval(pollTimer);
-    pollTimer = null;
-  }
-  if (child) {
-    try {
-      child.kill("SIGTERM");
-    } catch {
-    }
-    child = null;
-  }
-  if (info.state !== "error") info.state = "idle";
-}
-async function startFrontend(_strapi, opts) {
-  const { dir } = opts;
-  if (child && info.dir === dir && ["installing", "starting", "running"].includes(info.state)) {
-    return getRunStatus();
-  }
-  stopFrontend();
-  const pm = detectPM(dir);
-  const framework = detectFramework2(dir);
-  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, args) => (0, import_node_child_process.spawn)(cmd, args, { cwd: dir, env: { ...process.env }, stdio: ["ignore", "pipe", "pipe"] });
-  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)];
-  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) => {
-      child = null;
-      if (pollTimer) {
-        clearInterval(pollTimer);
-        pollTimer = null;
-      }
-      if (info.state === "running") info.state = "idle";
-      else {
-        info.state = "error";
-        info.error = `dev encerrou (c\xF3digo ${code}). Veja o log.`;
-      }
-    });
-    pollTimer = setInterval(async () => {
-      if (await urlUp(url)) {
-        info.state = "running";
-        if (pollTimer) {
-          clearInterval(pollTimer);
-          pollTimer = null;
-        }
-      }
-    }, 1500);
-  };
-  const needInstall = !import_node_fs5.default.existsSync(import_node_path5.default.join(dir, "node_modules"));
-  if (needInstall) {
-    pushLog(`Instalando depend\xEAncias com ${pm}\u2026`);
-    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\xE7\xE3o falhou (c\xF3digo ${code}). Veja o log.`;
-      }
-    });
-  } else {
-    startDev();
-  }
-  return getRunStatus();
-}
-
 // server/src/provision/integrate.ts
 var import_node_fs6 = __toESM(require("node:fs"));
 var import_node_path6 = __toESM(require("node:path"));
@@ -2088,8 +2399,11 @@ async function integrateFrontend(strapi, opts) {
 // server/src/controllers/frontend.ts
 var MANIFEST_NAME = "strapi.manifest.json";
 function ensureInside2(base, target) {
-  const n = import_node_path7.default.normalize(target);
-  return n === base || n.startsWith(base + import_node_path7.default.sep);
+  const b = import_node_path7.default.resolve(base);
+  const t = import_node_path7.default.resolve(target);
+  if (t === b) return true;
+  const rel = import_node_path7.default.relative(b, t);
+  return !!rel && !rel.startsWith("..") && !import_node_path7.default.isAbsolute(rel);
 }
 function toKebab(input) {
   const s = (input || "frontend").toLowerCase().replace(/\.zip$/, "").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").replace(/^[^a-z]+/, "");
@@ -2311,6 +2625,15 @@ var baseHeaders = {
   "Content-Type": "application/json",
   Accept: "application/json, text/event-stream"
 };
+var fetchT = async (url, opts, timeoutMs = 8e3) => {
+  const ctrl = new AbortController();
+  const t = setTimeout(() => ctrl.abort(), timeoutMs);
+  try {
+    return await fetch(url, { ...opts, signal: ctrl.signal });
+  } finally {
+    clearTimeout(t);
+  }
+};
 var parseSse = (text) => {
   const dataLines = text.split("\n").filter((l) => l.startsWith("data:")).map((l) => l.slice(5).trim()).filter(Boolean);
   const last = dataLines[dataLines.length - 1];
@@ -2334,7 +2657,7 @@ var McpClient = class {
     return h;
   }
   async init() {
-    const res = await fetch(this.url, {
+    const res = await fetchT(this.url, {
       method: "POST",
       headers: this.headers(),
       body: JSON.stringify({
@@ -2350,14 +2673,14 @@ var McpClient = class {
     });
     this.sessionId = res.headers.get("mcp-session-id") || void 0;
     await res.text();
-    await fetch(this.url, {
+    await fetchT(this.url, {
       method: "POST",
       headers: this.headers(),
       body: JSON.stringify({ jsonrpc: "2.0", method: "notifications/initialized" })
     });
   }
   async rpc(method, params, id) {
-    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 })
@@ -2473,16 +2796,18 @@ function createContentTools(strapi) {
   );
   const attrsOf = (uid) => strapi.contentTypes?.[uid]?.attributes || strapi.components?.[uid]?.attributes || {};
   const hasDraftAndPublish = (uid) => strapi.contentTypes?.[uid]?.options?.draftAndPublish === true;
-  const buildPopulate = (attributes, seen = /* @__PURE__ */ new Set()) => {
+  const MAX_DEPTH = 8;
+  const buildPopulate = (attributes, seen = /* @__PURE__ */ new Set(), depth = 0) => {
+    if (depth >= MAX_DEPTH) return {};
     const populate = {};
     for (const [name, a] of Object.entries(attributes)) {
       if (a.type === "component" && a.component) {
-        const sub = seen.has(a.component) ? {} : buildPopulate(attrsOf(a.component), new Set(seen).add(a.component));
+        const sub = seen.has(a.component) ? {} : buildPopulate(attrsOf(a.component), new Set(seen).add(a.component), depth + 1);
         populate[name] = Object.keys(sub).length ? { populate: sub } : true;
       } else if (a.type === "dynamiczone") {
         const on = {};
         for (const comp of a.components || []) {
-          const sub = seen.has(comp) ? {} : buildPopulate(attrsOf(comp), new Set(seen).add(comp));
+          const sub = seen.has(comp) ? {} : buildPopulate(attrsOf(comp), new Set(seen).add(comp), depth + 1);
           on[comp] = Object.keys(sub).length ? { populate: sub } : true;
         }
         populate[name] = { on };
@@ -2494,6 +2819,7 @@ function createContentTools(strapi) {
   };
   const walkFind = (node, attributes, basePath, needle, collect) => {
     if (!node || typeof node !== "object") return;
+    if (basePath.length > 24) return;
     for (const [name, a] of Object.entries(attributes)) {
       const v = node[name];
       if (v == null) continue;
@@ -2518,16 +2844,19 @@ function createContentTools(strapi) {
       }
     }
   };
-  const buscarTexto = async (termo) => {
+  const MAX_MATCHES = 100;
+  const buscarTexto = async (termo, status = "draft") => {
     const needle = String(termo || "").toLowerCase().trim();
     if (!needle) return { erro: "termo vazio" };
+    const st = status === "published" ? "published" : "draft";
     const matches = [];
     for (const ct of apiContentTypes()) {
+      if (matches.length >= MAX_MATCHES) break;
       const attributes = ct.attributes || {};
       const populate = buildPopulate(attributes);
       let entries = [];
       try {
-        const res = await strapi.documents(ct.uid).findMany({ status: "draft", populate, limit: 200 });
+        const res = await strapi.documents(ct.uid).findMany({ status: st, populate, limit: 200 });
         entries = Array.isArray(res) ? res : res ? [res] : [];
       } catch {
         continue;
@@ -2549,7 +2878,12 @@ function createContentTools(strapi) {
         });
       }
     }
-    return { total: matches.length, resultados: matches };
+    const truncated = matches.length > MAX_MATCHES;
+    return {
+      total: matches.length,
+      resultados: matches.slice(0, MAX_MATCHES),
+      ...truncated ? { truncado: true, nota: `mostrando ${MAX_MATCHES} de ${matches.length} resultados; refine o termo` } : {}
+    };
   };
   const sanitizeNode = (node, attributes) => {
     if (node == null) return node;
@@ -3037,7 +3371,7 @@ If the user shares their screen, an image is attached to the last message \u2014
 Be concise and actionable. ALWAYS answer in English.`
 };
 var chat_default2 = ({ strapi }) => ({
-  async chat({ messages, image, lang = "pt", previewUrl, autoPublish = false }) {
+  async chat({ messages, image, lang = "pt", previewUrl, previewStatus = "draft", autoPublish = false }) {
     const apiKey = process.env.OPENAI_API_KEY;
     if (!apiKey) {
       throw new Error(
@@ -3047,7 +3381,7 @@ var chat_default2 = ({ strapi }) => ({
     const language = lang === "en" ? "en" : "pt";
     const { buscarTexto, editarCampo, publicar, listarLocales, criarLocale, traduzir } = createContentTools(strapi);
     const LOCAL_TOOLS = {
-      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(),
@@ -3061,7 +3395,10 @@ var chat_default2 = ({ strapi }) => ({
     if (process.env.PLAYWRIGHT_MCP_URL) {
       try {
         const client = new McpClient(process.env.PLAYWRIGHT_MCP_URL, "playwright");
-        await client.init();
+        await Promise.race([
+          client.init(),
+          new Promise((_, rej) => setTimeout(() => rej(new Error("timeout")), 4e3))
+        ]);
         const list = await client.listTools();
         for (const t of list) {
           if (mcpByTool[t.name]) continue;
@@ -3133,11 +3470,22 @@ PUBLISH POLICY: DRAFT MODE (auto-publish OFF). Do NOT call publicar unless the u
       }
     });
     const callOpenAI = async (body) => {
-      const res = await fetch(OPENAI_URL4, {
-        method: "POST",
-        headers: { Authorization: `Bearer ${apiKey}`, "Content-Type": "application/json" },
-        body: JSON.stringify(body)
-      });
+      const ctrl = new AbortController();
+      const timer = setTimeout(() => ctrl.abort(), 6e4);
+      let res;
+      try {
+        res = await fetch(OPENAI_URL4, {
+          method: "POST",
+          headers: { Authorization: `Bearer ${apiKey}`, "Content-Type": "application/json" },
+          body: JSON.stringify(body),
+          signal: ctrl.signal
+        });
+      } catch (e) {
+        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();
     };
@@ -3176,6 +3524,11 @@ PUBLISH POLICY: DRAFT MODE (auto-publish OFF). Do NOT call publicar unless the u
           } catch (e) {
             content = `Erro ao chamar a tool ${name}: ${e?.message || e}`;
           }
+          const MAX_TOOL_CHARS = 12e3;
+          if (content.length > MAX_TOOL_CHARS) {
+            content = content.slice(0, MAX_TOOL_CHARS) + `
+\u2026[resultado truncado: ${content.length} chars]`;
+          }
           convo.push({ role: "tool", tool_call_id: call.id, content });
         }
         continue;
@@ -3299,196 +3652,166 @@ var routes_default = {
 
 // server/src/mcp/tools/buscar-texto.ts
 var import_utils2 = require("@strapi/utils");
-var tool = {
-  register(registerTool) {
-    registerTool({
-      name: "mcp_chat_buscar_texto",
-      title: "Search text across content (deep)",
-      description: 'Search a phrase across ALL content-types, single types, components and dynamic zones (recursive, substring). Returns matches with a `path` (e.g. ["dynamic_zone",2,"heading"]) to pass to mcp_chat_editar_campo.',
-      resolveInputSchema: () => import_utils2.z.object({ termo: import_utils2.z.string() }),
-      resolveOutputSchema: () => import_utils2.z.object({
-        total: import_utils2.z.number().optional(),
-        resultados: import_utils2.z.array(import_utils2.z.any()).optional(),
-        erro: import_utils2.z.string().optional()
-      }),
-      auth: { policies: [{ action: "plugin::content-manager.explorer.read" }] },
-      createHandler: (strapi) => async ({ args }) => {
-        const r = await createContentTools(strapi).buscarTexto(args?.termo);
-        return { content: [{ type: "text", text: JSON.stringify(r) }], structuredContent: r };
-      }
-    });
+
+// server/src/mcp/define.ts
+var defineTool = (def) => def;
+
+// server/src/mcp/tools/buscar-texto.ts
+var buscar_texto_default = defineTool({
+  name: "mcp_chat_buscar_texto",
+  title: "Search text across content (deep)",
+  description: 'Search a phrase across ALL content-types, single types, components and dynamic zones (recursive, substring). Returns matches with a `path` (e.g. ["dynamic_zone",2,"heading"]) to pass to mcp_chat_editar_campo.',
+  resolveInputSchema: () => import_utils2.z.object({ termo: import_utils2.z.string() }),
+  resolveOutputSchema: () => import_utils2.z.object({
+    total: import_utils2.z.number().optional(),
+    resultados: import_utils2.z.array(import_utils2.z.any()).optional(),
+    erro: import_utils2.z.string().optional()
+  }),
+  auth: { policies: [{ action: "plugin::content-manager.explorer.read" }] },
+  createHandler: (strapi) => async ({ args }) => {
+    const r = await createContentTools(strapi).buscarTexto(args.termo);
+    return { content: [{ type: "text", text: JSON.stringify(r) }], structuredContent: r };
   }
-};
-var buscar_texto_default = tool;
+});
 
 // server/src/mcp/tools/editar-campo.ts
 var import_utils3 = require("@strapi/utils");
-var tool2 = {
-  register(registerTool) {
-    registerTool({
-      name: "mcp_chat_editar_campo",
-      title: "Edit a (possibly nested) field",
-      description: "Edit a field value (saved as draft), including text nested in components/dynamic zones. Pass the `path` exactly as returned by mcp_chat_buscar_texto; for a simple top-level field you may use `campo`.",
-      resolveInputSchema: () => import_utils3.z.object({
-        uid: import_utils3.z.string(),
-        documentId: import_utils3.z.string(),
-        path: import_utils3.z.array(import_utils3.z.union([import_utils3.z.string(), import_utils3.z.number()])).optional(),
-        campo: import_utils3.z.string().optional(),
-        novo_valor: import_utils3.z.string(),
-        locale: import_utils3.z.string().optional()
-      }),
-      resolveOutputSchema: () => import_utils3.z.object({
-        ok: import_utils3.z.boolean().optional(),
-        uid: import_utils3.z.string().optional(),
-        documentId: import_utils3.z.string().optional(),
-        path: import_utils3.z.array(import_utils3.z.any()).optional(),
-        novo_valor: import_utils3.z.string().optional(),
-        erro: import_utils3.z.string().optional()
-      }),
-      auth: { policies: [{ action: "plugin::content-manager.explorer.update" }] },
-      createHandler: (strapi) => async ({ args }) => {
-        const r = await createContentTools(strapi).editarCampo(args);
-        return { content: [{ type: "text", text: JSON.stringify(r) }], structuredContent: r };
-      }
-    });
+var editar_campo_default = defineTool({
+  name: "mcp_chat_editar_campo",
+  title: "Edit a (possibly nested) field",
+  description: "Edit a field value (saved as draft), including text nested in components/dynamic zones. Pass the `path` exactly as returned by mcp_chat_buscar_texto; for a simple top-level field you may use `campo`.",
+  resolveInputSchema: () => import_utils3.z.object({
+    uid: import_utils3.z.string(),
+    documentId: import_utils3.z.string(),
+    path: import_utils3.z.array(import_utils3.z.union([import_utils3.z.string(), import_utils3.z.number()])).optional(),
+    campo: import_utils3.z.string().optional(),
+    novo_valor: import_utils3.z.string(),
+    locale: import_utils3.z.string().optional()
+  }),
+  resolveOutputSchema: () => import_utils3.z.object({
+    ok: import_utils3.z.boolean().optional(),
+    uid: import_utils3.z.string().optional(),
+    documentId: import_utils3.z.string().optional(),
+    path: import_utils3.z.array(import_utils3.z.any()).optional(),
+    novo_valor: import_utils3.z.string().optional(),
+    erro: import_utils3.z.string().optional()
+  }),
+  auth: { policies: [{ action: "plugin::content-manager.explorer.update" }] },
+  createHandler: (strapi) => async ({ args }) => {
+    const r = await createContentTools(strapi).editarCampo(args);
+    return { content: [{ type: "text", text: JSON.stringify(r) }], structuredContent: r };
   }
-};
-var editar_campo_default = tool2;
+});
 
 // server/src/mcp/tools/publicar.ts
 var import_utils4 = require("@strapi/utils");
-var tool3 = {
-  register(registerTool) {
-    registerTool({
-      name: "mcp_chat_publicar",
-      title: "Publish an entry",
-      description: 'Publish an entry by uid + documentId, making the change visible on the site. Pass `locale` to publish a specific language, or "*" for all.',
-      resolveInputSchema: () => import_utils4.z.object({ uid: import_utils4.z.string(), documentId: import_utils4.z.string(), locale: import_utils4.z.string().optional() }),
-      resolveOutputSchema: () => import_utils4.z.object({
-        ok: import_utils4.z.boolean().optional(),
-        uid: import_utils4.z.string().optional(),
-        documentId: import_utils4.z.string().optional(),
-        status: import_utils4.z.string().optional(),
-        locale: import_utils4.z.string().optional()
-      }),
-      auth: { policies: [{ action: "plugin::content-manager.explorer.publish" }] },
-      createHandler: (strapi) => async ({ args }) => {
-        const r = await createContentTools(strapi).publicar(args);
-        return { content: [{ type: "text", text: JSON.stringify(r) }], structuredContent: r };
-      }
-    });
+var publicar_default = defineTool({
+  name: "mcp_chat_publicar",
+  title: "Publish an entry",
+  description: 'Publish an entry by uid + documentId, making the change visible on the site. Pass `locale` to publish a specific language, or "*" for all. For content-types without Draft & Publish there is nothing to publish (returns status "no-draft-publish") \u2014 the edit is already live.',
+  resolveInputSchema: () => import_utils4.z.object({ uid: import_utils4.z.string(), documentId: import_utils4.z.string(), locale: import_utils4.z.string().optional() }),
+  resolveOutputSchema: () => import_utils4.z.object({
+    ok: import_utils4.z.boolean().optional(),
+    uid: import_utils4.z.string().optional(),
+    documentId: import_utils4.z.string().optional(),
+    status: import_utils4.z.string().optional(),
+    locale: import_utils4.z.string().optional()
+  }),
+  auth: { policies: [{ action: "plugin::content-manager.explorer.publish" }] },
+  createHandler: (strapi) => async ({ args }) => {
+    const r = await createContentTools(strapi).publicar(args);
+    return { content: [{ type: "text", text: JSON.stringify(r) }], structuredContent: r };
   }
-};
-var publicar_default = tool3;
+});
 
 // server/src/mcp/tools/listar-locales.ts
 var import_utils5 = require("@strapi/utils");
-var tool4 = {
-  register(registerTool) {
-    registerTool({
-      name: "mcp_chat_listar_locales",
-      title: "List i18n locales",
-      description: "List the configured locales (languages) and which one is the default.",
-      resolveInputSchema: () => import_utils5.z.object({}),
-      resolveOutputSchema: () => import_utils5.z.object({
-        default: import_utils5.z.string().optional(),
-        locales: import_utils5.z.array(import_utils5.z.any()).optional(),
-        erro: import_utils5.z.string().optional()
-      }),
-      auth: { policies: [{ action: "plugin::content-manager.explorer.read" }] },
-      createHandler: (strapi) => async () => {
-        const r = await createContentTools(strapi).listarLocales();
-        return { content: [{ type: "text", text: JSON.stringify(r) }], structuredContent: r };
-      }
-    });
+var listar_locales_default = defineTool({
+  name: "mcp_chat_listar_locales",
+  title: "List i18n locales",
+  description: "List the configured locales (languages) and which one is the default.",
+  resolveInputSchema: () => import_utils5.z.object({}),
+  resolveOutputSchema: () => import_utils5.z.object({
+    default: import_utils5.z.string().optional(),
+    locales: import_utils5.z.array(import_utils5.z.any()).optional(),
+    erro: import_utils5.z.string().optional()
+  }),
+  auth: { policies: [{ action: "plugin::content-manager.explorer.read" }] },
+  createHandler: (strapi) => async () => {
+    const r = await createContentTools(strapi).listarLocales();
+    return { content: [{ type: "text", text: JSON.stringify(r) }], structuredContent: r };
   }
-};
-var listar_locales_default = tool4;
+});
 
 // server/src/mcp/tools/criar-locale.ts
 var import_utils6 = require("@strapi/utils");
-var tool5 = {
-  register(registerTool) {
-    registerTool({
-      name: "mcp_chat_criar_locale",
-      title: "Create an i18n locale",
-      description: 'Create a locale (language). `code` must be a valid ISO code (e.g. "pt-BR", "es"). Idempotent: returns ok if it already exists.',
-      resolveInputSchema: () => import_utils6.z.object({ code: import_utils6.z.string(), name: import_utils6.z.string().optional() }),
-      resolveOutputSchema: () => import_utils6.z.object({
-        ok: import_utils6.z.boolean().optional(),
-        code: import_utils6.z.string().optional(),
-        name: import_utils6.z.string().optional(),
-        existed: import_utils6.z.boolean().optional(),
-        erro: import_utils6.z.string().optional()
-      }),
-      auth: { policies: [{ action: "plugin::i18n.locale.create" }] },
-      createHandler: (strapi) => async ({ args }) => {
-        const r = await createContentTools(strapi).criarLocale(args);
-        return { content: [{ type: "text", text: JSON.stringify(r) }], structuredContent: r };
-      }
-    });
+var criar_locale_default = defineTool({
+  name: "mcp_chat_criar_locale",
+  title: "Create an i18n locale",
+  description: 'Create a locale (language). `code` must be a valid ISO code (e.g. "pt-BR", "es"). Idempotent: returns ok if it already exists.',
+  resolveInputSchema: () => import_utils6.z.object({ code: import_utils6.z.string(), name: import_utils6.z.string().optional() }),
+  resolveOutputSchema: () => import_utils6.z.object({
+    ok: import_utils6.z.boolean().optional(),
+    code: import_utils6.z.string().optional(),
+    name: import_utils6.z.string().optional(),
+    existed: import_utils6.z.boolean().optional(),
+    erro: import_utils6.z.string().optional()
+  }),
+  auth: { policies: [{ action: "plugin::i18n.locale.create" }] },
+  createHandler: (strapi) => async ({ args }) => {
+    const r = await createContentTools(strapi).criarLocale(args);
+    return { content: [{ type: "text", text: JSON.stringify(r) }], structuredContent: r };
   }
-};
-var criar_locale_default = tool5;
+});
 
 // server/src/mcp/tools/traduzir.ts
 var import_utils7 = require("@strapi/utils");
-var tool6 = {
-  register(registerTool) {
-    registerTool({
-      name: "mcp_chat_traduzir",
-      title: "Translate localized content",
-      description: "Translate localized content into one or more languages. Creates missing locales, translates field by field (long text is split and reassembled, never overflows) and publishes. Without uid/documentId, translates ALL localized content-types. Handles many locales at once.",
-      resolveInputSchema: () => import_utils7.z.object({
-        target_locales: import_utils7.z.array(import_utils7.z.string()).min(1),
-        source_locale: import_utils7.z.string().optional(),
-        uid: import_utils7.z.string().optional(),
-        documentId: import_utils7.z.string().optional(),
-        publish: import_utils7.z.boolean().optional()
-      }),
-      resolveOutputSchema: () => import_utils7.z.object({
-        ok: import_utils7.z.boolean().optional(),
-        source: import_utils7.z.string().optional(),
-        por_locale: import_utils7.z.array(import_utils7.z.any()).optional(),
-        erro: import_utils7.z.string().optional()
-      }),
-      auth: { policies: [{ action: "plugin::content-manager.explorer.update" }] },
-      createHandler: (strapi) => async ({ args }) => {
-        const r = await createContentTools(strapi).traduzir(args);
-        return { content: [{ type: "text", text: JSON.stringify(r) }], structuredContent: r };
-      }
-    });
+var traduzir_default = defineTool({
+  name: "mcp_chat_traduzir",
+  title: "Translate localized content",
+  description: "Translate localized content into one or more languages. Creates missing locales, translates field by field (long text is split and reassembled, never overflows) and publishes (only on content-types with Draft & Publish). Without uid/documentId, translates ALL localized content-types. Handles many locales at once.",
+  resolveInputSchema: () => import_utils7.z.object({
+    target_locales: import_utils7.z.array(import_utils7.z.string()).min(1),
+    source_locale: import_utils7.z.string().optional(),
+    uid: import_utils7.z.string().optional(),
+    documentId: import_utils7.z.string().optional(),
+    publish: import_utils7.z.boolean().optional()
+  }),
+  resolveOutputSchema: () => import_utils7.z.object({
+    ok: import_utils7.z.boolean().optional(),
+    source: import_utils7.z.string().optional(),
+    por_locale: import_utils7.z.array(import_utils7.z.any()).optional(),
+    erro: import_utils7.z.string().optional()
+  }),
+  auth: { policies: [{ action: "plugin::content-manager.explorer.update" }] },
+  createHandler: (strapi) => async ({ args }) => {
+    const r = await createContentTools(strapi).traduzir(args);
+    return { content: [{ type: "text", text: JSON.stringify(r) }], structuredContent: r };
   }
-};
-var traduzir_default = tool6;
+});
 
 // server/src/mcp/tools/habilitar-i18n.ts
 var import_utils8 = require("@strapi/utils");
-var tool7 = {
-  register(registerTool) {
-    registerTool({
-      name: "mcp_chat_habilitar_i18n",
-      title: "Enable i18n on a content-type",
-      description: 'Enable translation on content-types not localized yet: marks the content-type and its textual fields/components as localized. Required before translating content provisioned without i18n. Omit `uid` (or pass "*") to enable ALL content-types at once. Edits the schema (dev-only); Strapi restarts.',
-      resolveInputSchema: () => import_utils8.z.object({ uid: import_utils8.z.string().optional(), campos: import_utils8.z.array(import_utils8.z.string()).optional() }),
-      resolveOutputSchema: () => import_utils8.z.object({
-        ok: import_utils8.z.boolean().optional(),
-        uid: import_utils8.z.string().optional(),
-        campos: import_utils8.z.array(import_utils8.z.string()).optional(),
-        contentTypes: import_utils8.z.array(import_utils8.z.any()).optional(),
-        total: import_utils8.z.number().optional(),
-        restart: import_utils8.z.boolean().optional(),
-        erro: import_utils8.z.string().optional()
-      }),
-      auth: { policies: [{ action: "plugin::content-type-builder.read" }] },
-      createHandler: (strapi) => async ({ args }) => {
-        const r = enableI18n({ strapi, uid: args?.uid, campos: args?.campos });
-        return { content: [{ type: "text", text: JSON.stringify(r) }], structuredContent: r };
-      }
-    });
+var habilitar_i18n_default = defineTool({
+  name: "mcp_chat_habilitar_i18n",
+  title: "Enable i18n on a content-type",
+  description: 'Enable translation on content-types not localized yet: marks the content-type and its textual fields/components as localized. Required before translating content provisioned without i18n. Omit `uid` (or pass "*") to enable ALL content-types at once. Edits the schema (dev-only); Strapi restarts.',
+  resolveInputSchema: () => import_utils8.z.object({ uid: import_utils8.z.string().optional(), campos: import_utils8.z.array(import_utils8.z.string()).optional() }),
+  resolveOutputSchema: () => import_utils8.z.object({
+    ok: import_utils8.z.boolean().optional(),
+    uid: import_utils8.z.string().optional(),
+    campos: import_utils8.z.array(import_utils8.z.string()).optional(),
+    contentTypes: import_utils8.z.array(import_utils8.z.any()).optional(),
+    total: import_utils8.z.number().optional(),
+    restart: import_utils8.z.boolean().optional(),
+    erro: import_utils8.z.string().optional()
+  }),
+  auth: { policies: [{ action: "plugin::content-type-builder.read" }] },
+  createHandler: (strapi) => async ({ args }) => {
+    const r = enableI18n({ strapi, uid: args.uid, campos: args.campos });
+    return { content: [{ type: "text", text: JSON.stringify(r) }], structuredContent: r };
   }
-};
-var habilitar_i18n_default = tool7;
+});
 
 // server/src/mcp/tools/index.ts
 var tools = [
@@ -3511,9 +3834,16 @@ var registerMcpTools = (strapi) => {
     );
     return;
   }
-  const { registerTool } = mcp;
-  for (const tool8 of tools) tool8.register(registerTool, strapi);
-  strapi.log.info(`[mcp-chat] ${tools.length} tools registradas no MCP nativo (mcp_chat_*).`);
+  let registered = 0;
+  for (const tool of tools) {
+    try {
+      mcp.registerTool(tool);
+      registered += 1;
+    } catch (e) {
+      strapi.log.warn(`[mcp-chat] tool "${tool?.name}" falhou ao registrar: ${e?.message ?? e}`);
+    }
+  }
+  strapi.log.info(`[mcp-chat] ${registered}/${tools.length} tools registradas no MCP nativo (mcp_chat_*).`);
 };
 
 // server/src/register.ts
@@ -3529,6 +3859,10 @@ var register_default = ({ strapi }) => {
 var index_default = {
   register: register_default,
   async bootstrap({ strapi }) {
+    try {
+      cleanupStaleFrontend(strapi.dirs.app.root);
+    } catch {
+    }
     try {
       const r = await runPendingProvision(strapi, strapi.dirs.app.root);
       if (r.ran) {
@@ -3542,7 +3876,10 @@ var index_default = {
     }
   },
   destroy() {
-    stopFrontend();
+    try {
+      stopFrontend();
+    } catch {
+    }
   },
   config: {
     default: {},