@interware/content-generator 0.6.1 → 0.7.1

package/dist/server/index.js

@@ -41,7 +41,20 @@ const ensureFolder = async (strapi, name2) => {
   const created = await strapi.plugin("upload").service("folder").create({ name: name2, parent: null });
   return created.id;
 };
+const SCHEDULE_CRON = "content-generator-publicar-programados";
 const bootstrap = async ({ strapi }) => {
+  strapi.cron.add({
+    [SCHEDULE_CRON]: {
+      task: async () => {
+        try {
+          await strapi.plugin(PLUGIN_ID).service("articles").publishDue();
+        } catch (err) {
+          strapi.log.error(`[content-generator] publicar programados: ${err.message}`);
+        }
+      },
+      options: { rule: "* * * * *" }
+    }
+  });
   strapi.admin.services.permission.actionProvider.registerMany([
     {
       section: "plugins",
@@ -100,26 +113,29 @@ const template = { schema };
 const contentTypes = {
   template
 };
+const POST_MAX = 3e3;
+const hashtags = (keywords) => keywords.map((k) => k.trim().replace(/\s+/g, "").replace(/[^\p{L}\p{N}_]/gu, "")).filter(Boolean).map((k) => `#${k}`).join(" ");
+const defaultPostText = ({ titulo, descripcion, keywords }, red) => [red === "facebook" ? titulo : "", descripcion, hashtags(keywords)].filter(Boolean).join("\n\n");
+const checkPostText = (input) => {
+  const text2 = typeof input === "string" ? input.trim() : "";
+  if (!text2) return { ok: true, text: null };
+  if ([...text2].length > POST_MAX) return { ok: false, error: `El texto de la publicación puede tener hasta ${POST_MAX} caracteres.` };
+  return { ok: true, text: text2 };
+};
+const validarMensaje = (ctx) => {
+  const check = checkPostText(ctx.request.body?.mensaje);
+  if ("error" in check) {
+    ctx.status = 400;
+    ctx.body = { data: null, error: { status: 400, name: "ValidationError", message: check.error } };
+    return false;
+  }
+  ctx.request.body = { ...ctx.request.body, mensaje: check.text ?? void 0 };
+  if (!check.text) delete ctx.request.body.mensaje;
+  return true;
+};
 const controller = ({ strapi }) => {
   const pluginService = () => strapi.plugin("strapi-content-generator-gemini").service("service");
   return {
-    async getArticles(ctx) {
-      const contentType = strapi.contentType("api::articulo.articulo");
-      await strapi.contentAPI.validate.query(ctx.query, contentType, {
-        auth: ctx.state.auth
-      });
-      const sanitizedQueryParams = await strapi.contentAPI.sanitize.query(
-        ctx.query,
-        contentType,
-        {
-          auth: ctx.state.auth
-        }
-      );
-      const documents = await pluginService().getArticulos(sanitizedQueryParams);
-      return await strapi.contentAPI.sanitize.output(documents, contentType, {
-        auth: ctx.state.auth
-      });
-    },
     async getCategories(ctx) {
       const contentType = strapi.contentType("api::categoria.categoria");
       await strapi.contentAPI.validate.query(ctx.query, contentType, {
@@ -137,29 +153,6 @@ const controller = ({ strapi }) => {
         auth: ctx.state.auth
       });
     },
-    async getUsers(ctx) {
-      const contentType = strapi.contentType("plugin::users-permissions.user");
-      await strapi.contentAPI.validate.query(ctx.query, contentType, {
-        auth: ctx.state.auth
-      });
-      const sanitizedQueryParams = await strapi.contentAPI.sanitize.query(
-        ctx.query,
-        contentType,
-        {
-          auth: ctx.state.auth
-        }
-      );
-      const documents = await pluginService().getUsuarios(sanitizedQueryParams);
-      return await strapi.contentAPI.sanitize.output(documents, contentType, {
-        auth: ctx.state.auth
-      });
-    },
-    async generateArticle(ctx) {
-      ctx.body = await pluginService().generateArticle(ctx);
-    },
-    async generateImageForArticle(ctx) {
-      ctx.body = await pluginService().generateImageForArticle(ctx);
-    },
     async downloadFile(ctx) {
       await pluginService().downloadFile(ctx);
     },
@@ -167,10 +160,10 @@ const controller = ({ strapi }) => {
       ctx.body = await pluginService().generateVideo(ctx);
     },
     async publishToLinkedIn(ctx) {
-      ctx.body = await pluginService().publishToLinkedIn(ctx);
+      if (validarMensaje(ctx)) ctx.body = await pluginService().publishToLinkedIn(ctx);
     },
     async publishToFacebook(ctx) {
-      ctx.body = await pluginService().publishToFacebook(ctx);
+      if (validarMensaje(ctx)) ctx.body = await pluginService().publishToFacebook(ctx);
     }
   };
 };
@@ -273,14 +266,11 @@ const safetySettings = (safety) => HARM_CATEGORIES.map((category) => ({
   category,
   threshold: safety ? genai.HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE : genai.HarmBlockThreshold.BLOCK_ONLY_HIGH
 }));
-const PEOPLE = {
-  none: "ALLOW_NONE",
-  adults: genai.PersonGeneration.ALLOW_ADULT
-};
+const NO_PEOPLE = "ALLOW_NONE";
 const imageConfig = ({ aspectRatio, imageSize, allowPeople }, backend = "gemini-api") => ({
   ...aspectRatio ? { aspectRatio } : {},
   ...imageSize ? { imageSize } : {},
-  ...backend === "vertex" ? { personGeneration: allowPeople ? PEOPLE.adults : PEOPLE.none } : {}
+  ...backend === "vertex" && !allowPeople ? { personGeneration: NO_PEOPLE } : {}
 });
 const promptPart = (text2, allowPeople, backend = "gemini-api") => ({
   text: backend === "gemini-api" && !allowPeople ? `${text2} ${PEOPLE_CLAUSE}` : text2
@@ -331,7 +321,7 @@ const INVISIBLE = /[­​-‏‪-‮⁠-⁤⁦-⁩]/g;
 const TAG = /<\/?[a-z][^>]*>/gi;
 const sanitizePrompt = (text2) => text2.normalize("NFC").replace(CONTROL, "").replace(INVISIBLE, "").replace(TAG, "").replace(/\s+/g, " ").trim();
 const PROMPT_LABELS = { label: "El prompt", empty: "Escribe un prompt." };
-const INSTRUCTION_LABELS = { label: "La instrucción", empty: "Describe el cambio que quieres." };
+const INSTRUCTION_LABELS$1 = { label: "La instrucción", empty: "Describe el cambio que quieres." };
 const checkPrompt = (text2, { label, empty } = PROMPT_LABELS) => {
   const clean2 = sanitizePrompt(text2);
   if (!clean2) return { ok: false, error: empty };
@@ -346,6 +336,10 @@ const EXPAND_INSTRUCTION = (concept) => [
   `Concepto: ${concept}`
 ].join("\n");
 class BlockedError extends Error {
+  constructor(message, detail) {
+    super(message);
+    this.detail = detail;
+  }
 }
 const sourceOf = (chunk) => {
   if (chunk.web?.uri) return { title: chunk.web.title || new URL(chunk.web.uri).hostname, uri: chunk.web.uri };
@@ -367,12 +361,21 @@ const BLOCK_REASONS = {
   PROHIBITED_CONTENT: "El modelo bloqueó la solicitud por contenido no permitido.",
   IMAGE_SAFETY: "El modelo bloqueó la imagen resultante por seguridad."
 };
+const blockMessage = (reason, googleMessage) => {
+  const code = googleMessage.match(/Support code:\s*(\d+)/i)?.[1];
+  const suffix = code ? ` (Código de Google: ${code})` : "";
+  if (/PersonGeneration/i.test(googleMessage)) {
+    return /input image/i.test(googleMessage) ? `Google rechazó la imagen de referencia por la configuración de «Personas». Prueba con otra imagen o cambia «Personas».${suffix}` : `Google filtró la imagen generada por la configuración de «Personas». Cambia el prompt o «Personas».${suffix}`;
+  }
+  return `${BLOCK_REASONS[reason] ?? "El modelo no devolvió una imagen. Intenta con otro prompt."}${suffix}`;
+};
 const imageFrom = (res, model) => {
   const parts = res.candidates?.[0]?.content?.parts ?? [];
   const part = parts.find((p) => p.inlineData?.data && (p.inlineData.mimeType ?? "").startsWith("image/"));
   if (part?.inlineData?.data) return { image: part.inlineData.data, mimeType: part.inlineData.mimeType ?? "image/png", model };
-  const reason = res.promptFeedback?.blockReason ?? res.candidates?.[0]?.finishReason;
-  throw new BlockedError(BLOCK_REASONS[String(reason)] ?? "El modelo no devolvió una imagen. Intenta con otro prompt.");
+  const reason = String(res.promptFeedback?.blockReason ?? res.candidates?.[0]?.finishReason ?? "");
+  const googleMessage = [res.candidates?.[0]?.finishMessage, res.promptFeedback?.blockReasonMessage].filter(Boolean).join(" ");
+  throw new BlockedError(blockMessage(reason, googleMessage), [reason, googleMessage].filter(Boolean).join(": ") || void 0);
 };
 const inline = async (file, read) => inlinePart(await read(file.filepath), file.mimetype ?? "image/png");
 const userTurn = (parts) => [{ role: "user", parts }];
@@ -387,25 +390,6 @@ const createImageStudio = (getClient, read = (p) => fs.promises.readFile(p)) =>
       return availableModels(null);
     }
   },
-  /**
-   * Imagen para un artículo (S4.12): antes usaba Imagen 4, que Google apagó. Usa el primer modelo
-   * disponible del catálogo y ajusta proporción y tamaño a lo que admite. Devuelve base64.
-   */
-  async generateForArticle(prompt, aspectRatio, imageSize) {
-    const [model] = (await this.models()).models;
-    const { image } = await this.generate({
-      prompt,
-      model,
-      aspectRatio: model.aspectRatios.includes(aspectRatio) ? aspectRatio : "16:9",
-      imageSize: model.sizes.includes(imageSize) ? imageSize : void 0,
-      safety: true,
-      // El estilo de marca de los artículos no lleva personas (su JSON ya lo pide); ahora también el parámetro.
-      allowPeople: false,
-      grounding: false,
-      references: []
-    });
-    return image;
-  },
   async generate(input) {
     const { models: api, backend } = await getClient();
     const text2 = cleanPrompt(input.prompt);
@@ -483,7 +467,7 @@ const parseGenerateInput = (fields, files) => {
   };
 };
 const parseEditInput = (fields, files) => {
-  const instruction = clean(str(fields.instruction), INSTRUCTION_LABELS);
+  const instruction = clean(str(fields.instruction), INSTRUCTION_LABELS$1);
   const [image] = list(files.image);
   if (!image) throw new InputError("Falta la imagen a editar.");
   const model = editModelFor(str(fields.model) || void 0);
@@ -501,7 +485,7 @@ const parseEditInput = (fields, files) => {
     aspectRatio: model.aspectRatios.includes(str(fields.aspectRatio)) ? str(fields.aspectRatio) : void 0
   };
 };
-const fail$2 = (ctx, status, name2, message) => {
+const fail$3 = (ctx, status, name2, message) => {
   ctx.status = status;
   ctx.body = { data: null, error: { status, name: name2, message } };
 };
@@ -511,10 +495,13 @@ const imageStudio = ({ strapi }) => {
     try {
       ctx.body = await work();
     } catch (err) {
-      if (err instanceof InputError) return fail$2(ctx, 400, "BadRequestError", err.message);
-      if (err instanceof BlockedError) return fail$2(ctx, 422, "UnprocessableEntityError", err.message);
+      if (err instanceof InputError) return fail$3(ctx, 400, "BadRequestError", err.message);
+      if (err instanceof BlockedError) {
+        strapi.log.warn(`[image-studio] bloqueo: ${err.detail ?? err.message}`);
+        return fail$3(ctx, 422, "UnprocessableEntityError", err.message);
+      }
       strapi.log.error(`[image-studio] ${err instanceof Error ? err.message : String(err)}`);
-      return fail$2(ctx, 502, "BadGatewayError", "El servicio de imágenes no respondió. Intenta de nuevo en un momento.");
+      return fail$3(ctx, 502, "BadGatewayError", "El servicio de imágenes no respondió. Intenta de nuevo en un momento.");
     }
   };
   return {
@@ -528,6 +515,454 @@ const imageStudio = ({ strapi }) => {
     })
   };
 };
+const MAX_URLS = 3;
+const isHttp = (value) => {
+  try {
+    const { protocol } = new URL(value);
+    return protocol === "http:" || protocol === "https:";
+  } catch {
+    return false;
+  }
+};
+const hostOf = (url) => {
+  try {
+    return new URL(url).hostname;
+  } catch {
+    return url;
+  }
+};
+const parseReferenceUrls = (input) => {
+  const list2 = (Array.isArray(input) ? input : []).filter((v) => typeof v === "string").map((v) => v.trim()).filter(Boolean);
+  const unique = [...new Set(list2)];
+  if (unique.length > MAX_URLS) throw new InputError(`Puedes dar hasta ${MAX_URLS} URLs de referencia.`);
+  const invalid = unique.find((u) => !isHttp(u));
+  if (invalid) throw new InputError(`La URL «${invalid}» no es válida.`);
+  return unique;
+};
+const sourcesFrom = (urls, res) => {
+  const referencias = urls.map((url) => ({ titulo: hostOf(url), url, tipo: "referencia" }));
+  const busqueda = (res?.candidates?.[0]?.groundingMetadata?.groundingChunks ?? []).map((chunk) => chunk.web).filter((web) => Boolean(web?.uri)).map((web) => ({ titulo: web.title || hostOf(web.uri), url: web.uri, tipo: "busqueda" }));
+  return [...referencias, ...busqueda].filter((f, i, all3) => all3.findIndex((o) => o.url === f.url) === i);
+};
+const ARTICLE_MODEL = "gemini-2.5-pro";
+const ENRICH_MODEL = "gemini-2.5-flash";
+const BASE_PROMPT_MAX = 2e4;
+const INSTRUCTION_LABELS = { label: "Las instrucciones", empty: "Escribe las instrucciones del artículo." };
+const parseCategoria = (input) => {
+  const c = input ?? {};
+  if (typeof c.id === "string" && c.id.trim()) return { id: c.id.trim() };
+  if (typeof c.nueva === "string" && c.nueva.trim()) return { nueva: c.nueva.trim().slice(0, 80) };
+  throw new InputError("Elige o escribe una categoría.");
+};
+const parseTemperatura = (input) => {
+  const n = typeof input === "number" ? input : typeof input === "string" ? Number(input) : NaN;
+  return Number.isFinite(n) ? Math.min(2, Math.max(0, n)) : 0.5;
+};
+const parseArticleInput = (body) => {
+  const check = checkPrompt(typeof body.instrucciones === "string" ? body.instrucciones : "", INSTRUCTION_LABELS);
+  if ("error" in check) throw new InputError(check.error);
+  return {
+    titulo: typeof body.titulo === "string" ? body.titulo.trim().slice(0, 200) : "",
+    categoria: parseCategoria(body.categoria),
+    temperatura: parseTemperatura(body.temperatura),
+    instrucciones: check.text,
+    urls: parseReferenceUrls(body.urls),
+    busqueda: body.busqueda === true || body.busqueda === "true",
+    usarPromptBase: !(body.usarPromptBase === false || body.usarPromptBase === "false"),
+    ...optionalBase(body.promptBase)
+  };
+};
+const optionalBase = (input) => {
+  const text2 = typeof input === "string" ? input.trim() : "";
+  if (!text2) return {};
+  if (text2.length > BASE_PROMPT_MAX) throw new InputError(`El prompt base puede tener hasta ${BASE_PROMPT_MAX} caracteres.`);
+  return { promptBase: text2 };
+};
+const parseBasePrompt = (input) => {
+  const base = optionalBase(input).promptBase;
+  if (!base) throw new InputError("Escribe el prompt base.");
+  return base;
+};
+const researchTools = ({ urls, busqueda }) => [
+  ...busqueda ? [{ googleSearch: {} }] : [],
+  ...urls.length ? [{ urlContext: {} }] : []
+];
+const temaLines = ({ titulo, categoria, instrucciones }) => [
+  titulo ? `- Título sugerido: "${titulo}"` : "",
+  categoria ? `- Categoría o tópico: "${categoria}"` : "",
+  instrucciones ? `- Instrucciones: "${instrucciones}"` : ""
+].filter(Boolean).join("\n");
+const researchPrompt = (tema) => `
+Eres analista de investigación de InterWare. Reúne la información que respaldará una columna de opinión para
+directores de TI, operaciones y finanzas.
+
+Tema:
+${temaLines(tema)}
+${tema.urls.length ? `
+Lee y usa como referencia principal estas páginas:
+${tema.urls.map((u) => `- ${u}`).join("\n")}
+` : ""}
+Entrega notas en español, concisas: hechos, cifras con su fuente, tendencias y ejemplos relevantes. No escribas el
+artículo. Si un dato no está respaldado por una fuente, no lo incluyas.
+`;
+const DEFAULT_BASE_PROMPT = `# ROL Y PERSONA (EL FONDO)
+Actúa como un Estratega Tecnológico de nivel C-Level y Arquitecto de Negocios de élite para 'InterWare'. Eres un columnista de opinión experto, escribiendo para una audiencia exclusiva de tomadores de decisión: Directores de TI (CTOs), Directores de Operaciones (COOs) y Directores Financieros (CFOs/FinOps).
+No eres un redactor de marketing ni un vendedor de software; eres un consultor de alto nivel que diagnostica problemas sistémicos complejos y ofrece perspectivas de valor incalculable. Tu objetivo es hacer que el lector cuestione la madurez de su propia infraestructura.
+
+# FILOSOFÍA DE MARCA: "ORQUESTACIÓN LATENTE"
+Toda tu narrativa debe estar impregnada de nuestra visión de negocio: "Evolución por Continuidad"
+- InterWare no inventa necesidades ni vende catálogos de servicios; InterWare resuelve la complejidad operativa con responsabilidad
+- Somos el orquestador invisible que garantiza que ecosistemas heterogéneos trabajen en perfecta armonía.
+- Tu ancla absoluta de confianza y diferenciador es: "El código tiene alma". Esto significa que no entregamos simple software; entregamos sistemas de misión crítica que no fallan, respaldados por equipos humanos de excelencia.
+- Tu respaldo de autoridad (menciónelo sutilmente como validación, nunca como presunción): Nos avalan casi 30 años de historia, más de 9,000 proyectos exitosos, primer centro autorizado de Java en LATAM  y más de 25 años como Partners Gold de IBM. Nuestra prueba de lealtad es que promediamos relaciones de más de 10 años con nuestros clientes.
+
+# REGLAS DE TONO Y LÉXICO (LA FORMA)
+1. El Tono: Profundamente autoritario, frío, elegante, quirúrgico y sofisticado. Escribe con la certeza de quien ha visto todas las fallas posibles en la industria y sabe cómo prevenirlas.
+2. Vocabulario Obligatorio (Usa al menos 4 de forma natural): Orquestación, resiliencia, fricción operativa, deuda técnica, telemetría, anticipación, interoperabilidad, misión crítica, observabilidad profunda, ecosistemas híbridos, primitivas de orquestación.
+3. Prohibición de Léxico Barato (Zero-Clutter Text): PROHIBIDO usar palabras literales o burdas como "fierros", "cables", "hardware", "servidores físicos" o "computadoras". En su lugar, usa "nodos", "infraestructura", "arquitecturas distribuidas", "activos digitales".
+
+# RESTRICCIONES ESTRICTAS ANTI-IA (EL ESTILO)
+- Cero Clichés de Marketing: NUNCA uses frases trilladas como "en el mundo digital de hoy", "en la era actual", "desata el poder", "revolucionar el mercado", "lleva tu empresa al siguiente nivel" o "somos tu mejor opción".
+- Cero Estructuras Robóticas: Evita transiciones predecibles como "En resumen", "En conclusión", "En primer lugar", "En segundo lugar".
+- Fluidez Orgánica: No abuses de las listas de viñetas (bullets). Si debes listar beneficios, intégralos en la prosa de manera fluida o usa negritas sutiles dentro de un párrafo.
+- Espacio Negativo Textual: Los tomadores de decisión no leen bloques densos de texto. Usa párrafos cortos (máximo 3 o 4 líneas). El texto debe "respirar".
+
+# INSTRUCCIÓN DE EJECUCIÓN: LA NARRATIVA DE LA COLUMNA
+Redacta una columna de opinión profunda y analítica sobre el tema de la sección «TEMA DEL ARTÍCULO».
+
+Tu artículo debe seguir este arco narrativo impecable (entre 600 y 800 palabras):
+
+1. EL TÍTULO ABSTRACTO: Crea un título de menos de 10 palabras que evoque un dolor de negocio o una revelación financiera, no una característica de software. Debe sonar a un artículo de *Harvard Business Review*.
+2. LA FRICCIÓN (El Diagnóstico Crudo): Abre el artículo sin introducciones banales. Golpea directamente diagnosticando el dolor del negocio (ej. la pérdida de rentabilidad por cuellos de botella operativos o el riesgo inminente de sistemas legados que nadie sabe mantener). Haz que el lector sienta que estás describiendo su empresa.
+3. LA ORQUESTACIÓN (El Núcleo): Desarrolla tu argumento explicando cómo una arquitectura inteligente (ya sea a través de microservicios, DevSecOps, automatización inteligente de negocio, o monitoreo sintético con herramientas como iwRobot) resuelve este problema de raíz. Transmite la idea de que la tecnología debe ser un habilitador transparente, no una carga.
+4. EL IMPACTO LATENTE: Teje dentro de la prosa (sin usar viñetas obvias de IA) los tres impactos estratégicos del tema. Habla de cómo se logra la Resiliencia, la Fluidez operativa, la Eficiencia financiera o la Anticipación ante el riesgo.
+5. EL CIERRE SUTIL (El CTA Elegante): En lugar de un llamado a la acción desesperado de ventas, cierra con una reflexión ejecutiva o una pregunta abierta que invite al lector a auditar mentalmente la madurez de su propia infraestructura. Una despedida que demuestre que, para orquestar la complejidad, se requiere la maestría de tres décadas.
+
+Recuerda: Eres un experto hablando con otro experto. Sé denso en valor y conciso en palabras`;
+const investigacionBlock = (investigacion) => investigacion ? `
+
+# INVESTIGACIÓN DE APOYO
+Usa estos datos como base factual. No inventes cifras, nombres ni estudios que no aparezcan aquí:
+${investigacion}` : "";
+const articlePrompt = ({ base = DEFAULT_BASE_PROMPT, investigacion, ...tema }) => `${base}
+
+# TEMA DEL ARTÍCULO
+${temaLines(tema)}${investigacionBlock(investigacion)}`;
+const rawPrompt = ({ instrucciones, investigacion }) => `${instrucciones}${investigacionBlock(investigacion)}`;
+const enrichPrompt = (texto) => `
+Eres editor de contenidos de InterWare, empresa mexicana de tecnología. Convierte esta idea en instrucciones claras
+para redactar un artículo de blog.
+
+Idea: "${texto}"
+
+Responde solo con las instrucciones, en español y en texto plano, con estas líneas:
+Tema: …
+Público: …
+Cubrir: …
+Tono: …
+Cierre: …
+Máximo 1500 caracteres. Sin comillas ni Markdown.
+`;
+const ARTICLE_SCHEMA = {
+  type: "object",
+  required: ["titulo", "descripcion", "content", "seo", "minute_read"],
+  properties: {
+    seo: {
+      type: "object",
+      required: ["metaTitle", "metaDescription", "metadata"],
+      properties: {
+        metaTitle: { type: "string" },
+        metaDescription: { type: "string" },
+        metadata: {
+          type: "array",
+          items: {
+            type: "object",
+            required: ["name", "content"],
+            properties: { name: { type: "string" }, content: { type: "string" } }
+          }
+        }
+      }
+    },
+    titulo: { type: "string", minLength: 40, maxLength: 70, description: "Título del artículo" },
+    descripcion: { type: "string", minLength: 80, maxLength: 160, description: "Descripción breve del artículo" },
+    slug: {
+      type: "string",
+      minLength: 80,
+      maxLength: 160,
+      description: "URL-friendly basado en el título (ej: estrategias-migracion-nube)"
+    },
+    content: { type: "string", description: "Contenido HTML compatible con CKEditor" },
+    minute_read: {
+      type: "integer",
+      minimum: 1,
+      maximum: 30,
+      description: "Tiempo de lectura calculado usando 200 palabras por minuto"
+    },
+    keywords: {
+      type: "array",
+      minItems: 3,
+      maxItems: 5,
+      items: { type: "object", required: ["name"], properties: { name: { type: "string" } } },
+      description: "Hash tags y palabras clave para la publicación en LinkedIn y Facebook"
+    }
+  }
+};
+const ZONA = "America/Mexico_City";
+const UN_ANIO_MS = 365 * 24 * 60 * 60 * 1e3;
+const fechaEnMexico = (date) => new Intl.DateTimeFormat("en-CA", { timeZone: ZONA, year: "numeric", month: "2-digit", day: "2-digit" }).format(date);
+const parseScheduleAt = (input, now) => {
+  const date = typeof input === "string" ? new Date(input) : /* @__PURE__ */ new Date(NaN);
+  if (Number.isNaN(date.getTime())) throw new InputError("La fecha y hora no son válidas.");
+  if (date.getTime() <= now.getTime()) throw new InputError("Elige una fecha y hora futuras.");
+  if (date.getTime() - now.getTime() > UN_ANIO_MS) throw new InputError("Programa con menos de un año de anticipación.");
+  return date;
+};
+const estadoDe = ({ publicado, programada }) => publicado ? "publicado" : programada ? "programado" : "borrador";
+class NotFoundError extends Error {
+}
+const memoryStore = () => {
+  let value = null;
+  return {
+    get: async () => value,
+    set: async (v) => {
+      value = v;
+    },
+    remove: async () => {
+      value = null;
+    }
+  };
+};
+const ROW_FIELDS = ["titulo", "fecha_publicacion", "publicacion_programada", "linkedInPostId", "facebookPostId"];
+const DETAIL_POPULATE = { image: true, categoria: true, seo: true, keywords: true };
+const silentLog = { info: () => void 0, warn: () => void 0, error: () => void 0 };
+const slugify = (text2) => text2.toLowerCase().normalize("NFD").replace(/[̀-ͯ]/g, "").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+const textOf = (res) => (res.text ?? res.candidates?.[0]?.content?.parts?.[0]?.text ?? "").trim();
+const toRow = (d, publicado) => ({
+  documentId: d.documentId,
+  titulo: d.titulo ?? "",
+  categoria: d.categoria?.categoria ?? null,
+  estado: estadoDe({ publicado, programada: d.publicacion_programada }),
+  imagen: Boolean(d.image),
+  fechaPublicacion: d.fecha_publicacion ?? null,
+  programadaPara: d.publicacion_programada ?? null,
+  linkedInPostId: d.linkedInPostId ?? null,
+  facebookPostId: d.facebookPostId ?? null
+});
+const toDetail = (d, publicado) => ({
+  ...toRow(d, publicado),
+  descripcion: d.descripcion ?? "",
+  content: d.content ?? "",
+  minuteRead: d.minute_read ?? null,
+  slug: d.slug ?? null,
+  imageUrl: d.image ? d.image.formats?.small?.url ?? d.image.formats?.thumbnail?.url ?? d.image.url ?? null : null,
+  imageName: d.image?.name ?? null,
+  seo: d.seo ? { metaTitle: d.seo.metaTitle, metaDescription: d.seo.metaDescription } : null,
+  keywords: (d.keywords ?? []).map((k) => k.name ?? "").filter(Boolean),
+  fuentes: Array.isArray(d.fuentes) ? d.fuentes : []
+});
+const createArticles = ({ articulos, categorias, getModels, now = () => /* @__PURE__ */ new Date(), log = silentLog, promptStore = memoryStore() }) => {
+  const draftOf = async (documentId, populate = DETAIL_POPULATE) => {
+    const d = await articulos.findOne({ documentId, status: "draft", populate });
+    if (!d) throw new NotFoundError("El artículo no existe.");
+    return d;
+  };
+  const isPublished = async (documentId) => Boolean(await articulos.findOne({ documentId, status: "published", fields: ["titulo"] }));
+  const detail = async (documentId) => {
+    const d = await draftOf(documentId);
+    return toDetail(d, await isPublished(documentId));
+  };
+  const resolveCategoria = async (input) => {
+    if ("id" in input) {
+      const c = await categorias.findOne({ documentId: input.id });
+      if (!c) throw new InputError("La categoría elegida ya no existe.");
+      return { id: c.documentId, nombre: c.categoria };
+    }
+    const found = await categorias.findFirst({ filters: { categoria: { $eqi: input.nueva } } });
+    if (found) return { id: found.documentId, nombre: found.categoria };
+    const created = await categorias.create({ data: { categoria: input.nueva, slug: slugify(input.nueva) } });
+    return { id: created.documentId, nombre: input.nueva };
+  };
+  const basePrompt = async () => {
+    const guardado = await promptStore.get();
+    return { prompt: guardado || DEFAULT_BASE_PROMPT, personalizado: Boolean(guardado) };
+  };
+  return {
+    basePrompt,
+    async saveBasePrompt(prompt) {
+      await promptStore.set(prompt);
+      return basePrompt();
+    },
+    async resetBasePrompt() {
+      await promptStore.remove();
+      return basePrompt();
+    },
+    async list() {
+      const [drafts, published] = await Promise.all([
+        articulos.findMany({ status: "draft", fields: ROW_FIELDS, populate: { image: { fields: ["id"] }, categoria: { fields: ["categoria"] } }, sort: ["createdAt:desc"] }),
+        articulos.findMany({ status: "published", fields: ["titulo"] })
+      ]);
+      const publicados = new Set(published.map((p) => p.documentId));
+      return { articles: drafts.map((d) => toRow(d, publicados.has(d.documentId))) };
+    },
+    detail,
+    async generate(input) {
+      const categoria = await resolveCategoria(input.categoria);
+      const models = await getModels();
+      const tema = { titulo: input.titulo, categoria: categoria.nombre, instrucciones: input.instrucciones };
+      const tools = researchTools(input);
+      let investigacion;
+      let fuentes = [];
+      if (tools.length) {
+        const research = await models.generateContent({ model: ARTICLE_MODEL, contents: researchPrompt({ ...tema, urls: input.urls }), config: { tools, temperature: 0.2 } });
+        investigacion = textOf(research) || void 0;
+        fuentes = sourcesFrom(input.urls, research);
+      }
+      const contents = input.usarPromptBase === false ? rawPrompt({ instrucciones: input.instrucciones, investigacion }) : articlePrompt({ ...tema, investigacion, base: input.promptBase ?? (await basePrompt()).prompt });
+      const res = await models.generateContent({
+        model: ARTICLE_MODEL,
+        contents,
+        config: { responseMimeType: "application/json", temperature: input.temperatura, responseSchema: ARTICLE_SCHEMA }
+      });
+      let parsed;
+      try {
+        parsed = JSON.parse(textOf(res));
+      } catch {
+        throw new Error("La respuesta del modelo no es un JSON válido.");
+      }
+      const created = await articulos.create({
+        data: {
+          titulo: parsed.titulo,
+          descripcion: parsed.descripcion,
+          content: parsed.content,
+          seo: parsed.seo,
+          minute_read: parsed.minute_read,
+          slug: parsed.slug,
+          keywords: parsed.keywords,
+          categoria: categoria.id,
+          image: null,
+          fuentes
+        },
+        status: "draft"
+      });
+      return { documentId: created.documentId };
+    },
+    async enrich(texto) {
+      const models = await getModels();
+      const res = await models.generateContent({ model: ENRICH_MODEL, contents: enrichPrompt(texto) });
+      const out = textOf(res).replace(/^["'«“]+|["'»”]+$/g, "").trim();
+      if (!out) throw new InputError("No se pudieron enriquecer las instrucciones. Intenta de nuevo.");
+      return out.slice(0, 2e3);
+    },
+    async setImage(documentId, fileId) {
+      const id = typeof fileId === "number" ? fileId : Number(fileId);
+      if (!Number.isInteger(id) || id <= 0) throw new InputError("Elige una imagen válida.");
+      await draftOf(documentId, {});
+      await articulos.update({ documentId, data: { image: id } });
+      if (await isPublished(documentId)) await articulos.publish({ documentId });
+      return detail(documentId);
+    },
+    async publish(documentId) {
+      const d = await draftOf(documentId);
+      if (!d.image) throw new InputError("Elige una imagen antes de publicar.");
+      await articulos.update({ documentId, data: { fecha_publicacion: fechaEnMexico(now()), publicacion_programada: null } });
+      await articulos.publish({ documentId });
+      return detail(documentId);
+    },
+    async schedule(documentId, at) {
+      const date = parseScheduleAt(at, now());
+      const d = await draftOf(documentId);
+      if (!d.image) throw new InputError("Elige una imagen antes de programar.");
+      if (await isPublished(documentId)) throw new InputError("El artículo ya está publicado.");
+      await articulos.update({ documentId, data: { publicacion_programada: date.toISOString(), fecha_publicacion: fechaEnMexico(date) } });
+      return detail(documentId);
+    },
+    async unschedule(documentId) {
+      await draftOf(documentId, {});
+      await articulos.update({ documentId, data: { publicacion_programada: null, fecha_publicacion: null } });
+      return detail(documentId);
+    },
+    /** D4: publica los borradores con programación vencida. Devuelve cuántos publicó. */
+    async publishDue() {
+      const due = await articulos.findMany({
+        status: "draft",
+        filters: { publicacion_programada: { $notNull: true, $lte: now().toISOString() } },
+        fields: ["publicacion_programada"],
+        populate: { image: { fields: ["id"] } }
+      });
+      let count = 0;
+      for (const d of due) {
+        if (!d.image) {
+          log.warn(`[articles] ${d.documentId} está programado pero no tiene imagen; no se publicó.`);
+          continue;
+        }
+        try {
+          await articulos.update({ documentId: d.documentId, data: { publicacion_programada: null } });
+          await articulos.publish({ documentId: d.documentId });
+          count += 1;
+        } catch (err) {
+          log.error(`[articles] no se pudo publicar ${d.documentId}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+      }
+      if (count) log.info(`[articles] ${count} artículo(s) programado(s) publicados.`);
+      return count;
+    }
+  };
+};
+const articles$1 = ({ strapi }) => createArticles({
+  articulos: strapi.documents("api::articulo.articulo"),
+  categorias: strapi.documents("api::categoria.categoria"),
+  getModels: async () => (await strapi.plugin("strapi-content-generator-gemini").service("service").geminiClient()).ai.models,
+  log: strapi.log,
+  promptStore: /* @__PURE__ */ (() => {
+    const store = () => strapi.store({ type: "plugin", name: "strapi-content-generator-gemini" });
+    const key = "ARTICLE_BASE_PROMPT";
+    return {
+      get: async () => await store().get({ key }) ?? null,
+      set: async (value) => {
+        await store().set({ key, value });
+      },
+      remove: async () => {
+        await store().delete({ key });
+      }
+    };
+  })()
+});
+const fail$2 = (ctx, status, name2, message) => {
+  ctx.status = status;
+  ctx.body = { data: null, error: { status, name: name2, message } };
+};
+const articles = ({ strapi }) => {
+  const articles2 = () => strapi.plugin("strapi-content-generator-gemini").service("articles");
+  const id = (ctx) => ctx.params?.documentId ?? "";
+  const run = async (ctx, work) => {
+    try {
+      ctx.body = await work();
+    } catch (err) {
+      if (err instanceof InputError) return fail$2(ctx, 400, "BadRequestError", err.message);
+      if (err instanceof NotFoundError) return fail$2(ctx, 404, "NotFoundError", err.message);
+      if (err instanceof Error && err.name === "ValidationError") return fail$2(ctx, 400, "ValidationError", err.message);
+      strapi.log.error(`[articles] ${err instanceof Error ? err.message : String(err)}`);
+      return fail$2(ctx, 502, "BadGatewayError", "El servicio de generación no respondió. Intenta de nuevo en un momento.");
+    }
+  };
+  return {
+    list: (ctx) => run(ctx, () => articles2().list()),
+    detail: (ctx) => run(ctx, () => articles2().detail(id(ctx))),
+    generate: (ctx) => run(ctx, () => articles2().generate(parseArticleInput(ctx.request.body ?? {}))),
+    enrich: (ctx) => run(ctx, async () => {
+      const raw = typeof ctx.request.body?.texto === "string" ? ctx.request.body.texto : "";
+      const texto = clean(raw, { label: "La idea", empty: "Escribe una idea para enriquecer." });
+      return { texto: await articles2().enrich(texto) };
+    }),
+    basePrompt: (ctx) => run(ctx, () => articles2().basePrompt()),
+    saveBasePrompt: (ctx) => run(ctx, () => articles2().saveBasePrompt(parseBasePrompt(ctx.request.body?.prompt))),
+    resetBasePrompt: (ctx) => run(ctx, () => articles2().resetBasePrompt()),
+    setImage: (ctx) => run(ctx, () => articles2().setImage(id(ctx), ctx.request.body?.fileId)),
+    publish: (ctx) => run(ctx, () => articles2().publish(id(ctx))),
+    schedule: (ctx) => run(ctx, () => articles2().schedule(id(ctx), ctx.request.body?.at)),
+    unschedule: (ctx) => run(ctx, () => articles2().unschedule(id(ctx)))
+  };
+};
 const NAVY = "#1F2A44";
 const RED = "#E4002B";
 const TEAL = "#00C7B1";
@@ -891,7 +1326,8 @@ const controllers = {
   controller,
   config: config$1,
   "image-studio": imageStudio,
-  templates
+  templates,
+  articles
 };
 const middlewares = {};
 const policies = {};
@@ -905,12 +1341,20 @@ const ADMIN_ACCESS_POLICIES = [
 ];
 const config = { policies: ADMIN_ACCESS_POLICIES };
 const admin = [
-  { method: "GET", path: "/posts", handler: "controller.getArticles", config },
+  { method: "GET", path: "/articles", handler: "articles.list", config },
+  // Las rutas fijas van antes de `/articles/:documentId` para que no las tome como id.
+  { method: "POST", path: "/articles/generate", handler: "articles.generate", config },
+  { method: "POST", path: "/articles/enrich", handler: "articles.enrich", config },
+  { method: "GET", path: "/articles/base-prompt", handler: "articles.basePrompt", config },
+  { method: "PUT", path: "/articles/base-prompt", handler: "articles.saveBasePrompt", config },
+  { method: "DELETE", path: "/articles/base-prompt", handler: "articles.resetBasePrompt", config },
+  { method: "GET", path: "/articles/:documentId", handler: "articles.detail", config },
+  { method: "PUT", path: "/articles/:documentId/image", handler: "articles.setImage", config },
+  { method: "POST", path: "/articles/:documentId/publish", handler: "articles.publish", config },
+  { method: "POST", path: "/articles/:documentId/schedule", handler: "articles.schedule", config },
+  { method: "DELETE", path: "/articles/:documentId/schedule", handler: "articles.unschedule", config },
   { method: "GET", path: "/categories", handler: "controller.getCategories", config },
-  { method: "GET", path: "/users", handler: "controller.getUsers", config },
   { method: "POST", path: "/download-file", handler: "controller.downloadFile", config },
-  { method: "POST", path: "/generate-article", handler: "controller.generateArticle", config },
-  { method: "POST", path: "/generate-image", handler: "controller.generateImageForArticle", config },
   { method: "GET", path: "/image-studio/models", handler: "image-studio.models", config },
   { method: "POST", path: "/image-studio/generate", handler: "image-studio.generate", config },
   { method: "POST", path: "/image-studio/edit", handler: "image-studio.edit", config },
@@ -4189,6 +4633,11 @@ const createGeminiClient = ({ serviceAccount, apiKey, allowVertex = true }, Ctor
     allowVertex ? "Configura la cuenta de servicio de Vertex AI o la llave de Gemini en Ajustes del plugin." : "El video necesita la llave de Gemini en Ajustes del plugin."
   );
 };
+const postData = (article) => ({
+  titulo: article.titulo ?? "",
+  descripcion: article.descripcion ?? "",
+  keywords: (Array.isArray(article.keywords) ? article.keywords : []).map((k) => k?.name ?? "")
+});
 const service = ({ strapi }) => {
   return {
     // ───────────────────────────────
@@ -4208,15 +4657,9 @@ const service = ({ strapi }) => {
     async geminiConfig() {
       return (await this.geminiClient()).ai;
     },
-    async getArticulos(sanitizedQueryParams) {
-      return await strapi.entityService.findMany("api::articulo.articulo", sanitizedQueryParams);
-    },
     async getCategorias(sanitizedQueryParams) {
       return await strapi.entityService.findMany("api::categoria.categoria", sanitizedQueryParams);
     },
-    async getUsuarios(sanitizedQueryParams) {
-      return await strapi.documents("plugin::users-permissions.user").findMany(sanitizedQueryParams);
-    },
     // ───────────────────────────────
     // 📥 Proxy File Download (bypasses browser CORS)
     // ───────────────────────────────
@@ -4286,232 +4729,6 @@ const service = ({ strapi }) => {
       }
       return uploadedFiles[0];
     },
-    // ───────────────────────────────
-    // 🧠 Generate Article with AI
-    // ───────────────────────────────
-    async generateArticle(ctx) {
-      const { titulo, categoria, autor, temperatura = 0.5, instrucciones } = ctx.request.body;
-      const promptArticulo = `
-        # ROL Y PERSONA (EL FONDO)
-        Actúa como un Estratega Tecnológico de nivel C-Level y Arquitecto de Negocios de élite para 'InterWare'. Eres un columnista de opinión experto, escribiendo para una audiencia exclusiva de tomadores de decisión: Directores de TI (CTOs), Directores de Operaciones (COOs) y Directores Financieros (CFOs/FinOps).
-        No eres un redactor de marketing ni un vendedor de software; eres un consultor de alto nivel que diagnostica problemas sistémicos complejos y ofrece perspectivas de valor incalculable. Tu objetivo es hacer que el lector cuestione la madurez de su propia infraestructura.
-
-        # FILOSOFÍA DE MARCA: "ORQUESTACIÓN LATENTE"
-        Toda tu narrativa debe estar impregnada de nuestra visión de negocio: "Evolución por Continuidad"
-        - InterWare no inventa necesidades ni vende catálogos de servicios; InterWare resuelve la complejidad operativa con responsabilidad
-        - Somos el orquestador invisible que garantiza que ecosistemas heterogéneos trabajen en perfecta armonía.
-        - Tu ancla absoluta de confianza y diferenciador es: "El código tiene alma". Esto significa que no entregamos simple software; entregamos sistemas de misión crítica que no fallan, respaldados por equipos humanos de excelencia.
-        - Tu respaldo de autoridad (menciónelo sutilmente como validación, nunca como presunción): Nos avalan casi 30 años de historia, más de 9,000 proyectos exitosos, primer centro autorizado de Java en LATAM  y más de 25 años como Partners Gold de IBM. Nuestra prueba de lealtad es que promediamos relaciones de más de 10 años con nuestros clientes.
-
-        # REGLAS DE TONO Y LÉXICO (LA FORMA)
-        1. El Tono: Profundamente autoritario, frío, elegante, quirúrgico y sofisticado. Escribe con la certeza de quien ha visto todas las fallas posibles en la industria y sabe cómo prevenirlas.
-        2. Vocabulario Obligatorio (Usa al menos 4 de forma natural): Orquestación, resiliencia, fricción operativa, deuda técnica, telemetría, anticipación, interoperabilidad, misión crítica, observabilidad profunda, ecosistemas híbridos, primitivas de orquestación.
-        3. Prohibición de Léxico Barato (Zero-Clutter Text): PROHIBIDO usar palabras literales o burdas como "fierros", "cables", "hardware", "servidores físicos" o "computadoras". En su lugar, usa "nodos", "infraestructura", "arquitecturas distribuidas", "activos digitales".
-
-        # RESTRICCIONES ESTRICTAS ANTI-IA (EL ESTILO)
-        - Cero Clichés de Marketing: NUNCA uses frases trilladas como "en el mundo digital de hoy", "en la era actual", "desata el poder", "revolucionar el mercado", "lleva tu empresa al siguiente nivel" o "somos tu mejor opción".
-        - Cero Estructuras Robóticas: Evita transiciones predecibles como "En resumen", "En conclusión", "En primer lugar", "En segundo lugar".
-        - Fluidez Orgánica: No abuses de las listas de viñetas (bullets). Si debes listar beneficios, intégralos en la prosa de manera fluida o usa negritas sutiles dentro de un párrafo.
-        - Espacio Negativo Textual: Los tomadores de decisión no leen bloques densos de texto. Usa párrafos cortos (máximo 3 o 4 líneas). El texto debe "respirar".
-
-        # INSTRUCCIÓN DE EJECUCIÓN: LA NARRATIVA DE LA COLUMNA
-        Redacta una columna de opinión profunda y analítica sobre el siguiente tema:
-        ${titulo ? `- Título sugerido: "${titulo}"` : ""}
-        ${categoria ? `- Categoría or tópico: "${categoria}"` : ""}
-        ${instrucciones ? `- Instrucciones adicionales: "${instrucciones}"` : ""}
-
-        Tu artículo debe seguir este arco narrativo impecable (entre 600 y 800 palabras):
-
-        1. EL TÍTULO ABSTRACTO: Crea un título de menos de 10 palabras que evoque un dolor de negocio o una revelación financiera, no una característica de software. Debe sonar a un artículo de *Harvard Business Review*.
-        2. LA FRICCIÓN (El Diagnóstico Crudo): Abre el artículo sin introducciones banales. Golpea directamente diagnosticando el dolor del negocio (ej. la pérdida de rentabilidad por cuellos de botella operativos o el riesgo inminente de sistemas legados que nadie sabe mantener). Haz que el lector sienta que estás describiendo su empresa.
-        3. LA ORQUESTACIÓN (El Núcleo): Desarrolla tu argumento explicando cómo una arquitectura inteligente (ya sea a través de microservicios, DevSecOps, automatización inteligente de negocio, o monitoreo sintético con herramientas como iwRobot) resuelve este problema de raíz. Transmite la idea de que la tecnología debe ser un habilitador transparente, no una carga.
-        4. EL IMPACTO LATENTE: Teje dentro de la prosa (sin usar viñetas obvias de IA) los tres impactos estratégicos del tema. Habla de cómo se logra la Resiliencia, la Fluidez operativa, la Eficiencia financiera o la Anticipación ante el riesgo.
-        5. EL CIERRE SUTIL (El CTA Elegante): En lugar de un llamado a la acción desesperado de ventas, cierra con una reflexión ejecutiva o una pregunta abierta que invite al lector a auditar mentalmente la madurez de su propia infraestructura. Una despedida que demuestre que, para orquestar la complejidad, se requiere la maestría de tres décadas.
-
-        Recuerda: Eres un experto hablando con otro experto. Sé denso en valor y conciso en palabras
-      `;
-      try {
-        const ai = await this.geminiConfig();
-        const result = await ai.models.generateContent({
-          model: "gemini-2.5-pro",
-          contents: promptArticulo,
-          config: {
-            responseMimeType: "application/json",
-            temperature: temperatura,
-            responseSchema: {
-              type: "object",
-              required: ["titulo", "descripcion", "content", "seo", "minute_read"],
-              properties: {
-                seo: {
-                  type: "object",
-                  required: ["metaTitle", "metaDescription", "metadata"],
-                  properties: {
-                    metaTitle: {
-                      type: "string"
-                    },
-                    metaDescription: {
-                      type: "string"
-                    },
-                    metadata: {
-                      type: "array",
-                      items: {
-                        type: "object",
-                        required: ["name", "content"],
-                        properties: {
-                          name: { type: "string" },
-                          content: { type: "string" }
-                        }
-                      }
-                    }
-                  }
-                },
-                titulo: {
-                  type: "string",
-                  minLength: 40,
-                  maxLength: 70,
-                  description: "Título del artículo"
-                },
-                descripcion: {
-                  type: "string",
-                  minLength: 80,
-                  maxLength: 160,
-                  description: "Descripción breve del artículo"
-                },
-                slug: {
-                  type: "string",
-                  minLength: 80,
-                  maxLength: 160,
-                  description: "URL-friendly basado en el título (ej: estrategias-migracion-nube)"
-                },
-                content: {
-                  type: "string",
-                  description: "Contenido HTML compatible con CKEditor"
-                },
-                minute_read: {
-                  type: "integer",
-                  minimum: 1,
-                  maximum: 30,
-                  description: "Tiempo de lectura calculado usando 200 palabras por minuto"
-                },
-                keywords: {
-                  type: "array",
-                  minItems: 3,
-                  maxItems: 5,
-                  items: {
-                    type: "object",
-                    required: ["name"],
-                    properties: {
-                      name: { type: "string" }
-                    }
-                  },
-                  description: "Hash tags y palabras clave para la publicación en LinkedIn y Facebook"
-                }
-              }
-            }
-          }
-        });
-        const rawText = result.candidates?.[0]?.content?.parts?.[0]?.text ?? "";
-        if (!rawText) {
-          throw new Error(
-            "La IA no generó texto. Revisa el prompt o el modelo."
-          );
-        }
-        const parsed = JSON.parse(rawText);
-        const article = await strapi.documents("api::articulo.articulo").create({
-          data: {
-            titulo: parsed.titulo,
-            descripcion: parsed.descripcion,
-            content: parsed.content,
-            seo: parsed.seo,
-            minute_read: parsed.minute_read,
-            slug: parsed.slug,
-            categoria,
-            autor,
-            image: null,
-            keywords: parsed.keywords
-          },
-          status: "draft"
-        });
-        return article;
-      } catch (err) {
-        console.error("🚀 ~ generateArticle ~ err:", err);
-        throw new Error(
-          "Error al generar el artículo. Revisa el prompt, el modelo o el JSON generado."
-        );
-      }
-    },
-    // ───────────────────────────────
-    // 🖼️ Generate Image for Article
-    // ───────────────────────────────
-    async generateImageForArticle(ctx) {
-      const { articleId, aspectRatio, imageSize } = ctx.request.body;
-      if (!articleId) {
-        throw new Error(
-          "Se requiere 'articleId' en el cuerpo de la petición."
-        );
-      }
-      try {
-        const article = await strapi.documents("api::articulo.articulo").findOne({
-          documentId: articleId
-        });
-        const promptJson = {
-          label: `blog-header-${articleId}`,
-          task: "generate_image",
-          canvas: {
-            resolution: imageSize || "1K",
-            aspect_ratio: aspectRatio || "16:9"
-          },
-          style: {
-            type: "architectural software engineering visualization",
-            aesthetic: "high-end technical 3D render / octane style",
-            background: "view of a bright white minimalist architectural gallery, sun-drenched space, white polished floors and tall glass windows",
-            lighting: "intense natural daylight, soft global illumination, clean diffused light with subtle volumetric rays from windows"
-          },
-          concept_brief: `Create a sophisticated 3D visualization that metaphorically represents the concept: "${article.titulo}" — ${article.descripcion}`,
-          subject: [
-            "a complex holographic or architectural 3D structure floating at the center of the gallery, inspired by the concept brief above",
-            "materials: frosted glass panels, white matte ceramic components, and polished metal accents",
-            "glowing energy connections and data filaments in red #E4002B and teal #00C7B1 connecting the structural elements",
-            "the structure casts a sharp, clean reflection on the white polished gallery floor",
-            "STRICTLY NO people, NO humans, NO hands, NO chairs",
-            "STRICTLY NO text, NO labels, NO words, NO letters, NO numbers",
-            "high-end 3D render, architectural photography style, 4k quality"
-          ],
-          camera: {
-            perspective: "three-quarter wide shot, slightly elevated, eye-level with the structure, showing both the subject and the gallery environment",
-            depth_of_field: "the main structure in sharp focus, gallery background beautifully blurred"
-          },
-          render: {
-            engine: "Octane or Cinema 4D",
-            effects: "bloom on glowing filaments and energy elements, ray-traced reflections on the white polished floor, subsurface scattering on frosted glass panels, volumetric light rays from gallery windows",
-            quality: "masterpiece, hyper-detailed"
-          },
-          output_format: "image/png"
-        };
-        const promptText = JSON.stringify(promptJson);
-        const generatedBase64Image = await strapi.plugin("strapi-content-generator-gemini").service("image-studio").generateForArticle(promptText, aspectRatio || "16:9", imageSize || "1K");
-        const buffer = Buffer.from(generatedBase64Image, "base64");
-        const uploadedFile = await this._uploadGeneratedFile(buffer, `article-${articleId}.png`, "image/png");
-        const articleModel = await strapi.getModel("api::articulo.articulo");
-        const sanitizedData = await strapi.contentAPI.sanitize.input(
-          {
-            image: uploadedFile.id
-          },
-          articleModel
-        );
-        await strapi.documents("api::articulo.articulo").update({
-          documentId: articleId,
-          data: sanitizedData
-        });
-        return {
-          message: "Imagen generada y asociada correctamente.",
-          image: uploadedFile
-        };
-      } catch (err) {
-        console.log("🚀 ~ service ~ err:", err);
-        throw new Error("Error al generar la imagen para el artículo.");
-      }
-    },
     // 🎞️ Internal Veo Video Generation / Extension Helper
     async _callVeoVideoGeneration(promptText, aspectRatio, durationSeconds, sceneRefs, previousVideo) {
       const { ai } = await this.geminiClient({ allowVertex: false });
@@ -4601,7 +4818,7 @@ const service = ({ strapi }) => {
     // 🌐 Social Media Publishing
     // ───────────────────────────────
     async publishToLinkedIn(ctx) {
-      const { articleId } = ctx.request.body;
+      const { articleId, mensaje } = ctx.request.body;
       const pluginStore = strapi.store({
         type: "plugin",
         name: "strapi-content-generator-gemini"
@@ -4616,7 +4833,6 @@ const service = ({ strapi }) => {
         populate: ["image", "keywords"]
       });
       if (!article) throw new Error(`Artículo con ID ${articleId} no encontrado.`);
-      const hashtags = article.keywords.map((k) => `#${k.name.trim().replace(/\s+/g, "").replace(/[^\w]/g, "")}`).join(" ");
       const articleUrl = `https://interware.com.mx/blog/${article.slug}`;
       const imageUrl = article.image?.url;
       if (!imageUrl) throw new Error("El artículo no tiene imagen.");
@@ -4651,9 +4867,7 @@ const service = ({ strapi }) => {
         });
         const postBody = {
           author: `urn:li:organization:${linkedInOrganizationId}`,
-          commentary: `${article.descripcion}
-
-${hashtags}`,
+          commentary: typeof mensaje === "string" && mensaje.trim() || defaultPostText(postData(article), "linkedin"),
           visibility: "PUBLIC",
           distribution: {
             feedDistribution: "MAIN_FEED",
@@ -4691,7 +4905,7 @@ ${hashtags}`,
       }
     },
     async publishToFacebook(ctx) {
-      const { articleId } = ctx.request.body;
+      const { articleId, mensaje } = ctx.request.body;
       const pluginStore = strapi.store({
         type: "plugin",
         name: "strapi-content-generator-gemini"
@@ -4720,16 +4934,8 @@ ${hashtags}`,
           throw new Error(`Artículo con ID ${articleId} no encontrado.`);
         }
         const articleUrl = `https://interware.com.mx/blog/${article.slug}`;
-        const hashtags = article.keywords.map(
-          (keyword) => `#${keyword.name.trim().replace(/\s+/g, "").replace(/[^\w]/g, "")}`
-          // quita caracteres raros
-        ).join(" ");
         const postBody = {
-          message: `${article.titulo}
-
-${article.descripcion}
-
-${hashtags}`,
+          message: typeof mensaje === "string" && mensaje.trim() || defaultPostText(postData(article), "facebook"),
           link: articleUrl,
           access_token: facebookAccessToken
         };
@@ -4766,7 +4972,8 @@ ${hashtags}`,
 const services = {
   service,
   "image-studio": imageStudio$1,
-  templates: templates$1
+  templates: templates$1,
+  articles: articles$1
 };
 const index = {
   register,