@saulwade/swl-ses 1.3.8 → 1.4.1

package/gateway/adapters/email.js

@@ -0,0 +1,221 @@
+'use strict';
+
+/**
+ * Email Adapter — Adaptador para notificaciones por correo electrónico.
+ *
+ * Soporta:
+ *   - Envío via SMTP directo (nodemailer)
+ *   - Envío via API de servicios (SendGrid, Mailgun, SES) — HTTP nativo
+ *   - Formato HTML con template básico para notificaciones
+ *   - Unidireccional (solo envío, sin recepción)
+ *
+ * Dependencia SMTP: nodemailer (npm install nodemailer)
+ * Dependencia API: ninguna (HTTP nativo)
+ *
+ * @module gateway/adapters/email
+ */
+
+const BaseAdapter = require('./base');
+const https = require('https');
+
+class EmailAdapter extends BaseAdapter {
+  constructor(config) {
+    super('email', config);
+    this._transporter = null;
+    this._mode = config.mode || 'api'; // 'smtp' | 'api'
+  }
+
+  async start() {
+    if (this._mode === 'smtp') {
+      return this._startSMTP();
+    }
+    return this._startAPI();
+  }
+
+  /**
+   * Modo SMTP con nodemailer.
+   */
+  async _startSMTP() {
+    let nodemailer;
+    try {
+      nodemailer = require('nodemailer');
+    } catch (_) {
+      console.log('[email] nodemailer no instalado. Ejecutar: npm install nodemailer');
+      return;
+    }
+
+    const host = this.config.smtpHost || process.env.SMTP_HOST;
+    const port = this.config.smtpPort || process.env.SMTP_PORT || 587;
+    const user = this.config.smtpUser || process.env.SMTP_USER;
+    const pass = this.config.smtpPass || process.env.SMTP_PASS;
+
+    if (!host || !user) {
+      console.log('[email] SMTP no configurado. Establecer SMTP_HOST y SMTP_USER.');
+      return;
+    }
+
+    this._transporter = nodemailer.createTransport({
+      host,
+      port: Number(port),
+      secure: Number(port) === 465,
+      auth: { user, pass },
+    });
+
+    this.running = true;
+    console.log(`[email] Adaptador iniciado (SMTP: ${host}:${port}).`);
+  }
+
+  /**
+   * Modo API (SendGrid, Mailgun, SES — via HTTP).
+   */
+  async _startAPI() {
+    const apiKey  = this.config.apiKey || process.env.EMAIL_API_KEY;
+    const service = this.config.service || process.env.EMAIL_SERVICE || 'sendgrid';
+
+    if (!apiKey) {
+      console.log(`[email] API key no configurada. Establecer EMAIL_API_KEY para ${service}.`);
+      return;
+    }
+
+    this._apiKey  = apiKey;
+    this._service = service;
+    this.running  = true;
+    console.log(`[email] Adaptador iniciado (API: ${service}).`);
+  }
+
+  async stop() {
+    if (this._transporter) {
+      this._transporter.close();
+      this._transporter = null;
+    }
+    this.running = false;
+    console.log('[email] Adaptador detenido.');
+  }
+
+  async send(message) {
+    const to   = message.chatId || this.config.defaultTo || process.env.EMAIL_DEFAULT_TO;
+    const from = this.config.from || process.env.EMAIL_FROM || 'swl-ses@noreply.com';
+
+    if (!to) return false;
+
+    const subject = this._buildSubject(message);
+    const html    = this._buildHTML(message);
+    const text    = this.formatMessage(message);
+
+    if (this._mode === 'smtp') {
+      return this._sendSMTP(from, to, subject, text, html);
+    }
+    return this._sendAPI(from, to, subject, text, html);
+  }
+
+  /**
+   * Envía via SMTP con nodemailer.
+   */
+  async _sendSMTP(from, to, subject, text, html) {
+    if (!this._transporter) return false;
+
+    try {
+      await this._transporter.sendMail({ from, to, subject, text, html });
+      return true;
+    } catch (err) {
+      console.error(`[email] Error SMTP: ${err.message}`);
+      return false;
+    }
+  }
+
+  /**
+   * Envía via SendGrid API (HTTP POST).
+   */
+  async _sendAPI(from, to, subject, text, html) {
+    if (!this._apiKey) return false;
+
+    if (this._service === 'sendgrid') {
+      return this._sendSendGrid(from, to, subject, text, html);
+    }
+
+    // Fallback genérico — tratar como webhook
+    console.log(`[email] Servicio "${this._service}" no implementado. Usar "sendgrid" o modo "smtp".`);
+    return false;
+  }
+
+  /**
+   * SendGrid v3 API.
+   */
+  _sendSendGrid(from, to, subject, text, html) {
+    const body = JSON.stringify({
+      personalizations: [{ to: [{ email: to }] }],
+      from: { email: from },
+      subject,
+      content: [
+        { type: 'text/plain', value: text },
+        { type: 'text/html', value: html },
+      ],
+    });
+
+    return new Promise((resolve) => {
+      const req = https.request({
+        hostname: 'api.sendgrid.com',
+        path: '/v3/mail/send',
+        method: 'POST',
+        headers: {
+          'Authorization': `Bearer ${this._apiKey}`,
+          'Content-Type': 'application/json',
+          'Content-Length': Buffer.byteLength(body),
+        },
+        timeout: 10000,
+      }, (res) => {
+        let data = '';
+        res.on('data', chunk => data += chunk);
+        res.on('end', () => resolve(res.statusCode >= 200 && res.statusCode < 300));
+      });
+
+      req.on('error', () => resolve(false));
+      req.on('timeout', () => { req.destroy(); resolve(false); });
+      req.write(body);
+      req.end();
+    });
+  }
+
+  _buildSubject(message) {
+    const payload = message.payload || message;
+    const status  = payload.status === 'completed' ? '✓' : '✗';
+    return `[SWL] ${status} ${payload.jobName || payload.title || 'Notificación'}`;
+  }
+
+  _buildHTML(message) {
+    const payload = message.payload || message;
+    const isError = payload.status === 'error';
+    const color   = isError ? '#dc3545' : '#28a745';
+
+    return `
+<!DOCTYPE html>
+<html><body style="font-family:system-ui,sans-serif;max-width:600px;margin:0 auto;padding:20px">
+  <div style="border-left:4px solid ${color};padding:12px 16px;margin-bottom:16px">
+    <h2 style="margin:0 0 8px;color:${color}">${payload.jobName || 'SWL Notificación'}</h2>
+    <p style="margin:0;color:#666">Estado: <strong>${payload.status || 'unknown'}</strong></p>
+  </div>
+  ${payload.output ? `<pre style="background:#f5f5f5;padding:12px;border-radius:4px;overflow-x:auto;font-size:13px">${_escapeHTML(payload.output.substring(0, 2000))}</pre>` : ''}
+  <hr style="border:none;border-top:1px solid #eee;margin:20px 0">
+  <p style="color:#999;font-size:12px">Enviado por SWL-SES Gateway — ${new Date().toISOString()}</p>
+</body></html>`.trim();
+  }
+
+  formatMessage(swlMessage) {
+    const payload = swlMessage.payload || swlMessage;
+
+    if (payload.jobName) {
+      const icon = payload.status === 'completed' ? '[OK]' : '[ERROR]';
+      const lines = [`${icon} ${payload.jobName}`, `Estado: ${payload.status}`];
+      if (payload.output) lines.push('', payload.output.substring(0, 1000));
+      return lines.join('\n');
+    }
+
+    return swlMessage.text || JSON.stringify(payload).substring(0, 500);
+  }
+}
+
+function _escapeHTML(str) {
+  return str.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+}
+
+module.exports = EmailAdapter;

