strapi-plugin-mcp-chat 0.6.0 → 0.7.0

package/dist/server/index.js

@@ -83,13 +83,13 @@ var audio_default = ({ strapi }) => ({
 });
 
 // server/src/controllers/frontend.ts
-var import_node_fs7 = __toESM(require("node:fs"));
-var import_node_path7 = __toESM(require("node:path"));
+var import_node_fs8 = __toESM(require("node:fs"));
+var import_node_path8 = __toESM(require("node:path"));
 var import_jszip = __toESM(require("jszip"));
 
 // server/src/provision/orchestrate.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"));
 
 // server/src/provision/manifest.ts
 var import_utils = require("@strapi/utils");
@@ -267,8 +267,8 @@ function validateManifest(raw) {
   const parsed = manifestSchema.safeParse(raw);
   if (parsed.success) return { ok: true, data: parsed.data };
   const errors = parsed.error.issues.map((i) => {
-    const path9 = i.path.length ? `${i.path.join(".")}: ` : "";
-    return `${path9}${i.message}`;
+    const path10 = i.path.length ? `${i.path.join(".")}: ` : "";
+    return `${path10}${i.message}`;
   });
   return { ok: false, errors };
 }
@@ -980,8 +980,8 @@ function buildPreviewConfig(manifest, framework = manifest.framework) {
     routes[apiUid(ct.singularName)] = ct.preview?.route ?? "/";
   }
   const routesJson = JSON.stringify(routes, null, 2);
-  const isNext = framework === "next";
-  const urlBranch = isNext ? `        // Next.js: rota de draft mode que seta o cookie e redireciona p/ \`path\`.
+  const isNext2 = framework === "next";
+  const urlBranch = isNext2 ? `        // 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 });
@@ -1185,6 +1185,347 @@ function linkFrontend(manifest, opts) {
   return result;
 }
 
