n8n-nodes-manfuservers-wasap-api 0.0.0-stage → 1.1.0

package/CHANGELOG.md

@@ -0,0 +1,21 @@
+# Changelog — n8n-nodes-manfuservers-wasap-api
+
+## 1.0.1 — URL por defecto
+- La credencial Manfuservers Wasap API trae por defecto https://manfuservers.com:9000.
+
+## 1.0.0 — primera versión pública con el nombre Manfuservers Wasap
+Sustituye al paquete `n8n-nodes-manfuservers-wasap-api` (versión 1.0.0), que queda pendiente de deprecar.
+- Credencial **Manfuservers Wasap API**: URL del servidor + API key de cliente, con prueba de conexión.
+- Nodo **Manfuservers Wasap**: texto, respuesta, imagen, vídeo, audio, nota de voz, documento, descarga multimedia, contactos, grupos, estado de sesión y mensajes.
+- Nodo **Manfuservers Wasap Trigger**: mensajes, imagen, audio, nota de voz, vídeo, documento, grupos y estado de sesión mediante webhook firmado (HMAC-SHA256). Entrega al menos una vez: deduplicar por `messageId`.
+- Remitente con nombre y número cuando están disponibles.
+- Protección de la cuenta incluida en el servidor (espaciado, escritura simulada, topes por hora y día).
+- Icono propio de Manfuservers.
+
+### Requisitos del servidor (los gestiona Manfuservers)
+- Clave con permisos `read`, `send`, `media` (archivos) y `events` (trigger); `raw` opcional.
+- La URL de n8n del cliente debe estar autorizada en el servidor.
+
+### Estado de verificación
+- Compilación TypeScript sin errores; 4/4 tests del paquete.
+- Carga en n8n 2.18.5 aislado y prueba de credencial. Ver el informe de pruebas en el repositorio.

package/LICENSE

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) 2026 Manfuservers
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -1,3 +1,43 @@
-# Temporary Holding Version
+# n8n-nodes-manfuservers-wasap-api
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+**Manfuservers Wasap** conecta WhatsApp con n8n: mensajes, multimedia, contactos, grupos y eventos entrantes, usando una sola API key por cliente.
+
+## Qué necesitas
+1. La **URL del servidor** que te facilite Manfuservers (`https://manfuservers.com:9000`). Sin `/api` ni `/v1`.
+2. Tu **API Key** de cliente. La sesión de WhatsApp queda asociada en el servidor.
+3. Tu n8n con nodos de comunidad habilitados (Settings → Community Nodes).
+
+## Instalación
+1. En n8n: Settings → Community Nodes → Install.
+2. Escribe `n8n-nodes-manfuservers-wasap-api` y confirma el aviso de paquete no verificado.
+3. Crea la credencial **Manfuservers Wasap API** con URL y API Key y pulsa *Test*.
+
+## Nodos
+- **Manfuservers Wasap**: enviar texto, responder, enviar imagen/vídeo/audio/nota de voz/documento, descargar multimedia, buscar y obtener contactos, listar grupos, estado de la sesión y obtener mensajes.
+- **Manfuservers Wasap Trigger**: recibe mensajes entrantes (texto, imagen, audio, nota de voz, vídeo, documento, grupos, estado de sesión). Elige los tipos de evento en el desplegable.
+
+Cada evento de entrada incluye el nombre del remitente y su número cuando WhatsApp lo permite.
+
+## Multimedia: recibir y analizar en n8n
+1. **Trigger** → tipo *Imagen*, *Audio*, *Nota de voz* o *Documento*.
+2. **Manfuservers Wasap** → Recurso *Multimedia* → *Descargar multimedia*. Chat e ID del mensaje se rellenan desde el trigger; el archivo sale como binario.
+3. Analiza según el tipo:
+   - **Imagen:** un nodo de visión (OpenAI, Gemini o similar) con el binario.
+   - **Audio / nota de voz:** transcripción (Whisper u otro servicio de voz a texto).
+   - **Documento:** nodo *Extract From File* (PDF, Word, CSV, Excel).
+
+## Protección de la cuenta
+Los envíos se espacian automáticamente, muestran «escribiendo…» antes del mensaje y tienen topes por hora y por día. Es transparente: no requiere configuración. Si WhatsApp limita la cuenta, el nodo devuelve un error claro y no reintenta de inmediato.
+
+## Límites conocidos
+- Envíos de hasta 32 MB.
+- Un archivo puede caducar en WhatsApp: el nodo informa «ya no disponible».
+- Los eventos llegan al menos una vez: usa `messageId` para evitar duplicados.
+- Los contactos sin nombre ni número vinculado aparecen como «Sin nombre · sin número vinculado».
+
+## Actualizar o desinstalar
+- Actualizar: Settings → Community Nodes → buscar el paquete → Update.
+- Desinstalar: Settings → Community Nodes → … → Uninstall. Los workflows que lo usan dejan de tener nodo hasta reinstalar.
+
+## Licencia
+MIT. El paquete no incluye el motor de WhatsApp ni el servidor comercial.

package/dist/credentials/ManfuserversWasapApi.credentials.d.ts

