n8n-nodes-wa-gateway 0.1.0

package/README.md

@@ -0,0 +1,38 @@
+# n8n-nodes-wa-gateway
+
+Node comunitário do n8n para o [wa-gateway](../../README.md).
+
+Dois nodes:
+
+| Node | Pra quê |
+|---|---|
+| **wa-gateway** | Enviar texto/imagem/documento/vídeo/áudio/localização/enquete, reagir, encaminhar, criar/gerenciar sessões, grupos, contatos, ler histórico. Aceita **binário do nó anterior** (converte pra base64 sozinho). |
+| **wa-gateway Trigger** | Recebe eventos de uma sessão. Ao ativar o workflow, **registra a URL do webhook na config da sessão automaticamente** (e remove ao desativar). Valida HMAC-SHA256 se você definir um segredo. |
+
+## Instalar
+
+**Pelo painel do n8n** (Settings → Community Nodes → Install): `n8n-nodes-wa-gateway`
+
+**Manual / dev:**
+```bash
+cd clients/n8n
+npm install
+npm run build
+# copie a pasta dist para ~/.n8n/custom/  (ou use N8N_CUSTOM_EXTENSIONS)
+```
+
+## Credencial
+
+`wa-gateway API`:
+- **Base URL** — `https://seu-gateway.exemplo.com`
+- **API Key** — a `API_KEY` do `.env` ou uma chave da tabela `api_keys`
+
+## Exemplos
+
+**Responder mensagem com IA:**
+`wa-gateway Trigger` (events: `message`) → `AI Agent` → `wa-gateway` (Mensagem · Enviar texto, chatId = `{{$json.payload.chatId}}`, text = `{{$json.output}}`).
+
+**Enviar uma imagem que veio de um HTTP Request / Google Drive:**
+node anterior produz binário na propriedade `data` → `wa-gateway` (Mensagem · Enviar imagem, Fonte da mídia = *Binário do nó anterior*).
+
+**Anti-ban:** marque *Enfileirar* nos envios pra passar pela fila com pacing por número.

package/dist/credentials/WaGatewayApi.credentials.d.ts

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

package/dist/credentials/WaGatewayApi.credentials.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WaGatewayApi = void 0;
+class WaGatewayApi {
+    constructor() {
+        this.name = 'waGatewayApi';
+        this.displayName = 'wa-gateway API';
+        this.documentationUrl = 'https://github.com/fdsriopreto-code/wa-gateway';
+        this.properties = [
+            {
+                displayName: 'Base URL',
+                name: 'baseUrl',
+                type: 'string',
+                default: 'http://localhost:3000',
+                placeholder: 'https://seu-gateway.exemplo.com',
+                required: true,
+            },
+            {
+                displayName: 'API Key',
+                name: 'apiKey',
+                type: 'string',
+                typeOptions: { password: true },
+                default: '',
+                required: true,
+                description: 'Vai no header X-Api-Key. A master key do .env funciona.',
+            },
+        ];
+        this.authenticate = {
+            type: 'generic',
+            properties: {
+                headers: {
+                    'X-Api-Key': '={{$credentials.apiKey}}',
+                },
+            },
+        };
+        this.test = {
+            request: {
+                baseURL: '={{$credentials.baseUrl.replace(/\\/$/, "")}}',
+                url: '/api/version',
+            },
+        };
+    }
+}
+exports.WaGatewayApi = WaGatewayApi;

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

@@ -0,0 +1,6 @@
+import type { IExecuteFunctions, INodeExecutionData, INodeType, INodeTypeDescription } from 'n8n-workflow';
+/** node ------------------------------------------------------------------- */
+export declare class WaGateway implements INodeType {
+    description: INodeTypeDescription;
+    execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]>;
+}

package/dist/nodes/WaGateway/WaGateway.node.js

