n8n-nodes-aib 0.2.1

package/README.md

@@ -0,0 +1,55 @@
+# n8n-nodes-aib
+
+Nós do **Sistema AIB Digital** para o n8n — a experiência do Chatwoot,
+no nosso sistema: conecta uma credencial e escolhe conta e caixa
+dentro do nó.
+
+## O que vem
+
+- **Credencial "AIB Digital API"** — URL do sistema + chave (`aib_...`).
+  Com chave de **agência**, os dropdowns listam todas as contas.
+- **AIB Digital Trigger** — dispara em `mensagem.recebida` (e outros
+  eventos escolhíveis). Ao ativar o workflow, registra a URL de
+  webhook na conta sozinho; ao desativar, remove.
+- **AIB Digital** (ações) — enviar mensagem, listar conversas/mensagens,
+  mover card no funil (dropdown de etapas), pausar/religar IA,
+  atribuir atendente, atualizar contato. Habilitado como **ferramenta
+  de agente de IA** (`usableAsTool`): plugue direto num AI Agent.
+
+## Segurança
+
+O gatilho recebe o segredo da conta ao registrar o webhook e confere
+a assinatura `x-aib-signature` (HMAC-SHA256) de cada evento — evento
+com assinatura errada leva 401 e não acorda o fluxo.
+
+## Instalar num n8n self-hosted
+
+O pacote fica publicado no próprio sistema:
+`https://app.aibdigitall.com/n8n-nodes-aib.tgz`
+
+No servidor do n8n:
+
+```sh
+mkdir -p ~/.n8n/nodes && cd ~/.n8n/nodes
+npm install https://app.aibdigitall.com/n8n-nodes-aib.tgz
+# reinicie o n8n
+```
+
+(Em Docker, o diretório é o volume de dados do n8n, ex.:
+`/home/node/.n8n/nodes` dentro do container.)
+
+## Depois de instalar
+
+1. Credentials → **AIB Digital API** → URL + chave de agência
+   (Integrações → Chaves de API → "chave de agência").
+2. Novo workflow → **AIB Digital Trigger** → escolha a conta → ative.
+3. A partir daí, cada mensagem recebida daquela conta chega no fluxo;
+   responda/mova card com o nó **AIB Digital**.
+
+## Atenção
+
+- Um destino de webhook **por conta**: ativar dois workflows com
+  gatilho para a mesma conta faz o segundo roubar o registro do
+  primeiro.
+- Rebuild: `bun install && bunx tsc && npm pack` na pasta do pacote;
+  o `.tgz` vai para `public/n8n-nodes-aib.tgz` no app.

package/dist/credentials/AibDigitalApi.credentials.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AibDigitalApi = void 0;
+/**
+ * A credencial do Sistema AIB Digital — o par URL + chave, como era
+ * com o Chatwoot. Com uma chave de AGÊNCIA, os nós listam todas as
+ * contas e caixas; com chave de conta, operam só aquela conta.
+ */
+class AibDigitalApi {
+    name = "aibDigitalApi";
+    displayName = "AIB Digital API";
+    documentationUrl = "https://app.aibdigitall.com";
+    properties = [
+        {
+            displayName: "URL do sistema",
+            name: "baseUrl",
+            type: "string",
+            default: "https://app.aibdigitall.com",
+            required: true,
+        },
+        {
+            displayName: "Chave de API",
+            name: "apiKey",
+            type: "string",
+            typeOptions: { password: true },
+            default: "",
+            required: true,
+            description: "Gerada em Integrações → Chaves de API. Use uma chave de agência para escolher a conta dentro do nó.",
+        },
+    ];
+    authenticate = {
+        type: "generic",
+        properties: {
+            headers: {
+                Authorization: "=Bearer {{$credentials.apiKey}}",
+            },
+        },
+    };
+    test = {
+        request: {
+            baseURL: "={{$credentials.baseUrl}}",
+            url: "/api/v1/ping",
+        },
+    };
+}
+exports.AibDigitalApi = AibDigitalApi;

package/dist/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/nodes/AibDigital/AibDigital.node.js