@@ -0,0 +1,8 @@
+import type { ICredentialType, INodeProperties, IAuthenticateGeneric, ICredentialTestRequest } from 'n8n-workflow';
+export declare class ManfuserversWasapApi implements ICredentialType {
+    name: string;
+    displayName: string;
+    properties: INodeProperties[];
+    authenticate: IAuthenticateGeneric;
+    test: ICredentialTestRequest;
+}

package/dist/credentials/ManfuserversWasapApi.credentials.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ManfuserversWasapApi = void 0;
+class ManfuserversWasapApi {
+    name = 'manfuserversWasapApi';
+    displayName = 'Manfuservers Wasap API';
+    properties = [
+        { displayName: 'URL del servidor', name: 'serverUrl', type: 'string', default: 'https://manfuservers.com:9000', placeholder: 'https://manfuservers.com:9000', required: true, description: 'URL pública comercial, sin /api ni /v1; nunca el contenedor ni la clave maestra' },
+        { displayName: 'API Key', name: 'apiKey', type: 'string', typeOptions: { password: true }, default: '', required: true, description: 'Clave comercial de tu cliente. Un carácter es válido, pero inseguro; se recomienda una clave larga' },
+    ];
+    authenticate = { type: 'generic', properties: { headers: { 'X-Api-Key': '={{$credentials.apiKey}}' } } };
+    test = { request: { baseURL: '={{$credentials.serverUrl}}', url: '/v1/connection', method: 'GET' } };
+}
+exports.ManfuserversWasapApi = ManfuserversWasapApi;

package/dist/nodes/ManfuserversWasap/ManfuserversWasap.node.d.ts

@@ -0,0 +1,10 @@
+import type { IExecuteFunctions, INodeExecutionData, INodeType, INodeTypeDescription, ILoadOptionsFunctions, INodeListSearchResult } from 'n8n-workflow';
+export declare class ManfuserversWasap implements INodeType {
+    description: INodeTypeDescription;
+    methods: {
+        listSearch: {
+            searchRecipients(this: ILoadOptionsFunctions, filter?: string, paginationToken?: string): Promise<INodeListSearchResult>;
+        };
+    };
+    execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]>;
+}

