strapi-plugin-mcp-chat 0.1.0

package/dist/server/index.js

@@ -0,0 +1,3511 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// server/src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  default: () => index_default
+});
+module.exports = __toCommonJS(index_exports);
+
+// server/src/controllers/chat.ts
+var chat_default = ({ strapi }) => ({
+  async message(ctx) {
+    const { messages, image, lang, previewUrl } = 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 });
+      ctx.body = result;
+    } catch (e) {
+      strapi.log.error(`[mcp-chat] ${e?.message || e}`);
+      return ctx.internalServerError(e?.message || "Erro ao processar o chat.");
+    }
+  }
+});
+
+// server/src/controllers/audio.ts
+var import_fs = require("fs");
+var audio_default = ({ strapi }) => ({
+  async stt(ctx) {
+    const files = ctx.request.files || {};
+    const file = files.audio || files.file;
+    if (!file) return ctx.badRequest('Envie um arquivo de \xE1udio no campo "audio".');
+    const f = Array.isArray(file) ? file[0] : file;
+    const buffer = f.filepath ? (0, import_fs.readFileSync)(f.filepath) : f.buffer;
+    const mimetype = f.mimetype || f.type || "audio/webm";
+    const language = ctx.query?.language || ctx.request.body?.language;
+    try {
+      const result = await strapi.plugin("mcp-chat").service("audio").transcribe(buffer, mimetype, language);
+      ctx.body = result;
+    } catch (e) {
+      strapi.log.error(`[mcp-chat:stt] ${e?.message || e}`);
+      return ctx.internalServerError(e?.message || "Erro na transcri\xE7\xE3o.");
+    }
+  },
+  async tts(ctx) {
+    const { text, voice } = ctx.request.body || {};
+    if (!text) return ctx.badRequest('Campo "text" \xE9 obrigat\xF3rio.');
+    try {
+      const result = await strapi.plugin("mcp-chat").service("audio").synthesize(text, voice);
+      ctx.body = result;
+    } catch (e) {
+      strapi.log.error(`[mcp-chat:tts] ${e?.message || e}`);
+      return ctx.internalServerError(e?.message || "Erro na s\xEDntese de voz.");
+    }
+  }
+});
+
+// server/src/controllers/frontend.ts
+var import_node_fs7 = __toESM(require("node:fs"));
+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"));
+
+// server/src/provision/manifest.ts
+var import_utils = require("@strapi/utils");
+var kebab = import_utils.z.string().min(1).max(48).regex(/^[a-z][a-z0-9-]*$/, 'use kebab-case (ex.: "produto", "post-blog")');
+var attrKey = import_utils.z.string().min(1).max(48).regex(/^[a-zA-Z][a-zA-Z0-9_]*$/, "nome de campo inv\xE1lido (use letras/n\xFAmeros/_)");
+var RESERVED_ATTRS = /* @__PURE__ */ new Set([
+  "id",
+  "documentId",
+  "createdAt",
+  "updatedAt",
+  "publishedAt",
+  "createdBy",
+  "updatedBy",
+  "locale",
+  "localizations"
+]);
+var SCALAR_TYPES = [
+  "string",
+  "text",
+  "richtext",
+  "blocks",
+  "email",
+  "integer",
+  "biginteger",
+  "float",
+  "decimal",
+  "boolean",
+  "date",
+  "datetime",
+  "time",
+  "json"
+];
+var commonOpts = {
+  required: import_utils.z.boolean().optional(),
+  unique: import_utils.z.boolean().optional(),
+  private: import_utils.z.boolean().optional(),
+  default: import_utils.z.union([import_utils.z.string(), import_utils.z.number(), import_utils.z.boolean()]).optional(),
+  /**
+   * Marca o campo como traduzível por locale (i18n). Opt-in: ausente ⇒ o campo
+   * é compartilhado entre locales (comportamento atual). Vira
+   * `pluginOptions.i18n.localized:true` no schema gerado. Só faz efeito se a
+   * própria content-type também tiver `localized:true`.
+   */
+  localized: import_utils.z.boolean().optional()
+};
+var scalarAttr = import_utils.z.object({
+  type: import_utils.z.enum(SCALAR_TYPES),
+  ...commonOpts
+});
+var uidAttr = import_utils.z.object({
+  type: import_utils.z.literal("uid"),
+  targetField: attrKey.optional(),
+  required: import_utils.z.boolean().optional()
+});
+var enumAttr = import_utils.z.object({
+  type: import_utils.z.literal("enumeration"),
+  enum: import_utils.z.array(import_utils.z.string().min(1)).min(1),
+  ...commonOpts
+});
+var mediaAttr = import_utils.z.object({
+  type: import_utils.z.literal("media"),
+  multiple: import_utils.z.boolean().optional(),
+  allowedTypes: import_utils.z.array(import_utils.z.enum(["images", "videos", "files", "audios"])).optional(),
+  required: import_utils.z.boolean().optional()
+});
+var RELATION_KINDS = [
+  "oneToOne",
+  "oneToMany",
+  "manyToOne",
+  "manyToMany"
+];
+var relationAttr = import_utils.z.object({
+  type: import_utils.z.literal("relation"),
+  relation: import_utils.z.enum(RELATION_KINDS),
+  target: kebab,
+  required: import_utils.z.boolean().optional()
+});
+var attribute = import_utils.z.union([
+  scalarAttr,
+  uidAttr,
+  enumAttr,
+  mediaAttr,
+  relationAttr
+]);
+var contentType = import_utils.z.object({
+  singularName: kebab,
+  pluralName: kebab.optional(),
+  displayName: import_utils.z.string().min(1).max(64).optional(),
+  kind: import_utils.z.enum(["collectionType", "singleType"]).default("collectionType"),
+  draftAndPublish: import_utils.z.boolean().default(true),
+  /**
+   * Liga a localização (i18n) na content-type. Necessário no nível da CT
+   * (confirmado em @strapi/i18n: `isLocalizedContentType` checa
+   * `pluginOptions.i18n.localized`). Os campos a traduzir devem marcar
+   * `localized:true` individualmente.
+   */
+  localized: import_utils.z.boolean().optional(),
+  description: import_utils.z.string().max(255).optional(),
+  attributes: import_utils.z.record(attrKey, attribute).refine((attrs) => Object.keys(attrs).length > 0, {
+    message: "a content-type precisa de pelo menos 1 campo"
+  }).refine(
+    (attrs) => Object.keys(attrs).every((k) => !RESERVED_ATTRS.has(k)),
+    { message: "um campo usa nome reservado da Strapi (ex.: id, createdAt)" }
+  ),
+  /**
+   * Rota do frontend usada para o preview, com placeholders de campo entre
+   * dois-pontos. Ex.: "/produtos/:slug". O adapter de cada framework usa isso
+   * para montar a URL de preview no PreviewPanel.
+   */
+  preview: import_utils.z.object({
+    route: import_utils.z.string().startsWith("/", 'a rota de preview deve come\xE7ar com "/"')
+  }).optional()
+}).superRefine((ct, ctx) => {
+  for (const [key, attr] of Object.entries(ct.attributes)) {
+    if (attr.type === "uid" && attr.targetField) {
+      const target = ct.attributes[attr.targetField];
+      if (!target) {
+        ctx.addIssue({
+          code: import_utils.z.ZodIssueCode.custom,
+          message: `uid "${key}" aponta para campo inexistente "${attr.targetField}"`
+        });
+      } else if (!["string", "text"].includes(target.type)) {
+        ctx.addIssue({
+          code: import_utils.z.ZodIssueCode.custom,
+          message: `uid "${key}" deve apontar para um campo string/text`
+        });
+      }
+    }
+  }
+});
+var FRAMEWORKS = ["next", "tanstack"];
+var manifestSchema = import_utils.z.object({
+  /** versão do formato do manifest, não do app. */
+  manifestVersion: import_utils.z.literal(1).default(1),
+  name: kebab,
+  framework: import_utils.z.enum(FRAMEWORKS),
+  strapiVersion: import_utils.z.string().optional(),
+  contentTypes: import_utils.z.array(contentType).min(1).max(60),
+  /** dados demo opcionais, semeados via Document Service após o restart. */
+  seed: import_utils.z.array(
+    import_utils.z.object({
+      uid: import_utils.z.string().optional(),
+      // resolvido pelo provisionador
+      singularName: kebab,
+      entries: import_utils.z.array(import_utils.z.record(import_utils.z.string(), import_utils.z.any())).max(500)
+    })
+  ).optional(),
+  /** nomes de env vars que o frontend espera (o adapter escreve o .env). */
+  env: import_utils.z.array(import_utils.z.string()).optional()
+}).superRefine((m, ctx) => {
+  const names = m.contentTypes.map((c) => c.singularName);
+  const seen = /* @__PURE__ */ new Set();
+  for (const n of names) {
+    if (seen.has(n)) {
+      ctx.addIssue({
+        code: import_utils.z.ZodIssueCode.custom,
+        message: `content-type duplicada: "${n}"`
+      });
+    }
+    seen.add(n);
+  }
+  const known = new Set(names);
+  for (const ct of m.contentTypes) {
+    for (const [key, attr] of Object.entries(ct.attributes)) {
+      if (attr.type === "relation" && !known.has(attr.target)) {
+        ctx.addIssue({
+          code: import_utils.z.ZodIssueCode.custom,
+          message: `rela\xE7\xE3o "${ct.singularName}.${key}" aponta para "${attr.target}", que n\xE3o est\xE1 no manifest`
+        });
+      }
+    }
+  }
+});
+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}`;
+  });
+  return { ok: false, errors };
+}
+
+// server/src/provision/generate.ts
+function toPlural(singular) {
+  if (/[^aeiou]y$/i.test(singular)) return singular.replace(/y$/i, "ies");
+  if (/(s|x|z|ch|sh)$/i.test(singular)) return `${singular}es`;
+  return `${singular}s`;
+}
+function toSnake(s) {
+  return s.replace(/-/g, "_");
+}
+function toTitle(s) {
+  return s.split("-").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
+}
+function apiUid(singularName) {
+  return `api::${singularName}.${singularName}`;
+}
+function i18nField(attr) {
+  return attr.localized ? { pluginOptions: { i18n: { localized: true } } } : {};
+}
+function buildAttribute(attr) {
+  switch (attr.type) {
+    case "uid":
+      return clean({
+        type: "uid",
+        targetField: attr.targetField,
+        required: attr.required
+      });
+    case "enumeration":
+      return clean({
+        type: "enumeration",
+        ...i18nField(attr),
+        enum: attr.enum,
+        required: attr.required,
+        unique: attr.unique,
+        private: attr.private,
+        default: attr.default
+      });
+    case "media":
+      return clean({
+        type: "media",
+        multiple: attr.multiple ?? false,
+        required: attr.required,
+        allowedTypes: attr.allowedTypes
+      });
+    case "relation":
+      return {
+        type: "relation",
+        relation: attr.relation,
+        target: apiUid(attr.target)
+      };
+    default:
+      return clean({
+        type: attr.type,
+        ...i18nField(attr),
+        required: attr.required,
+        unique: attr.unique,
+        private: attr.private,
+        default: attr.default
+      });
+  }
+}
+function clean(obj) {
+  for (const k of Object.keys(obj)) if (obj[k] === void 0) delete obj[k];
+  return obj;
+}
+function buildSchema(ct) {
+  const pluralName = ct.pluralName ?? toPlural(ct.singularName);
+  const attributes = {};
+  for (const [key, attr] of Object.entries(ct.attributes)) {
+    attributes[key] = buildAttribute(attr);
+  }
+  return clean({
+    kind: ct.kind,
+    collectionName: toSnake(pluralName),
+    info: {
+      singularName: ct.singularName,
+      pluralName,
+      displayName: ct.displayName ?? toTitle(ct.singularName),
+      description: ct.description ?? ""
+    },
+    options: {
+      draftAndPublish: ct.draftAndPublish
+    },
+    // Nível CT é obrigatório p/ o i18n reconhecer a content-type como localizada
+    // (@strapi/i18n: isLocalizedContentType lê pluginOptions.i18n.localized).
+    pluginOptions: ct.localized ? { i18n: { localized: true } } : void 0,
+    attributes
+  });
+}
+function controllerFile(singular) {
+  return `/**
+ * ${singular} controller
+ */
+import { factories } from '@strapi/strapi';
+
+export default factories.createCoreController('${apiUid(singular)}' as any);
+`;
+}
+function routeFile(singular) {
+  return `/**
+ * ${singular} router
+ */
+import { factories } from '@strapi/strapi';
+
+export default factories.createCoreRouter('${apiUid(singular)}' as any);
+`;
+}
+function serviceFile(singular) {
+  return `/**
+ * ${singular} service
+ */
+import { factories } from '@strapi/strapi';
+
+export default factories.createCoreService('${apiUid(singular)}' as any);
+`;
+}
+function generateApi(ct) {
+  const s = ct.singularName;
+  const base = s;
+  return {
+    singularName: s,
+    uid: apiUid(s),
+    files: {
+      [`${base}/content-types/${s}/schema.json`]: JSON.stringify(buildSchema(ct), null, 2) + "\n",
+      [`${base}/controllers/${s}.ts`]: controllerFile(s),
+      [`${base}/routes/${s}.ts`]: routeFile(s),
+      [`${base}/services/${s}.ts`]: serviceFile(s)
+    }
+  };
+}
+function generateAll(manifest) {
+  return manifest.contentTypes.map(generateApi);
+}
+
+// server/src/provision/write.ts
+var import_node_fs = __toESM(require("node:fs"));
+var import_node_path = __toESM(require("node:path"));
+function isDev() {
+  return process.env.NODE_ENV === "development";
+}
+function writeApis(apis, opts) {
+  const result = {
+    ok: false,
+    dryRun: !!opts.dryRun,
+    planned: [],
+    written: [],
+    skipped: [],
+    errors: []
+  };
+  if (!opts.allowOutsideDev && !isDev()) {
+    result.errors.push(
+      "Gera\xE7\xE3o de content-types s\xF3 \xE9 permitida em desenvolvimento (NODE_ENV=development). Em produ\xE7\xE3o, gere os types em dev e fa\xE7a deploy do c\xF3digo."
+    );
+    return result;
+  }
+  if (!import_node_path.default.isAbsolute(opts.apiRoot)) {
+    result.errors.push(`apiRoot deve ser um caminho absoluto: ${opts.apiRoot}`);
+    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)) {
+      result.skipped.push({
+        singularName: api.singularName,
+        reason: `j\xE1 existe em ${import_node_path.default.relative(opts.apiRoot, apiDir)} \u2014 preservado`
+      });
+      continue;
+    }
+    for (const [rel, content] of Object.entries(api.files)) {
+      const full = import_node_path.default.join(opts.apiRoot, rel);
+      const normalized = import_node_path.default.normalize(full);
+      if (normalized !== opts.apiRoot && !normalized.startsWith(opts.apiRoot + import_node_path.default.sep)) {
+        result.errors.push(`caminho fora de apiRoot bloqueado: ${rel}`);
+        continue;
+      }
+      result.planned.push(rel);
+      if (opts.dryRun) continue;
+      try {
+        import_node_fs.default.mkdirSync(import_node_path.default.dirname(full), { recursive: true });
+        import_node_fs.default.writeFileSync(full, content, "utf8");
+        result.written.push(rel);
+      } catch (e) {
+        result.errors.push(`falha ao escrever ${rel}: ${e?.message ?? e}`);
+      }
+    }
+  }
+  result.ok = result.errors.length === 0;
+  return result;
+}
+
+// server/src/provision/seed.ts
+async function seedContent(strapi, manifest) {
+  const result = {
+    ok: false,
+    created: [],
+    skipped: [],
+    errors: []
+  };
+  if (!manifest.seed?.length) {
+    result.ok = true;
+    return result;
+  }
+  const byName = new Map(
+    manifest.contentTypes.map((ct) => [ct.singularName, ct])
+  );
+  for (const group of manifest.seed) {
+    const uid = apiUid(group.singularName);
+    const def = byName.get(group.singularName);
+    if (!def) {
+      result.skipped.push({
+        uid,
+        reason: "singularName n\xE3o consta em contentTypes"
+      });
+      continue;
+    }
+    if (!strapi.contentTypes?.[uid]) {
+      result.skipped.push({
+        uid,
+        reason: "content-type ainda n\xE3o registrada (faltou restart?)"
+      });
+      continue;
+    }
+    const createOne = async (data) => {
+      const doc = await strapi.documents(uid).create({ data });
+      if (def.draftAndPublish && doc?.documentId) {
+        await strapi.documents(uid).publish({ documentId: doc.documentId });
+      }
+    };
+    try {
+      if (def.kind === "singleType") {
+        const current = await strapi.documents(uid).findFirst();
+        if (current) {
+          result.skipped.push({ uid, reason: "single type j\xE1 tem conte\xFAdo" });
+          continue;
+        }
+        if (group.entries[0]) {
+          await createOne(group.entries[0]);
+          result.created.push({ uid, count: 1 });
+        }
+        continue;
+      }
+      const existing = await strapi.documents(uid).findMany({ limit: 1 });
+      if (Array.isArray(existing) && existing.length > 0) {
+        result.skipped.push({ uid, reason: "cole\xE7\xE3o j\xE1 tem conte\xFAdo" });
+        continue;
+      }
+      let count = 0;
+      let failed = 0;
+      for (const data of group.entries) {
+        try {
+          await createOne(data);
+          count++;
+        } catch (e) {
+          failed++;
+          if (failed === 1) result.errors.push(`seed ${uid} (entrada): ${e?.message ?? e}`);
+        }
+      }
+      result.created.push({ uid, count });
+      if (failed) result.skipped.push({ uid, reason: `${failed} entrada(s) falharam` });
+    } catch (e) {
+      result.errors.push(`seed ${uid}: ${e?.message ?? e}`);
+    }
+  }
+  result.ok = result.errors.length === 0;
+  return result;
+}
+
+// server/src/provision/link.ts
+var import_node_fs2 = __toESM(require("node:fs"));
+var import_node_path2 = __toESM(require("node:path"));
+
+// server/src/provision/adapters.ts
+var nextAdapter = {
+  framework: "next",
+  envFileName: ".env.local",
+  defaultPort: 3e3,
+  buildEnv: ({ strapiUrl, apiToken, previewSecret, locales }) => {
+    const env = {
+      // pública: usada por Server e Client Components
+      NEXT_PUBLIC_STRAPI_URL: strapiUrl
+    };
+    if (locales && locales.length) env.NEXT_PUBLIC_LOCALES = locales.join(",");
+    if (apiToken) env.STRAPI_API_TOKEN = apiToken;
+    if (previewSecret) env.PREVIEW_SECRET = previewSecret;
+    return env;
+  },
+  previewBridgeHint: "app/_components/PreviewBridge.tsx montado no layout raiz (postMessage para o admin)"
+};
+var tanstackAdapter = {
+  framework: "tanstack",
+  envFileName: ".env",
+  defaultPort: 5173,
+  buildEnv: ({ strapiUrl, apiToken, previewSecret, locales }) => {
+    const env = {
+      // pública no Vite/TanStack: exposta via import.meta.env
+      VITE_STRAPI_URL: strapiUrl
+    };
+    if (locales && locales.length) env.VITE_LOCALES = locales.join(",");
+    if (apiToken) env.STRAPI_API_TOKEN = apiToken;
+    if (previewSecret) env.PREVIEW_SECRET = previewSecret;
+    return env;
+  },
+  previewBridgeHint: "src/components/PreviewBridge.tsx montado no __root (postMessage para o admin)"
+};
+var ADAPTERS = {
+  next: nextAdapter,
+  tanstack: tanstackAdapter
+};
+function getAdapter(framework) {
+  return ADAPTERS[framework];
+}
+function adapterForManifest(manifest) {
+  return getAdapter(manifest.framework);
+}
+
+// server/src/provision/types-gen.ts
+function toPascal(singular) {
+  return singular.split("-").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join("");
+}
+function scalarToTs(type) {
+  switch (type) {
+    case "string":
+    case "text":
+    case "richtext":
+    case "blocks":
+    case "email":
+    case "uid":
+    case "date":
+    case "datetime":
+    case "time":
+      return "string";
+    case "integer":
+    case "biginteger":
+    case "float":
+    case "decimal":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "json":
+      return "unknown";
+    default:
+      return "unknown";
+  }
+}
+function attrToTs(attr, pascalOf) {
+  switch (attr.type) {
+    case "enumeration":
+      return {
+        tsType: attr.enum.map((e) => JSON.stringify(e)).join(" | "),
+        optional: !attr.required
+      };
+    case "media":
+      return {
+        tsType: attr.multiple ? "StrapiMedia[]" : "StrapiMedia",
+        optional: !attr.required
+      };
+    case "relation": {
+      const target = pascalOf(attr.target);
+      const many = attr.relation === "oneToMany" || attr.relation === "manyToMany";
+      return { tsType: many ? `${target}[]` : target, optional: true };
+    }
+    case "uid":
+      return { tsType: "string", optional: !attr.required };
+    default:
+      return {
+        tsType: scalarToTs(attr.type),
+        optional: !attr.required
+      };
+  }
+}
+function buildInterface(ct) {
+  const name = ct.displayName ? toPascal(ct.singularName) : toPascal(ct.singularName);
+  const lines = [`export interface ${name} {`];
+  lines.push("  documentId: string;");
+  for (const [key, attr] of Object.entries(ct.attributes)) {
+    const { tsType, optional } = attrToTs(attr, toPascal);
+    lines.push(`  ${key}${optional ? "?" : ""}: ${tsType};`);
+  }
+  lines.push("  createdAt: string;");
+  lines.push("  updatedAt: string;");
+  lines.push("  publishedAt?: string;");
+  lines.push("}");
+  return lines.join("\n");
+}
+var PREAMBLE = `// Tipos gerados automaticamente a partir do strapi.manifest.json.
+// N\xC3O edite \xE0 m\xE3o \u2014 rode o link novamente para regenerar.
+
+export interface StrapiMedia {
+  id: number;
+  documentId: string;
+  url: string;
+  alternativeText?: string;
+  width?: number;
+  height?: number;
+  mime?: string;
+  name?: string;
+}
+`;
+function generateTypes(manifest) {
+  const interfaces = manifest.contentTypes.map(buildInterface).join("\n\n");
+  return `${PREAMBLE}
+${interfaces}
+`;
+}
+
+// server/src/provision/link.ts
+function parseEnv(content) {
+  const out = {};
+  for (const line of content.split("\n")) {
+    const m = line.match(/^\s*([A-Z0-9_]+)\s*=(.*)$/);
+    if (m) out[m[1]] = m[2];
+  }
+  return out;
+}
+function mergeEnv(existing, next) {
+  const current = parseEnv(existing);
+  const added = [];
+  const preserved = [];
+  const extra = [];
+  for (const [k, v] of Object.entries(next)) {
+    if (k in current) {
+      preserved.push(k);
+    } else {
+      added.push(k);
+      extra.push(`${k}=${v}`);
+    }
+  }
+  let content = existing;
+  if (extra.length) {
+    const block = "\n# adicionado pelo mcp-chat (link)\n" + extra.join("\n") + "\n";
+    content = existing.trimEnd() + "\n" + block;
+  }
+  return { content, added, preserved };
+}
+function buildPreviewConfig(manifest) {
+  const routes = {};
+  for (const ct of manifest.contentTypes) {
+    if (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.
+// Mapa uid -> rota do frontend (placeholders :campo s\xE3o preenchidos pelo doc).
+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') } },
+  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 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()}\`;
+      },
+    },
+  },
+});
+`;
+}
+function ensureInside(base, target) {
+  const n = import_node_path2.default.normalize(target);
+  return n === base || n.startsWith(base + import_node_path2.default.sep);
+}
+function linkFrontend(manifest, opts) {
+  const adapter = adapterForManifest(manifest);
+  const result = {
+    ok: false,
+    envFile: adapter.envFileName,
+    envAdded: [],
+    envPreserved: [],
+    typesFile: "strapi-types.ts",
+    previewFile: "config/admin.ts",
+    previewAction: "skipped",
+    errors: []
+  };
+  if (!import_node_path2.default.isAbsolute(opts.frontendDir) || !import_node_path2.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);
+    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 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");
+  } catch (e) {
+    result.errors.push(`env: ${e?.message ?? e}`);
+  }
+  try {
+    const typesPath = import_node_path2.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");
+  } 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");
+      }
+      result.previewAction = "created";
+    }
+  } catch (e) {
+    result.errors.push(`preview: ${e?.message ?? e}`);
+  }
+  result.ok = result.errors.length === 0;
+  return result;
+}
+
+// server/src/provision/permissions.ts
+async function grantPublicRead(strapi, manifest) {
+  const result = { granted: [], errors: [] };
+  let publicRole;
+  try {
+    publicRole = await strapi.query("plugin::users-permissions.role").findOne({ where: { type: "public" } });
+  } catch (e) {
+    result.errors.push(`papel public: ${e?.message ?? e}`);
+    return result;
+  }
+  if (!publicRole) {
+    result.errors.push('papel "public" n\xE3o encontrado (users-permissions ativo?)');
+    return result;
+  }
+  for (const ct of manifest.contentTypes) {
+    const uid = apiUid(ct.singularName);
+    const actions = ct.kind === "singleType" ? ["find"] : ["find", "findOne"];
+    for (const action of actions) {
+      const actionId = `${uid}.${action}`;
+      try {
+        const existing = await strapi.query("plugin::users-permissions.permission").findOne({ where: { action: actionId, role: publicRole.id } });
+        if (!existing) {
+          await strapi.query("plugin::users-permissions.permission").create({ data: { action: actionId, role: publicRole.id } });
+          result.granted.push(actionId);
+        }
+      } catch (e) {
+        result.errors.push(`${actionId}: ${e?.message ?? e}`);
+      }
+    }
+  }
+  return result;
+}
+
+// server/src/provision/orchestrate.ts
+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);
+}
+function donePath(strapiAppDir) {
+  return import_node_path3.default.join(strapiAppDir, MARKER_DIR, DONE_FILE);
+}
+function getProvisionStatus(strapiAppDir) {
+  const pending = import_node_fs3.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"));
+  } catch {
+  }
+  return { pending, done };
+}
+function stageProvision(strapi, input) {
+  const result = {
+    ok: false,
+    validation: { ok: false },
+    staged: false,
+    willReload: false,
+    errors: []
+  };
+  const v = validateManifest(input.rawManifest);
+  if (!v.ok) {
+    result.validation = { ok: false, errors: v.errors };
+    result.errors.push("manifest inv\xE1lido");
+    return result;
+  }
+  result.validation = { ok: true };
+  const apis = generateAll(v.data);
+  const write = writeApis(apis, { apiRoot: input.apiRoot, dryRun: input.dryRun });
+  result.write = write;
+  if (!write.ok) {
+    result.errors.push(...write.errors);
+    return result;
+  }
+  const marker = {
+    manifest: v.data,
+    frontendDir: input.frontendDir,
+    strapiAppDir: input.strapiAppDir,
+    context: input.context
+  };
+  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");
+      try {
+        import_node_fs3.default.unlinkSync(donePath(input.strapiAppDir));
+      } catch {
+      }
+      result.staged = true;
+    } catch (e) {
+      result.errors.push(`marcador: ${e?.message ?? e}`);
+      return result;
+    }
+  }
+  result.ok = true;
+  result.willReload = !input.dryRun && write.written.length > 0;
+  return result;
+}
+async function runPendingProvision(strapi, strapiAppDir) {
+  const result = { ran: false, errors: [] };
+  const mp = markerPath(strapiAppDir);
+  if (!import_node_fs3.default.existsSync(mp)) return result;
+  let marker;
+  try {
+    marker = JSON.parse(import_node_fs3.default.readFileSync(mp, "utf8"));
+  } catch (e) {
+    result.errors.push(`marcador ileg\xEDvel: ${e?.message ?? e}`);
+    return result;
+  }
+  result.ran = true;
+  try {
+    result.seed = await seedContent(strapi, marker.manifest);
+  } catch (e) {
+    result.errors.push(`seed: ${e?.message ?? e}`);
+  }
+  try {
+    result.permissions = await grantPublicRead(strapi, marker.manifest);
+    if (result.permissions.errors.length) {
+      result.errors.push(...result.permissions.errors.map((e) => `perm: ${e}`));
+    }
+  } catch (e) {
+    result.errors.push(`permiss\xF5es: ${e?.message ?? e}`);
+  }
+  try {
+    result.link = linkFrontend(marker.manifest, {
+      frontendDir: marker.frontendDir,
+      strapiAppDir: marker.strapiAppDir,
+      context: marker.context
+    });
+  } catch (e) {
+    result.errors.push(`link: ${e?.message ?? e}`);
+  }
+  try {
+    const adapter = adapterForManifest(marker.manifest);
+    const previewUrl = marker.context.frontendUrl || `http://localhost:${adapter.defaultPort}`;
+    const done = {
+      name: marker.manifest.name,
+      framework: marker.manifest.framework,
+      frontendDir: marker.frontendDir,
+      contentTypes: marker.manifest.contentTypes.map((c) => apiUid(c.singularName)),
+      previewUrl,
+      seedCreated: result.seed?.created ?? [],
+      linkErrors: result.link?.errors ?? [],
+      finishedAt: (/* @__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");
+  } catch (e) {
+    result.errors.push(`resumo: ${e?.message ?? e}`);
+  }
+  try {
+    import_node_fs3.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 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"
+]);
+var CODE_EXT = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx", ".mjs"]);
+var MAX_FILES = 18;
+var MAX_TOTAL_CHARS = 6e4;
+var MAX_FILE_CHARS = 12e3;
+function score(rel) {
+  const p = rel.toLowerCase();
+  let s = 0;
+  if (/(^|\/)(data|content|mocks?|seeds?|fixtures?)(\/|\.)/.test(p)) s += 10;
+  if (/(site|config|constants|catalog|products?|services?|posts?|items?)/.test(p)) s += 4;
+  if (p.startsWith("src/")) s += 2;
+  if (p.endsWith(".tsx") || p.endsWith(".jsx")) s -= 1;
+  return s;
+}
+function walk(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(".") && e.name !== ".") continue;
+    const full = import_node_path4.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));
+    }
+  }
+}
+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;
+    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;
+    } catch {
+    }
+  }
+  return { files, tree };
+}
+var MAX_TEXT_FILES = 25;
+var MAX_TEXTS_PER_FILE = 60;
+function extractTexts(content) {
+  const found = /* @__PURE__ */ new Set();
+  const add = (s) => {
+    const t = s.replace(/\s+/g, " ").trim();
+    if (t.length < 2 || t.length > 140) return;
+    if (!/[A-Za-zÀ-ÿ]/.test(t)) return;
+    if (/[{}<>()[\];=`|]|\$\{|=>|&&|\|\||https?:|@\//.test(t)) return;
+    if (/\b(return|const|let|var|function|map|filter|import|export|className|props)\b/.test(t)) return;
+    if (/\w\.\w/.test(t)) return;
+    if (/^[a-z]+([A-Z][a-z]+)+$/.test(t)) return;
+    if (!/[A-Za-zÀ-ÿ]{3,}/.test(t)) return;
+    found.add(t);
+  };
+  for (const m of content.matchAll(/>\s*([^<>{}\n][^<>{}]*?)\s*</g)) add(m[1]);
+  for (const m of content.matchAll(/\b(?:placeholder|title|alt|label|aria-label)\s*=\s*"([^"]+)"/g)) add(m[1]);
+  return [...found].slice(0, MAX_TEXTS_PER_FILE);
+}
+function collectPageTexts(frontendDir) {
+  const all = [];
+  walk(frontendDir, frontendDir, all);
+  const out = [];
+  const ranked = all.filter((rel) => /\.(tsx|jsx)$/.test(rel)).filter((rel) => !/\/(ui)\//.test(rel)).sort((a, b) => {
+    const pa = /routes?\/|pages?\//.test(a) ? 0 : 1;
+    const pb = /routes?\/|pages?\//.test(b) ? 0 : 1;
+    return pa - pb;
+  });
+  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"));
+      if (texts.length) out.push({ rel, texts });
+    } catch {
+    }
+  }
+  return out;
+}
+var RESERVED = /* @__PURE__ */ new Set([
+  "id",
+  "documentId",
+  "createdAt",
+  "updatedAt",
+  "publishedAt",
+  "createdBy",
+  "updatedBy",
+  "locale",
+  "localizations"
+]);
+var MAX_PAGE_TYPES = 45;
+function toFieldKey(text) {
+  const words = text.toLowerCase().replace(/[^a-z0-9]+/g, " ").trim().split(/\s+/).filter(Boolean).slice(0, 6);
+  if (!words.length) return "text";
+  let key = words[0] + words.slice(1).map((w) => w[0].toUpperCase() + w.slice(1)).join("");
+  key = key.slice(0, 44).replace(/^[^a-zA-Z]+/, "");
+  if (!key) key = "text";
+  if (RESERVED.has(key)) key = key + "Field";
+  return key;
+}
+function toPageName(rel) {
+  let base = rel.replace(/\\/g, "/").split("/").pop() || "page";
+  base = base.replace(/\.(tsx|jsx|ts|js)$/, "");
+  base = base.replace(/^\$+/, "").replace(/\$/g, "");
+  if (/^index$/.test(base)) base = "home";
+  else if (/^__?root$/.test(base)) base = "layout";
+  const kebab2 = base.replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/[^a-zA-Z0-9]+/g, "-").toLowerCase().replace(/^-+|-+$/g, "").replace(/^[^a-z]+/, "");
+  return ((kebab2 || "page") + "-content").slice(0, 48);
+}
+function buildPageContentTypes(pageTexts, budget) {
+  const contentTypes = [];
+  const seed = [];
+  const usedNames = /* @__PURE__ */ new Set();
+  const overflow = [];
+  const allowed = Math.max(0, Math.min(budget, MAX_PAGE_TYPES));
+  pageTexts.forEach((p, idx) => {
+    if (idx >= allowed) {
+      for (const t of p.texts) overflow.push({ page: toPageName(p.rel), value: t });
+      return;
+    }
+    let name = toPageName(p.rel);
+    while (usedNames.has(name)) name = name.replace(/(-\d+)?-content$/, "") + `-${idx}-content`;
+    usedNames.add(name);
+    const attributes = {};
+    const entry = {};
+    const usedKeys = /* @__PURE__ */ new Set();
+    for (const text of p.texts) {
+      let key = toFieldKey(text);
+      let k = key;
+      let n = 2;
+      while (usedKeys.has(k)) k = `${key}${n++}`.slice(0, 46);
+      usedKeys.add(k);
+      attributes[k] = { type: text.length > 80 ? "text" : "string" };
+      entry[k] = text;
+    }
+    if (!Object.keys(attributes).length) return;
+    contentTypes.push({
+      singularName: name,
+      displayName: name.replace(/-/g, " ").replace(/\b\w/g, (c) => c.toUpperCase()),
+      kind: "singleType",
+      draftAndPublish: true,
+      attributes
+    });
+    seed.push({ singularName: name, entries: [entry] });
+  });
+  if (overflow.length) {
+    contentTypes.push({
+      singularName: "page-text",
+      displayName: "Page Text",
+      kind: "collectionType",
+      draftAndPublish: true,
+      attributes: {
+        page: { type: "string" },
+        value: { type: "text" }
+      }
+    });
+    seed.push({ singularName: "page-text", entries: overflow });
+  }
+  return { contentTypes, seed };
+}
+function detectFramework(frontendDir) {
+  try {
+    const pkg = JSON.parse(import_node_fs4.default.readFileSync(import_node_path4.default.join(frontendDir, "package.json"), "utf8"));
+    const deps = { ...pkg.dependencies || {}, ...pkg.devDependencies || {} };
+    if (deps.next) return "next";
+    if (deps["@tanstack/react-start"]) return "tanstack";
+    if (deps.vite) return "tanstack";
+  } catch {
+  }
+  return "tanstack";
+}
+function buildPrompt(framework, c, name) {
+  const filesBlock = c.files.map((f) => `--- ARQUIVO: ${f.rel} ---
+${f.content}`).join("\n\n");
+  return `Voc\xEA \xE9 um arquiteto de conte\xFAdo Strapi 5. Analise o c\xF3digo de um frontend e projete o modelo de conte\xFAdo.
+
+Gere um JSON "strapi.manifest.json" com ESTE formato:
+{
+  "manifestVersion": 1,
+  "name": "${name}",
+  "framework": "${framework}",
+  "strapiVersion": "^5.47",
+  "contentTypes": [
+    {
+      "singularName": "kebab-case",          // ex.: "produto", "service", "blog-post"
+      "displayName": "Nome leg\xEDvel",
+      "kind": "collectionType" | "singleType", // listas = collectionType; config/\xFAnico = singleType
+      "draftAndPublish": true,
+      "attributes": {
+        "campo": { "type": "string|text|richtext|integer|decimal|boolean|date|datetime|email|json|uid|enumeration|media|relation", ... }
+        // uid: { "type":"uid", "targetField":"umCampoString" }
+        // enumeration: { "type":"enumeration", "enum":["a","b"] }
+        // media: { "type":"media", "multiple":false, "allowedTypes":["images"] }
+        // relation: { "type":"relation", "relation":"manyToOne|oneToMany|manyToMany|oneToOne", "target":"singularName-de-outro-type" }
+      },
+      "preview": { "route": "/rota/:slug" }   // opcional; s\xF3 se houver p\xE1gina de detalhe
+    }
+  ],
+  "seed": [
+    { "singularName": "...", "entries": [ { ...dados-extra\xEDdos-do-c\xF3digo... } ] }
+  ],
+  "env": ["${framework === "next" ? "NEXT_PUBLIC_STRAPI_URL" : "VITE_STRAPI_URL"}", "STRAPI_API_TOKEN", "PREVIEW_SECRET"]
+}
+
+REGRAS:
+- Crie uma content-type para cada COLE\xC7\xC3O de dados (arrays de objetos). Use os MESMOS nomes de campo do c\xF3digo.
+- 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.
+- 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.
+- Se n\xE3o houver cole\xE7\xF5es de dados, devolva contentTypes: [] e seed: [].
+- Responda APENAS com o JSON, nada de markdown.
+
+\xC1rvore de arquivos do projeto:
+${c.tree.slice(0, 200).join("\n")}
+
+Arquivos de dados (cole\xE7\xF5es):
+${filesBlock}`;
+}
+async function inferManifest(strapi, frontendDir, opts) {
+  const framework = detectFramework(frontendDir);
+  const result = {
+    ok: false,
+    inferred: true,
+    filesAnalyzed: [],
+    framework,
+    warnings: [],
+    errors: []
+  };
+  const existing = import_node_path4.default.join(frontendDir, "strapi.manifest.json");
+  if (import_node_fs4.default.existsSync(existing)) {
+    try {
+      const raw = JSON.parse(import_node_fs4.default.readFileSync(existing, "utf8"));
+      const v2 = validateManifest(raw);
+      result.inferred = false;
+      result.rawManifest = raw;
+      if (v2.ok) {
+        result.ok = true;
+        result.manifest = v2.data;
+      } else {
+        result.errors.push(...v2.errors ?? []);
+      }
+      return result;
+    } catch (e) {
+      result.errors.push(`manifest existente ileg\xEDvel: ${e?.message ?? e}`);
+      return result;
+    }
+  }
+  const collected = collectFiles(frontendDir);
+  const pageTexts = collectPageTexts(frontendDir);
+  result.filesAnalyzed = [
+    ...collected.files.map((f) => f.rel),
+    ...pageTexts.map((p) => p.rel)
+  ];
+  if (collected.files.length === 0 && pageTexts.length === 0) {
+    result.errors.push(
+      "N\xE3o encontrei dados nem textos para analisar. Adicione um strapi.manifest.json manualmente."
+    );
+    return result;
+  }
+  const envList = [
+    framework === "next" ? "NEXT_PUBLIC_STRAPI_URL" : "VITE_STRAPI_URL",
+    "STRAPI_API_TOKEN",
+    "PREVIEW_SECRET"
+  ];
+  let dataCts = [];
+  let dataSeed = [];
+  const apiKey = process.env.OPENAI_API_KEY;
+  if (apiKey && collected.files.length) {
+    const callOpenAI = async (messages2) => {
+      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: messages2 })
+      });
+      if (!res.ok) throw new Error(`OpenAI: ${await res.text()}`);
+      return res.json();
+    };
+    const messages = [
+      { role: "system", content: "Voc\xEA projeta modelos de conte\xFAdo Strapi 5 e responde s\xF3 com JSON v\xE1lido." },
+      { role: "user", content: buildPrompt(framework, collected, opts.name) }
+    ];
+    try {
+      for (let attempt = 0; attempt < 2; attempt++) {
+        const data = await callOpenAI(messages);
+        const raw = JSON.parse(data.choices?.[0]?.message?.content ?? "{}");
+        const candidate = {
+          manifestVersion: 1,
+          name: opts.name,
+          framework,
+          strapiVersion: "^5.47",
+          contentTypes: Array.isArray(raw.contentTypes) ? raw.contentTypes : [],
+          seed: Array.isArray(raw.seed) ? raw.seed : [],
+          env: envList
+        };
+        if (!candidate.contentTypes.length) break;
+        const v2 = validateManifest(candidate);
+        if (v2.ok) {
+          dataCts = v2.data.contentTypes;
+          dataSeed = v2.data.seed ?? [];
+          break;
+        }
+        if (attempt === 0) {
+          messages.push({ role: "assistant", content: JSON.stringify(raw) });
+          messages.push({ role: "user", content: "JSON REJEITADO pela valida\xE7\xE3o:\n" + (v2.errors ?? []).join("\n") + "\nCorrija e responda s\xF3 com o JSON." });
+        } else {
+          result.warnings.push("Modelo de dados (IA) inv\xE1lido \u2014 seguindo s\xF3 com os textos.");
+        }
+      }
+    } catch (e) {
+      result.warnings.push(`IA de dados indispon\xEDvel (seguindo s\xF3 com os textos): ${e?.message ?? e}`);
+    }
+  } else if (!apiKey) {
+    result.warnings.push("Sem OPENAI_API_KEY: modelando os TEXTOS (determin\xEDstico); cole\xE7\xF5es de dados n\xE3o inferidas.");
+  }
+  const budget = 60 - dataCts.length - 1;
+  const page = buildPageContentTypes(pageTexts, budget);
+  const finalManifest = {
+    manifestVersion: 1,
+    name: opts.name,
+    framework,
+    strapiVersion: "^5.47",
+    contentTypes: [...dataCts, ...page.contentTypes],
+    seed: [...dataSeed, ...page.seed],
+    env: envList
+  };
+  result.rawManifest = finalManifest;
+  let v = validateManifest(finalManifest);
+  if (!v.ok) {
+    result.warnings.push("Manifest combinado inv\xE1lido; caindo para s\xF3-textos. " + (v.errors ?? []).join("; "));
+    const pageOnly = { ...finalManifest, contentTypes: page.contentTypes, seed: page.seed };
+    result.rawManifest = pageOnly;
+    v = validateManifest(pageOnly);
+  }
+  if (v.ok) {
+    result.ok = true;
+    result.manifest = v.data;
+  } else {
+    result.errors.push(...v.errors ?? []);
+  }
+  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"));
+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([
+  "node_modules",
+  ".git",
+  "dist",
+  ".next",
+  ".output",
+  ".vinxi",
+  ".tanstack",
+  "build",
+  "coverage",
+  ".turbo",
+  ".cache",
+  "public"
+]);
+var CODE_EXT2 = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx", ".mjs"]);
+var MAX_DATA_FILES = 3;
+var MAX_FILE_CHARS2 = 16e3;
+function score2(rel) {
+  const p = rel.toLowerCase();
+  let s = 0;
+  if (/(^|\/)(data|content|mocks?|seeds?|fixtures?)(\/|\.)/.test(p)) s += 10;
+  if (/(site|config|constants|catalog|products?|services?|posts?|items?)/.test(p)) s += 4;
+  if (p.startsWith("src/")) s += 2;
+  if (p.endsWith(".tsx") || p.endsWith(".jsx")) s -= 3;
+  return s;
+}
+function walk2(dir, base, out) {
+  let entries;
+  try {
+    entries = import_node_fs6.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);
+    if (e.isDirectory()) {
+      if (SKIP_DIRS2.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));
+    }
+  }
+}
+function findDataFiles(frontendDir) {
+  const all = [];
+  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");
+      return /export\s+const\s+\w+\s*[:=]\s*(\[|\{)/.test(c);
+    } catch {
+      return false;
+    }
+  }).sort((a, b) => b.s - a.s).slice(0, MAX_DATA_FILES).map((x) => x.rel);
+}
+async function getLocales(strapi) {
+  try {
+    const svc = strapi.plugin("i18n").service("locales");
+    const all = await svc.find() || [];
+    const def = await svc.getDefaultLocale() || "en";
+    const codes = all.map((l) => l.code);
+    return { codes, def };
+  } catch {
+    return { codes: [], def: "en" };
+  }
+}
+function extractImports(src) {
+  return src.split("\n").filter((l) => /^\s*import\s.+from\s+['"].+['"];?\s*$/.test(l)).join("\n");
+}
+function exportNames(src) {
+  const names = [];
+  const re = /export\s+const\s+(\w+)\b/g;
+  let m;
+  while (m = re.exec(src)) names.push(m[1]);
+  return names;
+}
+function stripFence(s) {
+  const m = s.match(/```[a-zA-Z]*[ \t]*\r?\n([\s\S]*?)```/);
+  let out = (m ? m[1] : s).trim();
+  out = out.replace(/^\s*(?:javascript|typescript|tsx?|jsx?)\s*\n/i, "");
+  return out.trim();
+}
+var STRAPI_CLIENT_TS = `// Gerado pelo mcp-chat \u2014 client oficial @strapi/client.
+import { strapi } from "@strapi/client";
+
+function baseUrl(): string {
+  // Vite (TanStack) exp\xF5e via import.meta.env; Next via process.env.
+  try {
+    // @ts-ignore
+    const v = import.meta?.env?.VITE_STRAPI_URL;
+    if (v) return v;
+  } catch {}
+  if (typeof process !== "undefined") {
+    const p = process.env.NEXT_PUBLIC_STRAPI_URL || process.env.STRAPI_URL;
+    if (p) return p;
+  }
+  return "http://localhost:1337";
+}
+const token = typeof process !== "undefined" ? process.env.STRAPI_API_TOKEN : undefined;
+
+const client = strapi({ baseURL: baseUrl().replace(/\\/$/, "") + "/api", ...(token ? { auth: token } : {}) });
+
+export type FetchOpts = { locale?: string; status?: "draft" | "published" };
+const params = (o: FetchOpts) => ({ populate: "*" as const, ...(o.locale ? { locale: o.locale } : {}), ...(o.status ? { status: o.status } : {}) });
+
+/** Cole\xE7\xE3o (usa o pluralName). Retorna o array de documentos (shape flat v5). */
+export async function fetchCollection(plural: string, o: FetchOpts = {}): Promise<any[]> {
+  const r = await client.collection(plural).find(params(o));
+  return (r as any).data ?? [];
+}
+/** Single type (usa o singularName). Retorna o documento. */
+export async function fetchSingle(singular: string, o: FetchOpts = {}): Promise<any> {
+  const r = await client.single(singular).find(params(o));
+  return (r as any).data ?? null;
+}
+`;
+async function ensureClientDep(frontendDir, warnings) {
+  if (import_node_fs6.default.existsSync(import_node_path6.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"));
+    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");
+    }
+  } 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 args = pm === "npm" ? ["install", "@strapi/client", "--no-audit", "--no-fund"] : ["add", "@strapi/client"];
+  await new Promise((resolve) => {
+    try {
+      const c = (0, import_node_child_process2.spawn)(pm, args, { cwd: frontendDir, stdio: "ignore" });
+      c.on("exit", () => resolve());
+      c.on("error", () => {
+        warnings.push(`n\xE3o consegui instalar @strapi/client (${pm}); instale manualmente.`);
+        resolve();
+      });
+    } catch {
+      warnings.push("falha ao instalar @strapi/client; instale manualmente.");
+      resolve();
+    }
+  });
+}
+async function fetchSample(strapi, cts) {
+  const sample = {};
+  for (const ct of cts) {
+    const uid = apiUid(ct.singularName);
+    try {
+      if (ct.kind === "singleType") {
+        sample[ct.singularName] = await strapi.documents(uid).findFirst({ status: "published", populate: "*" });
+      } else {
+        const docs = await strapi.documents(uid).findMany({ status: "published", populate: "*", limit: 2 });
+        sample[ct.singularName] = Array.isArray(docs) ? docs : [];
+      }
+    } catch {
+      sample[ct.singularName] = ct.kind === "singleType" ? null : [];
+    }
+  }
+  return sample;
+}
+async function generateMapper(apiKey, baseSrc, sample, assetIds) {
+  const prompt = `Gere uma FUN\xC7\xC3O TypeScript pura chamada exatamente \`mapStrapiToData(raw: Record<string, any>)\` que recebe os dados da Content API do Strapi e retorna um objeto com EXATAMENTE os mesmos exports (mesmas chaves e MESMO shape) do arquivo de dados abaixo.
+
+REGRAS:
+- A fun\xE7\xE3o retorna um objeto cujas chaves s\xE3o os nomes dos \`export const\` do arquivo (ex.: site, services, projects\u2026), cada um no MESMO formato que o arquivo original.
+- \`raw\` tem uma chave por content-type (singularName): cole\xE7\xF5es s\xE3o arrays de documentos; single types s\xE3o um objeto. Documentos v\xEAm no shape FLAT do Strapi 5 (campos no topo: documentId, e os atributos diretamente).
+- Mapeie os campos do Strapi para os campos esperados pelo arquivo (casando por nome/significado). Para listas, use \`(raw.x ?? []).map(...)\`.
+- IMAGENS: o campo pode ser objeto de m\xEDdia com \`.url\`, uma string, ou null. Use \`(doc?.campo?.url ?? doc?.campo)\` quando houver; SEN\xC3O use o asset importado original como fallback. Assets importados dispon\xEDveis (use como vari\xE1veis): ${assetIds.join(", ") || "(nenhum)"}.
+- DEFENSIVO (OBRIGAT\xD3RIO \u2014 o SSR n\xE3o pode quebrar): use SEMPRE optional chaining \`?.\` e defaults \`??\`. NUNCA chame m\xE9todos (\`.replace\`, \`.map\`, \`.split\`, etc.) em valores que possam ser null/undefined \u2014 guarde antes: \`(x ?? "").replace(...)\`, \`(arr ?? []).map(...)\`. Todo acesso a sub-campo deve tolerar aus\xEAncia.
+- N\xE3o invente conte\xFAdo; campo ausente \u2192 default sensato (string vazia, array vazio, ou o fallback de imagem).
+- ISOLAMENTO POR EXPORT (OBRIGAT\xD3RIO): construa o resultado com CADA export no seu pr\xF3prio try/catch, para que uma falha num export N\xC3O derrube os outros. Padr\xE3o EXATO:
+  \`function mapStrapiToData(raw) { const out = {}; try { out.site = (/* ... */); } catch { out.site = {}; } try { out.services = (raw.service ?? []).map((s) => (/* ... */)); } catch { out.services = []; } /* ...um try/catch por export... */ return out; }\`
+- Responda APENAS com o c\xF3digo da fun\xE7\xE3o (sem imports, sem markdown, sem exports \u2014 s\xF3 \`function mapStrapiToData(raw) { ... }\`).
+
+ARQUIVO DE DADOS ORIGINAL (shape alvo):
+${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, {
+    method: "POST",
+    headers: { Authorization: `Bearer ${apiKey}`, "Content-Type": "application/json" },
+    body: JSON.stringify({
+      model: MODEL2,
+      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." },
+        { role: "user", content: prompt }
+      ]
+    })
+  });
+  if (!res.ok) throw new Error(await res.text());
+  const json = await res.json();
+  return stripFence(json.choices?.[0]?.message?.content ?? "");
+}
+function assetImportIds(src) {
+  const ids = [];
+  const re = /import\s+(\w+)\s+from\s+['"][^'"]+['"]/g;
+  let m;
+  while (m = re.exec(src)) ids.push(m[1]);
+  return ids;
+}
+function buildLiveDataModule(baseSrc, mapperCode, cts, locales, defLocale) {
+  const imports = extractImports(baseSrc).split("\n").filter((l) => /@\/assets|\.(png|jpe?g|svg|webp|gif)/i.test(l)).join("\n");
+  const names = exportNames(baseSrc);
+  const ctMeta = JSON.stringify(cts.map((c) => ({ s: c.singularName, p: c.pluralName, k: c.kind })));
+  const camel = (s) => s.replace(/-+([a-zA-Z0-9])/g, (_m, c) => c.toUpperCase());
+  const singleMap = {};
+  for (const c of cts) {
+    if (c.kind !== "singleType") continue;
+    const e = camel(c.singularName);
+    if (names.includes(e)) continue;
+    singleMap[c.singularName] = e;
+  }
+  const pageExports = Object.values(singleMap).map((e) => `export const ${e}: any = __live(${JSON.stringify(e)});`).join("\n");
+  const liveExports = names.map((n) => `export const ${n}: any = __live(${JSON.stringify(n)});`).join("\n") + (pageExports ? "\n" + pageExports : "");
+  return `// Live data from Strapi Content API (gerado pelo mcp-chat)
+${imports}
+import { fetchCollection, fetchSingle } from "./strapi-client";
+
+const __cts = ${ctMeta};
+const __single: Record<string, string> = ${JSON.stringify(singleMap)};
+export const __availableLocales = ${JSON.stringify(locales)};
+export const __defaultLocale = ${JSON.stringify(defLocale)};
+/** Locale ativo a partir de ?locale/cookie (cliente) \u2014 p/ o seletor. */
+export function __getLocale(): string {
+  try {
+    if (typeof window !== "undefined") {
+      const u = new URL(window.location.href).searchParams.get("locale");
+      if (u) return u;
+      const m = document.cookie.match(/(?:^|;\\s*)site-locale=([^;]+)/);
+      if (m) return decodeURIComponent(m[1]);
+    }
+  } catch {}
+  return __defaultLocale;
+}
+
+${mapperCode}
+
+const __store: Record<string, any> = {};
+export function hydrate(d: any) { if (d) for (const k of Object.keys(d)) __store[k] = d[k]; }
+
+export async function loadAllData(opts: { locale?: string; status?: "draft" | "published" } = {}) {
+  const raw: Record<string, any> = {};
+  await Promise.all(
+    __cts.map(async (c: any) => {
+      try {
+        raw[c.s] = c.k === "singleType" ? await fetchSingle(c.s, opts) : await fetchCollection(c.p, opts);
+      } catch {
+        raw[c.s] = c.k === "singleType" ? null : [];
+      }
+    })
+  );
+  let data: any = {};
+  try { data = mapStrapiToData(raw) || {}; }
+  catch (e) { if (typeof console !== "undefined") console.error("[mcp-chat] mapStrapiToData falhou:", e); }
+  hydrate(data);
+  // exp\xF5e o conte\xFAdo de p\xE1gina (single types) bruto/traduzido p/ os componentes.
+  for (const s of Object.keys(__single)) __store[__single[s]] = raw[s] || {};
+  return data;
+}
+
+// Exports "vivos": leem o store hidratado pelo loader (sem mudar os componentes).
+function __live(key: string): any {
+  return new Proxy(function () {} as any, {
+    get(_t, p) {
+      const v = __store[key];
+      const r = v == null ? (Array.isArray(__fallback(key)) ? [] : undefined) : (v as any)[p as any];
+      return typeof r === "function" ? r.bind(v) : r;
+    },
+    has(_t, p) { const v = __store[key]; return v != null && (p in (v as any)); },
+    ownKeys() { const v = __store[key]; return v ? Reflect.ownKeys(v as any) : []; },
+    getOwnPropertyDescriptor(_t, p) {
+      const v = __store[key]; if (v == null) return undefined;
+      const d = Object.getOwnPropertyDescriptor(v as any, p);
+      if (d) (d as any).configurable = true;
+      return d;
+    },
+  });
+}
+function __fallback(_k: string): any { return []; }
+
+${liveExports}
+`;
+}
+var switcherTsx = (dataImport) => `// Gerado pelo mcp-chat \u2014 seletor de idioma.
+import { __availableLocales, __getLocale } from "${dataImport}";
+
+const LABELS: Record<string, string> = {
+  en: "EN", "pt-BR": "PT", pt: "PT", es: "ES", fr: "FR", de: "DE", it: "IT",
+  nl: "NL", ja: "JA", ko: "KO", ru: "RU", ar: "AR", "zh-Hans": "ZH", zh: "ZH",
+};
+
+export function LanguageSwitcher() {
+  if (!__availableLocales || __availableLocales.length < 2) return null;
+  const current = __getLocale();
+  const onChange = (e: any) => {
+    const loc = e.target.value;
+    try { document.cookie = "site-locale=" + loc + ";path=/;max-age=31536000"; } catch {}
+    const u = new URL(window.location.href);
+    u.searchParams.set("locale", loc);
+    window.location.href = u.toString();
+  };
+  return (
+    <select
+      aria-label="Language"
+      value={current}
+      onChange={onChange}
+      style={{
+        border: "1px solid rgba(0,0,0,.15)", borderRadius: 9999, padding: "4px 10px",
+        fontSize: 13, fontWeight: 600, background: "transparent", cursor: "pointer",
+      }}
+    >
+      {__availableLocales.map((l: string) => (
+        <option key={l} value={l}>{LABELS[l] || l.toUpperCase()}</option>
+      ))}
+    </select>
+  );
+}
+
+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 rootRel = ["src/routes/__root.tsx", "src/routes/__root.jsx"].find(
+    (r) => import_node_fs6.default.existsSync(import_node_path6.default.join(frontendDir, r))
+  );
+  if (rootRel) {
+    const abs = import_node_path6.default.join(frontendDir, rootRel);
+    let src = import_node_fs6.default.readFileSync(abs, "utf8");
+    if (!src.includes("loadAllData")) {
+      src = `import { loadAllData } from "${dataImport}";
+` + src;
+      const m = src.match(/createRootRoute\w*\s*(?:<[\s\S]*?>)?\s*\([\s\S]*?\)\s*\(\s*\{/);
+      if (m) {
+        const at = m.index + m[0].length;
+        src = src.slice(0, at) + `
+  validateSearch: (s: Record<string, unknown>) => ({ locale: typeof s.locale === "string" ? s.locale : undefined }),
+  loaderDeps: ({ search }: any) => ({ locale: search.locale }),
+  loader: async ({ deps }: any) => { const data = await loadAllData({ locale: deps?.locale }); return { data }; },` + src.slice(at);
+      } else {
+        warnings.push("n\xE3o consegui injetar o loader no __root (padr\xE3o n\xE3o encontrado).");
+      }
+      import_node_fs6.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))
+  );
+  if (headerRel) {
+    const abs = import_node_path6.default.join(frontendDir, headerRel);
+    let src = import_node_fs6.default.readFileSync(abs, "utf8");
+    if (!src.includes("LanguageSwitcher")) {
+      src = `import { LanguageSwitcher } from "@/components/LanguageSwitcher";
+` + src;
+      if (/<button[^>]*lg:hidden/.test(src)) {
+        src = src.replace(/(\s*)(<button[^>]*lg:hidden)/, `$1<LanguageSwitcher />$1$2`);
+      } else {
+        src = src.replace(/<\/header>/, `  <LanguageSwitcher />
+    </header>`);
+      }
+      import_node_fs6.default.writeFileSync(abs, src, "utf8");
+    }
+  } else {
+    warnings.push("Header n\xE3o encontrado \u2014 adicione <LanguageSwitcher/> manualmente.");
+  }
+}
+var SYS_FIELDS = /* @__PURE__ */ new Set(["id", "documentId", "createdAt", "updatedAt", "publishedAt", "locale", "slug", "url"]);
+function buildValueMap(sample, cts) {
+  const camel = (s) => s.replace(/-+([a-zA-Z0-9])/g, (_m, c) => c.toUpperCase());
+  const map = {};
+  for (const ct of cts) {
+    if (ct.kind !== "singleType") continue;
+    const doc = sample[ct.singularName];
+    if (!doc || typeof doc !== "object") continue;
+    const exp = camel(ct.singularName);
+    for (const [field, val] of Object.entries(doc)) {
+      if (SYS_FIELDS.has(field)) continue;
+      if (typeof val !== "string") continue;
+      const v = val.trim();
+      if (v.length < 4) continue;
+      if (/^https?:\/\//.test(v)) continue;
+      if (map[v]) continue;
+      map[v] = `${exp}?.${field} ?? ${JSON.stringify(v)}`;
+    }
+  }
+  return map;
+}
+async function generateRewire(apiKey, src, subset, dataImport) {
+  const pairs = Object.entries(subset).map(([v, expr]) => `- ${JSON.stringify(v)}  \u2192  {${expr}}`).join("\n");
+  const prompt = `Religue este componente React/JSX ao CMS, trocando textos hardcoded por express\xF5es que leem do Strapi (j\xE1 localizadas).
+
+MAPA (texto exato no arquivo \u2192 express\xE3o a usar):
+${pairs}
+
+REGRAS ESTRITAS:
+- Para CADA ocorr\xEAncia EXATA de um texto do mapa, substitua pela express\xE3o, no formato correto do contexto:
+  \u2022 n\xF3 de texto JSX:  Texto  \u2192  {EXPR}
+  \u2022 atributo string:  attr="Texto"  \u2192  attr={EXPR}
+  \u2022 string JS usada como conte\xFAdo:  "Texto"  \u2192  (EXPR)
+- A EXPR j\xE1 tem fallback (?? "texto original"); use-a como veio (entre {} no JSX).
+- Adicione os imports necess\xE1rios no topo: importe os s\xEDmbolos usados (ex.: ${dataImport.includes("~") ? "~" : "@"}/data/site). Os exports de conte\xFAdo s\xE3o camelCase (ex.: homeContent).
+- N\xC3O altere mais NADA: estrutura, classes, l\xF3gica, imports existentes, nada fora do mapa.
+- Responda APENAS com o arquivo final (sem markdown).
+
+ARQUIVO:
+${src.length > MAX_FILE_CHARS2 ? src.slice(0, MAX_FILE_CHARS2) : src}`;
+  const res = await fetch(OPENAI_URL2, {
+    method: "POST",
+    headers: { Authorization: `Bearer ${apiKey}`, "Content-Type": "application/json" },
+    body: JSON.stringify({
+      model: MODEL2,
+      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." },
+        { role: "user", content: prompt }
+      ]
+    })
+  });
+  if (!res.ok) throw new Error(await res.text());
+  const json = await res.json();
+  return stripFence(json.choices?.[0]?.message?.content ?? "");
+}
+async function syntaxOk(code) {
+  let esbuild;
+  try {
+    esbuild = require("esbuild");
+  } catch {
+    esbuild = null;
+  }
+  if (esbuild?.transform) {
+    try {
+      await esbuild.transform(code, { loader: "tsx" });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  let depthC = 0, depthB = 0, depthP = 0, inStr = null, esc = false;
+  for (let i = 0; i < code.length; i++) {
+    const c = code[i];
+    if (inStr) {
+      if (esc) esc = false;
+      else if (c === "\\") esc = true;
+      else if (c === inStr) inStr = null;
+      continue;
+    }
+    if (c === '"' || c === "'" || c === "`") inStr = c;
+    else if (c === "{") depthC++;
+    else if (c === "}") depthC--;
+    else if (c === "[") depthB++;
+    else if (c === "]") depthB--;
+    else if (c === "(") depthP++;
+    else if (c === ")") depthP--;
+    if (depthC < 0 || depthB < 0 || depthP < 0) return false;
+  }
+  return depthC === 0 && depthB === 0 && depthP === 0 && /export\s/.test(code);
+}
+function normalizeDataImports(code, dataImport) {
+  const base = dataImport.replace(/\/[^/]+$/, "");
+  const esc = base.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const re = new RegExp(`import\\s*\\{([^}]*)\\}\\s*from\\s*["']${esc}/[^"']*["'];?[ \\t]*\\n?`, "g");
+  const specs = /* @__PURE__ */ new Set();
+  let m;
+  while (m = re.exec(code)) {
+    for (const s of m[1].split(",")) {
+      const t = s.trim();
+      if (t) specs.add(t);
+    }
+  }
+  if (!specs.size) return code;
+  const out = code.replace(re, "");
+  return `import { ${[...specs].join(", ")} } from "${dataImport}";
+` + out;
+}
+async function rewireComponents(strapi, opts, warnings) {
+  const map = buildValueMap(opts.sample, opts.cts);
+  if (!Object.keys(map).length) return [];
+  const rewired = [];
+  const files = [];
+  walk2(opts.frontendDir, opts.frontendDir, files);
+  const targets = files.filter(
+    (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);
+    let src;
+    try {
+      src = import_node_fs6.default.readFileSync(abs, "utf8");
+    } catch {
+      continue;
+    }
+    const subset = {};
+    for (const [v, expr] of Object.entries(map)) if (src.includes(v)) subset[v] = expr;
+    if (!Object.keys(subset).length) continue;
+    try {
+      let out = await generateRewire(opts.apiKey, src, subset, opts.dataImport);
+      if (!out || out.length < 30) {
+        warnings.push(`${rel}: rewire vazio, pulado.`);
+        continue;
+      }
+      out = normalizeDataImports(out, opts.dataImport);
+      if (!await syntaxOk(out)) {
+        warnings.push(`${rel}: rewire com erro de sintaxe, mantido original.`);
+        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");
+      rewired.push(rel);
+    } catch (e) {
+      warnings.push(`${rel}: rewire falhou (${e?.message ?? e}).`);
+    }
+  }
+  return rewired;
+}
+async function integrateFrontend(strapi, opts) {
+  const result = {
+    ok: false,
+    filesRewritten: [],
+    contentTypesFetched: [],
+    warnings: [],
+    errors: []
+  };
+  const apiKey = process.env.OPENAI_API_KEY;
+  if (!apiKey) {
+    result.errors.push("OPENAI_API_KEY n\xE3o configurada no .env do Strapi.");
+    return result;
+  }
+  const dataFiles = findDataFiles(opts.frontendDir);
+  if (dataFiles.length === 0) {
+    result.errors.push("N\xE3o encontrei um arquivo de dados para sincronizar (ex.: src/data/site.ts).");
+    return result;
+  }
+  const { codes, def } = await getLocales(strapi);
+  const locales = codes.length ? codes : [def];
+  const ctMeta = opts.manifest.contentTypes.map((ct) => ({
+    singularName: ct.singularName,
+    pluralName: strapi?.contentTypes?.[apiUid(ct.singularName)]?.info?.pluralName || `${ct.singularName}s`,
+    kind: ct.kind
+  }));
+  const sample = await fetchSample(strapi, ctMeta);
+  result.contentTypesFetched = ctMeta.map((c) => ({
+    uid: apiUid(c.singularName),
+    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);
+    try {
+      const original = import_node_fs6.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;
+      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");
+      result.filesRewritten.push(rel);
+    } catch (e) {
+      result.errors.push(`${rel}: ${e?.message ?? e}`);
+    }
+  }
+  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 dataImport = "@/" + rel0.replace(/^src\//, "").replace(/\.(tsx?|jsx?)$/, "");
+      injectSwitcher(opts.frontendDir, result.warnings, dataImport);
+      await ensureClientDep(opts.frontendDir, result.warnings);
+      try {
+        const rewired = await rewireComponents(
+          strapi,
+          { frontendDir: opts.frontendDir, sample, cts: ctMeta, apiKey, dataImport },
+          result.warnings
+        );
+        if (rewired.length) result.filesRewritten.push(...rewired);
+      } catch (e) {
+        result.warnings.push(`rewire: ${e?.message ?? e}`);
+      }
+    } catch (e) {
+      result.warnings.push(`wiring: ${e?.message ?? e}`);
+    }
+  }
+  result.ok = result.filesRewritten.length > 0;
+  return result;
+}
+
+// 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);
+}
+function toKebab(input) {
+  const s = (input || "frontend").toLowerCase().replace(/\.zip$/, "").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").replace(/^[^a-z]+/, "");
+  return s || "frontend";
+}
+function devOnly(ctx) {
+  if (process.env.NODE_ENV !== "development") {
+    ctx.badRequest(
+      "A provis\xE3o de frontend s\xF3 funciona em desenvolvimento (gera\xE7\xE3o de content-types \xE9 dev-only)."
+    );
+    return false;
+  }
+  return true;
+}
+var frontend_default = {
+  /** Etapa 1: extrai e descobre/infere o manifest (sem criar nada). */
+  async analyze(ctx) {
+    const strapi = ctx.strapi ?? global.strapi;
+    if (!devOnly(ctx)) return;
+    const files = ctx.request.files || {};
+    const file = files.frontend || files.file || Object.values(files)[0];
+    if (!file) return ctx.badRequest('Envie o .zip do frontend no campo "frontend".');
+    const filepath = file.filepath || file.path;
+    if (!filepath) return ctx.badRequest("Arquivo inv\xE1lido.");
+    const originalName = file.originalFilename || file.name || "frontend";
+    let zip;
+    try {
+      zip = await import_jszip.default.loadAsync(import_node_fs7.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
+    );
+    let rootPrefix = "";
+    if (manifestEntry) {
+      rootPrefix = manifestEntry.slice(0, manifestEntry.length - MANIFEST_NAME.length);
+    } else {
+      const tops = new Set(
+        entryNames.filter((n) => n.includes("/")).map((n) => n.slice(0, n.indexOf("/") + 1))
+      );
+      if (tops.size === 1) rootPrefix = [...tops][0];
+    }
+    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) {
+      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 });
+      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)) {
+          throw new Error(`entrada perigosa no zip bloqueada: ${entryName}`);
+        }
+        if (entry.dir) {
+          import_node_fs7.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"));
+        }
+      }
+    } catch (e) {
+      return ctx.internalServerError(`Falha ao extrair: ${e?.message ?? e}`);
+    }
+    const inf = await inferManifest(strapi, frontendDir, { name });
+    ctx.body = {
+      ok: inf.ok,
+      frontendDir,
+      inferred: inf.inferred,
+      framework: inf.framework,
+      filesAnalyzed: inf.filesAnalyzed,
+      // manifest cru (mesmo se inválido, para o usuário revisar/editar)
+      manifest: inf.rawManifest ?? inf.manifest ?? null,
+      warnings: inf.warnings,
+      errors: inf.errors,
+      message: inf.ok ? inf.inferred ? "Manifest inferido a partir do c\xF3digo. Revise e confirme para provisionar." : "Manifest encontrado no projeto. Revise e confirme para provisionar." : "N\xE3o foi poss\xEDvel obter um manifest v\xE1lido. Edite-o abaixo e tente provisionar."
+    };
+  },
+  /** Etapa 2: provisiona a partir do manifest confirmado. */
+  async provision(ctx) {
+    const strapi = ctx.strapi ?? global.strapi;
+    if (!devOnly(ctx)) return;
+    const body = ctx.request.body || {};
+    const rawManifest = body.manifest;
+    const frontendDir = body.frontendDir;
+    if (!rawManifest) return ctx.badRequest('Envie o "manifest".');
+    if (!frontendDir || !import_node_path7.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) {
+      return ctx.badRequest("frontendDir fora da pasta permitida.");
+    }
+    if (!import_node_fs7.default.existsSync(frontendDir)) {
+      return ctx.badRequest("frontendDir n\xE3o existe (rode a an\xE1lise primeiro).");
+    }
+    const v = validateManifest(rawManifest);
+    if (!v.ok) {
+      return ctx.badRequest({ message: "Manifest inv\xE1lido", errors: v.errors });
+    }
+    try {
+      import_node_fs7.default.writeFileSync(
+        import_node_path7.default.join(frontendDir, MANIFEST_NAME),
+        JSON.stringify(v.data, null, 2),
+        "utf8"
+      );
+    } catch (e) {
+      return ctx.internalServerError(`N\xE3o foi poss\xEDvel gravar o manifest: ${e?.message ?? e}`);
+    }
+    const port = strapi.config.get("server.port", 1337);
+    let locales = [];
+    try {
+      locales = (await strapi.plugin("i18n").service("locales").find() || []).map((l) => l.code);
+    } catch {
+    }
+    const context = { strapiUrl: `http://localhost:${port}`, locales };
+    const staged = stageProvision(strapi, {
+      rawManifest: v.data,
+      apiRoot,
+      frontendDir,
+      strapiAppDir,
+      context
+    });
+    if (!staged.ok) {
+      return ctx.badRequest({
+        message: "Provis\xE3o falhou",
+        validation: staged.validation,
+        errors: staged.errors
+      });
+    }
+    ctx.body = {
+      ok: true,
+      frontendDir,
+      contentTypes: staged.write?.written.filter((f) => f.endsWith("schema.json")).length ?? 0,
+      skipped: staged.write?.skipped ?? [],
+      willReload: staged.willReload,
+      message: staged.willReload ? "Provis\xE3o agendada. A Strapi vai reiniciar e ent\xE3o criar o conte\xFAdo e ligar o preview." : "Nenhuma content-type nova (j\xE1 existiam)."
+    };
+  },
+  /** Status da provisão — a UI faz polling após confirmar. */
+  status(ctx) {
+    const strapi = ctx.strapi ?? global.strapi;
+    ctx.body = getProvisionStatus(strapi.dirs.app.root);
+  },
+  /**
+   * Roda o dev server do frontend provisionado. A UI chama isto ao ligar o
+   * preview pela 1ª vez após o upload. Sem body, usa o último provisionado.
+   */
+  async run(ctx) {
+    const strapi = ctx.strapi ?? global.strapi;
+    if (!devOnly(ctx)) return;
+    const body = ctx.request.body || {};
+    let dir = body.dir;
+    let url = body.url;
+    if (!dir || !url) {
+      const st = getProvisionStatus(strapi.dirs.app.root);
+      if (st.done) {
+        dir = dir || st.done.frontendDir;
+        url = url || st.done.previewUrl;
+      }
+    }
+    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)) {
+      return ctx.badRequest("Pasta do frontend inv\xE1lida.");
+    }
+    ctx.body = await startFrontend(strapi, { dir, url });
+  },
+  /** Status do dev server do frontend (polling da UI). */
+  runStatus(ctx) {
+    ctx.body = getRunStatus();
+  },
+  /**
+   * Religa o frontend ao Strapi por SNAPSHOT: regenera o(s) arquivo(s) de dados
+   * com o conteúdo do Strapi, mantendo nomes de export e imagens originais.
+   * Usa o último provisionado por padrão.
+   */
+  async integrate(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_path7.default.resolve(strapi.dirs.app.root, "..");
+    if (!ensureInside2(parent, frontendDir) || !import_node_fs7.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"));
+    } 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 });
+  }
+};
+
+// server/src/mcp-client.ts
+var MCP_URL = process.env.MCP_URL || "http://localhost:1337/mcp";
+var baseHeaders = {
+  "Content-Type": "application/json",
+  Accept: "application/json, text/event-stream"
+};
+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];
+  return last ? JSON.parse(last) : null;
+};
+var McpClient = class {
+  /**
+   * @param url   endpoint MCP streamable. Default: o /mcp nativo da Strapi.
+   * @param name  rótulo p/ logs (ex.: 'strapi', 'playwright').
+   * @param token Bearer token (admin token, exigido pelo /mcp nativo).
+   */
+  constructor(url = MCP_URL, name = "strapi", token) {
+    this.url = url;
+    this.name = name;
+    this.token = token;
+  }
+  headers() {
+    const h = { ...baseHeaders };
+    if (this.token) h["Authorization"] = `Bearer ${this.token}`;
+    if (this.sessionId) h["mcp-session-id"] = this.sessionId;
+    return h;
+  }
+  async init() {
+    const res = await fetch(this.url, {
+      method: "POST",
+      headers: this.headers(),
+      body: JSON.stringify({
+        jsonrpc: "2.0",
+        id: 1,
+        method: "initialize",
+        params: {
+          protocolVersion: "2024-11-05",
+          capabilities: {},
+          clientInfo: { name: "mcp-chat-plugin", version: "0.1.0" }
+        }
+      })
+    });
+    this.sessionId = res.headers.get("mcp-session-id") || void 0;
+    await res.text();
+    await fetch(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, {
+      method: "POST",
+      headers: this.headers(),
+      body: JSON.stringify({ jsonrpc: "2.0", id, method, params })
+    });
+    const json = parseSse(await res.text());
+    if (json?.error) throw new Error(json.error.message || "Erro MCP");
+    return json?.result;
+  }
+  async listTools() {
+    const result = await this.rpc("tools/list", {}, 2);
+    return result?.tools || [];
+  }
+  async callTool(name, args) {
+    return this.rpc("tools/call", { name, arguments: args || {} }, 3);
+  }
+};
+
+// 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 approxTokens = (s) => Math.ceil((s || "").length / 4);
+var MAX_CHUNK_TOKENS = 1200;
+var splitParagraphs = (text) => text.split(/\n{2,}/);
+var splitSentences = (text) => text.match(/[^.!?]+(?:[.!?]+|$)/g) || [text];
+function splitForTranslation(value, _type) {
+  const text = String(value ?? "");
+  if (approxTokens(text) <= MAX_CHUNK_TOKENS) {
+    return { chunks: [text], join: (t) => t[0] ?? "" };
+  }
+  const segs = [];
+  for (const para of splitParagraphs(text)) {
+    if (approxTokens(para) <= MAX_CHUNK_TOKENS) {
+      segs.push(para);
+      continue;
+    }
+    let buf2 = "";
+    for (const sent of splitSentences(para)) {
+      if (buf2 && approxTokens(buf2 + sent) > MAX_CHUNK_TOKENS) {
+        segs.push(buf2);
+        buf2 = "";
+      }
+      buf2 += sent;
+    }
+    if (buf2) segs.push(buf2);
+  }
+  const chunks = [];
+  let buf = [];
+  let bufTok = 0;
+  for (const seg of segs) {
+    const t = approxTokens(seg);
+    if (buf.length && bufTok + t > MAX_CHUNK_TOKENS) {
+      chunks.push(buf.join("\n\n"));
+      buf = [];
+      bufTok = 0;
+    }
+    buf.push(seg);
+    bufTok += t;
+  }
+  if (buf.length) chunks.push(buf.join("\n\n"));
+  return { chunks, join: (t) => t.join("\n\n") };
+}
+async function translateChunk(apiKey, text, sourceLang, targetLang) {
+  if (!text || !text.trim()) return text;
+  const body = {
+    model: MODEL3,
+    temperature: 0,
+    max_tokens: Math.min(4e3, approxTokens(text) * 3 + 256),
+    messages: [
+      {
+        role: "system",
+        content: `You are a professional translator. Translate the user's text from ${sourceLang} to ${targetLang}. Preserve EXACTLY all markdown, HTML tags, URLs, and placeholders such as {name}, :slug, %s, {{var}}. Keep line breaks. Do NOT add quotes, notes, or explanations. Return ONLY the translated text.`
+      },
+      { role: "user", content: text }
+    ]
+  };
+  const res = await fetch(OPENAI_URL3, {
+    method: "POST",
+    headers: { Authorization: `Bearer ${apiKey}`, "Content-Type": "application/json" },
+    body: JSON.stringify(body)
+  });
+  if (!res.ok) throw new Error(`OpenAI translate: ${await res.text()}`);
+  const data = await res.json();
+  return (data.choices?.[0]?.message?.content ?? "").trim();
+}
+async function mapPool(items, limit, fn) {
+  const out = new Array(items.length);
+  let i = 0;
+  const workers = Array.from({ length: Math.max(1, Math.min(limit, items.length)) }, async () => {
+    while (i < items.length) {
+      const idx = i++;
+      out[idx] = await fn(items[idx], idx);
+    }
+  });
+  await Promise.all(workers);
+  return out;
+}
+async function translateText(apiKey, value, sourceLang, targetLang, type) {
+  if (typeof value !== "string" || !value.trim()) return { text: value, chunks: 0 };
+  const { chunks, join } = splitForTranslation(value, type);
+  const translated = await mapPool(
+    chunks,
+    4,
+    (c) => c.trim() ? translateChunk(apiKey, c, sourceLang, targetLang) : Promise.resolve(c)
+  );
+  return { text: join(translated), chunks: chunks.length };
+}
+
+// server/src/content-tools.ts
+var TEXTUAL = ["string", "text", "richtext"];
+function createContentTools(strapi) {
+  const apiContentTypes = () => Object.values(strapi.contentTypes).filter(
+    (ct) => ct.uid?.startsWith("api::")
+  );
+  const attrsOf = (uid) => strapi.contentTypes?.[uid]?.attributes || strapi.components?.[uid]?.attributes || {};
+  const buildPopulate = (attributes, seen = /* @__PURE__ */ new Set()) => {
+    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));
+        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));
+          on[comp] = Object.keys(sub).length ? { populate: sub } : true;
+        }
+        populate[name] = { on };
+      } else if (a.type === "media" || a.type === "relation") {
+        populate[name] = true;
+      }
+    }
+    return populate;
+  };
+  const walkFind = (node, attributes, basePath, needle, collect) => {
+    if (!node || typeof node !== "object") return;
+    for (const [name, a] of Object.entries(attributes)) {
+      const v = node[name];
+      if (v == null) continue;
+      const path9 = [...basePath, name];
+      if (TEXTUAL.includes(a.type)) {
+        if (typeof v === "string" && v.toLowerCase().includes(needle)) {
+          collect(path9, 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));
+        } else {
+          walkFind(v, sub, path9, 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);
+          }
+        });
+      }
+    }
+  };
+  const buscarTexto = async (termo) => {
+    const needle = String(termo || "").toLowerCase().trim();
+    if (!needle) return { erro: "termo vazio" };
+    const matches = [];
+    for (const ct of apiContentTypes()) {
+      const attributes = ct.attributes || {};
+      const populate = buildPopulate(attributes);
+      let entries = [];
+      try {
+        const res = await strapi.documents(ct.uid).findMany({ status: "draft", populate, limit: 200 });
+        entries = Array.isArray(res) ? res : res ? [res] : [];
+      } catch {
+        continue;
+      }
+      for (const e of entries) {
+        walkFind(e, attributes, [], needle, (path9, campo, valor) => {
+          matches.push({
+            uid: ct.uid,
+            tipo: ct.info?.displayName || ct.uid,
+            documentId: e.documentId,
+            path: path9,
+            campo,
+            valor_atual: valor.length > 300 ? valor.slice(0, 300) + "\u2026" : valor
+          });
+        });
+      }
+    }
+    return { total: matches.length, resultados: matches };
+  };
+  const sanitizeNode = (node, attributes) => {
+    if (node == null) return node;
+    const out = {};
+    if (node.id != null) out.id = node.id;
+    for (const [name, a] of Object.entries(attributes)) {
+      const v = node[name];
+      if (v === void 0) continue;
+      out[name] = sanitizeAttr(v, a);
+    }
+    return out;
+  };
+  const sanitizeAttr = (value, a) => {
+    if (value == null) return value;
+    if (a.type === "component" && a.component) {
+      const sub = attrsOf(a.component);
+      return a.repeatable && Array.isArray(value) ? value.map((it) => sanitizeNode(it, sub)) : sanitizeNode(value, sub);
+    }
+    if (a.type === "dynamiczone" && Array.isArray(value)) {
+      return value.map((it) => ({
+        __component: it.__component,
+        ...sanitizeNode(it, attrsOf(it.__component))
+      }));
+    }
+    if (a.type === "media") {
+      return Array.isArray(value) ? value.map((m) => m?.id).filter(Boolean) : value?.id ?? null;
+    }
+    if (a.type === "relation") {
+      return Array.isArray(value) ? value.map((r) => r?.id).filter(Boolean) : value?.id ?? null;
+    }
+    return value;
+  };
+  const editarCampo = async ({ uid, documentId, path: path9, campo, novo_valor, locale }) => {
+    const p = Array.isArray(path9) && path9.length ? path9 : campo ? [campo] : null;
+    if (!p) return { erro: 'informe "path" (array) ou "campo"' };
+    const attributes = strapi.contentTypes?.[uid]?.attributes || {};
+    const topAttr = p[0];
+    const ad = attributes[topAttr];
+    const loc = locale ? { locale } : {};
+    if (p.length === 1 && ad && TEXTUAL.includes(ad.type)) {
+      const updated2 = await strapi.documents(uid).update({ documentId, ...loc, data: { [topAttr]: novo_valor } });
+      return { ok: true, uid, documentId: updated2?.documentId || documentId, path: p, novo_valor, locale };
+    }
+    const populate = buildPopulate(attributes);
+    const entry = await strapi.documents(uid).findOne({ documentId, status: "draft", ...loc, populate });
+    if (!entry) return { erro: "entrada n\xE3o encontrada" };
+    let cur = entry;
+    for (let i = 0; i < p.length - 1; i++) {
+      if (cur == null) break;
+      cur = cur[p[i]];
+    }
+    if (cur == null) return { erro: `caminho inv\xE1lido: ${p.join(".")}` };
+    cur[p[p.length - 1]] = novo_valor;
+    const data = { [topAttr]: sanitizeAttr(entry[topAttr], ad) };
+    const updated = await strapi.documents(uid).update({ documentId, ...loc, data });
+    return { ok: true, uid, documentId: updated?.documentId || documentId, path: p, novo_valor, locale };
+  };
+  const publicar = async ({
+    uid,
+    documentId,
+    locale
+  }) => {
+    await strapi.documents(uid).publish({ documentId, ...locale ? { locale } : {} });
+    return { ok: true, uid, documentId, status: "published", locale };
+  };
+  const i18nLocalesSvc = () => strapi.plugin?.("i18n")?.service?.("locales");
+  const isoLocalesSvc = () => strapi.plugin?.("i18n")?.service?.("iso-locales");
+  const listarLocales = async () => {
+    const svc = i18nLocalesSvc();
+    if (!svc) return { erro: "plugin i18n indispon\xEDvel" };
+    const def = await svc.getDefaultLocale();
+    const all = await svc.find() || [];
+    return {
+      default: def,
+      locales: all.map((l) => ({ code: l.code, name: l.name, isDefault: l.code === def }))
+    };
+  };
+  const criarLocale = async ({ code, name }) => {
+    const svc = i18nLocalesSvc();
+    const iso = isoLocalesSvc();
+    if (!svc || !iso) return { erro: "plugin i18n indispon\xEDvel" };
+    const wanted = String(code || "").trim();
+    if (!wanted) return { erro: 'informe o "code" do locale (ex.: "pt-BR")' };
+    const list = iso.getIsoLocales();
+    const match = list.find((l) => l.code.toLowerCase() === wanted.toLowerCase());
+    if (!match) return { erro: `c\xF3digo de locale inv\xE1lido: "${wanted}" (n\xE3o est\xE1 na lista ISO do Strapi)` };
+    const existing = await svc.findByCode(match.code);
+    if (existing) return { ok: true, code: match.code, name: existing.name, existed: true };
+    const created = await svc.create({ code: match.code, name: name || match.name });
+    return { ok: true, code: created.code, name: created.name, existed: false };
+  };
+  const translateAttrValue = async (value, a, ctx) => {
+    if (value == null) return value;
+    if (TEXTUAL.includes(a.type)) {
+      const { text, chunks } = await translateText(ctx.apiKey, value, ctx.src, ctx.tgt, a.type);
+      ctx.bump(chunks);
+      return text;
+    }
+    if (a.type === "component" && a.component) {
+      const sub = attrsOf(a.component);
+      return a.repeatable && Array.isArray(value) ? Promise.all(value.map((it) => translateNodeSanitized(it, sub, ctx))) : translateNodeSanitized(value, sub, ctx);
+    }
+    if (a.type === "dynamiczone" && Array.isArray(value)) {
+      return Promise.all(
+        value.map(async (it) => ({
+          __component: it.__component,
+          ...await translateNodeSanitized(it, attrsOf(it.__component), ctx)
+        }))
+      );
+    }
+    return sanitizeAttr(value, a);
+  };
+  const translateNodeSanitized = async (node, attributes, ctx) => {
+    if (node == null) return node;
+    const out = {};
+    if (node.id != null) out.id = node.id;
+    for (const [name, a] of Object.entries(attributes)) {
+      if (node[name] === void 0) continue;
+      out[name] = await translateAttrValue(node[name], a, ctx);
+    }
+    return out;
+  };
+  const isLocalizedCT = (ct) => ct?.pluginOptions?.i18n?.localized === true;
+  const isLocalizedAttr = (a) => a?.pluginOptions?.i18n?.localized === true;
+  const traduzir = async ({
+    target_locales,
+    source_locale,
+    uid,
+    documentId,
+    publish = true
+  }) => {
+    const apiKey = process.env.OPENAI_API_KEY;
+    if (!apiKey) return { erro: "OPENAI_API_KEY n\xE3o configurada no .env do Strapi." };
+    const svc = i18nLocalesSvc();
+    const iso = isoLocalesSvc();
+    if (!svc || !iso) return { erro: "plugin i18n indispon\xEDvel" };
+    const targets = (Array.isArray(target_locales) ? target_locales : [target_locales]).filter(Boolean);
+    if (!targets.length) return { erro: 'informe target_locales (ex.: ["pt-BR","es"])' };
+    const src = source_locale || await svc.getDefaultLocale();
+    const cts = apiContentTypes().filter(
+      (ct) => isLocalizedCT(ct) && (!uid || ct.uid === uid)
+    );
+    if (!cts.length) {
+      return {
+        erro: uid ? `content-type "${uid}" n\xE3o \xE9 localizada (i18n desligado). Habilite i18n nos campos antes de traduzir.` : "nenhuma content-type localizada encontrada. Habilite i18n (pluginOptions.i18n.localized) nos campos a traduzir."
+      };
+    }
+    const isoList = iso.getIsoLocales();
+    const nameOf = (code) => isoList.find((l) => l.code.toLowerCase() === code.toLowerCase())?.name || code;
+    const por_locale = [];
+    for (const rawTgt of targets) {
+      const created = await criarLocale({ code: rawTgt });
+      if (created.erro) {
+        por_locale.push({ locale: rawTgt, erro: created.erro });
+        continue;
+      }
+      const tgt = created.code;
+      let documentos = 0;
+      let campos = 0;
+      let chunks = 0;
+      let publicados = 0;
+      for (const ct of cts) {
+        const attributes = ct.attributes || {};
+        const populate = buildPopulate(attributes);
+        let res;
+        try {
+          res = await strapi.documents(ct.uid).findMany({ status: "draft", locale: src, populate, limit: 1e3 });
+        } catch {
+          continue;
+        }
+        let entries = Array.isArray(res) ? res : res ? [res] : [];
+        if (documentId) entries = entries.filter((e) => e.documentId === documentId);
+        for (const e of entries) {
+          const ctx = {
+            apiKey,
+            src: nameOf(src),
+            tgt: nameOf(tgt),
+            bump: (c) => {
+              campos += 1;
+              chunks += c;
+            }
+          };
+          const data = {};
+          for (const [name, a] of Object.entries(attributes)) {
+            if (!isLocalizedAttr(a)) continue;
+            if (e[name] == null) continue;
+            data[name] = await translateAttrValue(e[name], a, ctx);
+          }
+          if (!Object.keys(data).length) continue;
+          await strapi.documents(ct.uid).update({ documentId: e.documentId, locale: tgt, data });
+          documentos += 1;
+          if (publish) {
+            await strapi.documents(ct.uid).publish({ documentId: e.documentId, locale: tgt });
+            publicados += 1;
+          }
+        }
+      }
+      por_locale.push({ locale: tgt, documentos, campos, chunks, publicados });
+    }
+    return { ok: true, source: src, por_locale };
+  };
+  return { buscarTexto, editarCampo, publicar, listarLocales, criarLocale, traduzir };
+}
+var openAiToolSpecs = [
+  {
+    type: "function",
+    function: {
+      name: "buscar_texto",
+      description: 'Procura uma palavra/frase em TODOS os content-types, single types, COMPONENTES e DYNAMIC ZONES do Strapi (substring, recursivo). Cada resultado traz uid, documentId, "path" (ex.: ["dynamic_zone",2,"heading"]), campo e valor_atual. Passe esse "path" para editar_campo.',
+      parameters: {
+        type: "object",
+        properties: {
+          termo: {
+            type: "string",
+            description: 'trecho distintivo do texto a localizar; N\xC3O inclua r\xF3tulos de status do preview, como "(Draft)"/"(Rascunho)"'
+          }
+        },
+        required: ["termo"]
+      }
+    }
+  },
+  {
+    type: "function",
+    function: {
+      name: "editar_campo",
+      description: 'Altera o valor de um campo (salva como rascunho). Use o "path" retornado por buscar_texto para campos aninhados; para campo simples no topo, pode usar "campo". Passe "locale" para gravar numa vers\xE3o de idioma espec\xEDfica.',
+      parameters: {
+        type: "object",
+        properties: {
+          uid: { type: "string" },
+          documentId: { type: "string" },
+          path: {
+            type: "array",
+            description: "caminho at\xE9 o campo, exatamente como veio de buscar_texto",
+            items: { type: ["string", "number"] }
+          },
+          campo: { type: "string", description: "alternativa ao path (campo simples no topo)" },
+          novo_valor: { type: "string" },
+          locale: { type: "string", description: 'opcional; c\xF3digo do locale (ex.: "pt-BR")' }
+        },
+        required: ["uid", "documentId", "novo_valor"]
+      }
+    }
+  },
+  {
+    type: "function",
+    function: {
+      name: "publicar",
+      description: 'Publica a entrada (torna a altera\xE7\xE3o vis\xEDvel no site p\xFAblico). Passe "locale" para publicar um idioma espec\xEDfico, ou "*" para todos.',
+      parameters: {
+        type: "object",
+        properties: {
+          uid: { type: "string" },
+          documentId: { type: "string" },
+          locale: { type: "string", description: 'opcional; c\xF3digo do locale ou "*" para todos' }
+        },
+        required: ["uid", "documentId"]
+      }
+    }
+  },
+  {
+    type: "function",
+    function: {
+      name: "listar_locales",
+      description: "Lista os locales (idiomas) configurados no Strapi e qual \xE9 o default.",
+      parameters: { type: "object", properties: {} }
+    }
+  },
+  {
+    type: "function",
+    function: {
+      name: "criar_locale",
+      description: 'Cria um locale (idioma) no Strapi. O "code" precisa ser um c\xF3digo ISO v\xE1lido (ex.: "pt-BR", "es", "fr"). Idempotente: se j\xE1 existir, n\xE3o recria.',
+      parameters: {
+        type: "object",
+        properties: {
+          code: { type: "string", description: 'c\xF3digo ISO do locale, ex.: "pt-BR"' },
+          name: { type: "string", description: "opcional; nome exibido (default = nome ISO)" }
+        },
+        required: ["code"]
+      }
+    }
+  },
+  {
+    type: "function",
+    function: {
+      name: "traduzir",
+      description: "Traduz o conte\xFAdo localizado para um ou mais idiomas. Cria os locales se preciso, traduz campo a campo (textos longos s\xE3o divididos e remontados \u2014 nunca estoura) e publica. Sem uid/documentId, traduz TODAS as content-types localizadas (todas as p\xE1ginas). Funciona para muitos locales de uma vez.",
+      parameters: {
+        type: "object",
+        properties: {
+          target_locales: {
+            type: "array",
+            items: { type: "string" },
+            description: 'lista de c\xF3digos de destino, ex.: ["pt-BR","es","fr"]'
+          },
+          source_locale: { type: "string", description: "idioma de origem; default = locale default do Strapi" },
+          uid: { type: "string", description: "opcional; restringe a uma content-type (ex.: api::home.home)" },
+          documentId: { type: "string", description: "opcional; restringe a um documento" },
+          publish: { type: "boolean", description: "publicar ap\xF3s traduzir (default true)" }
+        },
+        required: ["target_locales"]
+      }
+    }
+  },
+  {
+    type: "function",
+    function: {
+      name: "habilitar_i18n",
+      description: 'Habilita i18n (tradu\xE7\xE3o) em content-types que ainda n\xE3o s\xE3o localizadas: marca a CT e seus campos textuais/componentes como localizados. Necess\xE1rio antes de traduzir conte\xFAdo provisionado sem i18n. OMITA "uid" (ou passe "*") para habilitar em TODAS as content-types de uma vez (recomendado para "traduzir o site inteiro") \u2014 um \xFAnico restart. Edita o schema e a Strapi reinicia (em desenvolvimento). N\xC3O adivinhe uids.',
+      parameters: {
+        type: "object",
+        properties: {
+          uid: { type: "string", description: "opcional; ex.: api::home-content.home-content. Omita p/ TODAS." },
+          campos: {
+            type: "array",
+            items: { type: "string" },
+            description: "opcional; campos a localizar (default = todos os textuais/componentes)"
+          }
+        }
+      }
+    }
+  }
+];
+
+// server/src/provision/enable-i18n.ts
+var import_node_fs8 = __toESM(require("node:fs"));
+var import_node_path8 = __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");
+}
+function listAllUids(apiRoot) {
+  const out = [];
+  let apis = [];
+  try {
+    apis = import_node_fs8.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}`);
+    }
+  }
+  return out;
+}
+var withLocalized = (obj) => ({
+  ...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})` };
+  let schema;
+  try {
+    schema = JSON.parse(import_node_fs8.default.readFileSync(file, "utf8"));
+  } catch (e) {
+    return { erro: `schema.json ileg\xEDvel: ${e?.message ?? e}` };
+  }
+  schema.pluginOptions = withLocalized(schema.pluginOptions);
+  const attrs = schema.attributes || {};
+  const alvos = campos && campos.length ? campos : Object.keys(attrs).filter((k) => LOCALIZABLE.includes(attrs[k]?.type));
+  const changed = [];
+  for (const name of alvos) {
+    if (!attrs[name]) continue;
+    attrs[name].pluginOptions = withLocalized(attrs[name].pluginOptions);
+    changed.push(name);
+  }
+  try {
+    import_node_fs8.default.writeFileSync(file, JSON.stringify(schema, null, 2) + "\n", "utf8");
+  } catch (e) {
+    return { erro: `falha ao gravar schema.json: ${e?.message ?? e}` };
+  }
+  return { campos: changed };
+}
+function enableI18n(opts) {
+  const { strapi, uid, campos, allowOutsideDev } = 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");
+  if (!uid || uid === "*") {
+    const uids = listAllUids(apiRoot);
+    if (!uids.length) return { erro: `nenhuma content-type encontrada em ${apiRoot}` };
+    const done = [];
+    const errors = [];
+    for (const u of uids) {
+      const file2 = schemaPathFor(apiRoot, u);
+      const r2 = patchOne(file2, campos);
+      if ("erro" in r2) errors.push(`${u}: ${r2.erro}`);
+      else done.push({ uid: u, campos: r2.campos });
+    }
+    if (!done.length) return { erro: `nada habilitado. ${errors.join("; ")}` };
+    return { ok: true, contentTypes: done, total: done.length, restart: true };
+  }
+  const file = schemaPathFor(apiRoot, uid);
+  if (!file) return { erro: `uid inv\xE1lido: "${uid}" (esperado api::x.x)` };
+  const r = patchOne(file, campos);
+  if ("erro" in r) return { erro: r.erro };
+  return { ok: true, uid, campos: r.campos, restart: true };
+}
+
+// server/src/services/chat.ts
+var MODEL4 = process.env.OPENAI_CHAT_MODEL || "gpt-4o";
+var MAX_TURNS = 10;
+var OPENAI_URL4 = "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.
+
+Ferramentas de conte\xFAdo:
+- buscar_texto({termo}): procura uma palavra ou frase em TODOS os content-types, single types, COMPONENTES e DYNAMIC ZONES (recursivo, por substring). Retorna uma lista; cada item tem uid, documentId, "path" (caminho at\xE9 o campo, ex.: ["dynamic_zone",2,"heading"]), campo e valor_atual. Use SEMPRE isto primeiro \u2014 N\xC3O pe\xE7a ao usu\xE1rio onde est\xE1, ache sozinho. Busque um trecho distintivo e N\xC3O inclua r\xF3tulos que o preview adiciona, como "(Draft)"/"(Rascunho)".
+- editar_campo({uid, documentId, path, novo_valor}): troca o valor de um campo (salva como rascunho). Passe o "path" EXATAMENTE como veio de buscar_texto.
+- publicar({uid, documentId}): publica a entrada, deixando a mudan\xE7a vis\xEDvel no site.
+
+Fluxo padr\xE3o quando o usu\xE1rio pede uma mudan\xE7a no site (por texto, voz ou mostrando a tela):
+1. Use buscar_texto com um trecho distintivo do texto a alterar (sem r\xF3tulos de status).
+2. Se houver mais de um resultado, escolha o mais prov\xE1vel pelo contexto (e diga qual escolheu); se amb\xEDguo de verdade, pergunte.
+3. editar_campo passando o mesmo uid, documentId e path do resultado, com o novo valor.
+4. publicar a entrada.
+5. Confirme em 1 frase o que foi alterado e publicado (content-type, campo, antes \u2192 depois).
+
+Ferramentas de tradu\xE7\xE3o / idiomas (i18n):
+- listar_locales(): mostra os idiomas configurados e o default.
+- criar_locale({code}): cria um idioma (code ISO, ex.: "pt-BR"). Idempotente.
+- traduzir({target_locales, source_locale?, uid?, documentId?, publish?}): traduz o conte\xFAdo localizado para um ou MAIS idiomas. Cria os locales se faltarem, traduz campo a campo (textos longos s\xE3o divididos e remontados \u2014 n\xE3o estoura) e publica. Sem uid/documentId, traduz TODAS as p\xE1ginas.
+- habilitar_i18n({uid?, campos?}): liga a tradu\xE7\xE3o em content-types ainda n\xE3o localizadas (a Strapi reinicia). OMITA uid para habilitar em TODAS de uma vez. NUNCA adivinhe uids \u2014 para o site inteiro, sempre sem uid.
+
+Fluxo quando o usu\xE1rio pede tradu\xE7\xE3o (ex.: "quero o site todo em pt-BR"):
+1. Chame traduzir com target_locales (lista de c\xF3digos). N\xE3o precisa criar o locale antes \u2014 traduzir j\xE1 cria.
+2. Se traduzir disser que NENHUMA content-type \xE9 localizada (i18n desligado), chame habilitar_i18n SEM uid (habilita todas de uma vez), avise que a Strapi vai reiniciar e que \xE9 s\xF3 repetir o pedido ap\xF3s o restart. N\xC3O chame habilitar_i18n uid por uid nem invente nomes.
+3. Ap\xF3s o restart, ao repetir, traduzir funciona e localiza tudo.
+4. Confirme em 1 frase: idiomas, quantos documentos e campos foram traduzidos/publicados (use o resumo retornado, n\xE3o despeje o conte\xFAdo).
+
+Se o usu\xE1rio compartilhar a tela, uma imagem \xE9 anexada \xE0 \xFAltima mensagem \u2014 use-a para entender exatamente o que ele est\xE1 vendo e qual texto quer trocar.
+
+Seja objetivo e acion\xE1vel. Responda SEMPRE em portugu\xEAs.`,
+  en: `You are an assistant embedded in this project's Strapi 5 admin. You are NOT just a guide: you can actually EDIT and PUBLISH content through your tools.
+
+Content tools:
+- buscar_texto({termo}): searches a word or phrase across ALL content-types, single types, COMPONENTS and DYNAMIC ZONES (recursive, substring). Returns a list; each item has uid, documentId, "path" (the path to the field, e.g. ["dynamic_zone",2,"heading"]), field and current value. ALWAYS use this first \u2014 do NOT ask the user where it is, find it yourself. Search a distinctive snippet and do NOT include labels the preview adds, like "(Draft)".
+- editar_campo({uid, documentId, path, novo_valor}): replaces a field value (saved as draft). Pass the "path" EXACTLY as returned by buscar_texto.
+- publicar({uid, documentId}): publishes the entry, making the change visible on the site.
+
+Default flow when the user asks for a site change (by text, voice or by showing their screen):
+1. Use buscar_texto with a distinctive snippet of the text to change (no status labels).
+2. If there is more than one result, pick the most likely from context (and say which); if truly ambiguous, ask.
+3. editar_campo passing the same uid, documentId and path from the result, with the new value.
+4. publicar the entry.
+5. Confirm in one sentence what was changed and published (content-type, field, before \u2192 after).
+
+Translation / language tools (i18n):
+- listar_locales(): shows configured languages and the default.
+- criar_locale({code}): creates a language (ISO code, e.g. "pt-BR"). Idempotent.
+- traduzir({target_locales, source_locale?, uid?, documentId?, publish?}): translates localized content into one or MORE languages. It creates missing locales, translates field by field (long text is split and reassembled \u2014 never overflows) and publishes. Without uid/documentId it translates ALL pages.
+- habilitar_i18n({uid?, campos?}): enables translation on content-types not localized yet (Strapi restarts). OMIT uid to enable ALL at once. NEVER guess uids \u2014 for the whole site, always call it without uid.
+
+Flow when the user asks for translation (e.g. "I want the whole site in pt-BR"):
+1. Call traduzir with target_locales (list of codes). No need to create the locale first \u2014 traduzir creates it.
+2. If traduzir says NO content-type is localized (i18n off), call habilitar_i18n WITHOUT uid (enables all at once), warn that Strapi will restart and that they just need to repeat the request after the restart. Do NOT call habilitar_i18n per-uid or invent names.
+3. After the restart, repeating the request makes traduzir localize everything.
+4. Confirm in one sentence: languages, how many documents and fields were translated/published (use the returned summary, don't dump the content).
+
+If the user shares their screen, an image is attached to the last message \u2014 use it to understand exactly what they see and which text they want to change.
+
+Be concise and actionable. ALWAYS answer in English.`
+};
+var chat_default2 = ({ strapi }) => ({
+  async chat({ messages, image, lang = "pt", previewUrl }) {
+    const apiKey = process.env.OPENAI_API_KEY;
+    if (!apiKey) {
+      throw new Error(
+        "OPENAI_API_KEY n\xE3o configurada no .env do Strapi. Adicione e reinicie."
+      );
+    }
+    const language = lang === "en" ? "en" : "pt";
+    const { buscarTexto, editarCampo, publicar, listarLocales, criarLocale, traduzir } = createContentTools(strapi);
+    const LOCAL_TOOLS = {
+      buscar_texto: (a) => buscarTexto(a?.termo),
+      editar_campo: (a) => editarCampo(a),
+      publicar: (a) => publicar(a),
+      listar_locales: () => listarLocales(),
+      criar_locale: (a) => criarLocale(a),
+      traduzir: (a) => traduzir(a),
+      habilitar_i18n: async (a) => enableI18n({ strapi, uid: a?.uid, campos: a?.campos })
+    };
+    const localToolSpecs = openAiToolSpecs;
+    const mcpByTool = {};
+    const mcpTools = [];
+    if (process.env.PLAYWRIGHT_MCP_URL) {
+      try {
+        const client = new McpClient(process.env.PLAYWRIGHT_MCP_URL, "playwright");
+        await client.init();
+        const list = await client.listTools();
+        for (const t of list) {
+          if (mcpByTool[t.name]) continue;
+          mcpByTool[t.name] = client;
+          mcpTools.push(t);
+        }
+        strapi.log.info(`[mcp-chat] MCP "playwright" ok: ${list.length} tools`);
+      } catch (e) {
+        strapi.log.warn(`[mcp-chat] MCP "playwright" indispon\xEDvel: ${e?.message || e}`);
+      }
+    }
+    const tools2 = [
+      ...localToolSpecs,
+      ...mcpTools.map((t) => ({
+        type: "function",
+        function: {
+          name: t.name,
+          description: t.description || t.name,
+          parameters: t.inputSchema || { type: "object", properties: {} }
+        }
+      }))
+    ];
+    const hasBrowser = mcpTools.some((t) => String(t.name).startsWith("browser_"));
+    const adminBase = process.env.STRAPI_ADMIN_URL || "http://localhost:1337/admin";
+    const BROWSER_NOTE = {
+      pt: `
+
+Voc\xEA tamb\xE9m controla um navegador real via ferramentas browser_* (Playwright), apontado para o ADMIN DA STRAPI em ${adminBase} (o backend \u2014 \xE9 aqui que o conte\xFAdo muda de verdade, N\xC3O no site p\xFAblico). Pode navegar (browser_navigate), clicar, digitar, rolar, tirar seus pr\xF3prios screenshots (browser_take_screenshot) e inspecionar console/erros. Prefira sempre suas ferramentas diretas (buscar_texto/editar_campo/publicar) para alterar conte\xFAdo; use o navegador para VERIFICAR no admin que a edi\xE7\xE3o/publica\xE7\xE3o ficou correta, ou para fluxos da UI que as ferramentas diretas n\xE3o cobrem.`,
+      en: `
+
+You also control a real browser via browser_* tools (Playwright), pointed at the STRAPI ADMIN at ${adminBase} (the backend \u2014 this is where content actually changes, NOT the public site). You can navigate (browser_navigate), click, type, scroll, take your own screenshots (browser_take_screenshot) and inspect console/errors. Always prefer your direct tools (buscar_texto/editar_campo/publicar) to change content; use the browser to VERIFY in the admin that the edit/publish landed, or for admin UI flows the direct tools don't cover.`
+    };
+    const systemContent = SYSTEM[language] + (hasBrowser ? BROWSER_NOTE[language] : "");
+    const convo = [{ role: "system", content: systemContent }];
+    const pageNote = previewUrl ? language === "en" ? `
+
+[context: the user is viewing the page ${previewUrl} in the preview right now \u2014 assume "this/here" refers to what's on that page]` : `
+
+[contexto: o usu\xE1rio est\xE1 vendo a p\xE1gina ${previewUrl} no preview agora \u2014 assuma que "isso/aqui" se refere ao que est\xE1 nessa p\xE1gina]` : "";
+    messages.forEach((m, i) => {
+      const isLastUser = i === messages.length - 1 && m.role === "user";
+      if (isLastUser) {
+        const text = (m.content || "") + pageNote;
+        if (image) {
+          convo.push({
+            role: "user",
+            content: [
+              { type: "text", text: text || "(veja minha tela)" },
+              { type: "image_url", image_url: { url: image } }
+            ]
+          });
+        } else {
+          convo.push({ role: "user", content: text || m.content });
+        }
+      } else {
+        convo.push({ role: m.role, content: m.content });
+      }
+    });
+    const callOpenAI = async (body) => {
+      const res = await fetch(OPENAI_URL4, {
+        method: "POST",
+        headers: { Authorization: `Bearer ${apiKey}`, "Content-Type": "application/json" },
+        body: JSON.stringify(body)
+      });
+      if (!res.ok) throw new Error(`OpenAI chat: ${await res.text()}`);
+      return res.json();
+    };
+    let didWrite = false;
+    for (let turn = 0; turn < MAX_TURNS; turn++) {
+      const data = await callOpenAI({
+        model: MODEL4,
+        max_tokens: 2048,
+        messages: convo,
+        ...tools2.length > 0 ? { tools: tools2, tool_choice: "auto" } : {}
+      });
+      const msg = data.choices?.[0]?.message;
+      if (!msg) throw new Error("OpenAI: resposta sem message.");
+      convo.push(msg);
+      if (msg.tool_calls && msg.tool_calls.length > 0) {
+        for (const call of msg.tool_calls) {
+          const name = call.function?.name;
+          let content;
+          try {
+            const argsStr = call.function?.arguments || "{}";
+            const args = argsStr ? JSON.parse(argsStr) : {};
+            const local = LOCAL_TOOLS[name];
+            const owner = mcpByTool[name];
+            let r;
+            if (local) {
+              r = await local(args);
+              if (["editar_campo", "publicar", "criar_locale", "traduzir", "habilitar_i18n"].includes(name))
+                didWrite = true;
+              strapi.log.info(`[mcp-chat] tool ${name} -> ${JSON.stringify(r).slice(0, 200)}`);
+            } else if (owner) {
+              r = await owner.callTool(name, args);
+            } else {
+              r = { erro: `tool ${name} indispon\xEDvel` };
+            }
+            content = typeof r === "string" ? r : JSON.stringify(r);
+          } catch (e) {
+            content = `Erro ao chamar a tool ${name}: ${e?.message || e}`;
+          }
+          convo.push({ role: "tool", tool_call_id: call.id, content });
+        }
+        continue;
+      }
+      const text = (typeof msg.content === "string" ? msg.content : "").trim();
+      return {
+        reply: text || "(sem resposta)",
+        model: MODEL4,
+        lang: language,
+        didWrite,
+        toolsAvailable: tools2.length
+      };
+    }
+    return {
+      reply: language === "en" ? "(agent turn limit reached)" : "(limite de turnos do agente atingido)",
+      model: MODEL4,
+      lang: language,
+      didWrite,
+      toolsAvailable: tools2.length
+    };
+  }
+});
+
+// server/src/services/audio.ts
+var audio_default2 = ({ strapi }) => ({
+  async transcribe(buffer, mimetype, language) {
+    const key = process.env.OPENAI_API_KEY;
+    if (!key) throw new Error("OPENAI_API_KEY n\xE3o configurada no .env (necess\xE1ria p/ \xE1udio).");
+    const ext = mimetype.includes("mp4") ? "mp4" : mimetype.includes("ogg") ? "ogg" : mimetype.includes("wav") ? "wav" : "webm";
+    const form = new FormData();
+    form.append("file", new Blob([buffer], { type: mimetype }), `audio.${ext}`);
+    form.append("model", "whisper-1");
+    const raw = Array.isArray(language) ? language[0] : language;
+    const lang = raw === "en" || raw === "pt" ? raw : void 0;
+    if (lang) form.append("language", lang);
+    const res = await fetch("https://api.openai.com/v1/audio/transcriptions", {
+      method: "POST",
+      headers: { Authorization: `Bearer ${key}` },
+      body: form
+    });
+    if (!res.ok) throw new Error(`OpenAI STT: ${await res.text()}`);
+    const data = await res.json();
+    return { text: data.text };
+  },
+  async synthesize(text, voice = "echo") {
+    const key = process.env.OPENAI_API_KEY;
+    if (!key) throw new Error("OPENAI_API_KEY n\xE3o configurada no .env (necess\xE1ria p/ \xE1udio).");
+    const res = await fetch("https://api.openai.com/v1/audio/speech", {
+      method: "POST",
+      headers: { Authorization: `Bearer ${key}`, "Content-Type": "application/json" },
+      body: JSON.stringify({ model: "tts-1", input: text, voice, response_format: "mp3" })
+    });
+    if (!res.ok) throw new Error(`OpenAI TTS: ${await res.text()}`);
+    const buffer = Buffer.from(await res.arrayBuffer());
+    return { audio_base64: buffer.toString("base64"), content_type: "audio/mpeg" };
+  }
+});
+
+// server/src/routes/index.ts
+var routes_default = {
+  admin: {
+    type: "admin",
+    routes: [
+      {
+        method: "POST",
+        path: "/message",
+        handler: "chat.message",
+        config: { policies: [] }
+      },
+      {
+        method: "POST",
+        path: "/stt",
+        handler: "audio.stt",
+        config: { policies: [] }
+      },
+      {
+        method: "POST",
+        path: "/tts",
+        handler: "audio.tts",
+        config: { policies: [] }
+      },
+      {
+        method: "POST",
+        path: "/frontend/analyze",
+        handler: "frontend.analyze",
+        config: { policies: [] }
+      },
+      {
+        method: "POST",
+        path: "/frontend/provision",
+        handler: "frontend.provision",
+        config: { policies: [] }
+      },
+      {
+        method: "GET",
+        path: "/frontend/status",
+        handler: "frontend.status",
+        config: { policies: [] }
+      },
+      {
+        method: "POST",
+        path: "/frontend/run",
+        handler: "frontend.run",
+        config: { policies: [] }
+      },
+      {
+        method: "GET",
+        path: "/frontend/run-status",
+        handler: "frontend.runStatus",
+        config: { policies: [] }
+      },
+      {
+        method: "POST",
+        path: "/frontend/integrate",
+        handler: "frontend.integrate",
+        config: { policies: [] }
+      }
+    ]
+  }
+};
+
+// 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 };
+      }
+    });
+  }
+};
+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 = 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 = 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 = 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 = 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 = 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 = tool7;
+
+// server/src/mcp/tools/index.ts
+var tools = [
+  buscar_texto_default,
+  editar_campo_default,
+  publicar_default,
+  listar_locales_default,
+  criar_locale_default,
+  traduzir_default,
+  habilitar_i18n_default
+];
+
+// server/src/mcp/index.ts
+var registerMcpTools = (strapi) => {
+  const mcp = strapi?.ai?.mcp;
+  const enabled = typeof mcp?.isEnabled === "function" ? mcp.isEnabled() : !!mcp?.registerTool;
+  if (!mcp || typeof mcp.registerTool !== "function" || !enabled) {
+    strapi.log.warn(
+      "[mcp-chat] MCP nativo indispon\xEDvel/desligado \u2014 tools N\xC3O registradas. Requer Strapi >= 5.47.0 com `mcp: { enabled: true }` em config/server."
+    );
+    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_*).`);
+};
+
+// server/src/register.ts
+var register_default = ({ strapi }) => {
+  try {
+    registerMcpTools(strapi);
+  } catch (e) {
+    strapi.log.warn(`[mcp-chat] registro do MCP falhou (seguindo sem ele): ${e?.message ?? e}`);
+  }
+};
+
+// server/src/index.ts
+var index_default = {
+  register: register_default,
+  async bootstrap({ strapi }) {
+    try {
+      const r = await runPendingProvision(strapi, strapi.dirs.app.root);
+      if (r.ran) {
+        strapi.log.info(
+          `[mcp-chat] provis\xE3o conclu\xEDda: seed=${JSON.stringify(r.seed?.created ?? [])} link=${r.link?.previewAction ?? "n/a"}`
+        );
+        if (r.errors.length) strapi.log.warn(`[mcp-chat] provis\xE3o com avisos: ${r.errors.join("; ")}`);
+      }
+    } catch (e) {
+      strapi.log.error(`[mcp-chat] runPendingProvision falhou: ${e?.message ?? e}`);
+    }
+  },
+  destroy() {
+    stopFrontend();
+  },
+  config: {
+    default: {},
+    validator() {
+    }
+  },
+  controllers: { chat: chat_default, audio: audio_default, frontend: frontend_default },
+  routes: routes_default,
+  services: { chat: chat_default2, audio: audio_default2 }
+};