@@ -0,0 +1,249 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AibDigital = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+/** Chama a /api/v1 com a credencial do nó. */
+async function api(ctx, method, path, body, qs) {
+    const cred = (await ctx.getCredentials("aibDigitalApi"));
+    const base = String(cred.baseUrl).replace(/\/+$/, "");
+    return ctx.helpers.httpRequest({
+        method,
+        url: `${base}${path}`,
+        qs,
+        body,
+        json: true,
+        headers: { Authorization: `Bearer ${cred.apiKey}` },
+    });
+}
+/** A conta escolhida no nó (vazio = a conta da própria chave). */
+function contaQs(ctx, i) {
+    const conta = ctx.getNodeParameter("conta", i, "");
+    return conta ? { conta } : {};
+}
+class AibDigital {
+    description = {
+        displayName: "AIB Digital",
+        name: "aibDigital",
+        group: ["output"],
+        version: 1,
+        subtitle: '={{$parameter["operation"]}}',
+        description: "Opera o Sistema AIB Digital: conversas, mensagens e funil",
+        defaults: { name: "AIB Digital" },
+        // Vira ferramenta de agente de IA no n8n — o mesmo truque do nó
+        // do Chatwoot que a Íris usa (chatwootTool).
+        usableAsTool: true,
+        inputs: ["main"],
+        outputs: ["main"],
+        credentials: [{ name: "aibDigitalApi", required: true }],
+        properties: [
+            {
+                displayName: "Conta",
+                name: "conta",
+                type: "options",
+                typeOptions: { loadOptionsMethod: "getContas" },
+                default: "",
+                description: "O cliente. Com chave de agência, escolha aqui; com chave de conta, deixe vazio.",
+            },
+            {
+                displayName: "Operação",
+                name: "operation",
+                type: "options",
+                noDataExpression: true,
+                default: "enviarMensagem",
+                options: [
+                    { name: "Enviar mensagem", value: "enviarMensagem", action: "Enviar mensagem de texto" },
+                    { name: "Listar conversas", value: "listarConversas", action: "Listar conversas" },
+                    { name: "Buscar conversa", value: "buscarConversa", action: "Buscar uma conversa" },
+                    { name: "Listar mensagens", value: "listarMensagens", action: "Listar mensagens da conversa" },
+                    { name: "Mover etapa (Kanban)", value: "moverEtapa", action: "Mover card no funil" },
+                    { name: "Pausar/religar IA", value: "mudarIa", action: "Pausar ou religar a IA na conversa" },
+                    { name: "Atribuir atendente", value: "atribuirAtendente", action: "Atribuir a conversa a uma pessoa" },
+                    { name: "Atualizar contato", value: "atualizarContato", action: "Atualizar dados do contato" },
+                ],
+            },
+            // ── parâmetros por operação ─────────────────────────────
+            {
+                displayName: "Conversa (ID)",
+                name: "conversaId",
+                type: "string",
+                default: "",
+                required: true,
+                displayOptions: {
+                    show: { operation: ["enviarMensagem", "buscarConversa", "listarMensagens", "moverEtapa", "mudarIa", "atribuirAtendente"] },
+                },
+                description: "Vem do gatilho (data.conversa_id) ou de Listar conversas",
+            },
+            {
+                displayName: "Texto",
+                name: "conteudo",
+                type: "string",
+                typeOptions: { rows: 3 },
+                default: "",
+                required: true,
+                displayOptions: { show: { operation: ["enviarMensagem"] } },
+            },
+            {
+                displayName: "Responder à mensagem (ID)",
+                name: "citadaId",
+                type: "string",
+                default: "",
+                displayOptions: { show: { operation: ["enviarMensagem"] } },
+            },
+            {
+                displayName: "Etapa",
+                name: "etapaId",
+                type: "options",
+                typeOptions: { loadOptionsMethod: "getEtapas", loadOptionsDependsOn: ["conta"] },
+                default: "",
+                required: true,
+                displayOptions: { show: { operation: ["moverEtapa"] } },
+            },
+            {
+                displayName: "IA ativa",
+                name: "iaAtiva",
+                type: "boolean",
+                default: false,
+                displayOptions: { show: { operation: ["mudarIa"] } },
+                description: "Desligada = a Íris para de responder nesta conversa (agente-off)",
+            },
+            {
+                displayName: "Atendente (ID do usuário)",
+                name: "atendenteId",
+                type: "string",
+                default: "",
+                displayOptions: { show: { operation: ["atribuirAtendente"] } },
+                description: "Vazio desatribui. É o 'escalar humano': atribui e, se quiser, pause a IA em outra chamada.",
+            },
+            {
+                displayName: "Filtros",
+                name: "filtros",
+                type: "collection",
+                placeholder: "Adicionar filtro",
+                default: {},
+                displayOptions: { show: { operation: ["listarConversas"] } },
+                options: [
+                    { displayName: "Telefone", name: "telefone", type: "string", default: "" },
+                    { displayName: "Atualizadas desde (ISO)", name: "desde", type: "string", default: "" },
+                    {
+                        displayName: "Status",
+                        name: "status",
+                        type: "options",
+                        default: "open",
+                        options: [
+                            { name: "Abertas", value: "open" },
+                            { name: "Encerradas", value: "closed" },
+                        ],
+                    },
+                    { displayName: "Limite", name: "limite", type: "number", default: 50 },
+                ],
+            },
+            {
+                displayName: "Contato (ID)",
+                name: "contatoId",
+                type: "string",
+                default: "",
+                required: true,
+                displayOptions: { show: { operation: ["atualizarContato"] } },
+            },
+            {
+                displayName: "Campos do contato",
+                name: "camposContato",
+                type: "collection",
+                placeholder: "Adicionar campo",
+                default: {},
+                displayOptions: { show: { operation: ["atualizarContato"] } },
+                options: [
+                    { displayName: "Nome", name: "nome", type: "string", default: "" },
+                    { displayName: "E-mail", name: "email", type: "string", default: "" },
+                    { displayName: "Observações", name: "observacoes", type: "string", default: "" },
+                ],
+            },
+        ],
+    };
+    methods = {
+        loadOptions: {
+            async getContas() {
+                try {
+                    const res = await api(this, "GET", "/api/v1/contas");
+                    const contas = (res?.contas ?? []);
+                    return [
+                        { name: "— A conta da chave —", value: "" },
+                        ...contas.map((c) => ({
+                            name: ["ativa", "ativo", "active"].includes(c.status) ? c.nome : `${c.nome} (suspensa)`,
+                            value: c.id,
+                        })),
+                    ];
+                }
+                catch {
+                    // Chave de conta não lista contas (403): a única opção é ela mesma.
+                    return [{ name: "— A conta da chave —", value: "" }];
+                }
+            },
+            async getEtapas() {
+                const conta = this.getNodeParameter("conta", "");
+                const res = await api(this, "GET", "/api/v1/funis", undefined, conta ? { conta } : undefined);
+                const funis = (res?.funis ?? []);
+                return funis.flatMap((f) => f.etapas.map((e) => ({ name: `${f.nome} → ${e.nome}`, value: e.id })));
+            },
+        },
+    };
+    async execute() {
+        const items = this.getInputData();
+        const out = [];
+        const operation = this.getNodeParameter("operation", 0);
+        for (let i = 0; i < items.length; i++) {
+            const qs = contaQs(this, i);
+            let res;
+            if (operation === "enviarMensagem") {
+                const conversaId = this.getNodeParameter("conversaId", i);
+                const conteudo = this.getNodeParameter("conteudo", i);
+                const citadaId = this.getNodeParameter("citadaId", i, "");
+                res = await api(this, "POST", `/api/v1/conversas/${conversaId}/mensagens`, { conteudo, citada_id: citadaId || null }, qs);
+            }
+            else if (operation === "listarConversas") {
+                const f = this.getNodeParameter("filtros", i, {});
+                res = await api(this, "GET", "/api/v1/conversas", undefined, {
+                    ...qs,
+                    ...(f.telefone ? { telefone: f.telefone } : {}),
+                    ...(f.desde ? { desde: f.desde } : {}),
+                    ...(f.status ? { status: f.status } : {}),
+                    ...(f.limite ? { limite: String(f.limite) } : {}),
+                });
+            }
+            else if (operation === "buscarConversa") {
+                const conversaId = this.getNodeParameter("conversaId", i);
+                res = await api(this, "GET", `/api/v1/conversas/${conversaId}`, undefined, qs);
+            }
+            else if (operation === "listarMensagens") {
+                const conversaId = this.getNodeParameter("conversaId", i);
+                res = await api(this, "GET", `/api/v1/conversas/${conversaId}/mensagens`, undefined, qs);
+            }
+            else if (operation === "moverEtapa") {
+                const conversaId = this.getNodeParameter("conversaId", i);
+                const etapaId = this.getNodeParameter("etapaId", i);
+                res = await api(this, "POST", `/api/v1/conversas/${conversaId}/etapa`, { etapa_id: etapaId }, qs);
+            }
+            else if (operation === "mudarIa") {
+                const conversaId = this.getNodeParameter("conversaId", i);
+                const iaAtiva = this.getNodeParameter("iaAtiva", i);
+                res = await api(this, "PATCH", `/api/v1/conversas/${conversaId}`, { ia_ativa: iaAtiva }, qs);
+            }
+            else if (operation === "atribuirAtendente") {
+                const conversaId = this.getNodeParameter("conversaId", i);
+                const atendenteId = this.getNodeParameter("atendenteId", i, "");
+                res = await api(this, "PATCH", `/api/v1/conversas/${conversaId}`, { atendente_id: atendenteId || null }, qs);
+            }
+            else if (operation === "atualizarContato") {
+                const contatoId = this.getNodeParameter("contatoId", i);
+                const campos = this.getNodeParameter("camposContato", i, {});
+                res = await api(this, "PATCH", `/api/v1/contatos/${contatoId}`, campos, qs);
+            }
+            else {
+                throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Operação desconhecida: ${operation}`);
+            }
+            out.push({ json: res, pairedItem: { item: i } });
+        }
+        return [out];
+    }
+}
+exports.AibDigital = AibDigital;

package/dist/nodes/AibDigital/AibDigitalTrigger.node.js

@@ -0,0 +1,150 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AibDigitalTrigger = void 0;
+const crypto_1 = require("crypto");
+/**
+ * Gatilho "AIB Digital": acorda quando a conta recebe eventos.
+ *
+ * Ao ATIVAR o workflow, o nó registra a própria URL de webhook na
+ * conta escolhida (PUT /api/v1/webhook); ao desativar, remove. É o
+ * mesmo campo da tela de Integrações — o nó é um jeito de preenchê-lo.
+ *
+ * Um destino por conta: ativar um segundo workflow com gatilho para a
+ * MESMA conta rouba o registro do primeiro. É o desenho atual do
+ * sistema, não do nó.
+ */
+async function apiHook(ctx, method, path, body, qs) {
+    const cred = (await ctx.getCredentials("aibDigitalApi"));
+    const base = String(cred.baseUrl).replace(/\/+$/, "");
+    return ctx.helpers.httpRequest({
+        method,
+        url: `${base}${path}`,
+        qs,
+        body,
+        json: true,
+        headers: { Authorization: `Bearer ${cred.apiKey}` },
+    });
+}
+class AibDigitalTrigger {
+    description = {
+        displayName: "AIB Digital Trigger",
+        name: "aibDigitalTrigger",
+        group: ["trigger"],
+        version: 1,
+        description: "Dispara quando chega mensagem (ou outro evento) numa conta do Sistema AIB",
+        defaults: { name: "AIB Digital Trigger" },
+        inputs: [],
+        outputs: ["main"],
+        credentials: [{ name: "aibDigitalApi", required: true }],
+        webhooks: [
+            {
+                name: "default",
+                httpMethod: "POST",
+                responseMode: "onReceived",
+                path: "webhook",
+            },
+        ],
+        properties: [
+            {
+                displayName: "Conta",
+                name: "conta",
+                type: "options",
+                typeOptions: { loadOptionsMethod: "getContas" },
+                default: "",
+                description: "O cliente cujos eventos disparam este workflow",
+            },
+            {
+                displayName: "Eventos",
+                name: "eventos",
+                type: "multiOptions",
+                default: ["mensagem.recebida"],
+                options: [
+                    { name: "Mensagem recebida", value: "mensagem.recebida" },
+                    { name: "Conversa criada (lead novo)", value: "conversa.criada" },
+                    { name: "Mensagem enviada (via API)", value: "mensagem.enviada" },
+                    { name: "Card movido no funil", value: "conversa.etapa" },
+                    { name: "Conversa atualizada (IA/status)", value: "conversa.atualizada" },
+                    { name: "Resposta humana no painel (legado)", value: "message.outbound" },
+                ],
+                description: "Eventos que passam; os demais são descartados sem disparar o fluxo",
+            },
+        ],
+    };
+    methods = {
+        loadOptions: {
+            async getContas() {
+                try {
+                    const res = await apiHook(this, "GET", "/api/v1/contas");
+                    const contas = (res?.contas ?? []);
+                    return [
+                        { name: "— A conta da chave —", value: "" },
+                        ...contas.map((c) => ({ name: c.nome, value: c.id })),
+                    ];
+                }
+                catch {
+                    return [{ name: "— A conta da chave —", value: "" }];
+                }
+            },
+        },
+    };
+    webhookMethods = {
+        default: {
+            async checkExists() {
+                const conta = this.getNodeParameter("conta", "");
+                const url = this.getNodeWebhookUrl("default");
+                try {
+                    const res = await apiHook(this, "GET", "/api/v1/webhook", undefined, conta ? { conta } : undefined);
+                    return res?.url === url;
+                }
+                catch {
+                    return false;
+                }
+            },
+            async create() {
+                const conta = this.getNodeParameter("conta", "");
+                const url = this.getNodeWebhookUrl("default");
+                const res = await apiHook(this, "PUT", "/api/v1/webhook", { url }, conta ? { conta } : undefined);
+                // O segredo volta no registro; cada evento chega assinado com ele
+                // (x-aib-signature) e o webhook confere antes de acordar o fluxo.
+                const dados = this.getWorkflowStaticData("node");
+                dados.segredo = res?.segredo ?? null;
+                return true;
+            },
+            async delete() {
+                const conta = this.getNodeParameter("conta", "");
+                await apiHook(this, "DELETE", "/api/v1/webhook", undefined, conta ? { conta } : undefined);
+                return true;
+            },
+        },
+    };
+    async webhook() {
+        const body = this.getBodyData();
+        const eventos = this.getNodeParameter("eventos", []);
+        // Assinatura: hmac_sha256(segredo, corpo bruto) no x-aib-signature.
+        // Sem segredo guardado (registro antigo), passa — compatibilidade,
+        // como no nó do Chatwoot. Com segredo, assinatura errada é 401.
+        const segredo = this.getWorkflowStaticData("node").segredo;
+        if (segredo) {
+            const assinatura = this.getHeaderData()["x-aib-signature"] ?? "";
+            const corpo = JSON.stringify(this.getBodyData());
+            const esperada = (0, crypto_1.createHmac)("sha256", segredo).update(corpo).digest("hex");
+            const a = Buffer.from(assinatura);
+            const b = Buffer.from(esperada);
+            const valida = a.length === b.length && (0, crypto_1.timingSafeEqual)(a, b);
+            if (!valida) {
+                // Descarte SILENCIOSO: com responseMode onReceived o n8n já
+                // respondeu 200, e tentar responder de novo derrubava a
+                // conexão. Não disparar o fluxo é a proteção; não confirmar
+                // ao forjador que a assinatura era o problema é bônus.
+                return { noWebhookResponse: false };
+            }
+        }
+        // Evento fora da lista: 200 sem disparar — o sistema não precisa
+        // reenviar, e o fluxo não acorda à toa.
+        if (eventos.length && body?.event && !eventos.includes(body.event)) {
+            return { noWebhookResponse: false };
+        }
+        return { workflowData: [this.helpers.returnJsonArray([body])] };
+    }
+}
+exports.AibDigitalTrigger = AibDigitalTrigger;

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "n8n-nodes-aib",
+  "version": "0.2.1",
+  "description": "Nós do Sistema AIB Digital para n8n: gatilho de mensagens do WhatsApp (via AIB Inbox) e ações — enviar mensagem, mover card no funil, pausar IA — escolhendo conta e caixa por dropdown.",
+  "license": "MIT",
+  "author": "AIB Digital",
+  "keywords": [
+    "n8n-community-node-package",
+    "aib-digital",
+    "whatsapp",
+    "crm",
+    "inbox"
+  ],
+  "main": "dist/index.js",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc"
+  },
+  "n8n": {
+    "n8nNodesApiVersion": 1,
+    "credentials": [
+      "dist/credentials/AibDigitalApi.credentials.js"
+    ],
+    "nodes": [
+      "dist/nodes/AibDigital/AibDigital.node.js",
+      "dist/nodes/AibDigital/AibDigitalTrigger.node.js"
+    ]
+  },
+  "peerDependencies": {
+    "n8n-workflow": "*"
+  },
+  "devDependencies": {
+    "n8n-workflow": "^1.70.0",
+    "typescript": "^5.8.3"
+  },
+  "homepage": "https://app.aibdigitall.com"
+}