package/dist/nodes/ManfuserversWasap/ManfuserversWasap.node.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ManfuserversWasap = void 0;
+const helpers_1 = require("./helpers");
+const show = (resource, operation) => ({ show: { resource, ...(operation ? { operation } : {}) } });
+const operations = (resource, options, value) => ({ displayName: 'Operación', name: 'operation', type: 'options', options, default: value, displayOptions: show([resource]), noDataExpression: true });
+const sendOps = ['sendText', 'reply', 'sendImage', 'sendVideo', 'sendAudio', 'sendVoice', 'sendDocument'];
+class ManfuserversWasap {
+    description = {
+        displayName: 'Manfuservers Wasap', name: 'manfuserversWasap', icon: 'file:manfuservers-wasap.svg', group: ['transform'], version: 1,
+        description: 'Enviar mensajes y archivos, buscar contactos/grupos y descargar multimedia con tu clave comercial',
+        defaults: { name: 'Manfuservers Wasap' }, inputs: ['main'], outputs: ['main'],
+        credentials: [{ name: 'manfuserversWasapApi', required: true }],
+        properties: [
+            { displayName: 'Recurso', name: 'resource', type: 'options', noDataExpression: true, options: [{ name: 'Mensaje', value: 'message' }, { name: 'Multimedia', value: 'media' }, { name: 'Contacto', value: 'contact' }, { name: 'Grupo', value: 'group' }, { name: 'Sesión', value: 'session' }], default: 'message' },
+            operations('message', [{ name: 'Enviar texto', value: 'sendText' }, { name: 'Responder a un mensaje', value: 'reply' }, { name: 'Obtener mensajes', value: 'getMessages' }], 'sendText'),
+            operations('media', [{ name: 'Enviar imagen', value: 'sendImage' }, { name: 'Enviar vídeo', value: 'sendVideo' }, { name: 'Enviar audio como archivo', value: 'sendAudio' }, { name: 'Enviar nota de voz', value: 'sendVoice' }, { name: 'Enviar documento', value: 'sendDocument' }, { name: 'Descargar multimedia', value: 'download' }], 'sendImage'),
+            operations('contact', [{ name: 'Buscar contactos', value: 'searchContacts' }, { name: 'Obtener información', value: 'contactInfo' }], 'searchContacts'),
+            operations('group', [{ name: 'Listar o buscar grupos', value: 'listGroups' }], 'listGroups'),
+            operations('session', [{ name: 'Consultar estado', value: 'sessionStatus' }], 'sessionStatus'),
+            { displayName: 'Tipo de destinatario', name: 'recipientType', type: 'options', options: [{ name: 'Contacto', value: 'contact' }, { name: 'Grupo', value: 'group' }, { name: 'Número internacional', value: 'phone' }], default: 'contact', displayOptions: { show: { operation: [...sendOps, 'getMessages'] } } },
+            { displayName: 'Destinatario', name: 'recipient', type: 'resourceLocator', default: { mode: 'list', value: '' }, required: true,
+                modes: [{ displayName: 'Buscar por nombre, número o ID', name: 'list', type: 'list', typeOptions: { searchListMethod: 'searchRecipients', searchable: true } }, { displayName: 'ID real o expresión', name: 'id', type: 'string', hint: 'ID real de contacto/grupo. Alternativa si el motor no dispone de agenda' }],
+                displayOptions: { show: { operation: [...sendOps, 'getMessages'], recipientType: ['contact', 'group'] } } },
+            { displayName: 'Número internacional', name: 'phone', type: 'string', default: '', placeholder: '+34600000000', description: 'Incluye país. Se verifica en el servidor antes de usar el chat real', displayOptions: { show: { operation: [...sendOps, 'getMessages'], recipientType: ['phone'] } } },
+            { displayName: 'Mensaje', name: 'text', type: 'string', typeOptions: { rows: 4 }, default: '', required: true, displayOptions: { show: { operation: ['sendText', 'reply'] } } },
+            { displayName: 'ID del mensaje al que responder', name: 'replyTo', type: 'string', default: '={{$json.messageId}}', required: true, displayOptions: { show: { operation: ['reply'] } } },
+            { displayName: 'Origen del archivo', name: 'fileSource', type: 'options', options: [{ name: 'Binario de otro nodo', value: 'binary' }, { name: 'URL pública directa', value: 'url' }, { name: 'Base64 (avanzado)', value: 'base64' }], default: 'binary', displayOptions: { show: { operation: ['sendImage', 'sendVideo', 'sendAudio', 'sendVoice', 'sendDocument'] } } },
+            { displayName: 'Propiedad binaria', name: 'binaryProperty', type: 'string', default: 'data', required: true, description: 'Ejemplo: data, procedente de Google Drive u otro nodo', displayOptions: { show: { operation: ['sendImage', 'sendVideo', 'sendAudio', 'sendVoice', 'sendDocument'], fileSource: ['binary'] } } },
+            { displayName: 'URL pública del archivo', name: 'fileUrl', type: 'string', default: '', required: true, description: 'Descarga directa pública, sin redirecciones ni direcciones privadas. Para Google Drive usa preferentemente su salida binaria', displayOptions: { show: { fileSource: ['url'], operation: ['sendImage', 'sendVideo', 'sendAudio', 'sendVoice', 'sendDocument'] } } },
+            { displayName: 'Datos Base64', name: 'base64', type: 'string', typeOptions: { rows: 3 }, default: '', required: true, displayOptions: { show: { fileSource: ['base64'], operation: ['sendImage', 'sendVideo', 'sendAudio', 'sendVoice', 'sendDocument'] } } },
+            { displayName: 'Nombre de archivo', name: 'filename', type: 'string', default: 'archivo.bin', required: true, displayOptions: { show: { fileSource: ['url', 'base64'], operation: ['sendImage', 'sendVideo', 'sendAudio', 'sendVoice', 'sendDocument'] } } },
+            { displayName: 'Tipo MIME', name: 'mimeType', type: 'string', default: 'application/octet-stream', required: true, displayOptions: { show: { fileSource: ['url', 'base64'], operation: ['sendImage', 'sendVideo', 'sendAudio', 'sendVoice', 'sendDocument'] } } },
+            { displayName: 'Pie de archivo', name: 'caption', type: 'string', default: '', displayOptions: { show: { operation: ['sendImage', 'sendVideo', 'sendAudio', 'sendVoice', 'sendDocument'] } } },
+            { displayName: 'ID del chat', name: 'chatId', type: 'string', default: '={{$json.chatId}}', required: true, displayOptions: { show: { operation: ['download'] } } },
+            { displayName: 'ID del mensaje o multimedia', name: 'messageId', type: 'string', default: '={{$json.messageId || $json.media.id}}', required: true, displayOptions: { show: { operation: ['download'] } } },
+            { displayName: 'Propiedad binaria de salida', name: 'outputBinaryProperty', type: 'string', default: 'data', required: true, displayOptions: { show: { operation: ['download'] } } },
+            { displayName: 'Búsqueda', name: 'search', type: 'string', default: '', description: 'Nombre, número o identificador real', displayOptions: { show: { operation: ['searchContacts', 'listGroups'] } } },
+            { displayName: 'ID real del contacto', name: 'contactId', type: 'string', default: '={{$json.senderId}}', required: true, displayOptions: { show: { operation: ['contactInfo'] } } },
+            { displayName: 'Opciones avanzadas', name: 'options', type: 'collection', placeholder: 'Añadir opción', default: {}, options: [
+                    { displayName: 'Límite de resultados', name: 'limit', type: 'number', default: 50, typeOptions: { minValue: 1, maxValue: 100 } },
+                    { displayName: 'Desplazamiento de página', name: 'offset', type: 'number', default: 0, typeOptions: { minValue: 0, maxValue: 100000 } },
+                    { displayName: 'Datos raw saneados', name: 'raw', type: 'boolean', default: false, description: 'Solo para obtener mensajes; requiere permiso raw' },
+                    { displayName: 'Máximo de descarga (MB)', name: 'downloadMaxMB', type: 'number', default: 32, typeOptions: { minValue: 1, maxValue: 100 } },
+                ] },
+        ],
+    };
+    methods = { listSearch: { async searchRecipients(filter, paginationToken) {
+                const type = this.getNodeParameter('recipientType');
+                const result = await (0, helpers_1.api)(this, 'GET', `/v1/${type === 'group' ? 'groups' : 'contacts'}?search=${encodeURIComponent(filter || '')}&limit=50&offset=${Number(paginationToken || 0)}`);
+                return { results: result.items.map((r) => ({ name: r.label, value: r.id })), ...(result.nextOffset !== null ? { paginationToken: String(result.nextOffset) } : {}) };
+            } } };
+    async execute() {
+        const input = this.getInputData();
+        const output = [];
+        for (let i = 0; i < input.length; i++) {
+            try {
+                const operation = this.getNodeParameter('operation', i);
+                const opts = this.getNodeParameter('options', i, {});
+                const limit = Number(opts.limit || 50), offset = Number(opts.offset || 0);
+                let result;
+                if (operation === 'sessionStatus')
+                    result = await (0, helpers_1.api)(this, 'GET', '/v1/session');
+                else if (operation === 'searchContacts' || operation === 'listGroups')
+                    result = await (0, helpers_1.api)(this, 'GET', `/v1/${operation === 'listGroups' ? 'groups' : 'contacts'}?search=${encodeURIComponent(this.getNodeParameter('search', i))}&limit=${limit}&offset=${offset}`);
+                else if (operation === 'contactInfo')
+                    result = await (0, helpers_1.api)(this, 'GET', '/v1/contacts/' + encodeURIComponent(this.getNodeParameter('contactId', i)));
+                else if (operation === 'download') {
+                    const chat = this.getNodeParameter('chatId', i), mid = this.getNodeParameter('messageId', i);
+                    const r = await (0, helpers_1.api)(this, 'GET', '/v1/media/' + encodeURIComponent(chat) + '/' + encodeURIComponent(mid), undefined, { json: false, encoding: 'arraybuffer', returnFullResponse: true, headers: { 'X-Manfuservers-Max-Bytes': String(Number(opts.downloadMaxMB || 32) * 1048576) } });
+                    const buffer = Buffer.from(r.body);
+                    const disposition = String(r.headers['content-disposition'] || '');
+                    const match = disposition.match(/filename\*=UTF-8''([^;]+)/i);
+                    const filename = match ? decodeURIComponent(match[1]) : 'archivo.bin';
+                    const mime = String(r.headers['content-type'] || 'application/octet-stream').split(';')[0];
+                    const property = this.getNodeParameter('outputBinaryProperty', i);
+                    const binary = await this.helpers.prepareBinaryData(buffer, filename, mime);
+                    output.push({ json: { messageId: mid, chatId: chat, filename, mimeType: mime, size: buffer.length }, binary: { [property]: binary }, pairedItem: { item: i } });
+                    continue;
+                }
+                else {
+                    const type = this.getNodeParameter('recipientType', i);
+                    let chat;
+                    if (type === 'phone') {
+                        const verified = await (0, helpers_1.api)(this, 'POST', '/v1/resolve-number', { phone: (0, helpers_1.manualPhone)(this.getNodeParameter('phone', i)) });
+                        chat = verified.chatId;
+                    }
+                    else {
+                        const locator = this.getNodeParameter('recipient', i);
+                        chat = locator.value;
+                    }
+                    if (!chat)
+                        throw new Error('Selecciona un destinatario o introduce su ID real');
+                    if (operation === 'getMessages')
+                        result = await (0, helpers_1.api)(this, 'GET', `/v1/messages/${encodeURIComponent(chat)}?limit=${limit}&offset=${offset}&raw=${opts.raw === true}`);
+                    else if (operation === 'sendText' || operation === 'reply')
+                        result = await (0, helpers_1.api)(this, 'POST', '/v1/messages/text', { chatId: chat, text: this.getNodeParameter('text', i), ...(operation === 'reply' ? { replyTo: this.getNodeParameter('replyTo', i) } : {}) });
+                    else {
+                        const source = this.getNodeParameter('fileSource', i);
+                        let file;
+                        if (source === 'binary') {
+                            const property = this.getNodeParameter('binaryProperty', i);
+                            const meta = input[i].binary?.[property];
+                            if (!meta)
+                                throw new Error('No existe la propiedad binaria indicada');
+                            const buffer = await this.helpers.getBinaryDataBuffer(i, property);
+                            if (buffer.length > 33554432)
+                                throw new Error('Archivo mayor que 32 MB; divide el archivo o configura un flujo específico');
+                            file = { data: buffer.toString('base64'), filename: meta.fileName || 'archivo.bin', mimetype: meta.mimeType || 'application/octet-stream' };
+                        }
+                        else
+                            file = { filename: this.getNodeParameter('filename', i), mimetype: this.getNodeParameter('mimeType', i), ...(source === 'url' ? { url: this.getNodeParameter('fileUrl', i) } : { data: this.getNodeParameter('base64', i) }) };
+                        const kinds = { sendImage: 'image', sendVideo: 'video', sendAudio: 'audio', sendVoice: 'voice', sendDocument: 'document' };
+                        if (!kinds[operation])
+                            throw new Error('Operación no compatible');
+                        result = await (0, helpers_1.api)(this, 'POST', '/v1/messages/' + kinds[operation], { chatId: chat, file, caption: this.getNodeParameter('caption', i) });
+                    }
+                }
+                // Pagination remains explicit instead of silently fetching an entire history.
+                output.push({ json: result, pairedItem: { item: i } });
+            }
+            catch (error) {
+                const detailRaw = error?.response?.body?.detail ?? error?.cause?.body?.detail ?? error?.description;
+                const detail = typeof detailRaw === 'string' ? detailRaw : null;
+                const message = detail || 'Operación no completada. Revisa permisos, conexión, sesión y campos; consulta PRUEBAS/LIMITACIONES para capacidades del motor';
+                if (this.continueOnFail()) {
+                    output.push({ json: { error: message }, pairedItem: { item: i } });
+                    continue;
+                }
+                throw new Error('Elemento ' + (i + 1) + ': ' + message);
+            }
+        }
+        return [output];
+    }
+}
+exports.ManfuserversWasap = ManfuserversWasap;