+// server/src/provision/wire.ts
+var import_node_fs4 = __toESM(require("node:fs"));
+var import_node_path4 = __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([
+  "node_modules",
+  ".git",
+  "dist",
+  ".next",
+  ".output",
+  ".vinxi",
+  ".tanstack",
+  "build",
+  "coverage",
+  ".turbo",
+  ".cache",
+  "public"
+]);
+function ensureInside2(base, target) {
+  const b = import_node_path4.default.resolve(base);
+  const t = import_node_path4.default.resolve(target);
+  return t === b || t.startsWith(b + import_node_path4.default.sep);
+}
+function isNext(manifest) {
+  return manifest.framework === "next";
+}
+function usesAtAlias(frontendDir) {
+  for (const f of ["tsconfig.json", "tsconfig.app.json", "jsconfig.json"]) {
+    try {
+      const c = import_node_fs4.default.readFileSync(import_node_path4.default.join(frontendDir, f), "utf8");
+      if (/"@\/\*"\s*:/.test(c)) return true;
+    } catch {
+    }
+  }
+  return false;
+}
+function strapiClientSrc(manifest) {
+  const envExpr = isNext(manifest) ? "(typeof process !== 'undefined' ? process.env.NEXT_PUBLIC_STRAPI_URL : undefined)" : "(import.meta as any).env?.VITE_STRAPI_URL";
+  return `// Gerado pelo mcp-chat \u2014 camada de acesso \xE0 Strapi (REST, flat, sem nesting).
+// N\xE3o edite \xE0 m\xE3o: \xE9 regenerado ao religar o frontend.
+export const STRAPI_URL =
+  (${envExpr} || "http://localhost:1337").replace(/\\/$/, "");
+
+export type PreviewMode = { isPreview: boolean; status: "draft" | "published" };
+
+/** L\xEA o modo de preview da URL (?preview=1 / ?status=draft). */
+export function getPreviewMode(): PreviewMode {
+  if (typeof window === "undefined") return { isPreview: false, status: "published" };
+  const p = new URLSearchParams(window.location.search);
+  const status = p.get("status");
+  const isPreview = p.get("preview") === "1" || p.has("preview") || status === "draft";
+  return { isPreview, status: status === "draft" || isPreview ? "draft" : "published" };
+}
+
+/** Busca um singleType e devolve s\xF3 os atributos (objeto). null em erro. */
+export async function fetchSection<T = Record<string, any>>(
+  name: string,
+  status: "draft" | "published" = "published"
+): Promise<T | null> {
+  const qs = status === "draft" ? "?status=draft" : "";
+  try {
+    const res = await fetch(\`\${STRAPI_URL}/api/\${name}\${qs}\`);
+    if (!res.ok) return null;
+    const json = await res.json();
+    return (json?.data ?? null) as T | null;
+  } catch {
+    return null;
+  }
+}
+
+/** Busca uma collection (lista) pelo nome plural; ordena por sortOrder se existir. */
+export async function fetchCollection<T = Record<string, any>>(
+  pluralName: string,
+  status: "draft" | "published" = "published"
+): Promise<T[]> {
+  const qs = new URLSearchParams({ "sort": "sortOrder:asc", "pagination[pageSize]": "100" });
+  if (status === "draft") qs.set("status", "draft");
+  try {
+    const res = await fetch(\`\${STRAPI_URL}/api/\${pluralName}?\${qs.toString()}\`);
+    if (!res.ok) return [];
+    const json = await res.json();
+    return (Array.isArray(json?.data) ? json.data : []) as T[];
+  } catch {
+    return [];
+  }
+}
+`;
+}
+function hooksSrc(manifest, libImport) {
+  const clientDirective = isNext(manifest) ? `"use client";
+
+` : "";
+  return `${clientDirective}// Gerado pelo mcp-chat \u2014 hooks de leitura da Strapi (sem depend\xEAncias al\xE9m do React).
+// Em modo preview faz polling curto + refetch via postMessage (reflete edi\xE7\xF5es ao vivo).
+import { useEffect, useState } from "react";
+import { fetchSection, fetchCollection, getPreviewMode } from "${libImport}";
+
+export function useSection<T = Record<string, any>>(name: string): Partial<T> {
+  const [data, setData] = useState<Partial<T>>({});
+  useEffect(() => {
+    let alive = true;
+    const { isPreview, status } = getPreviewMode();
+    const load = () => fetchSection<T>(name, status).then((d) => { if (alive && d) setData(d as Partial<T>); });
+    load();
+    if (!isPreview) return () => { alive = false; };
+    const id = window.setInterval(load, 2500);
+    const onMsg = () => load();
+    window.addEventListener("message", onMsg);
+    return () => { alive = false; window.clearInterval(id); window.removeEventListener("message", onMsg); };
+  }, [name]);
+  return data;
+}
+
+export function useCollection<T = Record<string, any>>(pluralName: string): T[] {
+  const [data, setData] = useState<T[]>([]);
+  useEffect(() => {
+    let alive = true;
+    const { isPreview, status } = getPreviewMode();
+    const load = () => fetchCollection<T>(pluralName, status).then((d) => { if (alive) setData(d); });
+    load();
+    if (!isPreview) return () => { alive = false; };
+    const id = window.setInterval(load, 2500);
+    const onMsg = () => load();
+    window.addEventListener("message", onMsg);
+    return () => { alive = false; window.clearInterval(id); window.removeEventListener("message", onMsg); };
+  }, [pluralName]);
+  return data;
+}
+`;
+}
+function writeDataLayer(frontendDir, manifest, dryRun) {
+  const written = [];
+  const libDir = import_node_path4.default.join(frontendDir, "src", "lib");
+  const hooksDir = import_node_path4.default.join(frontendDir, "src", "hooks");
+  const libFile = import_node_path4.default.join(libDir, "strapi.ts");
+  const hooksFile = import_node_path4.default.join(hooksDir, "useStrapi.ts");
+  if (!ensureInside2(frontendDir, libFile) || !ensureInside2(frontendDir, hooksFile)) {
+    throw new Error("camada de dados fora do frontendDir");
+  }
+  const libImport = usesAtAlias(frontendDir) ? "@/lib/strapi" : "../lib/strapi";
+  if (!dryRun) {
+    import_node_fs4.default.mkdirSync(libDir, { recursive: true });
+    import_node_fs4.default.mkdirSync(hooksDir, { recursive: true });
+    import_node_fs4.default.writeFileSync(libFile, strapiClientSrc(manifest), "utf8");
+    import_node_fs4.default.writeFileSync(hooksFile, hooksSrc(manifest, libImport), "utf8");
+  }
+  written.push("src/lib/strapi.ts", "src/hooks/useStrapi.ts");
+  return written;
+}
+var CODE_EXT = /* @__PURE__ */ new Set([".tsx", ".jsx"]);
+var MAX_COMPONENT_CHARS = 16e3;
+function walkComponents(dir, base, out) {
+  let entries;
+  try {
+    entries = import_node_fs4.default.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const e of entries) {
+    if (e.name.startsWith(".")) continue;
+    const full = import_node_path4.default.join(dir, e.name);
+    if (e.isDirectory()) {
+      if (SKIP_DIRS.has(e.name) || e.name === "ui") continue;
+      walkComponents(full, base, out);
+    } else if (CODE_EXT.has(import_node_path4.default.extname(e.name))) {
+      out.push(import_node_path4.default.relative(base, full));
+    }
+  }
+}
+function resolvePlural(strapi, singularName) {
+  const real = strapi?.contentTypes?.[apiUid(singularName)]?.info?.pluralName;
+  return real || `${singularName}s`;
+}
+function contentModelSummary(strapi, manifest) {
+  const lines = [];
+  for (const ct of manifest.contentTypes) {
+    const fields = Object.keys(ct.attributes || {}).join(", ");
+    if (ct.kind === "singleType") {
+      lines.push(`singleType "${ct.singularName}" (useSection("${ct.singularName}")) campos: ${fields}`);
+    } else {
+      const plural = resolvePlural(strapi, ct.singularName);
+      lines.push(`collection "${ct.singularName}" (useCollection("${plural}")) campos: ${fields}`);
+    }
+  }
+  return lines.join("\n");
+}
+function wirePrompt(rel, source, model, hooksImport, seedSnippet) {
+  return `Voc\xEA religa um componente React para ler o conte\xFAdo da Strapi, SEM quebrar nada.
+
+MODELO DE CONTE\xDADO (use EXATAMENTE estes nomes de hook/campo):
+${model}
+
+DADOS SEMEADOS (para casar o texto hardcoded com o campo certo):
+${seedSnippet}
+
+REGRAS (siga \xE0 risca):
+- Importe os hooks de "${hooksImport}" (ex.: import { useSection, useCollection } from "${hooksImport}";).
+- Dentro do componente, chame os hooks necess\xE1rios (ex.: const hero = useSection("hero-section-content");).
+- Troque CADA texto hardcoded que casa com um campo por { obj.campo ?? "TEXTO ORIGINAL" } \u2014 SEMPRE mantenha o texto original como fallback no ?? .
+- Para listas (arrays hardcoded de objetos), troque o array por useCollection(...) e itere sobre ele; mantenha \xEDcones/imagens/classes/animacoes/layout EXATAMENTE como est\xE3o (n\xE3o s\xE3o conte\xFAdo).
+- N\xC3O altere imports de \xEDcones/assets, JSX estrutural, classes Tailwind, hooks de anima\xE7\xE3o, nada que n\xE3o seja texto/dado.
+- N\xC3O invente campos nem textos. Se um trecho n\xE3o casa com nenhum campo, deixe como est\xE1.
+- Mantenha o arquivo V\xC1LIDO e COMPLETO (TypeScript/TSX que compila). Responda com JSON: {"code":"<arquivo .tsx completo>"} e NADA al\xE9m disso.
+
+ARQUIVO: ${rel}
+\`\`\`tsx
+${source}
+\`\`\``;
+}
+function syntaxError(code) {
+  let esbuild;
+  try {
+    esbuild = require("esbuild");
+  } catch {
+    return null;
+  }
+  try {
+    esbuild.transformSync(code, { loader: "tsx", jsx: "automatic" });
+    return "";
+  } catch (e) {
+    return (e?.message || "erro de sintaxe").split("\n")[0];
+  }
+}
+function looksSane(original, next, hooksImport) {
+  if (!next || next.length < 40) return "sa\xEDda vazia/curta demais";
+  if (next.length < original.length * 0.5) return "sa\xEDda muito menor que o original (poss\xEDvel truncamento)";
+  if (!/export\s+default|export\s+function|export\s+const/.test(next)) return "sem export";
+  if (!next.includes(hooksImport)) return "n\xE3o importou os hooks";
+  const balanced = (s, a, b) => s.split(a).length - 1 === s.split(b).length - 1;
+  if (!balanced(next, "{", "}")) return "chaves desbalanceadas";
+  if (!balanced(next, "(", ")")) return "par\xEAnteses desbalanceados";
+  if (!balanced(next, "[", "]")) return "colchetes desbalanceados";
+  if (/```/.test(next)) return "markdown na sa\xEDda";
+  return null;
+}
+async function callOpenAI(apiKey, prompt) {
+  const res = await fetch(OPENAI_URL, {
+    method: "POST",
+    headers: { Authorization: `Bearer ${apiKey}`, "Content-Type": "application/json" },
+    body: JSON.stringify({
+      model: MODEL,
+      temperature: 0,
+      response_format: { type: "json_object" },
+      messages: [
+        { role: "system", content: 'Voc\xEA religa componentes React para a Strapi e responde s\xF3 com JSON {"code": "..."} v\xE1lido.' },
+        { role: "user", content: prompt }
+      ]
+    })
+  });
+  if (!res.ok) throw new Error(`OpenAI: ${await res.text()}`);
+  const data = await res.json();
+  const raw = JSON.parse(data.choices?.[0]?.message?.content ?? "{}");
+  return typeof raw.code === "string" ? raw.code : "";
+}
+async function wireFrontend(_strapi, opts) {
+  const { frontendDir, manifest } = opts;
+  const result = {
+    ok: false,
+    dataLayer: [],
+    componentsWired: [],
+    componentsSkipped: [],
+    warnings: [],
+    errors: []
+  };
+  if (!import_node_path4.default.isAbsolute(frontendDir)) {
+    result.errors.push("frontendDir deve ser absoluto");
+    return result;
+  }
+  try {
+    result.dataLayer = writeDataLayer(frontendDir, manifest, opts.dryRun);
+  } catch (e) {
+    result.errors.push(`camada de dados: ${e?.message ?? e}`);
+    return result;
+  }
+  const apiKey = process.env.OPENAI_API_KEY;
+  if (!apiKey) {
+    result.warnings.push("Sem OPENAI_API_KEY: camada de dados criada, mas os componentes N\xC3O foram religados (precisa da chave).");
+    result.ok = true;
+    return result;
+  }
+  const srcDir = import_node_path4.default.join(frontendDir, "src");
+  const all = [];
+  walkComponents(srcDir, frontendDir, all);
+  const components = all.filter((rel) => /(\/|^)(components|pages|app|routes)(\/|$)/.test(rel.replace(/\\/g, "/")));
+  const model = contentModelSummary(_strapi, manifest);
+  const hooksImport = usesAtAlias(frontendDir) ? "@/hooks/useStrapi" : "../hooks/useStrapi";
+  const seedSnippet = JSON.stringify(manifest.seed ?? []).slice(0, 6e3);
+  for (const rel of components) {
+    const abs = import_node_path4.default.join(frontendDir, rel);
+    if (!ensureInside2(frontendDir, abs)) continue;
+    let source;
+    try {
+      source = import_node_fs4.default.readFileSync(abs, "utf8");
+    } catch {
+      continue;
+    }
+    if (source.length > MAX_COMPONENT_CHARS) {
+      result.componentsSkipped.push({ rel, reason: "arquivo grande demais" });
+      continue;
+    }
+    if (source.includes("useStrapi")) {
+      result.componentsSkipped.push({ rel, reason: "j\xE1 religado" });
+      continue;
+    }
+    const check = (code) => {
+      const h = looksSane(source, code, hooksImport);
+      if (h) return h;
+      const s = syntaxError(code);
+      return s ? `sintaxe: ${s}` : null;
+    };
+    try {
+      const prompt = wirePrompt(rel, source, model, hooksImport, seedSnippet);
+      let next = await callOpenAI(apiKey, prompt);
+      let bad = check(next);
+      if (bad) {
+        const fix = `${prompt}
+
+A sua tentativa anterior foi REJEITADA por: ${bad}. Corrija e responda s\xF3 com o JSON {"code":"..."} do arquivo completo e v\xE1lido.`;
+        const next2 = await callOpenAI(apiKey, fix);
+        const bad2 = check(next2);
+        if (bad2) {
+          result.componentsSkipped.push({ rel, reason: bad2 });
+          continue;
+        }
+        next = next2;
+      }
+      if (!opts.dryRun) {
+        const bak = abs + ".bak";
+        if (!import_node_fs4.default.existsSync(bak)) import_node_fs4.default.writeFileSync(bak, source, "utf8");
+        import_node_fs4.default.writeFileSync(abs, next, "utf8");
+      }
+      result.componentsWired.push(rel);
+    } catch (e) {
+      result.componentsSkipped.push({ rel, reason: `IA: ${e?.message ?? e}` });
+    }
+  }
+  result.ok = true;
+  return result;
+}
+
 // server/src/provision/permissions.ts
 async function grantPublicRead(strapi, manifest) {
   const result = { granted: [], errors: [] };
@@ -1223,17 +1564,17 @@ var MARKER_DIR = ".mcp-chat";
 var MARKER_FILE = "pending-provision.json";
 var DONE_FILE = "last-provision.json";
 function markerPath(strapiAppDir) {
-  return import_node_path4.default.join(strapiAppDir, MARKER_DIR, MARKER_FILE);
+  return import_node_path5.default.join(strapiAppDir, MARKER_DIR, MARKER_FILE);
 }
 function donePath(strapiAppDir) {
-  return import_node_path4.default.join(strapiAppDir, MARKER_DIR, DONE_FILE);
+  return import_node_path5.default.join(strapiAppDir, MARKER_DIR, DONE_FILE);
 }
 function getProvisionStatus(strapiAppDir) {
-  const pending = import_node_fs4.default.existsSync(markerPath(strapiAppDir));
+  const pending = import_node_fs5.default.existsSync(markerPath(strapiAppDir));
   let done = null;
   try {
     const dp = donePath(strapiAppDir);
-    if (import_node_fs4.default.existsSync(dp)) done = JSON.parse(import_node_fs4.default.readFileSync(dp, "utf8"));
+    if (import_node_fs5.default.existsSync(dp)) done = JSON.parse(import_node_fs5.default.readFileSync(dp, "utf8"));
   } catch {
   }
   return { pending, done };
@@ -1269,10 +1610,10 @@ function stageProvision(strapi, input) {
   if (!input.dryRun) {
     try {
       const mp = markerPath(input.strapiAppDir);
-      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");
+      import_node_fs5.default.mkdirSync(import_node_path5.default.dirname(mp), { recursive: true });
+      import_node_fs5.default.writeFileSync(mp, JSON.stringify(marker, null, 2), "utf8");
       try {
-        import_node_fs4.default.unlinkSync(donePath(input.strapiAppDir));
+        import_node_fs5.default.unlinkSync(donePath(input.strapiAppDir));
       } catch {
       }
       result.staged = true;
@@ -1288,10 +1629,10 @@ function stageProvision(strapi, input) {
 async function runPendingProvision(strapi, strapiAppDir) {
   const result = { ran: false, errors: [] };
   const mp = markerPath(strapiAppDir);
-  if (!import_node_fs4.default.existsSync(mp)) return result;
+  if (!import_node_fs5.default.existsSync(mp)) return result;
   let marker;
   try {
-    marker = JSON.parse(import_node_fs4.default.readFileSync(mp, "utf8"));
+    marker = JSON.parse(import_node_fs5.default.readFileSync(mp, "utf8"));
   } catch (e) {
     result.errors.push(`marcador ileg\xEDvel: ${e?.message ?? e}`);
     return result;
@@ -1319,6 +1660,15 @@ async function runPendingProvision(strapi, strapiAppDir) {
   } catch (e) {
     result.errors.push(`link: ${e?.message ?? e}`);
   }
+  try {
+    result.wire = await wireFrontend(strapi, {
+      frontendDir: marker.frontendDir,
+      manifest: marker.manifest
+    });
+    if (result.wire.errors.length) result.errors.push(...result.wire.errors.map((e) => `wire: ${e}`));
+  } catch (e) {
+    result.errors.push(`wire: ${e?.message ?? e}`);
+  }
   try {
     const previewUrl = marker.context.frontendUrl || `http://localhost:${FRONTEND_BASE_PORT}`;
     const done = {
@@ -1332,24 +1682,24 @@ async function runPendingProvision(strapi, strapiAppDir) {
       finishedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
     const dp = donePath(strapiAppDir);
-    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");
+    import_node_fs5.default.mkdirSync(import_node_path5.default.dirname(dp), { recursive: true });
+    import_node_fs5.default.writeFileSync(dp, JSON.stringify(done, null, 2), "utf8");
   } catch (e) {
     result.errors.push(`resumo: ${e?.message ?? e}`);
   }
   try {
-    import_node_fs4.default.unlinkSync(mp);
+    import_node_fs5.default.unlinkSync(mp);
   } catch {
   }
   return result;
 }
 
 // server/src/provision/infer.ts
-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([
+var import_node_fs6 = __toESM(require("node:fs"));
+var import_node_path6 = __toESM(require("node:path"));
+var OPENAI_URL2 = "https://api.openai.com/v1/chat/completions";
+var MODEL2 = process.env.OPENAI_CHAT_MODEL || "gpt-4o";
+var SKIP_DIRS2 = /* @__PURE__ */ new Set([
   "node_modules",
   ".git",
   "dist",
@@ -1363,7 +1713,7 @@ var SKIP_DIRS = /* @__PURE__ */ new Set([
   ".cache",
   "public"
 ]);
-var CODE_EXT = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx", ".mjs"]);
+var CODE_EXT2 = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx", ".mjs"]);
 var MAX_FILES = 18;
 var MAX_TOTAL_CHARS = 6e4;
 var MAX_FILE_CHARS = 12e3;
@@ -1379,18 +1729,18 @@ function score(rel) {
 function walk(dir, base, out) {
   let entries;
   try {
-    entries = import_node_fs5.default.readdirSync(dir, { withFileTypes: true });
+    entries = import_node_fs6.default.readdirSync(dir, { withFileTypes: true });
   } catch {
     return;
   }
   for (const e of entries) {
     if (e.name.startsWith(".") && e.name !== ".") continue;
-    const full = import_node_path5.default.join(dir, e.name);
+    const full = import_node_path6.default.join(dir, e.name);
     if (e.isDirectory()) {
-      if (SKIP_DIRS.has(e.name)) continue;
+      if (SKIP_DIRS2.has(e.name)) continue;
       walk(full, base, out);
-    } else if (CODE_EXT.has(import_node_path5.default.extname(e.name))) {
-      out.push(import_node_path5.default.relative(base, full));
+    } else if (CODE_EXT2.has(import_node_path6.default.extname(e.name))) {
+      out.push(import_node_path6.default.relative(base, full));
     }
   }
 }
@@ -1405,7 +1755,7 @@ function collectFiles(frontendDir) {
   for (const rel of all) {
     let content;
     try {
-      content = import_node_fs5.default.readFileSync(import_node_path5.default.join(frontendDir, rel), "utf8");
+      content = import_node_fs6.default.readFileSync(import_node_path6.default.join(frontendDir, rel), "utf8");
     } catch {
       continue;
     }
@@ -1460,7 +1810,7 @@ function collectPageTexts(frontendDir) {
   for (const rel of ranked) {
     if (out.length >= MAX_TEXT_FILES) break;
     try {
-      const texts = extractTexts(import_node_fs5.default.readFileSync(import_node_path5.default.join(frontendDir, rel), "utf8"));
+      const texts = extractTexts(import_node_fs6.default.readFileSync(import_node_path6.default.join(frontendDir, rel), "utf8"));
       if (texts.length) out.push({ rel, texts });
     } catch {
     }
@@ -1550,7 +1900,7 @@ function buildPageContentTypes(pageTexts, budget) {
 }
 function detectFramework2(frontendDir) {
   try {
-    const pkg = JSON.parse(import_node_fs5.default.readFileSync(import_node_path5.default.join(frontendDir, "package.json"), "utf8"));
+    const pkg = JSON.parse(import_node_fs6.default.readFileSync(import_node_path6.default.join(frontendDir, "package.json"), "utf8"));
     const deps = { ...pkg.dependencies || {}, ...pkg.devDependencies || {} };
     if (deps.next) return "next";
     if (deps["@tanstack/react-start"]) return "tanstack";
@@ -1622,10 +1972,10 @@ async function inferManifest(strapi, frontendDir, opts) {
     warnings: [],
     errors: []
   };
-  const existing = import_node_path5.default.join(frontendDir, "strapi.manifest.json");
-  if (import_node_fs5.default.existsSync(existing)) {
+  const existing = import_node_path6.default.join(frontendDir, "strapi.manifest.json");
+  if (import_node_fs6.default.existsSync(existing)) {
     try {
-      const raw = JSON.parse(import_node_fs5.default.readFileSync(existing, "utf8"));
+      const raw = JSON.parse(import_node_fs6.default.readFileSync(existing, "utf8"));
       const v2 = validateManifest(raw);
       result.inferred = false;
       result.rawManifest = raw;
@@ -1662,11 +2012,11 @@ async function inferManifest(strapi, frontendDir, opts) {
   let dataSeed = [];
   const apiKey = process.env.OPENAI_API_KEY;
   if (apiKey && collected.files.length) {
-    const callOpenAI = async (messages2) => {
-      const res = await fetch(OPENAI_URL, {
+    const callOpenAI2 = async (messages2) => {
+      const res = await fetch(OPENAI_URL2, {
         method: "POST",
         headers: { Authorization: `Bearer ${apiKey}`, "Content-Type": "application/json" },
-        body: JSON.stringify({ model: MODEL, temperature: 0, response_format: { type: "json_object" }, messages: messages2 })
+        body: JSON.stringify({ model: MODEL2, temperature: 0, response_format: { type: "json_object" }, messages: messages2 })
       });
       if (!res.ok) throw new Error(`OpenAI: ${await res.text()}`);
       return res.json();
@@ -1677,7 +2027,7 @@ async function inferManifest(strapi, frontendDir, opts) {
     ];
     try {
       for (let attempt = 0; attempt < 2; attempt++) {
-        const data = await callOpenAI(messages);
+        const data = await callOpenAI2(messages);
         const raw = JSON.parse(data.choices?.[0]?.message?.content ?? "{}");
         const candidate = {
           manifestVersion: 1,
@@ -1712,7 +2062,7 @@ async function inferManifest(strapi, frontendDir, opts) {
     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"));
+        parts.push(import_node_fs6.default.readFileSync(import_node_path6.default.join(frontendDir, f.rel), "utf8"));
       } catch {
         parts.push(f.content);
       }
@@ -1779,12 +2129,12 @@ async function inferManifest(strapi, frontendDir, opts) {
 }
 
 // server/src/provision/integrate.ts
-var import_node_fs6 = __toESM(require("node:fs"));
-var import_node_path6 = __toESM(require("node:path"));
+var import_node_fs7 = __toESM(require("node:fs"));
+var import_node_path7 = __toESM(require("node:path"));
 var import_node_child_process2 = require("node:child_process");
-var OPENAI_URL2 = "https://api.openai.com/v1/chat/completions";
-var MODEL2 = process.env.OPENAI_CHAT_MODEL || "gpt-4o";
-var SKIP_DIRS2 = /* @__PURE__ */ new Set([
+var OPENAI_URL3 = "https://api.openai.com/v1/chat/completions";
+var MODEL3 = process.env.OPENAI_CHAT_MODEL || "gpt-4o";
+var SKIP_DIRS3 = /* @__PURE__ */ new Set([
   "node_modules",
   ".git",
   "dist",
@@ -1798,7 +2148,7 @@ var SKIP_DIRS2 = /* @__PURE__ */ new Set([
   ".cache",
   "public"
 ]);
-var CODE_EXT2 = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx", ".mjs"]);
+var CODE_EXT3 = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx", ".mjs"]);
 var MAX_DATA_FILES = 3;
 var MAX_FILE_CHARS2 = 16e3;
 function score2(rel) {
@@ -1813,18 +2163,18 @@ function score2(rel) {
 function walk2(dir, base, out) {
   let entries;
   try {
-    entries = import_node_fs6.default.readdirSync(dir, { withFileTypes: true });
+    entries = import_node_fs7.default.readdirSync(dir, { withFileTypes: true });
   } catch {
     return;
   }
   for (const e of entries) {
     if (e.name.startsWith(".")) continue;
-    const full = import_node_path6.default.join(dir, e.name);
+    const full = import_node_path7.default.join(dir, e.name);
     if (e.isDirectory()) {
-      if (SKIP_DIRS2.has(e.name)) continue;
+      if (SKIP_DIRS3.has(e.name)) continue;
       walk2(full, base, out);
-    } else if (CODE_EXT2.has(import_node_path6.default.extname(e.name))) {
-      out.push(import_node_path6.default.relative(base, full));
+    } else if (CODE_EXT3.has(import_node_path7.default.extname(e.name))) {
+      out.push(import_node_path7.default.relative(base, full));
     }
   }
 }
@@ -1833,7 +2183,7 @@ function findDataFiles(frontendDir) {
   walk2(frontendDir, frontendDir, all);
   return all.map((rel) => ({ rel, s: score2(rel) })).filter((x) => x.s > 0).filter(({ rel }) => {
     try {
-      const c = import_node_fs6.default.readFileSync(import_node_path6.default.join(frontendDir, rel), "utf8");
+      const c = import_node_fs7.default.readFileSync(import_node_path7.default.join(frontendDir, rel), "utf8");
       return /export\s+const\s+\w+\s*[:=]\s*(\[|\{)/.test(c);
     } catch {
       return false;
@@ -1902,19 +2252,19 @@ export async function fetchSingle(singular: string, o: FetchOpts = {}): Promise<
 }
 `;
 async function ensureClientDep(frontendDir, warnings) {
-  if (import_node_fs6.default.existsSync(import_node_path6.default.join(frontendDir, "node_modules", "@strapi", "client"))) return;
+  if (import_node_fs7.default.existsSync(import_node_path7.default.join(frontendDir, "node_modules", "@strapi", "client"))) return;
   try {
-    const pkgPath = import_node_path6.default.join(frontendDir, "package.json");
-    const pkg = JSON.parse(import_node_fs6.default.readFileSync(pkgPath, "utf8"));
+    const pkgPath = import_node_path7.default.join(frontendDir, "package.json");
+    const pkg = JSON.parse(import_node_fs7.default.readFileSync(pkgPath, "utf8"));
     pkg.dependencies = pkg.dependencies || {};
     if (!pkg.dependencies["@strapi/client"]) {
       pkg.dependencies["@strapi/client"] = "^1.6.2";
-      import_node_fs6.default.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n", "utf8");
+      import_node_fs7.default.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n", "utf8");
     }
   } catch (e) {
     warnings.push(`package.json do frontend: ${e?.message ?? e}`);
   }
-  const pm = import_node_fs6.default.existsSync(import_node_path6.default.join(frontendDir, "bun.lock")) || import_node_fs6.default.existsSync(import_node_path6.default.join(frontendDir, "bun.lockb")) ? "bun" : import_node_fs6.default.existsSync(import_node_path6.default.join(frontendDir, "pnpm-lock.yaml")) ? "pnpm" : import_node_fs6.default.existsSync(import_node_path6.default.join(frontendDir, "yarn.lock")) ? "yarn" : "npm";
+  const pm = import_node_fs7.default.existsSync(import_node_path7.default.join(frontendDir, "bun.lock")) || import_node_fs7.default.existsSync(import_node_path7.default.join(frontendDir, "bun.lockb")) ? "bun" : import_node_fs7.default.existsSync(import_node_path7.default.join(frontendDir, "pnpm-lock.yaml")) ? "pnpm" : import_node_fs7.default.existsSync(import_node_path7.default.join(frontendDir, "yarn.lock")) ? "yarn" : "npm";
   const args = pm === "npm" ? ["install", "@strapi/client", "--no-audit", "--no-fund"] : ["add", "@strapi/client"];
   await new Promise((resolve) => {
     try {
@@ -1966,11 +2316,11 @@ ${baseSrc.length > MAX_FILE_CHARS2 ? baseSrc.slice(0, MAX_FILE_CHARS2) : baseSrc
 
 AMOSTRA REAL DA RESPOSTA DO STRAPI (JSON, por singularName):
 ${JSON.stringify(sample, null, 1).slice(0, 18e3)}`;
-  const res = await fetch(OPENAI_URL2, {
+  const res = await fetch(OPENAI_URL3, {
     method: "POST",
     headers: { Authorization: `Bearer ${apiKey}`, "Content-Type": "application/json" },
     body: JSON.stringify({
-      model: MODEL2,
+      model: MODEL3,
       temperature: 0,
       messages: [
         { role: "system", content: "Voc\xEA gera uma fun\xE7\xE3o pura de mapeamento Strapi\u2192shape do frontend. Responde s\xF3 com a fun\xE7\xE3o." },
@@ -2124,15 +2474,15 @@ export function LanguageSwitcher() {
 export default LanguageSwitcher;
 `;
 function injectSwitcher(frontendDir, warnings, dataImport = "@/data/site") {
-  const compDir = import_node_path6.default.join(frontendDir, "src", "components");
-  import_node_fs6.default.mkdirSync(compDir, { recursive: true });
-  import_node_fs6.default.writeFileSync(import_node_path6.default.join(compDir, "LanguageSwitcher.tsx"), switcherTsx(dataImport), "utf8");
+  const compDir = import_node_path7.default.join(frontendDir, "src", "components");
+  import_node_fs7.default.mkdirSync(compDir, { recursive: true });
+  import_node_fs7.default.writeFileSync(import_node_path7.default.join(compDir, "LanguageSwitcher.tsx"), switcherTsx(dataImport), "utf8");
   const rootRel = ["src/routes/__root.tsx", "src/routes/__root.jsx"].find(
-    (r) => import_node_fs6.default.existsSync(import_node_path6.default.join(frontendDir, r))
+    (r) => import_node_fs7.default.existsSync(import_node_path7.default.join(frontendDir, r))
   );
   if (rootRel) {
-    const abs = import_node_path6.default.join(frontendDir, rootRel);
-    let src = import_node_fs6.default.readFileSync(abs, "utf8");
+    const abs = import_node_path7.default.join(frontendDir, rootRel);
+    let src = import_node_fs7.default.readFileSync(abs, "utf8");
     if (!src.includes("loadAllData")) {
       src = `import { loadAllData } from "${dataImport}";
 ` + src;
@@ -2146,17 +2496,17 @@ function injectSwitcher(frontendDir, warnings, dataImport = "@/data/site") {
       } else {
         warnings.push("n\xE3o consegui injetar o loader no __root (padr\xE3o n\xE3o encontrado).");
       }
-      import_node_fs6.default.writeFileSync(abs, src, "utf8");
+      import_node_fs7.default.writeFileSync(abs, src, "utf8");
     }
   } else {
     warnings.push("__root n\xE3o encontrado \u2014 dados ao vivo n\xE3o ligados ao SSR.");
   }
   const headerRel = ["src/components/Header.tsx", "src/components/Header.jsx"].find(
-    (r) => import_node_fs6.default.existsSync(import_node_path6.default.join(frontendDir, r))
+    (r) => import_node_fs7.default.existsSync(import_node_path7.default.join(frontendDir, r))
   );
   if (headerRel) {
-    const abs = import_node_path6.default.join(frontendDir, headerRel);
-    let src = import_node_fs6.default.readFileSync(abs, "utf8");
+    const abs = import_node_path7.default.join(frontendDir, headerRel);
+    let src = import_node_fs7.default.readFileSync(abs, "utf8");
     if (!src.includes("LanguageSwitcher")) {
       src = `import { LanguageSwitcher } from "@/components/LanguageSwitcher";
 ` + src;
@@ -2166,7 +2516,7 @@ function injectSwitcher(frontendDir, warnings, dataImport = "@/data/site") {
         src = src.replace(/<\/header>/, `  <LanguageSwitcher />
     </header>`);
       }
-      import_node_fs6.default.writeFileSync(abs, src, "utf8");
+      import_node_fs7.default.writeFileSync(abs, src, "utf8");
     }
   } else {
     warnings.push("Header n\xE3o encontrado \u2014 adicione <LanguageSwitcher/> manualmente.");
@@ -2212,11 +2562,11 @@ REGRAS ESTRITAS:
 
 ARQUIVO:
 ${src.length > MAX_FILE_CHARS2 ? src.slice(0, MAX_FILE_CHARS2) : src}`;
-  const res = await fetch(OPENAI_URL2, {
+  const res = await fetch(OPENAI_URL3, {
     method: "POST",
     headers: { Authorization: `Bearer ${apiKey}`, "Content-Type": "application/json" },
     body: JSON.stringify({
-      model: MODEL2,
+      model: MODEL3,
       temperature: 0,
       messages: [
         { role: "system", content: "Voc\xEA religa componentes ao CMS trocando s\xF3 os textos do mapa por express\xF5es. Responde s\xF3 com o c\xF3digo." },
@@ -2290,10 +2640,10 @@ async function rewireComponents(strapi, opts, warnings) {
     (rel) => /\.(tsx|jsx)$/.test(rel) && !/__root|routeTree\.gen|\/api\/|LanguageSwitcher|PreviewBridge|\/ui\//.test(rel)
   );
   for (const rel of targets) {
-    const abs = import_node_path6.default.join(opts.frontendDir, rel);
+    const abs = import_node_path7.default.join(opts.frontendDir, rel);
     let src;
     try {
-      src = import_node_fs6.default.readFileSync(abs, "utf8");
+      src = import_node_fs7.default.readFileSync(abs, "utf8");
     } catch {
       continue;
     }
@@ -2312,8 +2662,8 @@ async function rewireComponents(strapi, opts, warnings) {
         continue;
       }
       const bak = abs + ".bak";
-      if (!import_node_fs6.default.existsSync(bak)) import_node_fs6.default.writeFileSync(bak, src, "utf8");
-      import_node_fs6.default.writeFileSync(abs, out, "utf8");
+      if (!import_node_fs7.default.existsSync(bak)) import_node_fs7.default.writeFileSync(bak, src, "utf8");
+      import_node_fs7.default.writeFileSync(abs, out, "utf8");
       rewired.push(rel);
     } catch (e) {
       warnings.push(`${rel}: rewire falhou (${e?.message ?? e}).`);
@@ -2352,19 +2702,19 @@ async function integrateFrontend(strapi, opts) {
     count: Array.isArray(sample[c.singularName]) ? sample[c.singularName].length : sample[c.singularName] ? 1 : 0
   }));
   for (const rel of dataFiles) {
-    const abs = import_node_path6.default.join(opts.frontendDir, rel);
+    const abs = import_node_path7.default.join(opts.frontendDir, rel);
     try {
-      const original = import_node_fs6.default.readFileSync(abs, "utf8");
+      const original = import_node_fs7.default.readFileSync(abs, "utf8");
       const bak = abs + ".bak";
-      if (!import_node_fs6.default.existsSync(bak)) import_node_fs6.default.writeFileSync(bak, original, "utf8");
-      const baseSrc = import_node_fs6.default.existsSync(bak) ? import_node_fs6.default.readFileSync(bak, "utf8") : original;
+      if (!import_node_fs7.default.existsSync(bak)) import_node_fs7.default.writeFileSync(bak, original, "utf8");
+      const baseSrc = import_node_fs7.default.existsSync(bak) ? import_node_fs7.default.readFileSync(bak, "utf8") : original;
       const mapper = await generateMapper(apiKey, baseSrc, sample, assetImportIds(baseSrc));
       if (!mapper || !/mapStrapiToData/.test(mapper)) {
         result.warnings.push(`${rel}: mapeador inv\xE1lido, pulado.`);
         continue;
       }
       const moduleSrc = buildLiveDataModule(baseSrc, mapper, ctMeta, locales, def);
-      import_node_fs6.default.writeFileSync(abs, moduleSrc, "utf8");
+      import_node_fs7.default.writeFileSync(abs, moduleSrc, "utf8");
       result.filesRewritten.push(rel);
     } catch (e) {
       result.errors.push(`${rel}: ${e?.message ?? e}`);
@@ -2373,8 +2723,8 @@ async function integrateFrontend(strapi, opts) {
   if (result.filesRewritten.length > 0) {
     try {
       const rel0 = result.filesRewritten[0];
-      const dataDir = import_node_path6.default.dirname(import_node_path6.default.join(opts.frontendDir, rel0));
-      import_node_fs6.default.writeFileSync(import_node_path6.default.join(dataDir, "strapi-client.ts"), STRAPI_CLIENT_TS, "utf8");
+      const dataDir = import_node_path7.default.dirname(import_node_path7.default.join(opts.frontendDir, rel0));
+      import_node_fs7.default.writeFileSync(import_node_path7.default.join(dataDir, "strapi-client.ts"), STRAPI_CLIENT_TS, "utf8");
       const dataImport = "@/" + rel0.replace(/^src\//, "").replace(/\.(tsx?|jsx?)$/, "");
       injectSwitcher(opts.frontendDir, result.warnings, dataImport);
       await ensureClientDep(opts.frontendDir, result.warnings);
@@ -2398,12 +2748,12 @@ async function integrateFrontend(strapi, opts) {
 
 // server/src/controllers/frontend.ts
 var MANIFEST_NAME = "strapi.manifest.json";
-function ensureInside2(base, target) {
-  const b = import_node_path7.default.resolve(base);
-  const t = import_node_path7.default.resolve(target);
+function ensureInside3(base, target) {
+  const b = import_node_path8.default.resolve(base);
+  const t = import_node_path8.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);
+  const rel = import_node_path8.default.relative(b, t);
+  return !!rel && !rel.startsWith("..") && !import_node_path8.default.isAbsolute(rel);
 }
 function toKebab(input) {
   const s = (input || "frontend").toLowerCase().replace(/\.zip$/, "").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").replace(/^[^a-z]+/, "");
@@ -2431,13 +2781,13 @@ var frontend_default = {
     const originalName = file.originalFilename || file.name || "frontend";
     let zip;
     try {
-      zip = await import_jszip.default.loadAsync(import_node_fs7.default.readFileSync(filepath));
+      zip = await import_jszip.default.loadAsync(import_node_fs8.default.readFileSync(filepath));
     } catch (e) {
       return ctx.badRequest(`Zip inv\xE1lido: ${e?.message ?? e}`);
     }
     const entryNames = Object.keys(zip.files);
     const manifestEntry = entryNames.find(
-      (p) => import_node_path7.default.basename(p) === MANIFEST_NAME && !zip.files[p].dir
+      (p) => import_node_path8.default.basename(p) === MANIFEST_NAME && !zip.files[p].dir
     );
     let rootPrefix = "";
     if (manifestEntry) {
@@ -2450,27 +2800,27 @@ var frontend_default = {
     }
     const name = toKebab(originalName);
     const strapiAppDir = strapi.dirs.app.root;
-    const frontendDir = import_node_path7.default.resolve(strapiAppDir, "..", name);
-    if (import_node_fs7.default.existsSync(frontendDir) && import_node_fs7.default.readdirSync(frontendDir).length > 0) {
+    const frontendDir = import_node_path8.default.resolve(strapiAppDir, "..", name);
+    if (import_node_fs8.default.existsSync(frontendDir) && import_node_fs8.default.readdirSync(frontendDir).length > 0) {
       return ctx.badRequest(
         `A pasta de destino j\xE1 existe e n\xE3o est\xE1 vazia: ${frontendDir}. Renomeie o .zip ou remova a pasta.`
       );
     }
     try {
-      import_node_fs7.default.mkdirSync(frontendDir, { recursive: true });
+      import_node_fs8.default.mkdirSync(frontendDir, { recursive: true });
       for (const entryName of entryNames) {
         const entry = zip.files[entryName];
         const rel = rootPrefix && entryName.startsWith(rootPrefix) ? entryName.slice(rootPrefix.length) : entryName;
         if (!rel) continue;
-        const dest = import_node_path7.default.join(frontendDir, rel);
-        if (!ensureInside2(frontendDir, dest)) {
+        const dest = import_node_path8.default.join(frontendDir, rel);
+        if (!ensureInside3(frontendDir, dest)) {
           throw new Error(`entrada perigosa no zip bloqueada: ${entryName}`);
         }
         if (entry.dir) {
-          import_node_fs7.default.mkdirSync(dest, { recursive: true });
+          import_node_fs8.default.mkdirSync(dest, { recursive: true });
         } else {
-          import_node_fs7.default.mkdirSync(import_node_path7.default.dirname(dest), { recursive: true });
-          import_node_fs7.default.writeFileSync(dest, await entry.async("nodebuffer"));
+          import_node_fs8.default.mkdirSync(import_node_path8.default.dirname(dest), { recursive: true });
+          import_node_fs8.default.writeFileSync(dest, await entry.async("nodebuffer"));
         }
       }
     } catch (e) {
@@ -2498,16 +2848,16 @@ var frontend_default = {
     const rawManifest = body.manifest;
     const frontendDir = body.frontendDir;
     if (!rawManifest) return ctx.badRequest('Envie o "manifest".');
-    if (!frontendDir || !import_node_path7.default.isAbsolute(frontendDir)) {
+    if (!frontendDir || !import_node_path8.default.isAbsolute(frontendDir)) {
       return ctx.badRequest("frontendDir ausente ou inv\xE1lido.");
     }
     const strapiAppDir = strapi.dirs.app.root;
     const apiRoot = strapi.dirs.app.api;
-    const parent = import_node_path7.default.resolve(strapiAppDir, "..");
-    if (!ensureInside2(parent, frontendDir) || frontendDir === parent) {
+    const parent = import_node_path8.default.resolve(strapiAppDir, "..");
+    if (!ensureInside3(parent, frontendDir) || frontendDir === parent) {
       return ctx.badRequest("frontendDir fora da pasta permitida.");
     }
-    if (!import_node_fs7.default.existsSync(frontendDir)) {
+    if (!import_node_fs8.default.existsSync(frontendDir)) {
       return ctx.badRequest("frontendDir n\xE3o existe (rode a an\xE1lise primeiro).");
     }
     const v = validateManifest(rawManifest);
@@ -2515,8 +2865,8 @@ var frontend_default = {
       return ctx.badRequest({ message: "Manifest inv\xE1lido", errors: v.errors });
     }
     try {
-      import_node_fs7.default.writeFileSync(
-        import_node_path7.default.join(frontendDir, MANIFEST_NAME),
+      import_node_fs8.default.writeFileSync(
+        import_node_path8.default.join(frontendDir, MANIFEST_NAME),
         JSON.stringify(v.data, null, 2),
         "utf8"
       );
@@ -2578,8 +2928,8 @@ var frontend_default = {
     if (!dir || !url) {
       return ctx.badRequest("Nenhum frontend provisionado para rodar.");
     }
-    const parent = import_node_path7.default.resolve(strapi.dirs.app.root, "..");
-    if (!ensureInside2(parent, dir) || !import_node_fs7.default.existsSync(dir)) {
+    const parent = import_node_path8.default.resolve(strapi.dirs.app.root, "..");
+    if (!ensureInside3(parent, dir) || !import_node_fs8.default.existsSync(dir)) {
       return ctx.badRequest("Pasta do frontend inv\xE1lida.");
     }
     ctx.body = await startFrontend(strapi, { dir, url });
@@ -2603,19 +2953,48 @@ var frontend_default = {
       frontendDir = st.done?.frontendDir || "";
     }
     if (!frontendDir) return ctx.badRequest("Nenhum frontend provisionado.");
-    const parent = import_node_path7.default.resolve(strapi.dirs.app.root, "..");
-    if (!ensureInside2(parent, frontendDir) || !import_node_fs7.default.existsSync(frontendDir)) {
+    const parent = import_node_path8.default.resolve(strapi.dirs.app.root, "..");
+    if (!ensureInside3(parent, frontendDir) || !import_node_fs8.default.existsSync(frontendDir)) {
       return ctx.badRequest("Pasta do frontend inv\xE1lida.");
     }
     let manifest;
     try {
-      manifest = JSON.parse(import_node_fs7.default.readFileSync(import_node_path7.default.join(frontendDir, MANIFEST_NAME), "utf8"));
+      manifest = JSON.parse(import_node_fs8.default.readFileSync(import_node_path8.default.join(frontendDir, MANIFEST_NAME), "utf8"));
     } catch {
       return ctx.badRequest("Manifest do projeto n\xE3o encontrado (rode a provis\xE3o primeiro).");
     }
     const v = validateManifest(manifest);
     if (!v.ok) return ctx.badRequest({ message: "Manifest inv\xE1lido", errors: v.errors });
     ctx.body = await integrateFrontend(strapi, { frontendDir, manifest: v.data });
+  },
+  /**
+   * Religa o frontend à Strapi por FETCH AO VIVO: gera a camada de dados (REST,
+   * flat) e religa os componentes (com .bak + fallback + sanidade). Só escreve no
+   * frontend, nunca na Strapi. Usa o último provisionado por padrão.
+   */
+  async wire(ctx) {
+    const strapi = ctx.strapi ?? global.strapi;
+    if (!devOnly(ctx)) return;
+    const body = ctx.request.body || {};
+    let frontendDir = body.frontendDir;
+    if (!frontendDir) {
+      const st = getProvisionStatus(strapi.dirs.app.root);
+      frontendDir = st.done?.frontendDir || "";
+    }
+    if (!frontendDir) return ctx.badRequest("Nenhum frontend provisionado.");
+    const parent = import_node_path8.default.resolve(strapi.dirs.app.root, "..");
+    if (!ensureInside3(parent, frontendDir) || !import_node_fs8.default.existsSync(frontendDir)) {
+      return ctx.badRequest("Pasta do frontend inv\xE1lida.");
+    }
+    let manifest;
+    try {
+      manifest = JSON.parse(import_node_fs8.default.readFileSync(import_node_path8.default.join(frontendDir, MANIFEST_NAME), "utf8"));
+    } catch {
+      return ctx.badRequest("Manifest do projeto n\xE3o encontrado (rode a provis\xE3o primeiro).");
+    }
+    const v = validateManifest(manifest);
+    if (!v.ok) return ctx.badRequest({ message: "Manifest inv\xE1lido", errors: v.errors });
+    ctx.body = await wireFrontend(strapi, { frontendDir, manifest: v.data });
   }
 };
 
@@ -2699,8 +3078,8 @@ var McpClient = class {
 };
 
 // server/src/provision/translate.ts
-var OPENAI_URL3 = "https://api.openai.com/v1/chat/completions";
-var MODEL3 = process.env.OPENAI_CHAT_MODEL || "gpt-4o";
+var OPENAI_URL4 = "https://api.openai.com/v1/chat/completions";
+var MODEL4 = process.env.OPENAI_CHAT_MODEL || "gpt-4o";
 var approxTokens = (s) => Math.ceil((s || "").length / 4);
 var MAX_CHUNK_TOKENS = 1200;
 var splitParagraphs = (text) => text.split(/\n{2,}/);
@@ -2745,7 +3124,7 @@ function splitForTranslation(value, _type) {
 async function translateChunk(apiKey, text, sourceLang, targetLang) {
   if (!text || !text.trim()) return text;
   const body = {
-    model: MODEL3,
+    model: MODEL4,
     temperature: 0,
     max_tokens: Math.min(4e3, approxTokens(text) * 3 + 256),
     messages: [
@@ -2756,7 +3135,7 @@ async function translateChunk(apiKey, text, sourceLang, targetLang) {
       { role: "user", content: text }
     ]
   };
-  const res = await fetch(OPENAI_URL3, {
+  const res = await fetch(OPENAI_URL4, {
     method: "POST",
     headers: { Authorization: `Bearer ${apiKey}`, "Content-Type": "application/json" },
     body: JSON.stringify(body)
@@ -2823,22 +3202,22 @@ function createContentTools(strapi) {
     for (const [name, a] of Object.entries(attributes)) {
       const v = node[name];
       if (v == null) continue;
-      const path9 = [...basePath, name];
+      const path10 = [...basePath, name];
       if (TEXTUAL.includes(a.type)) {
         if (typeof v === "string" && v.toLowerCase().includes(needle)) {
-          collect(path9, name, v);
+          collect(path10, name, v);
         }
       } else if (a.type === "component" && a.component) {
         const sub = attrsOf(a.component);
         if (a.repeatable && Array.isArray(v)) {
-          v.forEach((item, i) => walkFind(item, sub, [...path9, i], needle, collect));
+          v.forEach((item, i) => walkFind(item, sub, [...path10, i], needle, collect));
         } else {
-          walkFind(v, sub, path9, needle, collect);
+          walkFind(v, sub, path10, needle, collect);
         }
       } else if (a.type === "dynamiczone" && Array.isArray(v)) {
         v.forEach((item, i) => {
           if (item?.__component) {
-            walkFind(item, attrsOf(item.__component), [...path9, i], needle, collect);
+            walkFind(item, attrsOf(item.__component), [...path10, i], needle, collect);
           }
         });
       }
@@ -2863,12 +3242,12 @@ function createContentTools(strapi) {
       }
       const dp = hasDraftAndPublish(ct.uid);
       for (const e of entries) {
-        walkFind(e, attributes, [], needle, (path9, campo, valor) => {
+        walkFind(e, attributes, [], needle, (path10, campo, valor) => {
           matches.push({
             uid: ct.uid,
             tipo: ct.info?.displayName || ct.uid,
             documentId: e.documentId,
-            path: path9,
+            path: path10,
             campo,
             valor_atual: valor.length > 300 ? valor.slice(0, 300) + "\u2026" : valor,
             // draftAndPublish=false → não há rascunho; a edição já é o conteúdo
@@ -2916,8 +3295,8 @@ function createContentTools(strapi) {
     }
     return value;
   };
-  const editarCampo = async ({ uid, documentId, path: path9, campo, novo_valor, locale }) => {
-    const p = Array.isArray(path9) && path9.length ? path9 : campo ? [campo] : null;
+  const editarCampo = async ({ uid, documentId, path: path10, campo, novo_valor, locale }) => {
+    const p = Array.isArray(path10) && path10.length ? path10 : campo ? [campo] : null;
     if (!p) return { erro: 'informe "path" (array) ou "campo"' };
     const attributes = strapi.contentTypes?.[uid]?.attributes || {};
     const topAttr = p[0];
@@ -3219,29 +3598,29 @@ var openAiToolSpecs = [
 ];
 
 // server/src/provision/enable-i18n.ts
-var import_node_fs8 = __toESM(require("node:fs"));
-var import_node_path8 = __toESM(require("node:path"));
+var import_node_fs9 = __toESM(require("node:fs"));
+var import_node_path9 = __toESM(require("node:path"));
 var LOCALIZABLE = ["string", "text", "richtext", "component", "dynamiczone"];
 var isDev2 = () => process.env.NODE_ENV === "development";
 function schemaPathFor(apiRoot, uid) {
   const m = /^api::([^.]+)\.([^.]+)$/.exec(uid);
   if (!m) return null;
   const [, api, ct] = m;
-  return import_node_path8.default.join(apiRoot, api, "content-types", ct, "schema.json");
+  return import_node_path9.default.join(apiRoot, api, "content-types", ct, "schema.json");
 }
 function listAllUids(apiRoot) {
   const out = [];
   let apis = [];
   try {
-    apis = import_node_fs8.default.readdirSync(apiRoot);
+    apis = import_node_fs9.default.readdirSync(apiRoot);
   } catch {
     return out;
   }
   for (const api of apis) {
-    const ctDir = import_node_path8.default.join(apiRoot, api, "content-types");
-    if (!import_node_fs8.default.existsSync(ctDir)) continue;
-    for (const ct of import_node_fs8.default.readdirSync(ctDir)) {
-      if (import_node_fs8.default.existsSync(import_node_path8.default.join(ctDir, ct, "schema.json"))) out.push(`api::${api}.${ct}`);
+    const ctDir = import_node_path9.default.join(apiRoot, api, "content-types");
+    if (!import_node_fs9.default.existsSync(ctDir)) continue;
+    for (const ct of import_node_fs9.default.readdirSync(ctDir)) {
+      if (import_node_fs9.default.existsSync(import_node_path9.default.join(ctDir, ct, "schema.json"))) out.push(`api::${api}.${ct}`);
     }
   }
   return out;
@@ -3251,10 +3630,10 @@ var withLocalized = (obj) => ({
   i18n: { ...(obj || {}).i18n || {}, localized: true }
 });
 function patchOne(file, campos) {
-  if (!import_node_fs8.default.existsSync(file)) return { erro: `schema.json n\xE3o encontrado (${file})` };
+  if (!import_node_fs9.default.existsSync(file)) return { erro: `schema.json n\xE3o encontrado (${file})` };
   let schema;
   try {
-    schema = JSON.parse(import_node_fs8.default.readFileSync(file, "utf8"));
+    schema = JSON.parse(import_node_fs9.default.readFileSync(file, "utf8"));
   } catch (e) {
     return { erro: `schema.json ileg\xEDvel: ${e?.message ?? e}` };
   }
@@ -3268,7 +3647,7 @@ function patchOne(file, campos) {
     changed.push(name);
   }
   try {
-    import_node_fs8.default.writeFileSync(file, JSON.stringify(schema, null, 2) + "\n", "utf8");
+    import_node_fs9.default.writeFileSync(file, JSON.stringify(schema, null, 2) + "\n", "utf8");
   } catch (e) {
     return { erro: `falha ao gravar schema.json: ${e?.message ?? e}` };
   }
@@ -3279,8 +3658,8 @@ function enableI18n(opts) {
   if (!allowOutsideDev && !isDev2()) {
     return { erro: "habilitar i18n s\xF3 \xE9 permitido em desenvolvimento (NODE_ENV=development)." };
   }
-  const srcDir = strapi?.dirs?.app?.src || import_node_path8.default.join(process.cwd(), "src");
-  const apiRoot = import_node_path8.default.join(srcDir, "api");
+  const srcDir = strapi?.dirs?.app?.src || import_node_path9.default.join(process.cwd(), "src");
+  const apiRoot = import_node_path9.default.join(srcDir, "api");
   if (!uid || uid === "*") {
     const uids = listAllUids(apiRoot);
     if (!uids.length) return { erro: `nenhuma content-type encontrada em ${apiRoot}` };
@@ -3303,9 +3682,9 @@ function enableI18n(opts) {
 }
 
 // server/src/services/chat.ts
-var MODEL4 = process.env.OPENAI_CHAT_MODEL || "gpt-4o";
+var MODEL5 = process.env.OPENAI_CHAT_MODEL || "gpt-4o";
 var MAX_TURNS = 10;
-var OPENAI_URL4 = "https://api.openai.com/v1/chat/completions";
+var OPENAI_URL5 = "https://api.openai.com/v1/chat/completions";
 var SYSTEM = {
   pt: `Voc\xEA \xE9 um assistente embutido no admin do Strapi 5 deste projeto. Voc\xEA N\xC3O \xE9 s\xF3 um guia: voc\xEA consegue EDITAR e PUBLICAR conte\xFAdo de verdade atrav\xE9s das ferramentas.
 
@@ -3469,12 +3848,12 @@ PUBLISH POLICY: DRAFT MODE (auto-publish OFF). Do NOT call publicar unless the u
         convo.push({ role: m.role, content: m.content });
       }
     });
-    const callOpenAI = async (body) => {
+    const callOpenAI2 = async (body) => {
       const ctrl = new AbortController();
       const timer = setTimeout(() => ctrl.abort(), 6e4);
       let res;
       try {
-        res = await fetch(OPENAI_URL4, {
+        res = await fetch(OPENAI_URL5, {
           method: "POST",
           headers: { Authorization: `Bearer ${apiKey}`, "Content-Type": "application/json" },
           body: JSON.stringify(body),
@@ -3491,8 +3870,8 @@ PUBLISH POLICY: DRAFT MODE (auto-publish OFF). Do NOT call publicar unless the u
     };
     let didWrite = false;
     for (let turn = 0; turn < MAX_TURNS; turn++) {
-      const data = await callOpenAI({
-        model: MODEL4,
+      const data = await callOpenAI2({
+        model: MODEL5,
         max_tokens: 2048,
         messages: convo,
         ...tools2.length > 0 ? { tools: tools2, tool_choice: "auto" } : {}
@@ -3536,7 +3915,7 @@ PUBLISH POLICY: DRAFT MODE (auto-publish OFF). Do NOT call publicar unless the u
       const text = (typeof msg.content === "string" ? msg.content : "").trim();
       return {
         reply: text || "(sem resposta)",
-        model: MODEL4,
+        model: MODEL5,
         lang: language,
         didWrite,
         toolsAvailable: tools2.length
@@ -3544,7 +3923,7 @@ PUBLISH POLICY: DRAFT MODE (auto-publish OFF). Do NOT call publicar unless the u
     }
     return {
       reply: language === "en" ? "(agent turn limit reached)" : "(limite de turnos do agente atingido)",
-      model: MODEL4,
+      model: MODEL5,
       lang: language,
       didWrite,
       toolsAvailable: tools2.length
@@ -3645,6 +4024,12 @@ var routes_default = {
         path: "/frontend/integrate",
         handler: "frontend.integrate",
         config: { policies: [] }
+      },
+      {
+        method: "POST",
+        path: "/frontend/wire",
+        handler: "frontend.wire",
+        config: { policies: [] }
       }
     ]
   }