@@ -0,0 +1,264 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WaGateway = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+/** helpers ------------------------------------------------------------------ */
+async function mediaToBase64(c) {
+    const source = c.get('mediaSource', 'binary');
+    if (source === 'base64') {
+        return { data: c.get('data'), mimetype: c.get('mimetype') || undefined, filename: c.get('filename') || undefined };
+    }
+    if (source === 'url') {
+        const url = c.get('url');
+        const buf = (await c.fn.helpers.httpRequest({ method: 'GET', url, encoding: 'arraybuffer' }));
+        return { data: Buffer.from(buf).toString('base64'), mimetype: undefined, filename: c.get('filename') || undefined };
+    }
+    // binary (default)
+    const prop = c.get('binaryProperty', 'data') || 'data';
+    const bin = c.fn.helpers.assertBinaryData(c.i, prop);
+    const buf = await c.fn.helpers.getBinaryDataBuffer(c.i, prop);
+    return { data: buf.toString('base64'), mimetype: bin.mimeType, filename: bin.fileName };
+}
+const S = (c) => encodeURIComponent(c.get('session'));
+const JIDp = (c) => encodeURIComponent(c.get('groupJid'));
+/** operation table -------------------------------------------------------- */
+const OPS = [
+    // ---- Session
+    { resource: 'session', operation: 'list', method: 'GET', path: () => '/api/sessions' },
+    { resource: 'session', operation: 'get', method: 'GET', path: (c) => `/api/sessions/${S(c)}` },
+    { resource: 'session', operation: 'create', method: 'POST', path: () => '/api/sessions',
+        body: (c) => ({ name: c.get('name'), start: c.get('start', true), config: c.get('config', undefined) }) },
+    { resource: 'session', operation: 'start', method: 'POST', path: (c) => `/api/sessions/${S(c)}/start` },
+    { resource: 'session', operation: 'stop', method: 'POST', path: (c) => `/api/sessions/${S(c)}/stop` },
+    { resource: 'session', operation: 'restart', method: 'POST', path: (c) => `/api/sessions/${S(c)}/restart` },
+    { resource: 'session', operation: 'logout', method: 'POST', path: (c) => `/api/sessions/${S(c)}/logout` },
+    { resource: 'session', operation: 'qr', method: 'GET', path: (c) => `/api/${S(c)}/auth/qr` },
+    { resource: 'session', operation: 'pairCode', method: 'POST', path: (c) => `/api/sessions/${S(c)}/auth/pair-code`,
+        body: (c) => ({ phone: String(c.get('phone')).replace(/\D/g, '') }) },
+    { resource: 'session', operation: 'me', method: 'GET', path: (c) => `/api/${S(c)}/me` },
+    // ---- Message
+    { resource: 'message', operation: 'sendText', method: 'POST', path: () => '/api/sendText',
+        body: (c) => ({ session: c.get('session'), chatId: c.get('chatId'), text: c.get('text'), linkPreview: c.get('linkPreview', false), ...queue(c) }) },
+    { resource: 'message', operation: 'sendLocation', method: 'POST', path: () => '/api/sendLocation',
+        body: (c) => ({ session: c.get('session'), chatId: c.get('chatId'), latitude: c.get('latitude'), longitude: c.get('longitude'), name: c.get('name', ''), ...queue(c) }) },
+    { resource: 'message', operation: 'sendPoll', method: 'POST', path: () => '/api/sendPoll',
+        body: (c) => ({ session: c.get('session'), chatId: c.get('chatId'), name: c.get('pollName'), options: String(c.get('pollOptions')).split('\n').map((x) => x.trim()).filter(Boolean), selectable: c.get('selectable', 1), ...queue(c) }) },
+    { resource: 'message', operation: 'react', method: 'POST', path: () => '/api/reaction',
+        body: (c) => ({ session: c.get('session'), chatId: c.get('chatId'), messageId: c.get('messageId'), emoji: c.get('emoji', ''), fromMe: c.get('fromMe', false) }) },
+    { resource: 'message', operation: 'forward', method: 'POST', path: () => '/api/forwardMessage',
+        body: (c) => ({ session: c.get('session'), toChatId: c.get('chatId'), messageId: c.get('messageId') }) },
+    // media (sendImage / sendFile / sendVideo / sendAudio) resolvido no execute
+    // ---- Group
+    { resource: 'group', operation: 'list', method: 'GET', path: (c) => `/api/groups?session=${S(c)}` },
+    { resource: 'group', operation: 'get', method: 'GET', path: (c) => `/api/groups/${JIDp(c)}?session=${S(c)}` },
+    { resource: 'group', operation: 'create', method: 'POST', path: () => '/api/groups',
+        body: (c) => ({ session: c.get('session'), name: c.get('name'), participants: lines(c, 'participants') }) },
+    { resource: 'group', operation: 'participants', method: 'POST', path: (c) => `/api/groups/${JIDp(c)}/participants`,
+        body: (c) => ({ session: c.get('session'), action: c.get('action'), participants: lines(c, 'participants') }) },
+    { resource: 'group', operation: 'setName', method: 'PUT', path: (c) => `/api/groups/${JIDp(c)}/name`,
+        body: (c) => ({ session: c.get('session'), name: c.get('name') }) },
+    { resource: 'group', operation: 'inviteLink', method: 'GET', path: (c) => `/api/groups/${JIDp(c)}/invite-link?session=${S(c)}` },
+    // ---- Contact
+    { resource: 'contact', operation: 'check', method: 'GET', path: (c) => `/api/contacts/check?session=${S(c)}&phone=${encodeURIComponent(c.get('phone'))}` },
+    { resource: 'contact', operation: 'info', method: 'GET', path: (c) => `/api/contacts/info?session=${S(c)}&jid=${encodeURIComponent(c.get('jid'))}` },
+    { resource: 'contact', operation: 'picture', method: 'GET', path: (c) => `/api/contacts/profile-picture?session=${S(c)}&jid=${encodeURIComponent(c.get('jid'))}` },
+    // ---- Chat / histórico
+    { resource: 'chat', operation: 'list', method: 'GET', path: (c) => `/api/chats?session=${S(c)}&limit=${c.get('limit', 100)}` },
+    { resource: 'chat', operation: 'history', method: 'GET', path: (c) => `/api/chats/${encodeURIComponent(c.get('chatId'))}/messages?session=${S(c)}&limit=${c.get('limit', 50)}` },
+];
+const queue = (c) => (c.get('enqueue', false) ? { enqueue: true, delay: c.get('delay', '') || undefined } : {});
+const lines = (c, n) => String(c.get(n, '')).split('\n').map((x) => x.trim()).filter(Boolean);
+/** node ------------------------------------------------------------------- */
+class WaGateway {
+    constructor() {
+        this.description = {
+            displayName: 'wa-gateway',
+            name: 'waGateway',
+            icon: 'file:waGateway.svg',
+            group: ['output'],
+            version: 1,
+            subtitle: '={{$parameter["operation"] + " · " + $parameter["resource"]}}',
+            description: 'Envia mensagens de WhatsApp e gerencia sessões pelo wa-gateway',
+            defaults: { name: 'wa-gateway' },
+            inputs: ['main'],
+            outputs: ['main'],
+            credentials: [{ name: 'waGatewayApi', required: true }],
+            properties: [
+                {
+                    displayName: 'Recurso', name: 'resource', type: 'options', noDataExpression: true,
+                    options: [
+                        { name: 'Mensagem', value: 'message' },
+                        { name: 'Sessão', value: 'session' },
+                        { name: 'Grupo', value: 'group' },
+                        { name: 'Contato', value: 'contact' },
+                        { name: 'Conversa (histórico)', value: 'chat' },
+                    ],
+                    default: 'message',
+                },
+                // operations per resource
+                opt('message', [
+                    ['Enviar texto', 'sendText'], ['Enviar imagem', 'sendImage'], ['Enviar documento', 'sendFile'],
+                    ['Enviar vídeo', 'sendVideo'], ['Enviar áudio', 'sendAudio'], ['Enviar localização', 'sendLocation'],
+                    ['Enviar enquete', 'sendPoll'], ['Reagir', 'react'], ['Encaminhar', 'forward'],
+                ], 'sendText'),
+                opt('session', [
+                    ['Criar', 'create'], ['Listar', 'list'], ['Detalhes', 'get'], ['Iniciar', 'start'], ['Parar', 'stop'],
+                    ['Reiniciar', 'restart'], ['Deslogar', 'logout'], ['QR (texto)', 'qr'], ['Parear por código', 'pairCode'], ['Meu perfil', 'me'],
+                ], 'create'),
+                opt('group', [
+                    ['Listar', 'list'], ['Detalhes', 'get'], ['Criar', 'create'], ['Participantes', 'participants'],
+                    ['Renomear', 'setName'], ['Link de convite', 'inviteLink'],
+                ], 'list'),
+                opt('contact', [['Checar número', 'check'], ['Info de perfil', 'info'], ['Foto de perfil', 'picture']], 'check'),
+                opt('chat', [['Listar conversas', 'list'], ['Histórico da conversa', 'history']], 'history'),
+                // ---- common fields
+                str('session', 'Sessão', { required: true, show: { resource: ['message', 'group', 'contact', 'chat'] } }),
+                str('session', 'Sessão', { required: true, show: { resource: ['session'], operation: ['get', 'start', 'stop', 'restart', 'logout', 'qr', 'pairCode', 'me'] } }),
+                str('chatId', 'Chat ID', { placeholder: '5599999999999@s.whatsapp.net', required: true,
+                    show: { resource: ['message'], operation: ['sendText', 'sendImage', 'sendFile', 'sendVideo', 'sendAudio', 'sendLocation', 'sendPoll', 'react', 'forward'] } }),
+                str('chatId', 'Chat ID', { required: true, show: { resource: ['chat'], operation: ['history'] } }),
+                str('text', 'Texto', { typeOptions: { rows: 3 }, required: true, show: { resource: ['message'], operation: ['sendText'] } }),
+                bool('linkPreview', 'Preview de link', false, { show: { resource: ['message'], operation: ['sendText'] } }),
+                // media
+                {
+                    displayName: 'Fonte da mídia', name: 'mediaSource', type: 'options',
+                    options: [
+                        { name: 'Binário do nó anterior', value: 'binary' },
+                        { name: 'URL pública', value: 'url' },
+                        { name: 'Base64 / data URI', value: 'base64' },
+                    ],
+                    default: 'binary',
+                    displayOptions: { show: { resource: ['message'], operation: ['sendImage', 'sendFile', 'sendVideo', 'sendAudio'] } },
+                },
+                str('binaryProperty', 'Propriedade binária', { default: 'data',
+                    show: { resource: ['message'], operation: ['sendImage', 'sendFile', 'sendVideo', 'sendAudio'], mediaSource: ['binary'] } }),
+                str('url', 'URL', { placeholder: 'https://…/arquivo.jpg', required: true,
+                    show: { resource: ['message'], operation: ['sendImage', 'sendFile', 'sendVideo', 'sendAudio'], mediaSource: ['url'] } }),
+                str('data', 'Base64', { typeOptions: { rows: 2 }, required: true,
+                    show: { resource: ['message'], operation: ['sendImage', 'sendFile', 'sendVideo', 'sendAudio'], mediaSource: ['base64'] } }),
+                str('caption', 'Legenda', { show: { resource: ['message'], operation: ['sendImage', 'sendFile', 'sendVideo'] } }),
+                str('filename', 'Nome do arquivo', { show: { resource: ['message'], operation: ['sendFile'] } }),
+                bool('voice', 'Nota de voz (PTT)', false, { show: { resource: ['message'], operation: ['sendAudio'] } }),
+                // location
+                num('latitude', 'Latitude', { required: true, show: { resource: ['message'], operation: ['sendLocation'] } }),
+                num('longitude', 'Longitude', { required: true, show: { resource: ['message'], operation: ['sendLocation'] } }),
+                str('name', 'Nome do lugar', { show: { resource: ['message'], operation: ['sendLocation'] } }),
+                // poll
+                str('pollName', 'Pergunta', { required: true, show: { resource: ['message'], operation: ['sendPoll'] } }),
+                str('pollOptions', 'Opções (uma por linha)', { typeOptions: { rows: 3 }, required: true, show: { resource: ['message'], operation: ['sendPoll'] } }),
+                num('selectable', 'Opções selecionáveis', { default: 1, show: { resource: ['message'], operation: ['sendPoll'] } }),
+                // react / forward
+                str('messageId', 'Message ID', { required: true, show: { resource: ['message'], operation: ['react', 'forward'] } }),
+                str('emoji', 'Emoji', { placeholder: '👍  (vazio = remove)', show: { resource: ['message'], operation: ['react'] } }),
+                bool('fromMe', 'A mensagem alvo é minha', false, { show: { resource: ['message'], operation: ['react'] } }),
+                // enqueue (anti-ban)
+                bool('enqueue', 'Enfileirar (pacing anti-ban)', false, { show: { resource: ['message'], operation: ['sendText', 'sendImage', 'sendFile', 'sendVideo', 'sendAudio', 'sendLocation', 'sendPoll'] } }),
+                str('delay', 'Delay extra', { placeholder: '30s', show: { resource: ['message'], operation: ['sendText', 'sendImage', 'sendFile', 'sendVideo', 'sendAudio', 'sendLocation', 'sendPoll'], enqueue: [true] } }),
+                // session create
+                str('name', 'Nome da sessão', { placeholder: 'default', required: true, show: { resource: ['session'], operation: ['create'] } }),
+                bool('start', 'Iniciar já', true, { show: { resource: ['session'], operation: ['create'] } }),
+                { displayName: 'Config (JSON)', name: 'config', type: 'json', default: '', description: 'webhooks / outbox / rawEvents (opcional)',
+                    displayOptions: { show: { resource: ['session'], operation: ['create'] } } },
+                str('phone', 'Telefone (E.164)', { placeholder: '5599999999999', required: true, show: { resource: ['session'], operation: ['pairCode'] } }),
+                // group
+                str('groupJid', 'Grupo (JID)', { placeholder: '...@g.us', required: true, show: { resource: ['group'], operation: ['get', 'participants', 'setName', 'inviteLink'] } }),
+                str('name', 'Nome', { required: true, show: { resource: ['group'], operation: ['create', 'setName'] } }),
+                str('participants', 'Participantes (um JID por linha)', { typeOptions: { rows: 3 }, show: { resource: ['group'], operation: ['create', 'participants'] } }),
+                { displayName: 'Ação', name: 'action', type: 'options', options: [
+                        { name: 'Adicionar', value: 'add' }, { name: 'Remover', value: 'remove' }, { name: 'Promover', value: 'promote' }, { name: 'Rebaixar', value: 'demote' },
+                    ], default: 'add', displayOptions: { show: { resource: ['group'], operation: ['participants'] } } },
+                // contact
+                str('phone', 'Telefones (vírgula)', { placeholder: '+5599...,+55...', required: true, show: { resource: ['contact'], operation: ['check'] } }),
+                str('jid', 'JID(s) (vírgula)', { placeholder: '...@s.whatsapp.net', required: true, show: { resource: ['contact'], operation: ['info', 'picture'] } }),
+                // chat
+                num('limit', 'Limite', { default: 50, show: { resource: ['chat'] } }),
+            ],
+        };
+    }
+    async execute() {
+        const items = this.getInputData();
+        const out = [];
+        const creds = await this.getCredentials('waGatewayApi');
+        const base = String(creds.baseUrl).replace(/\/$/, '');
+        for (let i = 0; i < items.length; i++) {
+            try {
+                const resource = this.getNodeParameter('resource', i);
+                const operation = this.getNodeParameter('operation', i);
+                const c = { fn: this, i, get: (n, d) => { try {
+                        return this.getNodeParameter(n, i, d);
+                    }
+                    catch {
+                        return d;
+                    } } };
+                let method = 'POST';
+                let path = '';
+                let body;
+                const mediaOp = ['sendImage', 'sendFile', 'sendVideo', 'sendAudio'];
+                if (resource === 'message' && mediaOp.includes(operation)) {
+                    const m = await mediaToBase64(c);
+                    path = '/api/' + operation;
+                    body = {
+                        session: c.get('session'), chatId: c.get('chatId'),
+                        data: m.data, mimetype: m.mimetype, filename: c.get('filename', m.filename) || m.filename,
+                        caption: c.get('caption', '') || undefined,
+                        voice: operation === 'sendAudio' ? c.get('voice', false) : undefined,
+                        ...queue(c),
+                    };
+                }
+                else {
+                    const op = OPS.find((o) => o.resource === resource && o.operation === operation);
+                    if (!op)
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `operação não suportada: ${resource}.${operation}`);
+                    method = op.method;
+                    path = op.path(c);
+                    body = op.body ? op.body(c) : undefined;
+                }
+                const res = await this.helpers.httpRequestWithAuthentication.call(this, 'waGatewayApi', {
+                    method,
+                    url: base + path,
+                    body,
+                    json: true,
+                });
+                out.push({ json: (res ?? {}), pairedItem: { item: i } });
+            }
+            catch (err) {
+                if (this.continueOnFail()) {
+                    out.push({ json: { error: err.message }, pairedItem: { item: i } });
+                    continue;
+                }
+                throw err;
+            }
+        }
+        return [out];
+    }
+}
+exports.WaGateway = WaGateway;
+/** property builders ---------------------------------------------------- */
+function opt(resource, entries, def) {
+    return {
+        displayName: 'Operação', name: 'operation', type: 'options', noDataExpression: true,
+        options: entries.map(([name, value]) => ({ name, value, action: name })),
+        default: def,
+        displayOptions: { show: { resource: [resource] } },
+    };
+}
+function str(name, displayName, o = {}) {
+    return {
+        displayName, name, type: 'string',
+        default: o.default ?? '', placeholder: o.placeholder, required: o.required,
+        typeOptions: o.typeOptions,
+        displayOptions: o.show ? { show: o.show } : undefined,
+    };
+}
+function num(name, displayName, o = {}) {
+    return {
+        displayName, name, type: 'number', default: o.default ?? 0, required: o.required,
+        displayOptions: o.show ? { show: o.show } : undefined,
+    };
+}
+function bool(name, displayName, def, o = {}) {
+    return {
+        displayName, name, type: 'boolean', default: def,
+        displayOptions: o.show ? { show: o.show } : undefined,
+    };
+}