package/dist/nodes/ManfuserversWasap/ManfuserversWasapChatTrigger.node.d.ts

@@ -0,0 +1,17 @@
+import type { INodeType, INodeTypeDescription, IHookFunctions, IWebhookFunctions, IWebhookResponseData, ILoadOptionsFunctions, INodeListSearchResult } from 'n8n-workflow';
+export declare class ManfuserversWasapChatTrigger implements INodeType {
+    description: INodeTypeDescription;
+    methods: {
+        listSearch: {
+            searchChats(this: ILoadOptionsFunctions, filter?: string, paginationToken?: string): Promise<INodeListSearchResult>;
+        };
+    };
+    webhookMethods: {
+        default: {
+            checkExists(this: IHookFunctions): Promise<boolean>;
+            create(this: IHookFunctions): Promise<boolean>;
+            delete(this: IHookFunctions): Promise<boolean>;
+        };
+    };
+    webhook(this: IWebhookFunctions): Promise<IWebhookResponseData>;
+}

package/dist/nodes/ManfuserversWasap/ManfuserversWasapChatTrigger.node.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ManfuserversWasapChatTrigger = void 0;
+const helpers_1 = require("./helpers");
+// Dispara con cada mensaje nuevo de UN chat: recibido o enviado desde tu teléfono.
+class ManfuserversWasapChatTrigger {
+    description = {
+        displayName: 'Manfuservers Wasap: Mensaje en chat', name: 'manfuserversWasapChatTrigger', icon: 'file:manfuservers-wasap.svg', group: ['trigger'], version: 1,
+        description: 'Se dispara con cada mensaje nuevo de un chat concreto, también los que escribes desde tu teléfono',
+        defaults: { name: 'Mensaje en chat' }, inputs: [], outputs: ['main'],
+        credentials: [{ name: 'manfuserversWasapApi', required: true }],
+        webhooks: [{ name: 'default', httpMethod: 'POST', responseMode: 'onReceived', path: 'wasap-chat' }],
+        properties: [
+            { displayName: 'Tipo de chat', name: 'chatType', type: 'options', default: 'contact', options: [
+                    { name: 'Contacto', value: 'contact' }, { name: 'Grupo', value: 'group' }, { name: 'Número internacional', value: 'phone' }
+                ] },
+            { displayName: 'Chat', name: 'chat', type: 'resourceLocator', default: { mode: 'list', value: '' }, required: true,
+                modes: [{ displayName: 'Buscar por nombre o número', name: 'list', type: 'list', typeOptions: { searchListMethod: 'searchChats', searchable: true } }],
+                displayOptions: { show: { chatType: ['contact', 'group'] } } },
+            { displayName: 'Número internacional', name: 'phone', type: 'string', default: '', placeholder: '+34600000000', required: true,
+                description: 'Incluye el país. El servidor verifica el número antes de escuchar el chat', displayOptions: { show: { chatType: ['phone'] } } },
+            { displayName: 'Mensajes a escuchar', name: 'direction', type: 'options', default: 'all', options: [
+                    { name: 'Todos (recibidos y enviados)', value: 'all' },
+                    { name: 'Solo los que envío yo (desde mi teléfono)', value: 'out' },
+                    { name: 'Solo los que recibo', value: 'in' }
+                ] },
+            { displayName: 'Datos raw saneados', name: 'raw', type: 'boolean', default: false, description: 'Requiere permiso raw de la clave. Añade datos técnicos saneados' },
+        ],
+    };
+    methods = { listSearch: { async searchChats(filter, paginationToken) {
+                const type = this.getNodeParameter('chatType');
+                const result = await (0, helpers_1.api)(this, 'GET', `/v1/${type === 'group' ? 'groups' : 'contacts'}?search=${encodeURIComponent(filter || '')}&limit=50&offset=${Number(paginationToken || 0)}`);
+                return { results: result.items.map((r) => ({ name: r.label, value: r.id })), ...(result.nextOffset !== null ? { paginationToken: String(result.nextOffset) } : {}) };
+            } } };
+    webhookMethods = { default: {
+            async checkExists() {
+                const data = this.getWorkflowStaticData('node');
+                if (!data.subscriptionId)
+                    return false;
+                try {
+                    return (await (0, helpers_1.api)(this, 'GET', '/v1/subscriptions/' + data.subscriptionId)).active === true;
+                }
+                catch {
+                    return false;
+                }
+            },
+            async create() {
+                const callback = this.getNodeWebhookUrl('default');
+                if (!callback)
+                    throw new Error('Guarda el workflow para obtener su URL de webhook');
+                const type = this.getNodeParameter('chatType');
+                let chat;
+                if (type === 'phone') {
+                    const verified = await (0, helpers_1.api)(this, 'POST', '/v1/resolve-number', { phone: (0, helpers_1.manualPhone)(this.getNodeParameter('phone')) });
+                    chat = verified.chatId;
+                }
+                else {
+                    chat = this.getNodeParameter('chat').value;
+                }
+                if (!chat)
+                    throw new Error('Selecciona el chat que quieres escuchar');
+                const credentials = await this.getCredentials('manfuserversWasapApi');
+                const secret = (0, helpers_1.hookSecret)(String(credentials.apiKey), String(this.getWorkflow().id || 'new'), this.getNode().id);
+                const result = await (0, helpers_1.api)(this, 'POST', '/v1/subscriptions', {
+                    workflow: String(this.getWorkflow().id || 'new') + ':' + this.getNode().id, callback, secret,
+                    events: ['message'], raw: this.getNodeParameter('raw'), includeOwn: true,
+                    chatId: chat, direction: this.getNodeParameter('direction'),
+                });
+                this.getWorkflowStaticData('node').subscriptionId = result.id;
+                return true;
+            },
+            async delete() {
+                const data = this.getWorkflowStaticData('node');
+                if (data.subscriptionId) {
+                    try {
+                        await (0, helpers_1.api)(this, 'DELETE', '/v1/subscriptions/' + data.subscriptionId);
+                    }
+                    catch {
+                        // Una clave revocada no puede borrar; el servidor ya deja de entregar eventos.
+                    }
+                }
+                delete data.subscriptionId;
+                return true;
+            },
+        } };
+    async webhook() {
+        const response = this.getResponseObject();
+        try {
+            const credentials = await this.getCredentials('manfuserversWasapApi');
+            const secret = (0, helpers_1.hookSecret)(String(credentials.apiKey), String(this.getWorkflow().id || 'new'), this.getNode().id);
+            const request = this.getRequestObject();
+            const signature = String(request.headers['x-manfuservers-signature'] || '');
+            const body = this.getBodyData();
+            const message = (0, helpers_1.decodeEnvelope)(body, signature, secret);
+            const state = this.getWorkflowStaticData('node');
+            const previous = Array.isArray(state.deliveryIds) ? state.deliveryIds : [];
+            if (previous.includes(String(body.deliveryId))) {
+                response.status(200).json({ accepted: true, duplicate: true });
+                return { noWebhookResponse: true };
+            }
+            state.deliveryIds = [...previous, String(body.deliveryId)].slice(-500);
+            response.status(200).json({ accepted: true });
+            return { noWebhookResponse: true, workflowData: [this.helpers.returnJsonArray(message)] };
+        }
+        catch {
+            response.status(401).json({ error: 'Firma o evento no válido' });
+            return { noWebhookResponse: true };
+        }
+    }
+}
+exports.ManfuserversWasapChatTrigger = ManfuserversWasapChatTrigger;

