@interware/content-generator 0.7.2 → 0.8.0

package/dist/server/index.js

@@ -1,6 +1,11 @@
 "use strict";
 const fs = require("fs");
 const genai = require("@google/genai");
+const node_crypto = require("node:crypto");
+const promises = require("node:fs/promises");
+const node_os = require("node:os");
+const node_path = require("node:path");
+const node_async_hooks = require("node:async_hooks");
 function _interopNamespace(e) {
   if (e && e.__esModule) return e;
   const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
@@ -20,10 +25,10 @@ function _interopNamespace(e) {
 }
 const fs__namespace = /* @__PURE__ */ _interopNamespace(fs);
 const PLUGIN_ID = "strapi-content-generator-gemini";
-const FOLDER_UID = "plugin::upload.folder";
+const FOLDER_UID$1 = "plugin::upload.folder";
 const hasValidPath = (path) => /^(\/\d+)+$/.test(path);
 const repairFolderPaths = async (strapi, name2) => {
-  const query = strapi.db.query(FOLDER_UID);
+  const query = strapi.db.query(FOLDER_UID$1);
   const folders = await query.findMany({ where: { name: name2 }, populate: ["parent"] });
   const repaired = [];
   for (const f of folders) {
@@ -35,13 +40,34 @@ const repairFolderPaths = async (strapi, name2) => {
   return repaired;
 };
 const ensureFolder = async (strapi, name2) => {
-  const folders = await strapi.db.query(FOLDER_UID).findMany({ where: { name: name2 }, populate: ["parent"] });
+  const folders = await strapi.db.query(FOLDER_UID$1).findMany({ where: { name: name2 }, populate: ["parent"] });
   const atRoot = folders.find((f) => !f.parent);
   if (atRoot) return atRoot.id;
   const created = await strapi.plugin("upload").service("folder").create({ name: name2, parent: null });
   return created.id;
 };
+const MODELS = { "plugin::upload.file": "file", "plugin::upload.folder": "folder" };
+const subscribeUploadLifecycles = (strapi, onChange) => {
+  const notify = (event, id) => {
+    const cmsType = MODELS[event.model.uid];
+    if (!cmsType || typeof id !== "number") return;
+    onChange(cmsType, id).catch((err) => strapi.log.warn(`[drive] no se pudo encolar ${cmsType} ${id}: ${err.message}`));
+  };
+  strapi.db.lifecycles.subscribe({
+    models: Object.keys(MODELS),
+    afterCreate: (event) => notify(event, event.result?.id),
+    afterUpdate: (event) => notify(event, event.result?.id),
+    afterDelete: (event) => notify(event, event.result?.id),
+    // `deleteMany` solo trae el `where`: los ids se leen antes de borrar.
+    async beforeDeleteMany(event) {
+      const rows = await strapi.db.query(event.model.uid).findMany({ where: event.params?.where, select: ["id"] });
+      if (event.state) event.state.driveIds = rows.map((r) => r.id);
+    },
+    afterDeleteMany: (event) => (event.state?.driveIds ?? []).forEach((id) => notify(event, id))
+  });
+};
 const SCHEDULE_CRON = "content-generator-publicar-programados";
+const DRIVE_CRON = "content-generator-drive";
 const bootstrap = async ({ strapi }) => {
   strapi.cron.add({
     [SCHEDULE_CRON]: {
@@ -55,6 +81,19 @@ const bootstrap = async ({ strapi }) => {
       options: { rule: "* * * * *" }
     }
   });
+  strapi.cron.add({
+    [DRIVE_CRON]: {
+      task: async () => {
+        try {
+          await strapi.plugin(PLUGIN_ID).service("drive").runCycle();
+        } catch (err) {
+          strapi.log.error(`[content-generator] sincronizar con Drive: ${err.message}`);
+        }
+      },
+      options: { rule: "*/15 * * * *" }
+    }
+  });
+  subscribeUploadLifecycles(strapi, (cmsType, cmsId) => strapi.plugin(PLUGIN_ID).service("drive").track(cmsType, cmsId));
   strapi.admin.services.permission.actionProvider.registerMany([
     {
       section: "plugins",
@@ -80,7 +119,7 @@ const config$2 = {
   validator() {
   }
 };
-const schema = {
+const schema$2 = {
   kind: "collectionType",
   collectionName: "iw_image_templates",
   info: {
@@ -109,9 +148,67 @@ const schema = {
     replacesBase: { type: "string" }
   }
 };
-const template = { schema };
+const template = { schema: schema$2 };
+const schema$1 = {
+  kind: "collectionType",
+  collectionName: "iw_drive_links",
+  info: {
+    singularName: "drive-link",
+    pluralName: "drive-links",
+    displayName: "Vínculo con Drive",
+    description: "Sincronización con Google Drive (content-generator)"
+  },
+  options: { draftAndPublish: false },
+  pluginOptions: {
+    "content-manager": { visible: false },
+    "content-type-builder": { visible: false }
+  },
+  attributes: {
+    cmsType: { type: "enumeration", enum: ["file", "folder"], required: true },
+    cmsId: { type: "integer", required: true },
+    /** Vacío mientras el archivo espera su primera subida. */
+    driveId: { type: "string" },
+    /** Lo marcó el usuario; los demás vínculos son contenido o ancestros de algo marcado. */
+    root: { type: "boolean", default: false },
+    name: { type: "string" },
+    parentCmsId: { type: "integer" },
+    /** Archivo: `url|size` de la última subida. */
+    version: { type: "string" },
+    /** `md5Checksum` de Drive de la última versión sincronizada (S7.4). */
+    driveRev: { type: "string" },
+    status: { type: "enumeration", enum: ["synced", "pending", "error", "skipped"], default: "pending" },
+    error: { type: "text" }
+  }
+};
+const driveLink = { schema: schema$1 };
+const schema = {
+  kind: "collectionType",
+  collectionName: "iw_drive_ops",
+  info: {
+    singularName: "drive-op",
+    pluralName: "drive-ops",
+    displayName: "Operación de Drive",
+    description: "Cola de la sincronización con Google Drive (content-generator)"
+  },
+  options: { draftAndPublish: false },
+  pluginOptions: {
+    "content-manager": { visible: false },
+    "content-type-builder": { visible: false }
+  },
+  attributes: {
+    cmsType: { type: "enumeration", enum: ["file", "folder"], required: true },
+    cmsId: { type: "integer", required: true },
+    attempts: { type: "integer", default: 0 },
+    /** Epoch en ms: no se procesa antes (espera creciente tras un error). */
+    runAfter: { type: "biginteger", default: "0" },
+    error: { type: "text" }
+  }
+};
+const driveOp = { schema };
 const contentTypes = {
-  template
+  template,
+  "drive-link": driveLink,
+  "drive-op": driveOp
 };
 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(" ");
@@ -486,7 +583,7 @@ const parseEditInput = (fields, files) => {
     aspectRatio: model.aspectRatios.includes(str(fields.aspectRatio)) ? str(fields.aspectRatio) : void 0
   };
 };
-const fail$3 = (ctx, status, name2, message) => {
+const fail$4 = (ctx, status, name2, message) => {
   ctx.status = status;
   ctx.body = { data: null, error: { status, name: name2, message } };
 };
@@ -496,13 +593,13 @@ const imageStudio = ({ strapi }) => {
     try {
       ctx.body = await work();
     } catch (err) {
-      if (err instanceof InputError) return fail$3(ctx, 400, "BadRequestError", err.message);
+      if (err instanceof InputError) return fail$4(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);
+        return fail$4(ctx, 422, "UnprocessableEntityError", err.message);
       }
       strapi.log.error(`[image-studio] ${err instanceof Error ? err.message : String(err)}`);
-      return fail$3(ctx, 502, "BadGatewayError", "El servicio de imágenes no respondió. Intenta de nuevo en un momento.");
+      return fail$4(ctx, 502, "BadGatewayError", "El servicio de imágenes no respondió. Intenta de nuevo en un momento.");
     }
   };
   return {
@@ -711,11 +808,11 @@ const ARTICLE_SCHEMA = {
 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 parseScheduleAt = (input, now2) => {
   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.");
+  if (date.getTime() <= now2.getTime()) throw new InputError("Elige una fecha y hora futuras.");
+  if (date.getTime() - now2.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";
@@ -761,7 +858,7 @@ const toDetail = (d, publicado) => ({
   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 createArticles = ({ articulos, categorias, getModels, now: now2 = () => /* @__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.");
@@ -865,12 +962,12 @@ const createArticles = ({ articulos, categorias, getModels, now = () => /* @__PU
     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.update({ documentId, data: { fecha_publicacion: fechaEnMexico(now2()), publicacion_programada: null } });
       await articulos.publish({ documentId });
       return detail(documentId);
     },
     async schedule(documentId, at) {
-      const date = parseScheduleAt(at, now());
+      const date = parseScheduleAt(at, now2());
       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.");
@@ -886,7 +983,7 @@ const createArticles = ({ articulos, categorias, getModels, now = () => /* @__PU
     async publishDue() {
       const due = await articulos.findMany({
         status: "draft",
-        filters: { publicacion_programada: { $notNull: true, $lte: now().toISOString() } },
+        filters: { publicacion_programada: { $notNull: true, $lte: now2().toISOString() } },
         fields: ["publicacion_programada"],
         populate: { image: { fields: ["id"] } }
       });
@@ -928,7 +1025,7 @@ const articles$1 = ({ strapi }) => createArticles({
     };
   })()
 });
-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 } };
 };
@@ -939,11 +1036,11 @@ const articles = ({ strapi }) => {
     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);
+      if (err instanceof InputError) return fail$3(ctx, 400, "BadRequestError", err.message);
+      if (err instanceof NotFoundError) return fail$3(ctx, 404, "NotFoundError", err.message);
+      if (err instanceof Error && err.name === "ValidationError") return fail$3(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 fail$3(ctx, 502, "BadGatewayError", "El servicio de generación no respondió. Intenta de nuevo en un momento.");
     }
   };
   return {
@@ -1109,7 +1206,7 @@ class TemplateInputError extends Error {
 }
 const LAYER_TYPES = ["text", "list", "quote", "rect", "shape", "badge", "logo", "image", "icon", "avatar", "qr"];
 const MAX_LAYERS = 200;
-const fail$1 = (message) => {
+const fail$2 = (message) => {
   throw new TemplateInputError(message);
 };
 const hasDataUrl = (value) => {
@@ -1120,26 +1217,26 @@ const hasDataUrl = (value) => {
 };
 const name = (v) => {
   const n = typeof v === "string" ? v.trim() : "";
-  if (!n || n.length > 120) fail$1("El nombre debe tener entre 1 y 120 caracteres.");
+  if (!n || n.length > 120) fail$2("El nombre debe tener entre 1 y 120 caracteres.");
   return n;
 };
 const size = (v) => {
-  if (!Number.isInteger(v) || v < 100 || v > 4e3) fail$1("Las medidas deben ser enteros de 100 a 4000 px.");
+  if (!Number.isInteger(v) || v < 100 || v > 4e3) fail$2("Las medidas deben ser enteros de 100 a 4000 px.");
   return v;
 };
 const nonNegative = (v, label) => {
-  if (typeof v !== "number" || !Number.isFinite(v) || v < 0) fail$1(`${label} debe ser un número positivo.`);
+  if (typeof v !== "number" || !Number.isFinite(v) || v < 0) fail$2(`${label} debe ser un número positivo.`);
   return v;
 };
 const layers = (v) => {
-  if (!Array.isArray(v) || v.length > MAX_LAYERS) fail$1(`Las capas deben ser una lista de hasta ${MAX_LAYERS}.`);
+  if (!Array.isArray(v) || v.length > MAX_LAYERS) fail$2(`Las capas deben ser una lista de hasta ${MAX_LAYERS}.`);
   v.forEach((l, i) => {
     const layer = l ?? {};
-    if (typeof layer.id !== "string" || !layer.id) fail$1(`La capa ${i + 1} no tiene id.`);
-    if (!LAYER_TYPES.includes(layer.type)) fail$1(`La capa ${i + 1} tiene un tipo desconocido.`);
-    if (typeof layer.x !== "number" || typeof layer.y !== "number") fail$1(`La capa ${i + 1} no tiene posición.`);
+    if (typeof layer.id !== "string" || !layer.id) fail$2(`La capa ${i + 1} no tiene id.`);
+    if (!LAYER_TYPES.includes(layer.type)) fail$2(`La capa ${i + 1} tiene un tipo desconocido.`);
+    if (typeof layer.x !== "number" || typeof layer.y !== "number") fail$2(`La capa ${i + 1} no tiene posición.`);
   });
-  if (hasDataUrl(v)) fail$1("Las imágenes deben guardarse en la Media Library, no dentro del template.");
+  if (hasDataUrl(v)) fail$2("Las imágenes deben guardarse en la Media Library, no dentro del template.");
   return v;
 };
 const text = (v, fallback) => typeof v === "string" ? v : fallback;
@@ -1169,7 +1266,7 @@ const validateTemplatePatch = (input) => {
   if ("safeMargin" in t) out.safeMargin = nonNegative(t.safeMargin, "El margen seguro");
   if ("gridUnit" in t) out.gridUnit = nonNegative(t.gridUnit, "La cuadrícula");
   if ("layers" in t) out.layers = layers(t.layers);
-  if (!Object.keys(out).length) fail$1("Nada que actualizar.");
+  if (!Object.keys(out).length) fail$2("Nada que actualizar.");
   return out;
 };
 const TEMPLATE_UID = "plugin::strapi-content-generator-gemini.template";
@@ -1285,7 +1382,7 @@ const templates$1 = ({ strapi }) => {
     { get: (p) => store().get(p), set: (p) => store().set(p) }
   );
 };
-const fail = (ctx, status, name2, message) => {
+const fail$1 = (ctx, status, name2, message) => {
   ctx.status = status;
   ctx.body = { data: null, error: { status, name: name2, message } };
 };
@@ -1296,10 +1393,10 @@ const templates = ({ strapi }) => {
       ctx.body = await work();
       ctx.status = status;
     } catch (err) {
-      if (err instanceof TemplateInputError) return fail(ctx, 400, "BadRequestError", err.message);
-      if (err instanceof TemplateNotFoundError) return fail(ctx, 404, "NotFoundError", err.message);
+      if (err instanceof TemplateInputError) return fail$1(ctx, 400, "BadRequestError", err.message);
+      if (err instanceof TemplateNotFoundError) return fail$1(ctx, 404, "NotFoundError", err.message);
       strapi.log.error(`[templates] ${err instanceof Error ? err.message : String(err)}`);
-      return fail(ctx, 500, "InternalServerError", "No se pudo completar la operación con los templates.");
+      return fail$1(ctx, 500, "InternalServerError", "No se pudo completar la operación con los templates.");
     }
   };
   const body = (ctx) => ctx.request.body ?? {};
@@ -1323,11 +1420,1261 @@ const templates = ({ strapi }) => {
     deleteFolder: (ctx) => run(ctx, async () => ({ folders: await svc().deleteFolder(body(ctx).path) }))
   };
 };
+const DRIVE_SCOPE = "https://www.googleapis.com/auth/drive";
+const OAUTH_STATE_KEY = "DRIVE_OAUTH_STATE";
+const AUTH_URL = "https://accounts.google.com/o/oauth2/v2/auth";
+const TOKEN_URL = "https://oauth2.googleapis.com/token";
+const REVOKE_URL = "https://oauth2.googleapis.com/revoke";
+const STATE_TTL_MS = 10 * 6e4;
+class DriveAuthError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "DriveAuthError";
+  }
+}
+const authUrl = (client, redirectUri, state) => {
+  const params = new URLSearchParams({
+    client_id: client.clientId,
+    redirect_uri: redirectUri,
+    response_type: "code",
+    scope: DRIVE_SCOPE,
+    // Sin `offline` no hay refresh token; sin `consent`, Google no lo repite si la cuenta ya autorizó antes.
+    access_type: "offline",
+    prompt: "consent",
+    include_granted_scopes: "true",
+    state
+  });
+  return `${AUTH_URL}?${params}`;
+};
+const newState = async (store, now2 = Date.now()) => {
+  const value = node_crypto.randomBytes(24).toString("hex");
+  await store.set({ key: OAUTH_STATE_KEY, value: { value, expiresAt: now2 + STATE_TTL_MS } });
+  return value;
+};
+const checkState = async (store, state, now2 = Date.now()) => {
+  const saved = await store.get({ key: OAUTH_STATE_KEY });
+  await store.delete({ key: OAUTH_STATE_KEY });
+  return typeof state === "string" && !!saved?.value && saved.value === state && (saved.expiresAt ?? 0) >= now2;
+};
+const postToken = async (fetchFn, body) => {
+  const res = await fetchFn(TOKEN_URL, {
+    method: "POST",
+    headers: { "content-type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams(body).toString()
+  });
+  const data = await res.json().catch(() => ({}));
+  if (!res.ok || !data.access_token) throw new DriveAuthError(`Google rechazó la conexión (${data.error ?? `HTTP ${res.status}`}).`);
+  return data;
+};
+const exchangeCode = async ({
+  client,
+  code,
+  redirectUri,
+  fetch: fetchFn
+}) => {
+  const data = await postToken(fetchFn, {
+    code,
+    client_id: client.clientId,
+    client_secret: client.clientSecret,
+    redirect_uri: redirectUri,
+    grant_type: "authorization_code"
+  });
+  if (!data.refresh_token) throw new DriveAuthError("Google no entregó un token de actualización. Intenta conectar de nuevo.");
+  return { accessToken: data.access_token, expiresIn: data.expires_in ?? 3600, refreshToken: data.refresh_token };
+};
+const refreshAccessToken = async ({
+  client,
+  refreshToken,
+  fetch: fetchFn
+}) => {
+  const data = await postToken(fetchFn, {
+    client_id: client.clientId,
+    client_secret: client.clientSecret,
+    refresh_token: refreshToken,
+    grant_type: "refresh_token"
+  });
+  return { accessToken: data.access_token, expiresIn: data.expires_in ?? 3600 };
+};
+const revokeToken = async (token, fetchFn) => {
+  await fetchFn(REVOKE_URL, {
+    method: "POST",
+    headers: { "content-type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams({ token })
+  });
+};
+const API = "https://www.googleapis.com/drive/v3";
+const MAX_RETRIES = 4;
+const EXPIRY_MARGIN_MS = 6e4;
+const RATE_REASONS = /* @__PURE__ */ new Set(["rateLimitExceeded", "userRateLimitExceeded"]);
+class DriveNotConnectedError extends Error {
+  constructor() {
+    super("Google Drive no está conectado.");
+    this.name = "DriveNotConnectedError";
+  }
+}
+class DriveApiError extends Error {
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+    this.name = "DriveApiError";
+  }
+}
+const isRetryable = (status, body) => status === 429 || status >= 500 || status === 403 && !!body.error?.errors?.some((e) => RATE_REASONS.has(e.reason ?? ""));
+const createDriveClient = ({
+  getCredentials,
+  fetch: fetchFn,
+  sleep = (ms) => new Promise((r) => setTimeout(r, ms)),
+  now: now2 = Date.now
+}) => {
+  let cached = null;
+  const accessToken = async (force = false) => {
+    if (!force && cached && cached.expiresAt - EXPIRY_MARGIN_MS > now2()) return cached.token;
+    const credentials = await getCredentials();
+    if (!credentials) throw new DriveNotConnectedError();
+    const { accessToken: token, expiresIn } = await refreshAccessToken({ ...credentials, fetch: fetchFn });
+    cached = { token, expiresAt: now2() + expiresIn * 1e3 };
+    return token;
+  };
+  const send = async (path, init = {}) => {
+    const url = path.startsWith("https://") ? path : `${API}${path}`;
+    let renewed = false;
+    for (let attempt = 0; ; attempt++) {
+      const headers = new Headers(init.headers);
+      headers.set("authorization", `Bearer ${await accessToken()}`);
+      const res = await fetchFn(url, { ...init, headers });
+      if (res.ok) return res;
+      const body = await res.json().catch(() => ({}));
+      if (res.status === 401 && !renewed) {
+        renewed = true;
+        await accessToken(true);
+        continue;
+      }
+      if (attempt < MAX_RETRIES && isRetryable(res.status, body)) {
+        await sleep(1e3 * 2 ** attempt);
+        continue;
+      }
+      throw new DriveApiError(res.status, `Drive respondió ${res.status}: ${body.error?.message ?? res.statusText}`);
+    }
+  };
+  const request = async (path, init = {}) => {
+    const res = await send(path, init);
+    return res.status === 204 ? null : await res.json();
+  };
+  const download2 = async (path) => new Uint8Array(await (await send(path)).arrayBuffer());
+  const about = async () => {
+    const params = new URLSearchParams({ fields: "user(emailAddress),storageQuota(limit,usage)" });
+    const data = await request(`/about?${params}`);
+    return {
+      email: data.user?.emailAddress ?? "",
+      usage: Number(data.storageQuota?.usage ?? 0),
+      limit: data.storageQuota?.limit ? Number(data.storageQuota.limit) : null
+    };
+  };
+  return { request, download: download2, about, reset: () => void (cached = null) };
+};
+const DRIVE_CLIENT_KEY = "DRIVE_CLIENT";
+const asObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
+const readJson = (value) => {
+  if (typeof value !== "string") return null;
+  try {
+    return asObject(JSON.parse(value));
+  } catch {
+    return null;
+  }
+};
+const isText = (v) => typeof v === "string" && v.trim() !== "";
+const readClient = (data) => {
+  const web = asObject(data.web);
+  if (!web) return { ok: false, message: "El cliente debe ser de tipo Aplicación web." };
+  const uris = Array.isArray(web.redirect_uris) ? web.redirect_uris.filter(isText) : [];
+  const missing = [
+    !isText(web.client_id) && "client_id",
+    !isText(web.client_secret) && "client_secret",
+    uris.length === 0 && "redirect_uris"
+  ].filter(Boolean);
+  if (missing.length) return { ok: false, message: `Al JSON del cliente le falta ${missing.join(", ")}.` };
+  return {
+    ok: true,
+    client: { clientId: web.client_id, clientSecret: web.client_secret, redirectUris: uris }
+  };
+};
+const parseClientConfig = (value, redirectUri) => {
+  const data = readJson(value);
+  if (!data) return { ok: false, message: "El archivo no es un JSON válido." };
+  const result = readClient(data);
+  if ("client" in result && !result.client.redirectUris.includes(redirectUri)) {
+    return { ok: false, message: `Este cliente no tiene autorizada la URL ${redirectUri}. Agrégala en Google Cloud.` };
+  }
+  return result;
+};
+const storedClient = (client) => JSON.stringify({ web: { client_id: client.clientId, client_secret: client.clientSecret, redirect_uris: client.redirectUris } });
+const loadClient = (stored) => {
+  const data = readJson(stored);
+  if (!data) return null;
+  const result = readClient(data);
+  return "client" in result ? result.client : null;
+};
+const publicClient = (stored) => {
+  const client = loadClient(stored);
+  if (!client) return { configured: false, clientId: null, last4: null };
+  return { configured: true, clientId: client.clientId, last4: maskSecret(client.clientSecret).last4 };
+};
+const DRIVE_ROOT = "root";
+const FOLDER_MIME = "application/vnd.google-apps.folder";
+const UPLOAD = "https://www.googleapis.com/upload/drive/v3/files";
+const quote = (value) => `'${value.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`;
+const findChild = async (http, parentId, name2) => {
+  const params = new URLSearchParams({
+    q: `${quote(parentId)} in parents and name = ${quote(name2)} and trashed = false`,
+    fields: "files(id,name,mimeType)",
+    pageSize: "10",
+    spaces: "drive"
+  });
+  const { files } = await http.request(`/files?${params}`);
+  return files?.[0] ?? null;
+};
+const createFolder = async (http, parentId, name2) => {
+  const { id } = await http.request("/files?fields=id", {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ name: name2, mimeType: FOLDER_MIME, parents: [parentId] })
+  });
+  return id;
+};
+const multipart = (metadata, mime, content) => {
+  const boundary = `iw-${node_crypto.randomBytes(12).toString("hex")}`;
+  const head = `--${boundary}\r
+Content-Type: application/json; charset=UTF-8\r
+\r
+${JSON.stringify(metadata)}\r
+--${boundary}\r
+Content-Type: ${mime}\r
+\r
+`;
+  const body = Buffer.concat([Buffer.from(head, "utf8"), Buffer.from(content), Buffer.from(`\r
+--${boundary}--`, "utf8")]);
+  return { body, contentType: `multipart/related; boundary=${boundary}` };
+};
+const uploadFile = async (http, parentId, file) => {
+  const metadata = { name: file.name, parents: [parentId], ...file.description ? { description: file.description } : {} };
+  const { body, contentType } = multipart(metadata, file.mime, file.content);
+  const { id, md5Checksum } = await http.request(`${UPLOAD}?uploadType=multipart&fields=id,md5Checksum`, {
+    method: "POST",
+    headers: { "content-type": contentType },
+    body
+  });
+  return { id, md5: md5Checksum ?? null };
+};
+const updateContent = async (http, driveId, file) => {
+  const metadata = { name: file.name, ...file.description ? { description: file.description } : {} };
+  const { body, contentType } = multipart(metadata, file.mime, file.content);
+  const { md5Checksum } = await http.request(
+    `${UPLOAD}/${encodeURIComponent(driveId)}?uploadType=multipart&fields=id,md5Checksum`,
+    { method: "PATCH", headers: { "content-type": contentType }, body }
+  );
+  return { id: driveId, md5: md5Checksum ?? null };
+};
+const updateMeta = async (http, driveId, { name: name2, from, to }) => {
+  const params = new URLSearchParams({ fields: "id" });
+  if (to && from && to !== from) {
+    params.set("addParents", to);
+    params.set("removeParents", from);
+  }
+  await http.request(`/files/${encodeURIComponent(driveId)}?${params}`, {
+    method: "PATCH",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify(name2 ? { name: name2 } : {})
+  });
+};
+const trash = async (http, driveId) => {
+  try {
+    await http.request(`/files/${encodeURIComponent(driveId)}?fields=id`, {
+      method: "PATCH",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ trashed: true })
+    });
+  } catch (err) {
+    if (err instanceof DriveApiError && err.status === 404) return;
+    throw err;
+  }
+};
+const download = async (http, driveId) => {
+  if (!http.download) throw new Error("El cliente de Drive no puede descargar.");
+  return http.download(`/files/${encodeURIComponent(driveId)}?alt=media`);
+};
+const ENTRY_FIELDS = "id,name,mimeType,size,modifiedTime,webViewLink,parents";
+const toEntry = (f) => ({
+  id: f.id,
+  name: f.name,
+  mimeType: f.mimeType,
+  size: f.size ? Number(f.size) : null,
+  modifiedTime: f.modifiedTime ?? null,
+  webViewLink: f.webViewLink ?? null,
+  parents: f.parents ?? []
+});
+const listChildren = async (http, parentId, pageToken) => {
+  const params = new URLSearchParams({
+    q: `${quote(parentId)} in parents and trashed = false`,
+    fields: `nextPageToken,files(${ENTRY_FIELDS})`,
+    orderBy: "folder,name_natural",
+    pageSize: "200",
+    spaces: "drive"
+  });
+  if (pageToken) params.set("pageToken", pageToken);
+  const data = await http.request(`/files?${params}`);
+  return { items: (data.files ?? []).map(toEntry), nextPageToken: data.nextPageToken ?? null };
+};
+const getFile = async (http, id) => toEntry(await http.request(`/files/${encodeURIComponent(id)}?fields=${ENTRY_FIELDS}`));
+const countTree = async (http, folderId, limit = 1e3) => {
+  let files = 0;
+  let folders = 0;
+  const queue = [folderId];
+  while (queue.length && files + folders < limit) {
+    const parent = queue.shift();
+    let token;
+    do {
+      const page = await listChildren(http, parent, token);
+      for (const item of page.items) {
+        if (item.mimeType === FOLDER_MIME) {
+          folders++;
+          queue.push(item.id);
+        } else files++;
+      }
+      token = page.nextPageToken ?? void 0;
+    } while (token && files + folders < limit);
+  }
+  return { files, folders, truncated: files + folders >= limit };
+};
+const getMeta = async (http, id) => {
+  try {
+    return await http.request(
+      `/files/${encodeURIComponent(id)}?fields=id,name,mimeType,parents,trashed,md5Checksum,size`
+    );
+  } catch (err) {
+    if (err instanceof DriveApiError && err.status === 404) return null;
+    throw err;
+  }
+};
+const rootId = async (http) => (await http.request("/files/root?fields=id")).id;
+const startPageToken = async (http) => (await http.request("/changes/startPageToken")).startPageToken;
+const CHANGE_FIELDS = "nextPageToken,newStartPageToken,changes(fileId,removed,file(id,name,mimeType,parents,trashed,md5Checksum,size))";
+const listChanges = async (http, pageToken) => {
+  const params = new URLSearchParams({ pageToken, fields: CHANGE_FIELDS, includeRemoved: "true", spaces: "drive", pageSize: "1000" });
+  return http.request(`/changes?${params}`);
+};
+const driveOps = (http) => ({
+  findChild: (parentId, name2) => findChild(http, parentId, name2),
+  createFolder: (parentId, name2) => createFolder(http, parentId, name2),
+  uploadFile: (parentId, file) => uploadFile(http, parentId, file),
+  updateContent: (driveId, file) => updateContent(http, driveId, file),
+  updateMeta: (driveId, change) => updateMeta(http, driveId, change),
+  trash: (driveId) => trash(http, driveId),
+  download: (driveId) => download(http, driveId),
+  startPageToken: () => startPageToken(http),
+  rootId: () => rootId(http),
+  listChildren: (parentId, pageToken) => listChildren(http, parentId, pageToken),
+  getFile: (id) => getFile(http, id),
+  getMeta: (id) => getMeta(http, id),
+  countTree: (folderId) => countTree(http, folderId),
+  listChanges: (pageToken) => listChanges(http, pageToken)
+});
+class DriveSyncError extends Error {
+  constructor(message, status = 400) {
+    super(message);
+    this.status = status;
+    this.name = "DriveSyncError";
+  }
+}
+const collisionMessage = (name2) => `Ya existe «${name2}» en Drive y no se sincronizó desde el CMS. Cambia el nombre para sincronizarla.`;
+const pathIds = (path) => path.split("/").filter(Boolean).map(Number).filter((n) => Number.isInteger(n));
+const OUTSIDE = "Solo se sincroniza lo que está dentro de «Generated».";
+const ROOT_ITSELF = "Marca una carpeta o archivo dentro de «Generated», no la raíz.";
+const load = async (cms, cmsType, cmsId) => {
+  if (cmsType === "folder") {
+    const folder = await cms.folder(cmsId);
+    if (folder) return { type: "folder", folder };
+  } else {
+    const file = await cms.file(cmsId);
+    if (file) return { type: "file", file };
+  }
+  throw new DriveSyncError("El elemento ya no existe en la Biblioteca.");
+};
+const ancestorsOf = async (cms, root, path) => {
+  const ids = pathIds(path);
+  if (ids[0] !== root.pathId) return null;
+  const below = ids.slice(1);
+  if (!below.length) return [];
+  const folders = await cms.foldersByPathIds(below);
+  const byPathId = new Map(folders.map((f) => [f.pathId, f]));
+  return below.map((p) => byPathId.get(p)).filter((f) => !!f);
+};
+const containerPath = (item) => item.type === "folder" ? item.folder.path.slice(0, item.folder.path.lastIndexOf("/")) || "/" : item.file.folderPath;
+const ensureFolderLink = async (deps, folder, parentDriveId, root) => {
+  const existing = await deps.links.find("folder", folder.id);
+  if (existing?.driveId) return root && !existing.root ? deps.links.update(existing.id, { root: true }) : existing;
+  if (await deps.drive.findChild(parentDriveId, folder.name)) throw new DriveSyncError(collisionMessage(folder.name), 409);
+  const driveId = await deps.drive.createFolder(parentDriveId, folder.name);
+  const data = { driveId, name: folder.name, parentCmsId: folder.parentId, status: "synced", error: null };
+  return existing ? deps.links.update(existing.id, { ...data, root: root || existing.root }) : deps.links.create({ cmsType: "folder", cmsId: folder.id, root, version: null, driveRev: null, ...data });
+};
+const mark = async (deps, cmsType, cmsId) => {
+  const root = await deps.cms.generatedRoot();
+  if (!root) throw new DriveSyncError(OUTSIDE);
+  if (cmsType === "folder" && cmsId === root.id) throw new DriveSyncError(ROOT_ITSELF);
+  const item = await load(deps.cms, cmsType, cmsId);
+  const ancestors = await ancestorsOf(deps.cms, root, containerPath(item));
+  if (!ancestors || item.type === "file" && item.file.folderId === null) throw new DriveSyncError(OUTSIDE);
+  let parentDriveId = DRIVE_ROOT;
+  for (const folder of ancestors) parentDriveId = (await ensureFolderLink(deps, folder, parentDriveId, false)).driveId;
+  if (item.type === "folder") {
+    await ensureFolderLink(deps, item.folder, parentDriveId, true);
+  } else {
+    const existing = await deps.links.find("file", item.file.id);
+    if (existing) {
+      if (!existing.root) await deps.links.update(existing.id, { root: true });
+    } else {
+      if (await deps.drive.findChild(parentDriveId, item.file.name)) throw new DriveSyncError(collisionMessage(item.file.name), 409);
+      await deps.links.create({
+        cmsType: "file",
+        cmsId: item.file.id,
+        driveId: null,
+        root: true,
+        name: null,
+        parentCmsId: null,
+        version: null,
+        driveRev: null,
+        status: "pending",
+        error: null
+      });
+    }
+  }
+  await deps.ops.push(cmsType, cmsId);
+};
+const neededLinkIds = async (deps) => {
+  const all3 = await deps.links.all();
+  const rootPaths = [];
+  const ancestorPathIds = /* @__PURE__ */ new Set();
+  const keep = /* @__PURE__ */ new Set();
+  for (const link of all3.filter((l) => l.root)) {
+    keep.add(link.id);
+    if (link.cmsType === "folder") {
+      const folder = await deps.cms.folder(link.cmsId);
+      if (!folder) continue;
+      rootPaths.push(folder.path);
+      pathIds(folder.path).slice(0, -1).forEach((p) => ancestorPathIds.add(p));
+    } else {
+      const file = await deps.cms.file(link.cmsId);
+      if (file) pathIds(file.folderPath).forEach((p) => ancestorPathIds.add(p));
+    }
+  }
+  const under = (path) => rootPaths.some((r) => path === r || path.startsWith(`${r}/`));
+  for (const link of all3) {
+    if (keep.has(link.id)) continue;
+    if (link.cmsType === "folder") {
+      const folder = await deps.cms.folder(link.cmsId);
+      if (folder && (under(folder.path) || ancestorPathIds.has(folder.pathId))) keep.add(link.id);
+    } else {
+      const file = await deps.cms.file(link.cmsId);
+      if (file && under(file.folderPath)) keep.add(link.id);
+    }
+  }
+  return keep;
+};
+const unmark = async (deps, cmsType, cmsId) => {
+  const link = await deps.links.find(cmsType, cmsId);
+  if (!link?.root) throw new DriveSyncError("Ese elemento no está marcado para sincronizar.");
+  await deps.links.update(link.id, { root: false });
+  const keep = await neededLinkIds(deps);
+  for (const l of await deps.links.all()) if (!keep.has(l.id)) await deps.links.remove(l.id);
+};
+const isSynced = async (deps, cmsType, cmsId) => {
+  const all3 = await deps.links.all();
+  const roots = all3.filter((l) => l.root);
+  if (roots.some((l) => l.cmsType === cmsType && l.cmsId === cmsId)) return true;
+  const path = cmsType === "folder" ? (await deps.cms.folder(cmsId))?.path : (await deps.cms.file(cmsId))?.folderPath;
+  if (!path) return false;
+  for (const l of roots.filter((r) => r.cmsType === "folder")) {
+    const folder = await deps.cms.folder(l.cmsId);
+    if (folder && (path === folder.path ? cmsType === "file" : path.startsWith(`${folder.path}/`))) return true;
+  }
+  return false;
+};
+const FOLDER_UID = "plugin::upload.folder";
+const FILE_UID = "plugin::upload.file";
+const LINK_UID = "plugin::strapi-content-generator-gemini.drive-link";
+const OP_UID = "plugin::strapi-content-generator-gemini.drive-op";
+const toFolder = (r) => ({
+  id: r.id,
+  pathId: Number(r.pathId),
+  name: r.name,
+  path: r.path,
+  parentId: r.parent?.id ?? null
+});
+const toFile = (r) => ({
+  id: r.id,
+  name: r.name,
+  folderId: r.folder?.id ?? null,
+  folderPath: r.folderPath ?? "/",
+  url: r.url ?? "",
+  size: Number(r.size ?? 0),
+  mime: r.mime ?? "application/octet-stream"
+});
+const strapiCms = (strapi, fetchFn = fetch) => {
+  const folders = () => strapi.db.query(FOLDER_UID);
+  const files = () => strapi.db.query(FILE_UID);
+  const withParent = { populate: ["parent"] };
+  const withFolder = { populate: ["folder"] };
+  return {
+    async generatedRoot() {
+      const rows = await folders().findMany({ where: { name: "Generated" }, ...withParent });
+      const root = rows.find((r) => !r.parent);
+      return root ? toFolder(root) : null;
+    },
+    async folder(id) {
+      const r = await folders().findOne({ where: { id }, ...withParent });
+      return r ? toFolder(r) : null;
+    },
+    async file(id) {
+      const r = await files().findOne({ where: { id }, ...withFolder });
+      return r ? toFile(r) : null;
+    },
+    async foldersByPathIds(pathIds2) {
+      if (!pathIds2.length) return [];
+      return (await folders().findMany({ where: { pathId: { $in: pathIds2 } }, ...withParent })).map(toFolder);
+    },
+    async childFolders(folderId) {
+      return (await folders().findMany({ where: { parent: { id: folderId } }, ...withParent })).map(toFolder);
+    },
+    async childFiles(folderId) {
+      return (await files().findMany({ where: { folder: { id: folderId } }, ...withFolder })).map(toFile);
+    },
+    async readFile(file) {
+      if (/^https?:\/\//.test(file.url)) {
+        const res = await fetchFn(file.url);
+        if (!res.ok) throw new Error(`No se pudo leer ${file.name} (${res.status}).`);
+        return new Uint8Array(await res.arrayBuffer());
+      }
+      return new Uint8Array(await promises.readFile(node_path.join(strapi.dirs.static.public, file.url)));
+    }
+  };
+};
+const strapiCmsWriter = (strapi) => {
+  const upload = () => strapi.plugin("upload").service("upload");
+  const folderService = () => strapi.plugin("upload").service("folder");
+  const fileById = async (id) => toFile(await strapi.db.query(FILE_UID).findOne({ where: { id }, populate: ["folder"] }));
+  const system = { user: { id: null } };
+  const withTempFile = async (name2, mime, content, work) => {
+    const filepath = node_path.join(node_os.tmpdir(), `iw-drive-${node_crypto.randomBytes(8).toString("hex")}`);
+    await promises.writeFile(filepath, content);
+    try {
+      return await work({ filepath, originalFilename: name2, mimetype: mime, size: content.length });
+    } finally {
+      await promises.rm(filepath, { force: true });
+    }
+  };
+  return {
+    uploadFile: (folderId, name2, mime, content) => withTempFile(name2, mime, content, async (file) => {
+      const [row] = await upload().upload({ data: { fileInfo: { name: name2, folder: folderId } }, files: file });
+      return fileById(row.id);
+    }),
+    replaceFile: async (id, name2, mime, content) => {
+      const current = await strapi.db.query(FILE_UID).findOne({ where: { id }, populate: ["folder"] });
+      return withTempFile(name2, mime, content, async (file) => {
+        await upload().replace(id, { data: { fileInfo: { name: name2, folder: current?.folder?.id ?? null } }, file });
+        return fileById(id);
+      });
+    },
+    updateFile: async (id, { name: name2, folderId }) => {
+      await upload().updateFileInfo(id, { name: name2, ...folderId !== void 0 ? { folder: folderId } : {} });
+    },
+    deleteFile: async (id) => {
+      const row = await strapi.db.query(FILE_UID).findOne({ where: { id } });
+      if (row) await upload().remove(row);
+    },
+    createFolder: async (name2, parentId) => {
+      const row = await folderService().create({ name: name2, parent: parentId });
+      return toFolder({ ...row, parent: { id: parentId } });
+    },
+    updateFolder: async (id, { name: name2, parentId }) => {
+      const current = await strapi.db.query(FOLDER_UID).findOne({ where: { id }, populate: ["parent"] });
+      if (!current) return;
+      await folderService().update(id, { name: name2 ?? current.name, ...parentId !== void 0 ? { parent: parentId } : {} }, system);
+    },
+    deleteFolder: async (id) => {
+      await folderService().deleteByIds([id]);
+    }
+  };
+};
+const toLink = (r) => ({
+  id: r.id,
+  cmsType: r.cmsType,
+  cmsId: Number(r.cmsId),
+  driveId: r.driveId ?? null,
+  root: !!r.root,
+  name: r.name ?? null,
+  parentCmsId: r.parentCmsId ?? null,
+  version: r.version ?? null,
+  driveRev: r.driveRev ?? null,
+  status: r.status ?? "pending",
+  error: r.error ?? null
+});
+const strapiLinks = (strapi) => {
+  const q = () => strapi.db.query(LINK_UID);
+  return {
+    all: async () => (await q().findMany({ orderBy: { id: "asc" } })).map(toLink),
+    find: async (cmsType, cmsId) => {
+      const r = await q().findOne({ where: { cmsType, cmsId } });
+      return r ? toLink(r) : null;
+    },
+    findByDriveId: async (driveId) => {
+      const r = await q().findOne({ where: { driveId } });
+      return r ? toLink(r) : null;
+    },
+    create: async (data) => toLink(await q().create({ data })),
+    update: async (id, data) => toLink(await q().update({ where: { id }, data })),
+    remove: async (id) => void await q().delete({ where: { id } })
+  };
+};
+const toOp = (r) => ({
+  id: r.id,
+  cmsType: r.cmsType,
+  cmsId: Number(r.cmsId),
+  attempts: Number(r.attempts ?? 0),
+  runAfter: Number(r.runAfter ?? 0),
+  error: r.error ?? null
+});
+const strapiOps = (strapi) => {
+  const q = () => strapi.db.query(OP_UID);
+  return {
+    async push(cmsType, cmsId) {
+      if (await q().findOne({ where: { cmsType, cmsId } })) return;
+      await q().create({ data: { cmsType, cmsId, attempts: 0, runAfter: "0" } });
+    },
+    ready: async (limit, now2) => (await q().findMany({ where: { runAfter: { $lte: String(now2) } }, orderBy: { id: "asc" }, limit })).map(toOp),
+    done: async (op) => void await q().delete({ where: { id: op.id } }),
+    retry: async (op, error, runAfter) => void await q().update({ where: { id: op.id }, data: { attempts: op.attempts + 1, error, runAfter: String(runAfter) } }),
+    count: async () => q().count()
+  };
+};
+const MAX_FILE_BYTES = 30 * 1024 * 1024;
+const echo = new node_async_hooks.AsyncLocalStorage();
+const withoutEcho = (work) => echo.run(true, work);
+const isEcho = () => echo.getStore() === true;
+const versionOf = (file) => `${file.url}|${file.size}`;
+const PAGE_TOKEN_KEY = "DRIVE_PAGE_TOKEN";
+const ROOT_ID_KEY = "DRIVE_ROOT_ID";
+const FULL_CHECK_KEY = "DRIVE_FULL_CHECK";
+const NATIVE = "application/vnd.google-apps.";
+const MOVED_AWAY = "Se movió en Drive a una carpeta que no está sincronizada. Regrésalo en Drive o muévelo en el CMS.";
+const isNative = (f) => f.mimeType.startsWith(NATIVE) && f.mimeType !== FOLDER_MIME;
+const driveRootId = async (deps) => {
+  const saved = await deps.store.get({ key: ROOT_ID_KEY });
+  if (saved) return saved;
+  const id = await deps.drive.rootId();
+  await deps.store.set({ key: ROOT_ID_KEY, value: id });
+  return id;
+};
+const cmsParentOf = async (deps, f, rootId2) => {
+  const parent = f.parents?.[0];
+  if (!parent) return null;
+  if (parent === rootId2 || parent === DRIVE_ROOT) return (await deps.cms.generatedRoot())?.id ?? null;
+  const link = await deps.links.findByDriveId(parent);
+  return link?.cmsType === "folder" ? link.cmsId : null;
+};
+const pruneLinks = async (deps) => {
+  const keep = await neededLinkIds(deps);
+  for (const l of await deps.links.all()) if (!keep.has(l.id)) await deps.links.remove(l.id);
+};
+const dropDeadLinks = async (deps) => {
+  for (const l of await deps.links.all()) {
+    const exists = l.cmsType === "folder" ? await deps.cms.folder(l.cmsId) : await deps.cms.file(l.cmsId);
+    if (!exists) await deps.links.remove(l.id);
+  }
+};
+const removeInCms = async (deps, link) => {
+  if (link.cmsType === "folder") await deps.writer.deleteFolder(link.cmsId);
+  else await deps.writer.deleteFile(link.cmsId);
+  deps.log?.info?.(`[drive] Drive → CMS: borrado «${link.name}»`);
+  await deps.links.remove(link.id);
+  if (link.cmsType === "folder") await dropDeadLinks(deps);
+};
+const updateLinked = async (deps, link, f, parentCms) => {
+  let changed = false;
+  if (link.cmsType === "folder") {
+    if (f.name !== link.name || parentCms !== link.parentCmsId) {
+      await deps.writer.updateFolder(link.cmsId, { name: f.name, parentId: parentCms });
+      deps.log?.info?.(`[drive] Drive → CMS: carpeta «${link.name}» → «${f.name}»`);
+      await deps.links.update(link.id, { name: f.name, parentCmsId: parentCms, status: "synced", error: null });
+      return true;
+    }
+    return false;
+  }
+  if (f.md5Checksum && f.md5Checksum !== link.driveRev) {
+    if (Number(f.size ?? 0) > MAX_FILE_BYTES) {
+      await deps.links.update(link.id, { status: "skipped", error: "La versión de Drive pesa más de 30 MB; no se trae al CMS." });
+      return true;
+    }
+    const content = await deps.drive.download(f.id);
+    const cmsFile = await deps.writer.replaceFile(link.cmsId, f.name, f.mimeType, content);
+    deps.log?.info?.(`[drive] Drive → CMS: contenido nuevo de «${f.name}»`);
+    await deps.links.update(link.id, { version: versionOf(cmsFile), driveRev: f.md5Checksum, name: f.name, status: "synced", error: null });
+    link = { ...link, name: f.name };
+    changed = true;
+  }
+  if (f.name !== link.name || parentCms !== link.parentCmsId) {
+    await deps.writer.updateFile(link.cmsId, { name: f.name, folderId: parentCms });
+    deps.log?.info?.(`[drive] Drive → CMS: archivo «${link.name}» → «${f.name}»`);
+    const cmsFile = await deps.cms.file(link.cmsId);
+    await deps.links.update(link.id, { name: f.name, parentCmsId: parentCms, ...cmsFile ? { version: versionOf(cmsFile) } : {}, status: "synced", error: null });
+    changed = true;
+  }
+  return changed;
+};
+const createInCms = async (deps, f, parentCms) => {
+  if (f.mimeType === FOLDER_MIME) {
+    const folder = await deps.writer.createFolder(f.name, parentCms);
+    await deps.links.create({ cmsType: "folder", cmsId: folder.id, driveId: f.id, root: false, name: f.name, parentCmsId: parentCms, version: null, driveRev: null, status: "synced", error: null });
+    return;
+  }
+  if (Number(f.size ?? 0) > MAX_FILE_BYTES) {
+    deps.log?.warn(`[drive] «${f.name}» pesa más de 30 MB; no se trae al CMS.`);
+    return;
+  }
+  const content = await deps.drive.download(f.id);
+  const file = await deps.writer.uploadFile(parentCms, f.name, f.mimeType, content);
+  await deps.links.create({
+    cmsType: "file",
+    cmsId: file.id,
+    driveId: f.id,
+    root: false,
+    name: f.name,
+    parentCmsId: parentCms,
+    version: versionOf(file),
+    driveRev: f.md5Checksum ?? null,
+    status: "synced",
+    error: null
+  });
+};
+const applyChange = async (deps, change, rootId2) => {
+  const link = await deps.links.findByDriveId(change.fileId);
+  const f = change.file;
+  if (change.removed || f?.trashed) {
+    if (!link) return false;
+    await removeInCms(deps, link);
+    return true;
+  }
+  if (!f || isNative(f)) return false;
+  const parentCms = await cmsParentOf(deps, f, rootId2);
+  const parentInside = parentCms !== null && await isSynced(deps, "folder", parentCms);
+  if (link) {
+    const pathOnly = !link.root && !await isSynced(deps, link.cmsType, link.cmsId);
+    if (parentCms === null) {
+      if (f.name !== link.name) deps.log?.info?.(`[drive] «${f.name}» no se aplica: su carpeta en Drive (${f.parents?.[0] ?? "ninguna"}) no está vinculada`);
+      if (pathOnly || link.status === "error" && link.error === MOVED_AWAY) return false;
+      await deps.links.update(link.id, { status: "error", error: MOVED_AWAY });
+      return true;
+    }
+    const changed = await updateLinked(deps, link, f, parentCms);
+    if (!pathOnly && !link.root && !parentInside) {
+      await deps.links.remove(link.id);
+      await pruneLinks(deps);
+      return true;
+    }
+    return changed;
+  }
+  if (!parentInside) return false;
+  await createInCms(deps, f, parentCms);
+  return true;
+};
+const fullCheck = async (deps, rootId2) => {
+  let applied = 0;
+  let errors = 0;
+  const all3 = await deps.links.all();
+  deps.log?.info?.(`[drive] revisión completa contra Drive: ${all3.length} vínculos`);
+  for (const link of all3) {
+    if (!link.driveId) continue;
+    if (!await deps.links.find(link.cmsType, link.cmsId)) continue;
+    try {
+      const meta = await deps.drive.getMeta(link.driveId);
+      if (await applyChange(deps, { fileId: link.driveId, removed: meta === null, ...meta ? { file: meta } : {} }, rootId2)) applied++;
+    } catch (err) {
+      errors++;
+      deps.log?.warn(`[drive] revisión de ${link.cmsType} ${link.cmsId}: ${err.message}`);
+    }
+  }
+  return { applied, errors };
+};
+const pullChanges = async (deps, { full = false } = {}) => {
+  let token = await deps.store.get({ key: PAGE_TOKEN_KEY });
+  const rootId2 = await driveRootId(deps);
+  let applied = 0;
+  let errors = 0;
+  if (!token) {
+    token = await deps.drive.startPageToken();
+    await deps.store.set({ key: PAGE_TOKEN_KEY, value: token });
+    await deps.store.delete({ key: FULL_CHECK_KEY });
+  }
+  if (full) await deps.store.delete({ key: FULL_CHECK_KEY });
+  if (!await deps.store.get({ key: FULL_CHECK_KEY })) {
+    const checked = await withoutEcho(() => fullCheck(deps, rootId2));
+    await deps.store.set({ key: FULL_CHECK_KEY, value: true });
+    applied += checked.applied;
+    errors += checked.errors;
+  }
+  await withoutEcho(async () => {
+    for (; ; ) {
+      const page = await deps.drive.listChanges(token);
+      for (const change of page.changes ?? []) {
+        try {
+          if (await applyChange(deps, change, rootId2)) applied++;
+        } catch (err) {
+          errors++;
+          deps.log?.warn(`[drive] cambio de Drive ${change.fileId}: ${err.message}`);
+        }
+      }
+      token = page.nextPageToken ?? page.newStartPageToken ?? token;
+      await deps.store.set({ key: PAGE_TOKEN_KEY, value: token });
+      if (!page.nextPageToken) break;
+    }
+  });
+  return { applied, errors };
+};
+const LOCK_KEY = "DRIVE_LOCK";
+const LAST_RUN_KEY = "DRIVE_LAST_RUN";
+const LOCK_MS = 10 * 6e4;
+const BATCH = 50;
+const MAX_ATTEMPTS = 5;
+const TOO_BIG = "Pesa más de 30 MB; no se sube a Drive.";
+const bytesOf = (file) => file.size * 1e3;
+const now = (deps) => (deps.now ?? Date.now)();
+const driveParent = async (deps, parentCmsId, depth = 0) => {
+  const root = await deps.cms.generatedRoot();
+  if (parentCmsId === null || parentCmsId === root?.id) return DRIVE_ROOT;
+  let link = await deps.links.find("folder", parentCmsId);
+  if (!link?.driveId && depth < 20) {
+    await processItem(deps, "folder", parentCmsId, depth + 1);
+    link = await deps.links.find("folder", parentCmsId);
+  }
+  if (!link?.driveId) throw new Error(`La carpeta ${parentCmsId} todavía no está en Drive.`);
+  return link.driveId;
+};
+const saveError = async (deps, link, cmsType, cmsId, error, status = "error") => {
+  if (link) await deps.links.update(link.id, { status, error });
+  else await deps.links.create({ cmsType, cmsId, driveId: null, root: false, name: null, parentCmsId: null, version: null, driveRev: null, status, error });
+};
+const syncFolder = async (deps, folder, link, depth) => {
+  const parent = await driveParent(deps, folder.parentId, depth);
+  if (!link?.driveId) {
+    if (await deps.drive.findChild(parent, folder.name)) return saveError(deps, link, "folder", folder.id, collisionMessage(folder.name));
+    const driveId = await deps.drive.createFolder(parent, folder.name);
+    const data = { driveId, name: folder.name, parentCmsId: folder.parentId, status: "synced", error: null };
+    if (link) await deps.links.update(link.id, data);
+    else await deps.links.create({ cmsType: "folder", cmsId: folder.id, root: false, version: null, driveRev: null, ...data });
+  } else if (link.name !== folder.name || link.parentCmsId !== folder.parentId) {
+    const from = link.parentCmsId === folder.parentId ? parent : await driveParent(deps, link.parentCmsId, depth).catch(() => parent);
+    await deps.drive.updateMeta(link.driveId, { name: folder.name, from, to: parent });
+    await deps.links.update(link.id, { name: folder.name, parentCmsId: folder.parentId, status: "synced", error: null });
+  }
+  if (!link?.driveId) {
+    for (const f of await deps.cms.childFolders(folder.id)) await deps.ops.push("folder", f.id);
+    for (const f of await deps.cms.childFiles(folder.id)) await deps.ops.push("file", f.id);
+  }
+};
+const syncFile = async (deps, file, link, depth) => {
+  if (bytesOf(file) > MAX_FILE_BYTES) return saveError(deps, link, "file", file.id, TOO_BIG, "skipped");
+  const parent = await driveParent(deps, file.folderId, depth);
+  const version = versionOf(file);
+  const upload = async () => ({ name: file.name, mime: file.mime, content: await deps.cms.readFile(file), description: await deps.describe?.(file) });
+  if (!link?.driveId) {
+    if (await deps.drive.findChild(parent, file.name)) return saveError(deps, link, "file", file.id, collisionMessage(file.name));
+    const { id: driveId, md5 } = await deps.drive.uploadFile(parent, await upload());
+    const data = { driveId, name: file.name, parentCmsId: file.folderId, version, driveRev: md5, status: "synced", error: null };
+    if (link) await deps.links.update(link.id, data);
+    else await deps.links.create({ cmsType: "file", cmsId: file.id, root: false, ...data });
+    return;
+  }
+  let driveRev = link.driveRev;
+  if (link.version !== version) driveRev = (await deps.drive.updateContent(link.driveId, await upload())).md5;
+  if (link.name !== file.name || link.parentCmsId !== file.folderId) {
+    const from = link.parentCmsId === file.folderId ? parent : await driveParent(deps, link.parentCmsId, depth).catch(() => parent);
+    await deps.drive.updateMeta(link.driveId, { name: file.name, from, to: parent });
+  }
+  await deps.links.update(link.id, { name: file.name, parentCmsId: file.folderId, version, driveRev, status: "synced", error: null });
+};
+const processItem = async (deps, cmsType, cmsId, depth = 0) => {
+  const link = await deps.links.find(cmsType, cmsId);
+  const item = cmsType === "folder" ? await deps.cms.folder(cmsId) : await deps.cms.file(cmsId);
+  if (!item) {
+    if (link?.driveId) await deps.drive.trash(link.driveId);
+    if (link) await deps.links.remove(link.id);
+    return;
+  }
+  if (!await isSynced(deps, cmsType, cmsId)) {
+    if (link && !(await neededLinkIds(deps)).has(link.id)) await deps.links.remove(link.id);
+    return;
+  }
+  if (cmsType === "folder") await syncFolder(deps, item, link, depth);
+  else await syncFile(deps, item, link, depth);
+};
+const reconcile = async (deps) => {
+  const links = await deps.links.all();
+  const linked = new Set(links.map((l) => `${l.cmsType}:${l.cmsId}`));
+  for (const link of links) {
+    if (link.cmsType === "file") {
+      const file = await deps.cms.file(link.cmsId);
+      if (!file || !link.driveId || file.name !== link.name || file.folderId !== link.parentCmsId || versionOf(file) !== link.version) {
+        if (link.status !== "skipped" || !file || bytesOf(file) <= MAX_FILE_BYTES) await deps.ops.push("file", link.cmsId);
+      }
+      continue;
+    }
+    const folder = await deps.cms.folder(link.cmsId);
+    if (!folder || !link.driveId || folder.name !== link.name || folder.parentId !== link.parentCmsId) {
+      await deps.ops.push("folder", link.cmsId);
+      if (!folder) continue;
+    }
+    if (!await isSynced(deps, "folder", link.cmsId)) continue;
+    for (const f of await deps.cms.childFolders(folder.id)) if (!linked.has(`folder:${f.id}`)) await deps.ops.push("folder", f.id);
+    for (const f of await deps.cms.childFiles(folder.id)) if (!linked.has(`file:${f.id}`)) await deps.ops.push("file", f.id);
+  }
+};
+const acquire = async (deps) => {
+  const lock = await deps.store.get({ key: LOCK_KEY });
+  if (lock?.until && lock.until > now(deps)) return false;
+  await deps.store.set({ key: LOCK_KEY, value: { until: now(deps) + LOCK_MS } });
+  return true;
+};
+const runSync = async (deps, { budgetMs = 4 * 6e4, full = false } = {}) => {
+  if (!await acquire(deps)) return { skipped: true, pulled: 0, processed: 0, errors: 0, pending: await deps.ops.count() };
+  const started = now(deps);
+  let processed = 0;
+  let errors = 0;
+  let pulled = 0;
+  try {
+    if (deps.writer) {
+      const result = await pullChanges({ ...deps, writer: deps.writer }, { full });
+      pulled = result.applied;
+      errors += result.errors;
+    }
+    await reconcile(deps);
+    while (now(deps) - started < budgetMs) {
+      const batch = await deps.ops.ready(BATCH, now(deps));
+      if (!batch.length) break;
+      for (const op of batch) {
+        try {
+          await processItem(deps, op.cmsType, op.cmsId);
+          await deps.ops.done(op);
+          processed++;
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          errors++;
+          if (err instanceof DriveSyncError || op.attempts + 1 >= MAX_ATTEMPTS) {
+            await deps.ops.done(op);
+            await saveError(deps, await deps.links.find(op.cmsType, op.cmsId), op.cmsType, op.cmsId, message);
+          } else {
+            await deps.ops.retry(op, message, now(deps) + 3e4 * 2 ** op.attempts);
+          }
+          deps.log?.warn(`[drive] ${op.cmsType} ${op.cmsId}: ${message}`);
+        }
+      }
+    }
+  } finally {
+    await deps.store.set({ key: LAST_RUN_KEY, value: { at: now(deps), pulled, processed, errors } });
+    deps.log?.info?.(`[drive] ciclo terminado: ${pulled} cambios de Drive traídos, ${processed} elementos subidos o revisados, ${errors} errores`);
+    await deps.store.delete({ key: LOCK_KEY });
+  }
+  return { skipped: false, pulled, processed, errors, pending: await deps.ops.count() };
+};
+const debounce = (run, delayMs = 5e3, onError = () => {
+}) => {
+  let timer = null;
+  return () => {
+    if (timer) clearTimeout(timer);
+    timer = setTimeout(() => {
+      timer = null;
+      run().catch(onError);
+    }, delayMs);
+    timer.unref?.();
+  };
+};
+const DRIVE_TOKEN_KEY = "DRIVE_TOKEN";
+const DRIVE_ORIGINS_KEY = "DRIVE_ORIGINS";
+class DriveInputError extends Error {
+  constructor(message, status = 400) {
+    super(message);
+    this.status = status;
+  }
+}
+const NOT_CONNECTED = { connected: false, email: null, usage: null, limit: null, error: null };
+const REVOKED = "Desconectada: vuelve a conectar la cuenta.";
+const createDriveService = ({
+  store,
+  fetch: fetchFn,
+  log,
+  sync
+}) => {
+  const client = async () => loadClient(await store.get({ key: DRIVE_CLIENT_KEY }));
+  const token = async () => await store.get({ key: DRIVE_TOKEN_KEY });
+  const http = createDriveClient({
+    fetch: fetchFn,
+    getCredentials: async () => {
+      const [c, t] = await Promise.all([client(), token()]);
+      return c && t?.refreshToken ? { client: c, refreshToken: t.refreshToken } : null;
+    }
+  });
+  const clientFor = async (redirectUri) => {
+    const c = await client();
+    if (!c) throw new DriveInputError("Primero carga el JSON del cliente OAuth.");
+    if (typeof redirectUri !== "string" || !c.redirectUris.includes(redirectUri)) {
+      throw new DriveInputError(`Este cliente no tiene autorizada la URL ${String(redirectUri)}. Agrégala en Google Cloud.`);
+    }
+    return c;
+  };
+  const forgetToken = async () => {
+    const t = await token();
+    if (t?.refreshToken) {
+      await revokeToken(t.refreshToken, fetchFn).catch((err) => log.warn(`[drive] no se pudo revocar el token: ${err.message}`));
+    }
+    await store.delete({ key: DRIVE_TOKEN_KEY });
+    http.reset();
+  };
+  const connected = async () => !!await client() && !!(await token())?.refreshToken;
+  const describe = async (file) => {
+    const origins = await store.get({ key: DRIVE_ORIGINS_KEY }) ?? {};
+    const origin2 = origins[String(file.id)];
+    if (!origin2) return void 0;
+    return `Template: ${origin2.name}
+${sync?.serverUrl ?? ""}/admin/plugins/strapi-content-generator-gemini-studio?tab=templates`;
+  };
+  const syncDeps = () => {
+    if (!sync) throw new Error("La sincronización con Drive no está configurada.");
+    return { drive: driveOps(http), cms: sync.cms, writer: sync.writer, links: sync.links, ops: sync.ops, store, describe, log };
+  };
+  const requireConnection = async () => {
+    if (!await connected()) throw new DriveInputError("Conecta Google Drive en Ajustes antes de sincronizar.");
+  };
+  const asInput = async (work) => {
+    try {
+      return await work();
+    } catch (err) {
+      if (err instanceof DriveSyncError) throw new DriveInputError(err.message, err.status);
+      throw err;
+    }
+  };
+  const runCycle = async ({ full = false } = {}) => await connected() ? runSync(syncDeps(), { full }) : null;
+  const schedule = debounce(() => runCycle(), 5e3, (err) => log.warn(`[drive] el ciclo de sincronización falló: ${err instanceof Error ? err.message : String(err)}`));
+  return {
+    http: () => http,
+    connected,
+    runCycle,
+    /** Marca para sincronizar y programa el ciclo. */
+    async mark(cmsType, cmsId) {
+      await requireConnection();
+      await asInput(() => mark(syncDeps(), cmsType, cmsId));
+      schedule();
+    },
+    async unmark(cmsType, cmsId) {
+      await asInput(() => unmark(syncDeps(), cmsType, cmsId));
+    },
+    /** «Sincronizar ahora»; con `full`, «Revisión completa»: compara todo lo vinculado contra Drive. */
+    async syncNow(full = false) {
+      await requireConnection();
+      return runCycle({ full });
+    },
+    /** Lifecycle de upload: encola si el elemento está (o estaba) en lo sincronizado. */
+    async track(cmsType, cmsId) {
+      if (isEcho() || !sync || !await connected()) return;
+      const deps = syncDeps();
+      if (await deps.links.find(cmsType, cmsId) || await isSynced(deps, cmsType, cmsId)) {
+        await deps.ops.push(cmsType, cmsId);
+        schedule();
+      }
+    },
+    async linkStatuses() {
+      const isConnected = await connected();
+      if (!isConnected || !sync) return { connected: false, items: {}, lastRun: null, pending: 0 };
+      const items = {};
+      const deps = syncDeps();
+      for (const l of await sync.links.all()) {
+        items[`${l.cmsType}:${l.cmsId}`] = { status: l.status, root: l.root, inside: await isSynced(deps, l.cmsType, l.cmsId), error: l.error };
+      }
+      const lastRun = await store.get({ key: LAST_RUN_KEY }) ?? null;
+      return { connected: true, items, lastRun, pending: await sync.ops.count() };
+    },
+    /** Vista de Drive (S7.2): una carpeta en vivo con su ruta y qué hijos están sincronizados. */
+    async browse(folderId, pageToken) {
+      await requireConnection();
+      const ops = driveOps(http);
+      const id = typeof folderId === "string" && folderId !== "" ? folderId : "root";
+      const page = await ops.listChildren(id, typeof pageToken === "string" && pageToken ? pageToken : void 0);
+      const rootId2 = await store.get({ key: "DRIVE_ROOT_ID" }) ?? await ops.rootId();
+      const isRoot = id === "root" || id === rootId2;
+      const path = [];
+      if (!isRoot) {
+        let current = await ops.getFile(id);
+        path.unshift({ id: current.id, name: current.name });
+        for (let depth = 0; depth < 30 && current.parents[0] && current.parents[0] !== rootId2; depth++) {
+          current = await ops.getFile(current.parents[0]);
+          path.unshift({ id: current.id, name: current.name });
+        }
+      }
+      const linked = new Set((sync ? await sync.links.all() : []).map((l) => l.driveId).filter(Boolean));
+      return {
+        path,
+        items: page.items.map((item) => ({ ...item, synced: linked.has(item.id) })),
+        nextPageToken: page.nextPageToken
+      };
+    },
+    /** Cuántos elementos se irían a la papelera con esta carpeta, y si está sincronizada. */
+    async countItem(id) {
+      await requireConnection();
+      if (typeof id !== "string" || !id) throw new DriveInputError("Elemento de Drive inválido.");
+      const synced = !!(sync && await sync.links.findByDriveId(id));
+      return { ...await driveOps(http).countTree(id), synced };
+    },
+    /** Eliminar desde la vista: a la papelera de Drive. Si estaba sincronizado, el siguiente ciclo lo borra del CMS. */
+    async trashItem(id) {
+      await requireConnection();
+      if (typeof id !== "string" || !id || id === "root") throw new DriveInputError("Elemento de Drive inválido.");
+      await driveOps(http).trash(id);
+      schedule();
+    },
+    /** El panel avisa que un archivo salió de un template (S7.3). */
+    async setOrigin(fileId, documentId, name2) {
+      if (typeof fileId !== "number" || typeof documentId !== "string" || typeof name2 !== "string" || !name2.trim()) {
+        throw new DriveInputError("Origen del template inválido.");
+      }
+      const origins = await store.get({ key: DRIVE_ORIGINS_KEY }) ?? {};
+      await store.set({ key: DRIVE_ORIGINS_KEY, value: { ...origins, [String(fileId)]: { documentId, name: name2.trim() } } });
+    },
+    /** Guarda el cliente del JSON de Google. Un cliente nuevo invalida la conexión anterior. */
+    async saveClient(json, redirectUri) {
+      const parsed = parseClientConfig(json, typeof redirectUri === "string" ? redirectUri : "");
+      if ("message" in parsed) throw new DriveInputError(parsed.message);
+      const previous = await client();
+      if (previous && previous.clientId !== parsed.client.clientId) await forgetToken();
+      await store.set({ key: DRIVE_CLIENT_KEY, value: storedClient(parsed.client) });
+      http.reset();
+    },
+    async removeClient() {
+      await forgetToken();
+      await store.delete({ key: DRIVE_CLIENT_KEY });
+    },
+    async authorizationUrl(redirectUri) {
+      const c = await clientFor(redirectUri);
+      return authUrl(c, redirectUri, await newState(store));
+    },
+    async exchange({ code, state, redirectUri }) {
+      if (!await checkState(store, state) || typeof code !== "string" || code === "") {
+        throw new DriveInputError("La conexión no se pudo verificar. Intenta de nuevo.");
+      }
+      const c = await clientFor(redirectUri);
+      let refreshToken;
+      try {
+        ({ refreshToken } = await exchangeCode({ client: c, code, redirectUri, fetch: fetchFn }));
+      } catch (err) {
+        if (err instanceof DriveAuthError) throw new DriveInputError(err.message);
+        throw err;
+      }
+      await store.set({ key: DRIVE_TOKEN_KEY, value: { refreshToken, email: null } });
+      http.reset();
+      const { email } = await http.about();
+      await store.set({ key: DRIVE_TOKEN_KEY, value: { refreshToken, email } });
+    },
+    disconnect: forgetToken,
+    async status() {
+      const pub = publicClient(await store.get({ key: DRIVE_CLIENT_KEY }));
+      const t = await token();
+      if (!pub.configured || !t?.refreshToken) return { client: pub, connection: NOT_CONNECTED, sync: null };
+      const syncState = async () => {
+        if (!sync) return null;
+        const failing = (await sync.links.all()).filter((l) => (l.status === "error" || l.status === "skipped") && l.error);
+        return {
+          lastRun: await store.get({ key: LAST_RUN_KEY }) ?? null,
+          pending: await sync.ops.count(),
+          errors: failing.slice(0, 20).map((l) => ({ key: `${l.cmsType}:${l.cmsId}`, name: l.name ?? `${l.cmsType === "file" ? "Archivo" : "Carpeta"} ${l.cmsId}`, error: l.error }))
+        };
+      };
+      try {
+        const about = await http.about();
+        return {
+          client: pub,
+          connection: { connected: true, email: about.email, usage: about.usage, limit: about.limit, error: null },
+          sync: await syncState()
+        };
+      } catch (err) {
+        if (err instanceof DriveAuthError || err instanceof DriveNotConnectedError) {
+          return { client: pub, connection: { ...NOT_CONNECTED, email: t.email, error: REVOKED }, sync: null };
+        }
+        return { client: pub, connection: { ...NOT_CONNECTED, connected: true, email: t.email, error: err.message }, sync: await syncState() };
+      }
+    }
+  };
+};
+const drive$1 = ({ strapi }) => createDriveService({
+  store: strapi.store({ type: "plugin", name: "strapi-content-generator-gemini" }),
+  fetch: (...args) => fetch(...args),
+  log: strapi.log,
+  sync: {
+    cms: strapiCms(strapi),
+    writer: strapiCmsWriter(strapi),
+    links: strapiLinks(strapi),
+    ops: strapiOps(strapi),
+    serverUrl: String(strapi.config.get("server.url") ?? "").replace(/\/+$/, "")
+  }
+});
+const fail = (ctx, status, name2, message) => {
+  ctx.status = status;
+  ctx.body = { data: null, error: { status, name: name2, message } };
+};
+const drive = ({ strapi }) => {
+  const svc = () => strapi.plugin("strapi-content-generator-gemini").service("drive");
+  const run = async (ctx, work) => {
+    try {
+      ctx.body = await work() ?? { ok: true };
+      ctx.status = 200;
+    } catch (err) {
+      if (err instanceof DriveInputError) return fail(ctx, err.status, err.status === 409 ? "ConflictError" : "ValidationError", err.message);
+      strapi.log.error(`[drive] ${err instanceof Error ? err.message : String(err)}`);
+      return fail(ctx, 500, "InternalServerError", "No se pudo completar la operación con Google Drive.");
+    }
+  };
+  const body = (ctx) => ctx.request.body ?? {};
+  const target = (raw) => {
+    const cmsId = Number(raw.cmsId);
+    if (raw.cmsType !== "file" && raw.cmsType !== "folder" || !Number.isInteger(cmsId) || cmsId <= 0) {
+      throw new DriveInputError("Elemento de la Biblioteca inválido.");
+    }
+    return { cmsType: raw.cmsType, cmsId };
+  };
+  return {
+    status: (ctx) => run(ctx, () => svc().status()),
+    saveClient: (ctx) => run(ctx, () => svc().saveClient(body(ctx).json, body(ctx).redirectUri).then(() => void 0)),
+    removeClient: (ctx) => run(ctx, () => svc().removeClient().then(() => void 0)),
+    authorizationUrl: (ctx) => run(ctx, async () => ({ url: await svc().authorizationUrl(ctx.query.redirectUri) })),
+    exchange: (ctx) => run(ctx, () => svc().exchange(body(ctx)).then(() => void 0)),
+    disconnect: (ctx) => run(ctx, () => svc().disconnect().then(() => void 0)),
+    links: (ctx) => run(ctx, () => svc().linkStatuses()),
+    mark: (ctx) => run(ctx, async () => {
+      const { cmsType, cmsId } = target(body(ctx));
+      await svc().mark(cmsType, cmsId);
+    }),
+    unmark: (ctx) => run(ctx, async () => {
+      const { cmsType, cmsId } = target(ctx.params ?? {});
+      await svc().unmark(cmsType, cmsId);
+    }),
+    syncNow: (ctx) => run(ctx, () => svc().syncNow(body(ctx).full === true)),
+    browse: (ctx) => run(ctx, () => svc().browse(ctx.params?.id, ctx.query.pageToken)),
+    count: (ctx) => run(ctx, () => svc().countItem(ctx.params?.id)),
+    trash: (ctx) => run(ctx, () => svc().trashItem(ctx.params?.id).then(() => void 0)),
+    origin: (ctx) => run(ctx, () => svc().setOrigin(body(ctx).fileId, body(ctx).templateDocumentId, body(ctx).templateName).then(() => void 0))
+  };
+};
 const controllers = {
   controller,
   config: config$1,
   "image-studio": imageStudio,
   templates,
+  drive,
   articles
 };
 const middlewares = {};
@@ -1376,7 +2723,21 @@ const admin = [
   { method: "POST", path: "/template-folders/delete", handler: "templates.deleteFolder", config },
   { method: "GET", path: "/config", handler: "config.get", config },
   { method: "POST", path: "/config", handler: "config.set", config },
-  { method: "DELETE", path: "/config/vertex", handler: "config.removeVertex", config }
+  { method: "DELETE", path: "/config/vertex", handler: "config.removeVertex", config },
+  { method: "GET", path: "/drive/status", handler: "drive.status", config },
+  { method: "POST", path: "/drive/client", handler: "drive.saveClient", config },
+  { method: "DELETE", path: "/drive/client", handler: "drive.removeClient", config },
+  { method: "GET", path: "/drive/oauth/url", handler: "drive.authorizationUrl", config },
+  { method: "POST", path: "/drive/oauth/exchange", handler: "drive.exchange", config },
+  { method: "DELETE", path: "/drive/oauth", handler: "drive.disconnect", config },
+  { method: "GET", path: "/drive/links", handler: "drive.links", config },
+  { method: "POST", path: "/drive/links", handler: "drive.mark", config },
+  { method: "DELETE", path: "/drive/links/:cmsType/:cmsId", handler: "drive.unmark", config },
+  { method: "POST", path: "/drive/sync", handler: "drive.syncNow", config },
+  { method: "POST", path: "/drive/origin", handler: "drive.origin", config },
+  { method: "GET", path: "/drive/folders/:id", handler: "drive.browse", config },
+  { method: "GET", path: "/drive/items/:id/count", handler: "drive.count", config },
+  { method: "DELETE", path: "/drive/items/:id", handler: "drive.trash", config }
 ];
 const contentApi = [];
 const routes = {
@@ -2883,13 +4244,13 @@ function speedometer(samplesCount, min) {
   let firstSampleTS;
   min = min !== void 0 ? min : 1e3;
   return function push(chunkLength) {
-    const now = Date.now();
+    const now2 = Date.now();
     const startedAt = timestamps[tail];
     if (!firstSampleTS) {
-      firstSampleTS = now;
+      firstSampleTS = now2;
     }
     bytes[head] = chunkLength;
-    timestamps[head] = now;
+    timestamps[head] = now2;
     let i = tail;
     let bytesCount = 0;
     while (i !== head) {
@@ -2900,10 +4261,10 @@ function speedometer(samplesCount, min) {
     if (head === tail) {
       tail = (tail + 1) % samplesCount;
     }
-    if (now - firstSampleTS < min) {
+    if (now2 - firstSampleTS < min) {
       return;
     }
-    const passed = startedAt && now - startedAt;
+    const passed = startedAt && now2 - startedAt;
     return passed ? Math.round(bytesCount * 1e3 / passed) : void 0;
   };
 }
@@ -2912,8 +4273,8 @@ function throttle(fn, freq) {
   let threshold = 1e3 / freq;
   let lastArgs;
   let timer;
-  const invoke = (args, now = Date.now()) => {
-    timestamp = now;
+  const invoke = (args, now2 = Date.now()) => {
+    timestamp = now2;
     lastArgs = null;
     if (timer) {
       clearTimeout(timer);
@@ -2922,10 +4283,10 @@ function throttle(fn, freq) {
     fn(...args);
   };
   const throttled = (...args) => {
-    const now = Date.now();
-    const passed = now - timestamp;
+    const now2 = Date.now();
+    const passed = now2 - timestamp;
     if (passed >= threshold) {
-      invoke(args, now);
+      invoke(args, now2);
     } else {
       lastArgs = args;
       if (!timer) {
@@ -4585,8 +5946,8 @@ axios.VERSION = VERSION$1;
 axios.toFormData = toFormData$1;
 axios.AxiosError = AxiosError$1;
 axios.Cancel = axios.CanceledError;
-axios.all = function all(promises) {
-  return Promise.all(promises);
+axios.all = function all(promises2) {
+  return Promise.all(promises2);
 };
 axios.spread = spread$1;
 axios.isAxiosError = isAxiosError$1;
@@ -4974,6 +6335,7 @@ const services = {
   service,
   "image-studio": imageStudio$1,
   templates: templates$1,
+  drive: drive$1,
   articles: articles$1
 };
 const index = {