@saulwade/swl-ses 1.3.8 → 1.4.0

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;

package/gateway/adapters/whatsapp.js

@@ -0,0 +1,214 @@
+'use strict';
+
+/**
+ * WhatsApp Adapter — Adaptador para WhatsApp Business API / bridges.
+ *
+ * Soporta dos modos:
+ *   1. WhatsApp Business API (Cloud API de Meta) — producción
+ *   2. whatsapp-web.js (bridge no oficial) — desarrollo/personal
+ *
+ * Ambos modos son bidireccionales: envío y recepción de mensajes.
+ *
+ * Dependencia modo Business API: ninguna (HTTP nativo)
+ * Dependencia modo bridge: whatsapp-web.js (npm install whatsapp-web.js)
+ *
+ * @module gateway/adapters/whatsapp
+ */
+
+const BaseAdapter = require('./base');
+const https = require('https');
+
+/** Límite de caracteres por mensaje de WhatsApp. */
+const MAX_MSG_LENGTH = 4096;
+
+/** Comandos reconocidos. */
+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 WhatsAppAdapter extends BaseAdapter {
+  constructor(config) {
+    super('whatsapp', config);
+    this._client = null;
+    this._mode = config.mode || 'business'; // 'business' | 'bridge'
+  }
+
+  async start() {
+    if (this._mode === 'bridge') {
+      return this._startBridge();
+    }
+    return this._startBusinessAPI();
+  }
+
+  /**
+   * Modo Business API (Cloud API de Meta).
+   * Requiere: WHATSAPP_TOKEN, WHATSAPP_PHONE_ID
+   */
+  async _startBusinessAPI() {
+    const token   = this.config.token || process.env.WHATSAPP_TOKEN;
+    const phoneId = this.config.phoneId || process.env.WHATSAPP_PHONE_ID;
+
+    if (!token || !phoneId) {
+      console.log('[whatsapp] Token o Phone ID no configurado. Establecer WHATSAPP_TOKEN y WHATSAPP_PHONE_ID.');
+      return;
+    }
+
+    this._token   = token;
+    this._phoneId = phoneId;
+    this.running  = true;
+    console.log('[whatsapp] Adaptador iniciado (Business API mode).');
+  }
+
+  /**
+   * Modo bridge con whatsapp-web.js.
+   * Requiere: npm install whatsapp-web.js
+   */
+  async _startBridge() {
+    let wwjs;
+    try {
+      wwjs = require('whatsapp-web.js');
+    } catch (_) {
+      console.log('[whatsapp] whatsapp-web.js no instalado. Ejecutar: npm install whatsapp-web.js');
+      return;
+    }
+
+    const { Client, LocalAuth } = wwjs;
+
+    this._client = new Client({
+      authStrategy: new LocalAuth({ dataPath: '.planning/whatsapp-session' }),
+      puppeteer: { headless: true },
+    });
+
+    this._client.on('qr', (qr) => {
+      console.log('[whatsapp] Escanea el código QR para conectar:');
+      console.log('[whatsapp] QR:', qr.substring(0, 50) + '...');
+    });
+
+    this._client.on('ready', () => {
+      this.running = true;
+      console.log('[whatsapp] Adaptador iniciado (bridge mode).');
+    });
+
+    this._client.on('message', (msg) => {
+      if (msg.fromMe) return;
+
+      const text    = msg.body || '';
+      const parts   = text.split(/\s+/);
+      const command = COMMANDS[parts[0]] ? parts[0] : null;
+      const args    = command ? parts.slice(1).join(' ') : '';
+
+      this._emitMessage({
+        chatId:   msg.from,
+        userId:   msg.from,
+        userName: msg._data?.notifyName || msg.from,
+        text:     text,
+        command:  command,
+        args:     args,
+        raw:      msg,
+      });
+    });
+
+    this._client.on('auth_failure', () => {
+      console.error('[whatsapp] Autenticación fallida. Eliminar .planning/whatsapp-session/ y reiniciar.');
+    });
+
+    try {
+      await this._client.initialize();
+    } catch (err) {
+      console.error(`[whatsapp] Error inicializando: ${err.message}`);
+    }
+  }
+
+  async stop() {
+    if (this._client) {
+      try { await this._client.destroy(); } catch (_) {}
+      this._client = null;
+    }
+    this.running = false;
+    console.log('[whatsapp] Adaptador detenido.');
+  }
+
+  async send(message) {
+    const chatId = message.chatId || this.config.defaultChat;
+    if (!chatId) return false;
+
+    const text = this.formatMessage(message);
+
+    if (this._mode === 'business') {
+      return this._sendBusinessAPI(chatId, text);
+    }
+
+    // Bridge mode
+    if (!this._client) return false;
+    try {
+      await this._client.sendMessage(chatId, text);
+      return true;
+    } catch (err) {
+      console.error(`[whatsapp] Error enviando: ${err.message}`);
+      return false;
+    }
+  }
+
+  /**
+   * Envía mensaje via WhatsApp Business Cloud API.
+   */
+  async _sendBusinessAPI(to, text) {
+    if (!this._token || !this._phoneId) return false;
+
+    const body = JSON.stringify({
+      messaging_product: 'whatsapp',
+      to: to.replace(/[^0-9]/g, ''),
+      type: 'text',
+      text: { body: text.substring(0, MAX_MSG_LENGTH) },
+    });
+
+    return new Promise((resolve) => {
+      const req = https.request({
+        hostname: 'graph.facebook.com',
+        path: `/v18.0/${this._phoneId}/messages`,
+        method: 'POST',
+        headers: {
+          'Authorization': `Bearer ${this._token}`,
+          '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();
+    });
+  }
+
+  formatMessage(swlMessage) {
+    const payload = swlMessage.payload || swlMessage;
+
+    if (payload.jobName) {
+      const icon = payload.status === 'completed' ? '✅' : '❌';
+      const lines = [
+        `${icon} *${payload.jobName}*`,
+        `Estado: ${payload.status}`,
+      ];
+      if (payload.output) {
+        lines.push('```' + payload.output.substring(0, 800) + '```');
+      }
+      return lines.join('\n');
+    }
+
+    return swlMessage.text || JSON.stringify(payload).substring(0, 500);
+  }
+}
+
+module.exports = WhatsAppAdapter;