@interware/content-generator 0.4.4 → 0.6.0

package/dist/server/src/services/service.d.ts

@@ -2,9 +2,19 @@
 /// <reference types="node" />
 import type { Core } from '@strapi/strapi';
 import { GoogleGenAI, Video } from '@google/genai';
+import type { GeminiClient } from '../utils/geminiClient';
 declare const service: ({ strapi }: {
     strapi: Core.Strapi;
 }) => {
+    /**
+     * Cliente de Google y su backend (S5.1): con la cuenta de servicio de Ajustes, Vertex AI en `global`; si
+     * no, la llave (`GOOGLE_API_KEY` del entorno gana a la del store, como antes; D10). El video pide
+     * `allowVertex: false` (D7).
+     */
+    geminiClient({ allowVertex }?: {
+        allowVertex?: boolean;
+    }): Promise<GeminiClient>;
+    /** Atajo para los usos que solo necesitan el cliente (artículos). */
     geminiConfig(): Promise<GoogleGenAI>;
     getArticulos(sanitizedQueryParams: any): Promise<{
         id: import("@strapi/types/dist/data").ID;
@@ -57,55 +67,6 @@ declare const service: ({ strapi }: {
         sfid?: string;
         username?: string;
     }[]>;
-    getImagenes(): Promise<{
-        id: import("@strapi/types/dist/data").ID;
-        documentId: string;
-        locale?: string;
-        createdAt?: import("@strapi/types/dist/schema/attribute").DateTimeValue;
-        publishedAt?: import("@strapi/types/dist/schema/attribute").DateTimeValue;
-        updatedAt?: import("@strapi/types/dist/schema/attribute").DateTimeValue;
-        provider?: string;
-        alternativeText?: string;
-        caption?: string;
-        ext?: string;
-        folderPath?: string;
-        formats?: import("@strapi/types/dist/utils").JSONValue;
-        hash?: string;
-        height?: number;
-        mime?: string;
-        name?: string;
-        previewUrl?: string;
-        provider_metadata?: import("@strapi/types/dist/utils").JSONValue;
-        size?: number;
-        url?: string;
-        width?: number;
-    }[]>;
-    eliminarImagen(sanitizedQueryParams: any): Promise<{
-        documentId: string;
-        entries: {
-            id: import("@strapi/types/dist/data").ID;
-            documentId: string;
-            locale?: string;
-            createdAt?: import("@strapi/types/dist/schema/attribute").DateTimeValue;
-            publishedAt?: import("@strapi/types/dist/schema/attribute").DateTimeValue;
-            updatedAt?: import("@strapi/types/dist/schema/attribute").DateTimeValue;
-            provider?: string;
-            alternativeText?: string;
-            caption?: string;
-            ext?: string;
-            folderPath?: string;
-            formats?: import("@strapi/types/dist/utils").JSONValue;
-            hash?: string;
-            height?: number;
-            mime?: string;
-            name?: string;
-            previewUrl?: string;
-            provider_metadata?: import("@strapi/types/dist/utils").JSONValue;
-            size?: number;
-            url?: string;
-            width?: number;
-        }[];
-    }>;
     downloadFile(ctx: any): Promise<void>;
     _uploadGeneratedFile(file: Buffer | string, filename: string, mimeType: string, folderName?: string): Promise<any>;
     generateArticle(ctx: any): Promise<{
@@ -128,14 +89,6 @@ declare const service: ({ strapi }: {
         message: string;
         image: any;
     }>;
-    _callGeminiImageGeneration(promptText: string, aspectRatio: string, imageSizeLabel: string, referenceImages: {
-        buffer: Buffer;
-        mimeType: string;
-    }[]): Promise<string>;
-    generateImage(ctx: any): Promise<{
-        message: string;
-        file: any;
-    }>;
     _callVeoVideoGeneration(promptText: string, aspectRatio: string, durationSeconds: number, sceneRefs: {
         buffer: Buffer;
         mimeType: string;

package/dist/server/src/services/templates.d.ts

@@ -0,0 +1,81 @@
+import type { Core } from '@strapi/strapi';
+import type { TemplateInput } from '../templates/validate';
+export declare const TEMPLATE_UID = "plugin::strapi-content-generator-gemini.template";
+export declare class TemplateNotFoundError extends Error {
+}
+export interface StoredTemplate extends TemplateInput {
+    documentId: string;
+    updatedAt: string;
+    replacesBase?: string;
+}
+type Doc = Record<string, unknown>;
+interface DocumentsApi {
+    findMany(params?: Doc): Promise<Doc[]>;
+    findOne(params: {
+        documentId: string;
+    }): Promise<Doc | null>;
+    create(params: {
+        data: Doc;
+    }): Promise<Doc>;
+    update(params: {
+        documentId: string;
+        data: Doc;
+    }): Promise<Doc>;
+    delete(params: {
+        documentId: string;
+    }): Promise<unknown>;
+}
+interface Store {
+    get(params: {
+        key: string;
+    }): Promise<unknown>;
+    set(params: {
+        key: string;
+        value: unknown;
+    }): Promise<void>;
+}
+/**
+ * «Mis templates» (diseño S4.6). Recibe el document service y el plugin store por inyección para
+ * probarse sin Strapi. Renombrar y eliminar carpetas actualizan el store y los templates en una
+ * sola operación del panel (D5).
+ */
+export declare const createTemplatesService: (docs: DocumentsApi, store: Store) => {
+    list(): Promise<StoredTemplate[]>;
+    findOne(documentId: string): Promise<StoredTemplate>;
+    create(input: unknown): Promise<StoredTemplate>;
+    update(documentId: string, patch: unknown): Promise<StoredTemplate>;
+    remove(documentId: string): Promise<void>;
+    /**
+     * Guarda la versión editada de una plantilla base (S4.15): la crea la primera vez y después la
+     * actualiza. Vive en la raíz y conserva la base como origen.
+     */
+    saveBase(baseId: unknown, input: unknown): Promise<StoredTemplate>;
+    /** Vuelve a la versión de InterWare: borra la editada, si existe. */
+    restoreBase(baseId: unknown): Promise<void>;
+    folders: () => Promise<string[]>;
+    createFolder(path: unknown): Promise<string[]>;
+    renameFolder(from: unknown, to: unknown): Promise<string[]>;
+    deleteFolder(path: unknown): Promise<string[]>;
+};
+/** El document service y el store se piden en cada llamada: al instanciar el servicio el content-type podría no estar registrado. */
+declare const _default: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => {
+    list(): Promise<StoredTemplate[]>;
+    findOne(documentId: string): Promise<StoredTemplate>;
+    create(input: unknown): Promise<StoredTemplate>;
+    update(documentId: string, patch: unknown): Promise<StoredTemplate>;
+    remove(documentId: string): Promise<void>;
+    /**
+     * Guarda la versión editada de una plantilla base (S4.15): la crea la primera vez y después la
+     * actualiza. Vive en la raíz y conserva la base como origen.
+     */
+    saveBase(baseId: unknown, input: unknown): Promise<StoredTemplate>;
+    /** Vuelve a la versión de InterWare: borra la editada, si existe. */
+    restoreBase(baseId: unknown): Promise<void>;
+    folders: () => Promise<string[]>;
+    createFolder(path: unknown): Promise<string[]>;
+    renameFolder(from: unknown, to: unknown): Promise<string[]>;
+    deleteFolder(path: unknown): Promise<string[]>;
+};
+export default _default;

package/dist/server/src/templates/folders.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Carpetas de «Mis templates» como rutas (`Redes/LinkedIn`), igual que el prototipo (diseño S4.6,
+ * D4). La raíz es la cadena vacía. Funciones puras para probar sin base de datos.
+ */
+export declare const cleanPath: (path: string) => string;
+export declare const parentOf: (path: string) => string;
+export declare const nameOf: (path: string) => string;
+/** Une una carpeta y un nombre; una «/» dentro del nombre se vuelve guion (como en la biblioteca). */
+export declare const joinPath: (parent: string, name: string) => string;
+/** ¿`path` es `base` o está dentro de ella? La raíz nunca está «bajo» una carpeta. */
+export declare const isUnder: (path: string, base: string) => boolean;
+export declare const renamePath: (path: string, from: string, to: string) => string;
+/** Árbol completo: cada ruta con sus ancestros, sin raíz ni duplicados, en orden alfabético. */
+export declare const folderTree: (paths: string[]) => string[];

package/dist/server/src/templates/validate.d.ts

@@ -0,0 +1,23 @@
+/** Entrada inválida: el controlador la responde como 400. */
+export declare class TemplateInputError extends Error {
+}
+/**
+ * Tipos de capa del editor. Contrato compartido con el admin: `layerTypes.test.ts` del admin lo
+ * compara con `LayerType` para que no se desincronicen (diseño S4.6, D3).
+ */
+export declare const LAYER_TYPES: readonly ["text", "list", "quote", "rect", "shape", "badge", "logo", "image", "icon", "avatar", "qr"];
+export interface TemplateInput {
+    name: string;
+    folder: string;
+    width: number;
+    height: number;
+    background: string;
+    safeMargin: number;
+    gridUnit: number;
+    layers: Record<string, unknown>[];
+    baseId?: string;
+}
+/** Valida y normaliza un template completo (crear). Descarta campos desconocidos. */
+export declare const validateTemplate: (input: unknown) => TemplateInput;
+/** Valida solo los campos presentes (actualizar). */
+export declare const validateTemplatePatch: (input: unknown) => Partial<TemplateInput>;

package/dist/server/src/utils/folders.d.ts

@@ -0,0 +1,15 @@
+import type { Core } from '@strapi/strapi';
+/** Ruta válida de carpeta en Strapi: ids separados por diagonal (`/44/45`). */
+export declare const hasValidPath: (path: string) => boolean;
+/**
+ * Corrige el `path` de las carpetas con ese nombre cuyo `path` no cumple el formato de Strapi. El
+ * plugin creaba «Generated» con `path: '/generated'` (diseño S4.3); Strapi calcula `/<pathId>` bajo
+ * la ruta de la carpeta superior. Idempotente: las carpetas válidas no se tocan.
+ */
+export declare const repairFolderPaths: (strapi: Core.Strapi, name: string) => Promise<{
+    id: number;
+    from: string;
+    to: string;
+}[]>;
+/** Id de la carpeta de la raíz con ese nombre; la crea con el folder service de Strapi si falta. */
+export declare const ensureFolder: (strapi: Core.Strapi, name: string) => Promise<number>;

package/dist/server/src/utils/geminiClient.d.ts

@@ -0,0 +1,24 @@
+import { GoogleGenAI } from '@google/genai';
+import type { Backend } from '../image-studio/geminiConfig';
+/** Región de Vertex AI: `global` (decisión de Israel, S5.1). Nano Banana 2 no está en la región de México. */
+export declare const VERTEX_LOCATION = "global";
+export interface GeminiClient {
+    ai: GoogleGenAI;
+    backend: Backend;
+}
+interface ClientInput {
+    /** JSON guardado en el plugin store (`VERTEX_SERVICE_ACCOUNT`), o null. */
+    serviceAccount: unknown;
+    /** Llave de la Gemini API (entorno o plugin store), o null. */
+    apiKey: unknown;
+    /** El video (Veo) usa la llave aunque haya cuenta de servicio (D7). */
+    allowVertex?: boolean;
+}
+type GenAIConstructor = new (options: ConstructorParameters<typeof GoogleGenAI>[0]) => GoogleGenAI;
+/**
+ * Crea el cliente de Google y dice con qué backend (S5.1): con cuenta de servicio, Vertex AI en `global`; si no,
+ * la llave de la Gemini API. Las credenciales nunca aparecen en los errores. Si Vertex falla después, el error
+ * llega tal cual: no se cae a la llave en silencio (D9).
+ */
+export declare const createGeminiClient: ({ serviceAccount, apiKey, allowVertex }: ClientInput, Ctor?: GenAIConstructor) => GeminiClient;
+export {};

package/dist/server/src/utils/secrets.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Estado público de una credencial guardada: si existe y sus últimos 4 caracteres, para que el
+ * panel pueda identificarla sin recibir nunca el valor completo.
+ */
+export interface MaskedSecret {
+    configured: boolean;
+    last4: string | null;
+}
+export declare const maskSecret: (value: unknown) => MaskedSecret;

package/dist/server/src/utils/serviceAccount.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Cuenta de servicio de Google Cloud para Vertex AI (S5.1). Un admin pega su JSON en Ajustes y se guarda
+ * en el plugin store (decisión de Israel). Se conserva solo lo que usa el cliente; los mensajes de error
+ * nombran campos, nunca repiten el contenido: la llave privada es un secreto.
+ */
+/** Clave de la cuenta de servicio en el plugin store (S5.1, D8). */
+export declare const VERTEX_KEY = "VERTEX_SERVICE_ACCOUNT";
+export interface ServiceAccount {
+    projectId: string;
+    clientEmail: string;
+    privateKey: string;
+}
+export type ParseResult = {
+    ok: true;
+    account: ServiceAccount;
+} | {
+    ok: false;
+    message: string;
+};
+/** Estado público para `GET /config`: proyecto y correo, nunca la llave. */
+export interface PublicServiceAccount {
+    configured: boolean;
+    projectId: string | null;
+    clientEmail: string | null;
+}
+export declare const parseServiceAccount: (value: unknown) => ParseResult;
+/** JSON mínimo que se guarda en el store: lo que `parseServiceAccount` vuelve a leer. */
+export declare const storedServiceAccount: (account: ServiceAccount) => string;
+export declare const publicServiceAccount: (stored: unknown) => PublicServiceAccount;

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.4.4",
+  "version": "0.6.0",
   "keywords": [],
   "type": "commonjs",
   "publishConfig": {
@@ -23,27 +23,34 @@
     }
   },
   "files": [
-    "dist"
+    "dist",
+    "static"
   ],
   "scripts": {
     "build": "strapi-plugin build",
     "watch": "strapi-plugin watch",
     "watch:link": "strapi-plugin watch:link",
     "verify": "strapi-plugin verify",
+    "test": "vitest run",
     "changeset": "changeset",
     "publish:packages": "changeset publish",
     "version:packages": "changeset version",
     "release": "npm run build && changeset publish",
-    "test:ts:front": "run -T tsc -p admin/tsconfig.json",
-    "test:ts:back": "run -T tsc -p server/tsconfig.json",
+    "test:ts": "npm run test:ts:front && npm run test:ts:back",
+    "test:ts:front": "tsc --noEmit -p admin/tsconfig.json",
+    "test:ts:back": "tsc --noEmit -p server/tsconfig.json",
     "prepare": "husky"
   },
   "dependencies": {
-    "@google/genai": "^1.30.0",
+    "@google/genai": "^1.49.0",
+    "@radix-ui/react-tooltip": "1.0.7",
     "@reduxjs/toolkit": "^1.9.7",
-    "@strapi/design-system": "^2.0.0-rc.30",
-    "@strapi/icons": "^2.0.0-rc.30",
+    "@strapi/design-system": "^2.2.3",
+    "@strapi/icons": "^2.2.3",
     "formik": "^2.4.9",
+    "html-to-image": "^1.11.13",
+    "onnxruntime-web": "1.30.0",
+    "qrcode-generator": "^2.0.4",
     "react-intl": "^7.1.14",
     "react-redux": "^8.1.3",
     "yup": "^1.7.1"
@@ -54,18 +61,24 @@
     "@commitlint/cli": "^20.3.1",
     "@commitlint/config-conventional": "^20.3.1",
     "@strapi/sdk-plugin": "^5.4.0",
-    "@strapi/strapi": "^5.33.3",
-    "@strapi/typescript-utils": "^5.33.3",
+    "@strapi/strapi": "^5.51.0",
+    "@strapi/typescript-utils": "^5.51.0",
+    "@testing-library/jest-dom": "^6.9.1",
+    "@testing-library/react": "^16.3.3",
+    "@testing-library/user-event": "^14.6.7",
     "@types/react": "^18",
     "@types/react-dom": "^18",
+    "@vitejs/plugin-react": "^5.2.0",
     "cz-conventional-changelog": "^3.3.0",
     "husky": "^9.1.7",
+    "jsdom": "^29.1.1",
     "prettier": "^3.6.2",
     "react": "^18",
     "react-dom": "^18",
     "react-router-dom": "^6.30.2",
     "styled-components": "^6.1.19",
-    "typescript": "^5.9.3"
+    "typescript": "^5.9.3",
+    "vitest": "^3.2.7"
   },
   "peerDependencies": {
     "@strapi/sdk-plugin": "^5.3.2",

package/static/background-worker.d.mts

@@ -0,0 +1,15 @@
+/** Tipos del worker de «Quitar fondo» (`background-worker.mjs`). */
+export declare const MODEL_URL: string;
+export declare const ORT_DIR: string;
+export declare const INPUT_SIZE: number;
+export declare const toInputTensor: (rgba: Uint8ClampedArray, width: number, height: number) => Float32Array;
+export declare const normalizeMask: (probs: Float32Array) => Float32Array;
+
+type WorkerIn = { type: 'load' } | { type: 'run'; id: number; rgba: ArrayBuffer };
+interface Deps {
+  post: (data: Record<string, unknown>, transfer?: Transferable[]) => void;
+  loadOrt: () => Promise<any>;
+  hasWebGPU: () => Promise<boolean>;
+}
+export declare const handleMessage: (msg: WorkerIn, deps: Deps) => Promise<void>;
+export declare const resetWorker: () => void;

package/static/background-worker.mjs

@@ -0,0 +1,87 @@
+/**
+ * Worker de «Quitar fondo» (S4.17, ADR-007). El CMS lo sirve desde `/ort/` junto a onnxruntime-web
+ * (lo copia `npm run assets:image-studio` de web-cms desde este paquete), así la inferencia no
+ * bloquea el panel. Recibe los píxeles a 1024 × 1024, corre ISNet con WebGPU (o WASM si el navegador
+ * no tiene WebGPU) y devuelve la máscara 0–1. El escalado al tamaño original y el alfa los hace el panel.
+ *
+ * Mensajes: `{ type: 'load' }` → `status` / `ready` | `error`; `{ type: 'run', id, rgba }` → `mask` | `error`.
+ */
+export const MODEL_URL = '/models/isnet/model.onnx';
+export const ORT_DIR = '/ort/';
+export const INPUT_SIZE = 1024;
+
+/** RGBA → tensor NCHW `[1, 3, h, w]` con la normalización del modelo: (x − 128) / 256. El alfa se descarta. */
+export const toInputTensor = (rgba, width, height) => {
+  const plane = width * height;
+  const out = new Float32Array(3 * plane);
+  for (let i = 0; i < plane; i++) {
+    for (let c = 0; c < 3; c++) out[c * plane + i] = (rgba[4 * i + c] - 128) / 256;
+  }
+  return out;
+};
+
+/** Probabilidades del modelo → máscara estirada a 0–1 (mín–máx, como rembg). */
+export const normalizeMask = (probs) => {
+  let min = Infinity;
+  let max = -Infinity;
+  for (const v of probs) {
+    if (v < min) min = v;
+    if (v > max) max = v;
+  }
+  const range = max - min;
+  const out = new Float32Array(probs.length);
+  if (range > 1e-6) for (let i = 0; i < probs.length; i++) out[i] = (probs[i] - min) / range;
+  return out;
+};
+
+let session = null;
+let ortModule = null;
+
+/** Solo para pruebas. */
+export const resetWorker = () => {
+  session = null;
+  ortModule = null;
+};
+
+/**
+ * Atiende un mensaje. Las dependencias llegan por parámetro para probarlo sin worker ni GPU.
+ * @param {{ type: 'load' } | { type: 'run', id: number, rgba: ArrayBuffer }} msg
+ */
+export const handleMessage = async (msg, { post, loadOrt, hasWebGPU }) => {
+  if (msg.type === 'load') {
+    try {
+      post({ type: 'status', status: 'Descargando modelo…' });
+      const backend = (await hasWebGPU()) ? 'webgpu' : 'wasm';
+      ortModule = await loadOrt();
+      ortModule.env.wasm.wasmPaths = ORT_DIR;
+      // Sin aislamiento cross-origin (COEP apagada en el CMS) WASM corre en un solo hilo.
+      ortModule.env.wasm.numThreads = 1;
+      session = await ortModule.InferenceSession.create(MODEL_URL, { executionProviders: [backend], logSeverityLevel: 3 });
+      return post({ type: 'ready', backend });
+    } catch (err) {
+      session = null;
+      return post({ type: 'error', message: String(err?.message ?? err) });
+    }
+  }
+  if (msg.type === 'run') {
+    try {
+      if (!session) throw new Error('El modelo no está cargado.');
+      const input = new ortModule.Tensor('float32', toInputTensor(new Uint8ClampedArray(msg.rgba), INPUT_SIZE, INPUT_SIZE), [1, 3, INPUT_SIZE, INPUT_SIZE]);
+      const result = await session.run({ [session.inputNames[0]]: input });
+      const mask = normalizeMask(result[session.outputNames[0]].data);
+      return post({ type: 'mask', id: msg.id, mask: mask.buffer }, [mask.buffer]);
+    } catch (err) {
+      return post({ type: 'error', id: msg.id, message: String(err?.message ?? err) });
+    }
+  }
+};
+
+// Solo dentro de un worker (en las pruebas este módulo se importa como uno normal).
+if (typeof WorkerGlobalScope !== 'undefined' && self instanceof WorkerGlobalScope) {
+  const deps = {
+    post: (data, transfer) => self.postMessage(data, transfer ?? []),
+    loadOrt: () => import(`${ORT_DIR}ort.webgpu.bundle.min.mjs`),
+    hasWebGPU: async () => Boolean(self.navigator.gpu && (await self.navigator.gpu.requestAdapter().catch(() => null))),
+  };
+  self.onmessage = (e) => handleMessage(e.data, deps);
+}