package/dist/nodes/ManfuserversWasap/ManfuserversWasapTrigger.node.d.ts

@@ -0,0 +1,12 @@
+import type { INodeType, INodeTypeDescription, IHookFunctions, IWebhookFunctions, IWebhookResponseData } from 'n8n-workflow';
+export declare class ManfuserversWasapTrigger implements INodeType {
+    description: INodeTypeDescription;
+    webhookMethods: {
+        default: {
+            checkExists(this: IHookFunctions): Promise<boolean>;
+            create(this: IHookFunctions): Promise<boolean>;
+            delete(this: IHookFunctions): Promise<boolean>;
+        };
+    };
+    webhook(this: IWebhookFunctions): Promise<IWebhookResponseData>;
+}

package/dist/nodes/ManfuserversWasap/ManfuserversWasapTrigger.node.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ManfuserversWasapTrigger = void 0;
+const helpers_1 = require("./helpers");
+class ManfuserversWasapTrigger {
+    description = {
+        displayName: 'Manfuservers Wasap Trigger', name: 'manfuserversWasapTrigger', icon: 'file:manfuservers-wasap.svg', group: ['trigger'], version: 1,
+        description: 'Recibe mensajes y archivos de tu sesión mediante webhooks firmados, sin polling de WhatsApp',
+        defaults: { name: 'Manfuservers Wasap Trigger' }, inputs: [], outputs: ['main'],
+        credentials: [{ name: 'manfuserversWasapApi', required: true }],
+        webhooks: [{ name: 'default', httpMethod: 'POST', responseMode: 'onReceived', path: 'wasap' }],
+        properties: [
+            { displayName: 'Eventos', name: 'events', type: 'multiOptions', required: true, default: ['message'], options: [
+                    { name: 'Cualquier mensaje', value: 'message' }, { name: 'Imagen', value: 'image' }, { name: 'Audio', value: 'audio' },
+                    { name: 'Nota de voz', value: 'voice' }, { name: 'Vídeo', value: 'video' }, { name: 'Documento', value: 'document' },
+                    { name: 'Cualquier multimedia', value: 'media' }, { name: 'Mensaje en grupo', value: 'group' }, { name: 'Estado de sesión', value: 'session.status' },
+                ] },
+            { displayName: 'Modo avanzado (raw saneado)', name: 'raw', type: 'boolean', default: false, description: 'Requiere permiso raw. Mantiene la salida simple y añade raw sin claves ni datos de conexión internos' },
+            { displayName: 'Incluir mensajes propios', name: 'includeOwn', type: 'boolean', default: false, description: 'Puede provocar bucles de respuestas. Desactivado por defecto' },
+            { displayName: 'El administrador debe conectar los webhooks nativos y permitir el origen URL de n8n. Activar este workflow registra solo su suscripción; no reemplaza las demás.', name: 'notice', type: 'notice', default: '' },
+        ],
+    };
+    webhookMethods = { default: {
+            async checkExists() {
+                const data = this.getWorkflowStaticData('node');
+                if (!data.subscriptionId)
+                    return false;
+                try {
+                    return (await (0, helpers_1.api)(this, 'GET', '/v1/subscriptions/' + data.subscriptionId)).active === true;
+                }
+                catch {
+                    return false;
+                }
+            },
+            async create() {
+                const callback = this.getNodeWebhookUrl('default');
+                if (!callback)
+                    throw new Error('Guarda el workflow para obtener su URL de webhook');
+                const credentials = await this.getCredentials('manfuserversWasapApi');
+                const secret = (0, helpers_1.hookSecret)(String(credentials.apiKey), String(this.getWorkflow().id || 'new'), this.getNode().id);
+                const result = await (0, helpers_1.api)(this, 'POST', '/v1/subscriptions', {
+                    workflow: String(this.getWorkflow().id || 'new') + ':' + this.getNode().id, callback, secret,
+                    events: this.getNodeParameter('events'), raw: this.getNodeParameter('raw'), includeOwn: this.getNodeParameter('includeOwn'),
+                });
+                this.getWorkflowStaticData('node').subscriptionId = result.id;
+                return true;
+            },
+            async delete() {
+                const data = this.getWorkflowStaticData('node');
+                if (data.subscriptionId) {
+                    try {
+                        await (0, helpers_1.api)(this, 'DELETE', '/v1/subscriptions/' + data.subscriptionId);
+                    }
+                    catch {
+                        // A revoked key cannot delete. Backend already blocks delivery; admin can clean orphaned subscriptions.
+                    }
+                }
+                delete data.subscriptionId;
+                return true;
+            },
+        } };
+    async webhook() {
+        const response = this.getResponseObject();
+        try {
+            const credentials = await this.getCredentials('manfuserversWasapApi');
+            const secret = (0, helpers_1.hookSecret)(String(credentials.apiKey), String(this.getWorkflow().id || 'new'), this.getNode().id);
+            const request = this.getRequestObject();
+            const signature = String(request.headers['x-manfuservers-signature'] || '');
+            const body = this.getBodyData();
+            const message = (0, helpers_1.decodeEnvelope)(body, signature, secret);
+            if (message.fromMe && !this.getNodeParameter('includeOwn')) {
+                response.status(200).json({ accepted: true, filtered: true });
+                return { noWebhookResponse: true };
+            }
+            const state = this.getWorkflowStaticData('node');
+            const previous = Array.isArray(state.deliveryIds) ? state.deliveryIds : [];
+            if (previous.includes(String(body.deliveryId))) {
+                response.status(200).json({ accepted: true, duplicate: true });
+                return { noWebhookResponse: true };
+            }
+            state.deliveryIds = [...previous, String(body.deliveryId)].slice(-500);
+            response.status(200).json({ accepted: true });
+            return { noWebhookResponse: true, workflowData: [this.helpers.returnJsonArray(message)] };
+        }
+        catch {
+            response.status(401).json({ error: 'Firma o evento webhook no válido' });
+            return { noWebhookResponse: true };
+        }
+    }
+}
+exports.ManfuserversWasapTrigger = ManfuserversWasapTrigger;