package/gateway/adapters/slack.js

@@ -0,0 +1,192 @@
+'use strict';
+
+/**
+ * Slack Adapter — Adaptador para Slack via Bolt SDK.
+ *
+ * Soporta:
+ *   - Envío de notificaciones con Blocks (formato rico)
+ *   - Recepción de comandos slash y mensajes directos
+ *   - Threads para conversaciones agrupadas
+ *   - Rate limiting (Slack: 1 msg/seg por canal)
+ *
+ * Dependencia: @slack/bolt (npm install @slack/bolt)
+ * Si no está instalada, el adaptador se desactiva silenciosamente.
+ *
+ * @module gateway/adapters/slack
+ */
+
+const BaseAdapter = require('./base');
+
+/** Límite de caracteres por mensaje de Slack. */
+const MAX_MSG_LENGTH = 3000;
+
+/** Comandos reconocidos en mensajes directos al bot. */
+const COMMANDS = {
+  'status':   'Estado del sistema SWL',
+  'salud':    'Ejecutar diagnóstico de salud',
+  'sesiones': 'Listar últimas sesiones',
+  'approve':  'Aprobar operación pendiente',
+  'reject':   'Rechazar operación pendiente',
+};
+
+class SlackAdapter extends BaseAdapter {
+  constructor(config) {
+    super('slack', config);
+    this._app = null;
+  }
+
+  async start() {
+    let Bolt;
+    try {
+      Bolt = require('@slack/bolt');
+    } catch (_) {
+      console.log('[slack] @slack/bolt no instalado. Ejecutar: npm install @slack/bolt');
+      return;
+    }
+
+    const token     = this.config.token || process.env.SLACK_BOT_TOKEN;
+    const sigSecret = this.config.signingSecret || process.env.SLACK_SIGNING_SECRET;
+    const appToken  = this.config.appToken || process.env.SLACK_APP_TOKEN;
+
+    if (!token) {
+      console.log('[slack] Token no configurado. Establecer SLACK_BOT_TOKEN.');
+      return;
+    }
+
+    try {
+      const opts = {
+        token,
+        signingSecret: sigSecret || 'dummy',
+      };
+
+      // Socket mode (recomendado, sin servidor público)
+      if (appToken) {
+        opts.socketMode = true;
+        opts.appToken   = appToken;
+      }
+
+      this._app = new Bolt.App(opts);
+
+      // Escuchar mensajes directos al bot
+      this._app.message(async ({ message, say }) => {
+        if (message.subtype) return; // Ignorar ediciones, joins, etc.
+
+        const text    = message.text || '';
+        const parts   = text.trim().split(/\s+/);
+        const cmdWord = parts[0].toLowerCase().replace(/^\//, '');
+        const command = COMMANDS[cmdWord] ? cmdWord : null;
+        const args    = command ? parts.slice(1).join(' ') : '';
+
+        this._emitMessage({
+          chatId:   message.channel,
+          userId:   message.user,
+          userName: message.user,
+          text:     text,
+          command:  command ? `/${command}` : null,
+          args:     args,
+          threadTs: message.thread_ts || message.ts,
+          raw:      message,
+        });
+      });
+
+      if (appToken) {
+        await this._app.start();
+      }
+
+      this.running = true;
+      console.log(`[slack] Adaptador iniciado (${appToken ? 'socket' : 'events'} mode).`);
+    } catch (err) {
+      console.error(`[slack] Error al iniciar: ${err.message}`);
+    }
+  }
+
+  async stop() {
+    if (this._app) {
+      try { await this._app.stop(); } catch (_) {}
+      this._app = null;
+    }
+    this.running = false;
+    console.log('[slack] Adaptador detenido.');
+  }
+
+  async send(message) {
+    if (!this._app) return false;
+
+    const channel = message.chatId || this.config.defaultChannel || process.env.SLACK_DEFAULT_CHANNEL;
+    if (!channel) return false;
+
+    const text   = this.formatMessage(message);
+    const blocks = this._buildBlocks(message);
+
+    try {
+      await this._app.client.chat.postMessage({
+        token: this.config.token || process.env.SLACK_BOT_TOKEN,
+        channel,
+        text,
+        blocks,
+        unfurl_links: false,
+      });
+      return true;
+    } catch (err) {
+      console.error(`[slack] Error enviando: ${err.message}`);
+      return false;
+    }
+  }
+
+  /**
+   * Construye Slack Blocks para notificaciones estructuradas.
+   * @private
+   */
+  _buildBlocks(message) {
+    const payload = message.payload || message;
+    if (!payload.jobName && !payload.title) return undefined;
+
+    const isError = payload.status === 'error';
+    const icon    = isError ? ':x:' : ':white_check_mark:';
+    const blocks  = [];
+
+    blocks.push({
+      type: 'header',
+      text: { type: 'plain_text', text: `${payload.jobName || payload.title || 'SWL'}` },
+    });
+
+    blocks.push({
+      type: 'section',
+      fields: [
+        { type: 'mrkdwn', text: `*Estado:*\n${icon} \`${payload.status || 'unknown'}\`` },
+        { type: 'mrkdwn', text: `*Fuente:*\nSWL-SES Gateway` },
+      ],
+    });
+
+    if (payload.output) {
+      blocks.push({
+        type: 'section',
+        text: { type: 'mrkdwn', text: '```' + payload.output.substring(0, 2500) + '```' },
+      });
+    }
+
+    blocks.push({ type: 'divider' });
+
+    return blocks;
+  }
+
+  formatMessage(swlMessage) {
+    const payload = swlMessage.payload || swlMessage;
+
+    if (payload.jobName) {
+      const icon = payload.status === 'completed' ? ':white_check_mark:' : ':x:';
+      const lines = [
+        `${icon} *${payload.jobName}*`,
+        `Estado: \`${payload.status}\``,
+      ];
+      if (payload.output) {
+        lines.push('```' + payload.output.substring(0, 1000) + '```');
+      }
+      return lines.join('\n');
+    }
+
+    return swlMessage.text || JSON.stringify(payload).substring(0, 500);
+  }
+}
+
+module.exports = SlackAdapter;

package/gateway/adapters/telegram.js

@@ -0,0 +1,183 @@
+'use strict';
+
+/**
+ * Telegram Adapter — Adaptador de plataforma para Telegram Bot API.
+ *
+ * Usa polling HTTP (sin webhook, sin servidor público). Soporta:
+ *   - Recepción de mensajes y comandos (/status, /salud, /approve)
+ *   - Envío de notificaciones con formato Markdown
+ *   - Batching de mensajes largos (split a 4096 chars)
+ *   - Rate limiting (30 msg/seg Telegram limit)
+ *   - Filtro de usuarios permitidos (allowedUsers)
+ *
+ * Dependencia: node-telegram-bot-api (npm install node-telegram-bot-api)
+ * Si no está instalada, el adaptador se desactiva silenciosamente.
+ *
+ * Inspirado en Hermes Agent (gateway/platforms/telegram.py).
+ *
+ * @module gateway/adapters/telegram
+ */
+
+const BaseAdapter = require('./base');
+
+/** Límite de caracteres por mensaje de Telegram. */
+const MAX_MSG_LENGTH = 4096;
+
+/** Comandos reconocidos por el bot. */
+const COMMANDS = {
+  '/status':   'Estado del sistema SWL',
+  '/salud':    'Ejecutar diagnóstico de salud',
+  '/sesiones': 'Listar últimas sesiones',
+  '/approve':  'Aprobar operación pendiente',
+  '/reject':   'Rechazar operación pendiente',
+  '/help':     'Mostrar ayuda',
+};
+
+class TelegramAdapter extends BaseAdapter {
+  constructor(config) {
+    super('telegram', config);
+    this._bot = null;
+    this._allowedUsers = new Set(config.allowedUsers || []);
+  }
+
+  async start() {
+    let TelegramBot;
+    try {
+      TelegramBot = require('node-telegram-bot-api');
+    } catch (_) {
+      console.log('[telegram] node-telegram-bot-api no instalado. Ejecutar: npm install node-telegram-bot-api');
+      return;
+    }
+
+    const token = this.config.token || process.env.TELEGRAM_BOT_TOKEN;
+    if (!token) {
+      console.log('[telegram] Token no configurado. Establecer TELEGRAM_BOT_TOKEN.');
+      return;
+    }
+
+    this._bot = new TelegramBot(token, { polling: true });
+    this.running = true;
+
+    this._bot.on('message', (msg) => {
+      // Filtrar usuarios no permitidos
+      if (this._allowedUsers.size > 0 && !this._allowedUsers.has(String(msg.from.id))) {
+        return;
+      }
+
+      const text = msg.text || '';
+
+      // Parsear comando
+      const parts   = text.split(/\s+/);
+      const command = parts[0];
+      const args    = parts.slice(1).join(' ');
+
+      this._emitMessage({
+        chatId:   String(msg.chat.id),
+        userId:   String(msg.from.id),
+        userName: msg.from.username || msg.from.first_name || 'unknown',
+        text:     text,
+        command:  COMMANDS[command] ? command : null,
+        args:     args,
+        raw:      msg,
+      });
+    });
+
+    this._bot.on('polling_error', (err) => {
+      // Log silencioso — no crashear
+      if (err.code === 'ETELEGRAM' && err.message.includes('409')) {
+        console.error('[telegram] Conflicto: otro bot con el mismo token. Deteniendo polling.');
+        this.stop();
+      }
+    });
+
+    console.log('[telegram] Adaptador iniciado (polling mode).');
+  }
+
+  async stop() {
+    if (this._bot) {
+      try { await this._bot.stopPolling(); } catch (_) {}
+      this._bot = null;
+    }
+    this.running = false;
+    console.log('[telegram] Adaptador detenido.');
+  }
+
+  async send(message) {
+    if (!this._bot) return false;
+
+    const chatId = message.chatId || this.config.homeChat;
+    if (!chatId) return false;
+
+    const text = this.formatMessage(message);
+
+    // Batching: split en chunks de MAX_MSG_LENGTH
+    const chunks = _splitMessage(text, MAX_MSG_LENGTH);
+
+    for (const chunk of chunks) {
+      try {
+        await this._bot.sendMessage(chatId, chunk, {
+          parse_mode: 'Markdown',
+          disable_web_page_preview: true,
+        });
+      } catch (err) {
+        // Retry sin Markdown si falla el parse
+        try {
+          await this._bot.sendMessage(chatId, chunk);
+        } catch (_) {
+          return false;
+        }
+      }
+    }
+
+    return true;
+  }
+
+  formatMessage(swlMessage) {
+    const payload = swlMessage.payload || swlMessage;
+
+    if (payload.jobName) {
+      // Notificación de cron
+      const status = payload.status === 'completed' ? '✓' : '✗';
+      const lines = [
+        `${status} *${payload.jobName}*`,
+        `Estado: \`${payload.status}\``,
+      ];
+      if (payload.output) {
+        lines.push('```', payload.output.substring(0, 1000), '```');
+      }
+      return lines.join('\n');
+    }
+
+    // Mensaje genérico
+    return swlMessage.text || JSON.stringify(payload).substring(0, 500);
+  }
+}
+
+/**
+ * Divide un mensaje largo en chunks respetando el límite de caracteres.
+ * Intenta dividir en líneas completas.
+ */
+function _splitMessage(text, maxLength) {
+  if (text.length <= maxLength) return [text];
+
+  const chunks = [];
+  let remaining = text;
+
+  while (remaining.length > 0) {
+    if (remaining.length <= maxLength) {
+      chunks.push(remaining);
+      break;
+    }
+
+    // Buscar el último newline dentro del límite
+    let splitAt = remaining.lastIndexOf('\n', maxLength);
+    if (splitAt < maxLength * 0.3) splitAt = maxLength; // Si no hay newline útil, cortar
+
+    chunks.push(remaining.substring(0, splitAt));
+    remaining = remaining.substring(splitAt).trimStart();
+  }
+
+  return chunks;
+}
+
+module.exports = TelegramAdapter;

package/gateway/adapters/webhook.js

@@ -0,0 +1,113 @@
+'use strict';
+
+/**
+ * Webhook Adapter — Adaptador genérico para webhooks HTTP.
+ *
+ * Envía notificaciones a un endpoint configurable via POST.
+ * No recibe mensajes (unidireccional: SWL → Webhook).
+ *
+ * Compatible con: Slack Incoming Webhooks, Microsoft Teams, ntfy.sh,
+ * Pushover, cualquier endpoint que acepte JSON POST.
+ *
+ * @module gateway/adapters/webhook
+ */
+
+const BaseAdapter = require('./base');
+const https = require('https');
+const http  = require('http');
+const { URL } = require('url');
+
+class WebhookAdapter extends BaseAdapter {
+  constructor(config) {
+    super('webhook', config);
+  }
+
+  async start() {
+    const url = this.config.url || process.env.WEBHOOK_URL;
+    if (!url) {
+      console.log('[webhook] URL no configurada. Establecer WEBHOOK_URL.');
+      return;
+    }
+
+    this.running = true;
+    console.log('[webhook] Adaptador iniciado (unidireccional).');
+  }
+
+  async stop() {
+    this.running = false;
+    console.log('[webhook] Adaptador detenido.');
+  }
+
+  async send(message) {
+    const url = this.config.url || process.env.WEBHOOK_URL;
+    if (!url) return false;
+
+    const payload = {
+      source: 'swl-ses',
+      timestamp: new Date().toISOString(),
+      ...message,
+      text: this.formatMessage(message),
+    };
+
+    try {
+      await _postJSON(url, payload, this.config.secret || process.env.WEBHOOK_SECRET);
+      return true;
+    } catch (err) {
+      console.error(`[webhook] Error: ${err.message}`);
+      return false;
+    }
+  }
+}
+
+/**
+ * POST JSON a una URL con timeout y HMAC opcional.
+ * @param {string} url
+ * @param {object} data
+ * @param {string} [secret]
+ * @returns {Promise<string>}
+ */
+function _postJSON(url, data, secret) {
+  return new Promise((resolve, reject) => {
+    const parsed  = new URL(url);
+    const client  = parsed.protocol === 'https:' ? https : http;
+    const body    = JSON.stringify(data);
+    const headers = {
+      'Content-Type': 'application/json',
+      'Content-Length': Buffer.byteLength(body),
+      'User-Agent': 'SWL-SES-Gateway/1.0',
+    };
+
+    // HMAC signature si hay secret
+    if (secret) {
+      const crypto = require('crypto');
+      const sig = crypto.createHmac('sha256', secret).update(body).digest('hex');
+      headers['X-SWL-Signature'] = `sha256=${sig}`;
+    }
+
+    const req = client.request({
+      hostname: parsed.hostname,
+      port:     parsed.port,
+      path:     parsed.pathname + parsed.search,
+      method:   'POST',
+      headers,
+      timeout:  10000,
+    }, (res) => {
+      let responseBody = '';
+      res.on('data', chunk => responseBody += chunk);
+      res.on('end', () => {
+        if (res.statusCode >= 200 && res.statusCode < 300) {
+          resolve(responseBody);
+        } else {
+          reject(new Error(`HTTP ${res.statusCode}: ${responseBody.substring(0, 200)}`));
+        }
+      });
+    });
+
+    req.on('error', reject);
+    req.on('timeout', () => { req.destroy(); reject(new Error('Timeout')); });
+    req.write(body);
+    req.end();
+  });
+}
+
+module.exports = WebhookAdapter;