package/dist/nodes/WaGateway/waGateway.svg

@@ -0,0 +1,5 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 100 100" width="100" height="100">
+  <rect width="100" height="100" rx="26" fill="#25d366"/>
+  <path d="M50 22c-15.5 0-28 12-28 26.8 0 5.2 1.6 10 4.3 14.1L22 78l15.9-4.1c3.8 2 8.1 3.1 12.6 3.1 15.5 0 28-12 28-26.8S65.5 22 50 22z" fill="#03130a" opacity=".92"/>
+  <text x="50" y="60" font-size="30" text-anchor="middle" fill="#25d366" font-family="sans-serif" font-weight="bold">w</text>
+</svg>

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

@@ -0,0 +1,16 @@
+import type { IHookFunctions, IWebhookFunctions, INodeType, INodeTypeDescription, IWebhookResponseData } from 'n8n-workflow';
+/**
+ * Trigger do wa-gateway: cria um webhook no n8n e o registra automaticamente
+ * na config da sessão ao ativar o workflow (e remove ao desativar).
+ */
+export declare class WaGatewayTrigger 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/WaGatewayTrigger/WaGatewayTrigger.node.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WaGatewayTrigger = void 0;
+const crypto_1 = require("crypto");
+/**
+ * Trigger do wa-gateway: cria um webhook no n8n e o registra automaticamente
+ * na config da sessão ao ativar o workflow (e remove ao desativar).
+ */
+class WaGatewayTrigger {
+    constructor() {
+        this.description = {
+            displayName: 'wa-gateway Trigger',
+            name: 'waGatewayTrigger',
+            icon: 'file:../WaGateway/waGateway.svg',
+            group: ['trigger'],
+            version: 1,
+            subtitle: '={{$parameter["session"] + " · " + ($parameter["events"] || "*")}}',
+            description: 'Recebe eventos de uma sessão do wa-gateway (mensagens, status, grupos…)',
+            defaults: { name: 'wa-gateway Trigger' },
+            inputs: [],
+            outputs: ['main'],
+            credentials: [{ name: 'waGatewayApi', required: true }],
+            webhooks: [
+                { name: 'default', httpMethod: 'POST', responseMode: 'onReceived', path: 'webhook' },
+            ],
+            properties: [
+                {
+                    displayName: 'Sessão', name: 'session', type: 'string', default: '', required: true,
+                    description: 'Nome da sessão que vai disparar o fluxo',
+                },
+                {
+                    displayName: 'Eventos', name: 'events', type: 'string', default: 'message',
+                    placeholder: 'message, session.status, group.update  ·  ou  *',
+                    description: 'Lista separada por vírgula. Aceita curinga: message.*, session.*, *',
+                },
+                {
+                    displayName: 'Segredo HMAC', name: 'secret', type: 'string', typeOptions: { password: true }, default: '',
+                    description: 'Se preenchido: assina o webhook e valida X-Webhook-Signature nas entradas',
+                },
+                {
+                    displayName: 'Registrar webhook na sessão automaticamente', name: 'autoRegister', type: 'boolean', default: true,
+                    description: 'Whether to add/remove esta URL em config.webhooks da sessão ao ativar/desativar',
+                },
+            ],
+        };
+        this.webhookMethods = {
+            default: {
+                async checkExists() {
+                    if (!this.getNodeParameter('autoRegister', true))
+                        return true;
+                    const url = this.getNodeWebhookUrl('default');
+                    const cfg = await getConfig.call(this);
+                    return (cfg.webhooks || []).some((w) => w.url === url);
+                },
+                async create() {
+                    if (!this.getNodeParameter('autoRegister', true))
+                        return true;
+                    const url = this.getNodeWebhookUrl('default');
+                    const events = splitCsv(this.getNodeParameter('events', 'message'));
+                    const secret = this.getNodeParameter('secret', '');
+                    const cfg = await getConfig.call(this);
+                    cfg.webhooks = (cfg.webhooks || []).filter((w) => w.url !== url);
+                    const wh = { url, events: events.length ? events : ['*'] };
+                    if (secret)
+                        wh.hmac = { secret };
+                    cfg.webhooks.push(wh);
+                    await putConfig.call(this, cfg);
+                    return true;
+                },
+                async delete() {
+                    if (!this.getNodeParameter('autoRegister', true))
+                        return true;
+                    const url = this.getNodeWebhookUrl('default');
+                    try {
+                        const cfg = await getConfig.call(this);
+                        cfg.webhooks = (cfg.webhooks || []).filter((w) => w.url !== url);
+                        await putConfig.call(this, cfg);
+                    }
+                    catch {
+                        /* sessão pode nem existir mais */
+                    }
+                    return true;
+                },
+            },
+        };
+    }
+    async webhook() {
+        const req = this.getRequestObject();
+        const body = req.body;
+        const secret = this.getNodeParameter('secret', '');
+        if (secret) {
+            const sig = req.headers['x-webhook-signature'] || '';
+            const raw = typeof req.rawBody === 'string' ? Buffer.from(req.rawBody) : req.rawBody || Buffer.from(JSON.stringify(body));
+            const expected = 'sha256=' + (0, crypto_1.createHmac)('sha256', secret).update(raw).digest('hex');
+            const a = Buffer.from(sig);
+            const b = Buffer.from(expected);
+            if (a.length !== b.length || !(0, crypto_1.timingSafeEqual)(a, b)) {
+                return { webhookResponse: { statusCode: 401, body: 'assinatura inválida' } };
+            }
+        }
+        // filtro local extra (o gateway já filtra, mas caso a config divirja)
+        const evName = body.event || '';
+        const wanted = splitCsv(this.getNodeParameter('events', ''));
+        if (wanted.length && !wanted.some((p) => matchEvent(p, evName))) {
+            return { noWebhookResponse: false, workflowData: [[]] };
+        }
+        return { workflowData: [this.helpers.returnJsonArray([body])] };
+    }
+}
+exports.WaGatewayTrigger = WaGatewayTrigger;
+async function base() {
+    const creds = await this.getCredentials('waGatewayApi');
+    return String(creds.baseUrl).replace(/\/$/, '');
+}
+async function getConfig() {
+    const session = this.getNodeParameter('session');
+    const res = (await this.helpers.httpRequestWithAuthentication.call(this, 'waGatewayApi', {
+        method: 'GET',
+        url: (await base.call(this)) + '/api/sessions/' + encodeURIComponent(session),
+        json: true,
+    }));
+    const cfg = res.config || {};
+    return { ...cfg, webhooks: Array.isArray(cfg.webhooks) ? cfg.webhooks : [] };
+}
+async function putConfig(cfg) {
+    const session = this.getNodeParameter('session');
+    await this.helpers.httpRequestWithAuthentication.call(this, 'waGatewayApi', {
+        method: 'PUT',
+        url: (await base.call(this)) + '/api/sessions/' + encodeURIComponent(session),
+        body: { config: cfg },
+        json: true,
+    });
+}
+function splitCsv(s) {
+    return (s || '').split(',').map((x) => x.trim()).filter(Boolean);
+}
+function matchEvent(pattern, name) {
+    if (pattern === '*' || pattern === name)
+        return true;
+    if (pattern.endsWith('.*'))
+        return name.startsWith(pattern.slice(0, -1)) || name === pattern.slice(0, -2);
+    return false;
+}

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "n8n-nodes-wa-gateway",
+  "version": "0.1.0",
+  "description": "Node n8n para o wa-gateway — API HTTP multi-sessão de WhatsApp",
+  "keywords": ["n8n-community-node-package", "n8n", "whatsapp", "wa-gateway", "whatsapp-api"],
+  "license": "MIT",
+  "author": {
+    "name": "fdsriopreto-code"
+  },
+  "homepage": "https://github.com/fdsriopreto-code/wa-gateway",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/fdsriopreto-code/wa-gateway.git",
+    "directory": "clients/n8n"
+  },
+  "engines": {
+    "node": ">=18.10"
+  },
+  "main": "index.js",
+  "scripts": {
+    "build": "tsc && cp nodes/WaGateway/*.svg dist/nodes/WaGateway/",
+    "dev": "tsc --watch",
+    "lint": "tsc --noEmit",
+    "prepublishOnly": "npm run build"
+  },
+  "files": ["dist"],
+  "n8n": {
+    "n8nNodesApiVersion": 1,
+    "credentials": ["dist/credentials/WaGatewayApi.credentials.js"],
+    "nodes": [
+      "dist/nodes/WaGateway/WaGateway.node.js",
+      "dist/nodes/WaGatewayTrigger/WaGatewayTrigger.node.js"
+    ]
+  },
+  "devDependencies": {
+    "@types/node": "^20",
+    "n8n-workflow": "*",
+    "typescript": "^5.4"
+  }
+}