package/dist/nodes/ManfuserversWasap/helpers.d.ts

@@ -0,0 +1,6 @@
+import type { IExecuteFunctions, ILoadOptionsFunctions, IHookFunctions, IWebhookFunctions, IHttpRequestOptions } from 'n8n-workflow';
+export type Context = IExecuteFunctions | ILoadOptionsFunctions | IHookFunctions | IWebhookFunctions;
+export declare function api(context: Context, method: string, path: string, body?: unknown, extra?: Partial<IHttpRequestOptions>): Promise<any>;
+export declare function manualPhone(value: string): string;
+export declare function hookSecret(key: string, workflow: string, node: string): string;
+export declare function decodeEnvelope(envelope: any, signature: string, secret: string): any;

package/dist/nodes/ManfuserversWasap/helpers.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.api = api;
+exports.manualPhone = manualPhone;
+exports.hookSecret = hookSecret;
+exports.decodeEnvelope = decodeEnvelope;
+const node_crypto_1 = require("node:crypto");
+async function api(context, method, path, body, extra = {}) {
+    const credentials = await context.getCredentials('manfuserversWasapApi');
+    const base = String(credentials.serverUrl).replace(/\/$/, '');
+    const url = new URL(base);
+    if (!['http:', 'https:'].includes(url.protocol) || url.username || url.password || url.search || url.hash || (url.pathname !== '/' && url.pathname !== ''))
+        throw new Error('URL del servidor no válida; usa solo origen y puerto');
+    return context.helpers.httpRequestWithAuthentication.call(context, 'manfuserversWasapApi', { method: method, url: base + path, body: body, json: true, timeout: 60000, disableFollowRedirect: true, ...extra });
+}
+function manualPhone(value) {
+    const phone = value.replace(/[ ()-]/g, '');
+    if (!/^\+?[1-9]\d{6,14}$/.test(phone))
+        throw new Error('Introduce un número internacional completo, con código de país. No se adivina el país');
+    return phone.replace(/^\+/, '');
+}
+function hookSecret(key, workflow, node) {
+    return (0, node_crypto_1.createHmac)('sha256', key).update('manfuservers-wasap:' + workflow + ':' + node).digest('hex');
+}
+function decodeEnvelope(envelope, signature, secret) {
+    if (!envelope || typeof envelope.deliveryId !== 'string' || !/^[a-f0-9-]{36}$/i.test(envelope.deliveryId) || typeof envelope.payload !== 'string' || envelope.payload.length > 1500000 || !/^[A-Za-z0-9+/]*={0,2}$/.test(envelope.payload))
+        throw new Error('Evento no válido');
+    const expected = (0, node_crypto_1.createHmac)('sha256', secret).update(envelope.deliveryId + '.' + envelope.payload).digest('hex');
+    if (!/^[a-f0-9]{64}$/i.test(signature) || !(0, node_crypto_1.timingSafeEqual)(Buffer.from(expected, 'hex'), Buffer.from(signature, 'hex')))
+        throw new Error('Firma webhook no válida');
+    return JSON.parse(Buffer.from(envelope.payload, 'base64').toString('utf8'));
+}

package/dist/nodes/ManfuserversWasap/manfuservers-wasap.svg

@@ -0,0 +1,20 @@
+<svg width="512" height="512" viewBox="0 0 512 512" fill="none" xmlns="http://www.w3.org/2000/svg">
+  <defs>
+    <linearGradient id="bg" x1="64" y1="40" x2="432" y2="472" gradientUnits="userSpaceOnUse">
+      <stop stop-color="#A78BFA"/>
+      <stop offset="0.55" stop-color="#60A5FA"/>
+      <stop offset="1" stop-color="#34D399"/>
+    </linearGradient>
+    <radialGradient id="glow" cx="0" cy="0" r="1" gradientUnits="userSpaceOnUse" gradientTransform="translate(256 120) rotate(90) scale(300)">
+      <stop stop-color="#FFFFFF" stop-opacity="0.35"/>
+      <stop offset="1" stop-color="#FFFFFF" stop-opacity="0"/>
+    </radialGradient>
+  </defs>
+  <rect x="24" y="24" width="464" height="464" rx="120" fill="#050510"/>
+  <rect x="40" y="40" width="432" height="432" rx="104" fill="url(#bg)"/>
+  <rect x="40" y="40" width="432" height="432" rx="104" fill="url(#glow)"/>
+  <path d="M176 146H336A56 56 0 0 1 392 202V262A56 56 0 0 1 336 318H240L170 370V318H176A56 56 0 0 1 120 262V202A56 56 0 0 1 176 146Z" fill="#050510"/>
+  <circle cx="200" cy="232" r="17" fill="url(#bg)"/>
+  <circle cx="256" cy="232" r="17" fill="url(#bg)"/>
+  <circle cx="312" cy="232" r="17" fill="url(#bg)"/>
+</svg>

package/package.json

@@ -1,6 +1,51 @@
 {
   "name": "n8n-nodes-manfuservers-wasap-api",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.1.0",
+  "description": "Manfuservers Wasap: WhatsApp para n8n: mensajes, multimedia, contactos, grupos, eventos y escucha de chats",
+  "license": "MIT",
+  "keywords": [
+    "n8n-community-node-package",
+    "whatsapp",
+    "manfuservers",
+    "wasap",
+    "n8n"
+  ],
+  "author": {
+    "name": "Manfuservers"
+  },
+  "main": "dist/nodes/ManfuserversWasap/ManfuserversWasap.node.js",
+  "files": [
+    "dist",
+    "LICENSE",
+    "README.md",
+    "CHANGELOG.md"
+  ],
+  "scripts": {
+    "build": "tsc && node scripts/copy-icons.cjs",
+    "test": "node --test tests/*.test.cjs",
+    "pack:check": "npm pack --dry-run"
+  },
+  "n8n": {
+    "n8nNodesApiVersion": 1,
+    "credentials": [
+      "dist/credentials/ManfuserversWasapApi.credentials.js"
+    ],
+    "nodes": [
+      "dist/nodes/ManfuserversWasap/ManfuserversWasap.node.js",
+      "dist/nodes/ManfuserversWasap/ManfuserversWasapTrigger.node.js",
+      "dist/nodes/ManfuserversWasap/ManfuserversWasapChatTrigger.node.js"
+    ]
+  },
+  "devDependencies": {
+    "n8n-workflow": "2.18.3",
+    "typescript": "5.9.3",
+    "@types/node": "24.10.0"
+  },
+  "engines": {
+    "node": ">=22.16"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  }
+}