@saulwade/swl-ses 1.3.8 → 1.4.1

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;

package/gateway/agent-executor.js

@@ -0,0 +1,322 @@
+'use strict';
+
+/**
+ * agent-executor.js
+ *
+ * Contrato unificado de ejecución de agentes SWL.
+ *
+ * Implementa el patrón "execute(name, input) → string" de Managed Agents:
+ * cualquier agente SWL expone la misma interfaz al orquestador, independientemente
+ * de su tipo (implementador, planificador, revisor, etc.).
+ *
+ * Esto permite que el gateway/cron y el orquestador-swl invoquen agentes
+ * de forma programática con trazabilidad completa via run-log.js y HandoffContext.
+ *
+ * Integra con:
+ *   - manifiestos/handoff-context.json  — schema de trazabilidad entre agentes
+ *   - hooks/lib/run-log.js              — observabilidad de invocaciones
+ *   - hooks/lib/abort-registry.js       — cancelación cooperativa
+ *
+ * Uso:
+ *   const executor = require('./agent-executor');
+ *
+ *   // Invocación simple
+ *   const result = await executor.executeAgent('planificador-swl', 'Planifica la feature X');
+ *
+ *   // Con HandoffContext (trazabilidad multi-agente)
+ *   const result = await executor.executeAgent('implementador-swl', prompt, {
+ *     handoff: {
+ *       reason:        'task_delegation',
+ *       parentAgent:   'orquestador-swl',
+ *       transferCount: 1,
+ *       sessionId:     'abc123',
+ *     },
+ *     timeoutMs: 300_000,
+ *   });
+ *
+ *   console.log(result.output);   // string con respuesta del agente
+ *   console.log(result.status);   // 'completed' | 'failed' | 'aborted' | 'timeout'
+ *   console.log(result.handoff);  // HandoffContext actualizado (transferCount++)
+ *
+ * @module gateway/agent-executor
+ */
+
+const { execFile }  = require('child_process');
+const path          = require('path');
+
+// run-log puede no estar disponible fuera del repo — importación defensiva
+let runLog;
+try { runLog = require('../hooks/lib/run-log'); } catch (_) { runLog = null; }
+
+// abort-registry — cancelación cooperativa
+let abortRegistry;
+try { abortRegistry = require('../hooks/lib/abort-registry'); } catch (_) { abortRegistry = null; }
+
+// ---------------------------------------------------------------------------
+// Constantes
+// ---------------------------------------------------------------------------
+
+/** Máximo de transferencias en cadena antes de rechazar (anti-loop). */
+const MAX_TRANSFER_COUNT = 10;
+
+/** Timeout por defecto en ms (5 minutos). */
+const DEFAULT_TIMEOUT_MS = 300_000;
+
+/** Modelo Claude por defecto para agentes programáticos. */
+const DEFAULT_MODEL = 'claude-sonnet-4-6';
+
+// ---------------------------------------------------------------------------
+// Tipos (JSDoc)
+// ---------------------------------------------------------------------------
+
+/**
+ * @typedef {{
+ *   reason:        string,
+ *   parentAgent:   string,
+ *   transferCount: number,
+ *   sessionId?:    string,
+ *   metadata?:     object,
+ * }} HandoffContext
+ *
+ * @typedef {{
+ *   output:    string,
+ *   sessionId: string|null,
+ *   status:    'completed'|'failed'|'aborted'|'timeout',
+ *   handoff:   HandoffContext|null,
+ *   durationMs: number,
+ *   error?:    string,
+ * }} ExecuteResult
+ *
+ * @typedef {{
+ *   handoff?:   HandoffContext,
+ *   sessionId?: string,
+ *   timeoutMs?: number,
+ *   model?:     string,
+ *   cwd?:       string,
+ * }} ExecuteOptions
+ */
+
+// ---------------------------------------------------------------------------
+// API principal
+// ---------------------------------------------------------------------------
+
+/**
+ * Ejecuta un agente SWL con una entrada dada y retorna su output.
+ * Implementa el contrato unificado execute(name, input) → string de Managed Agents.
+ *
+ * @param {string}         agentName - Nombre del agente SWL (ej: 'planificador-swl').
+ * @param {string}         input     - Prompt de entrada para el agente.
+ * @param {ExecuteOptions} [opts]    - Opciones de ejecución.
+ * @returns {Promise<ExecuteResult>}
+ */
+async function executeAgent(agentName, input, opts) {
+  const {
+    handoff    = null,
+    sessionId  = null,
+    timeoutMs  = DEFAULT_TIMEOUT_MS,
+    model      = DEFAULT_MODEL,
+    cwd        = process.cwd(),
+  } = opts || {};
+
+  const startMs = Date.now();
+
+  // --- Validación de anti-loop de HandoffContext ---
+  if (handoff && handoff.transferCount >= MAX_TRANSFER_COUNT) {
+    return {
+      output:     '',
+      sessionId,
+      status:     'failed',
+      handoff:    null,
+      durationMs: 0,
+      error:      `transferCount (${handoff.transferCount}) supera el máximo permitido (${MAX_TRANSFER_COUNT}). Posible loop de agentes.`,
+    };
+  }
+
+  // --- Verificar si hay abort activo ---
+  if (abortRegistry) {
+    try {
+      const estado = abortRegistry.getStatus();
+      if (estado === 'force' || estado === 'graceful') {
+        return {
+          output:     '',
+          sessionId,
+          status:     'aborted',
+          handoff:    null,
+          durationMs: Date.now() - startMs,
+          error:      `Ejecución cancelada: abort ${estado} activo.`,
+        };
+      }
+    } catch (_) { /* abort-registry no crítico */ }
+  }
+
+  // --- Registrar invocación en run-log ---
+  if (runLog && sessionId) {
+    try {
+      runLog.agentInvoked(sessionId, agentName);
+    } catch (_) { /* observabilidad no crítica */ }
+  }
+
+  // --- Construir HandoffContext actualizado ---
+  const handoffActualizado = handoff ? {
+    ...handoff,
+    transferCount: handoff.transferCount + 1,
+    sessionId:     sessionId || handoff.sessionId,
+  } : null;
+
+  // --- Construir prompt con contexto de agente ---
+  const promptCompleto = _buildPrompt(agentName, input, handoffActualizado);
+
+  // --- Ejecutar via claude CLI ---
+  return new Promise((resolve) => {
+    const args = [
+      '--print',
+      '--model', model,
+      '--no-update-check',
+      promptCompleto,
+    ];
+
+    let stdout = '';
+    let stderr = '';
+    let timedOut = false;
+
+    const proc = execFile('claude', args, {
+      cwd,
+      timeout:   timeoutMs,
+      maxBuffer: 10 * 1024 * 1024, // 10 MB
+      env:       { ...process.env },
+    }, (err, out, err2) => {
+      stdout = out || '';
+      stderr = err2 || '';
+
+      const durationMs = Date.now() - startMs;
+
+      if (timedOut) {
+        resolve({ output: stdout, sessionId, status: 'timeout', handoff: handoffActualizado, durationMs, error: 'timeout' });
+        return;
+      }
+
+      if (err && !stdout) {
+        resolve({
+          output:     stderr || err.message,
+          sessionId,
+          status:     'failed',
+          handoff:    handoffActualizado,
+          durationMs,
+          error:      err.message,
+        });
+        return;
+      }
+
+      resolve({
+        output:    stdout.trim(),
+        sessionId,
+        status:    'completed',
+        handoff:   handoffActualizado,
+        durationMs,
+      });
+    });
+
+    proc.on('error', (err) => {
+      if (err.code === 'ETIMEDOUT') timedOut = true;
+    });
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Construye el prompt completo incluyendo el rol del agente y el HandoffContext.
+ * El agente recibirá suficiente contexto para actuar sin conocer la conversación padre.
+ *
+ * @param {string}           agentName
+ * @param {string}           input
+ * @param {HandoffContext|null} handoff
+ * @returns {string}
+ */
+function _buildPrompt(agentName, input, handoff) {
+  const partes = [];
+
+  if (handoff) {
+    partes.push(`[Contexto de transferencia]`);
+    partes.push(`Agente solicitante: ${handoff.parentAgent}`);
+    partes.push(`Motivo: ${handoff.reason}`);
+    partes.push(`Transferencia #${handoff.transferCount}`);
+    if (handoff.sessionId) partes.push(`Sesión: ${handoff.sessionId}`);
+    partes.push('');
+  }
+
+  partes.push(`Eres el agente ${agentName} del sistema SWL.`);
+  partes.push('');
+  partes.push(input);
+
+  return partes.join('\n');
+}
+
+// ---------------------------------------------------------------------------
+// Ejecución en lote (pipeline)
+// ---------------------------------------------------------------------------
+
+/**
+ * Ejecuta una secuencia de agentes en pipeline, pasando el output de cada uno
+ * como parte del input del siguiente. Implementa el patrón PipelineContext.
+ *
+ * @param {Array<{ agentName: string, buildInput: (prevOutput: string, stepResults: object[]) => string }>} pasos
+ * @param {{ pipelineName: string, sessionId?: string, timeoutMs?: number }} opts
+ * @returns {Promise<{ status: string, stepResults: object[], finalOutput: string }>}
+ */
+async function executePipeline(pasos, opts) {
+  const { pipelineName, sessionId = null, timeoutMs = DEFAULT_TIMEOUT_MS } = opts || {};
+  const stepResults = [];
+  let prevOutput    = '';
+  let finalOutput   = '';
+
+  for (let i = 0; i < pasos.length; i++) {
+    const { agentName, buildInput } = pasos[i];
+    const input = buildInput(prevOutput, stepResults);
+
+    const handoff = {
+      reason:        'pipeline_execution',
+      parentAgent:   pipelineName,
+      transferCount: i,
+      sessionId,
+      metadata: {
+        pipelineName,
+        currentStep: i + 1,
+        totalSteps:  pasos.length,
+        isLastStep:  i === pasos.length - 1,
+      },
+    };
+
+    const result = await executeAgent(agentName, input, { handoff, sessionId, timeoutMs });
+
+    stepResults.push({
+      step:      i + 1,
+      agentName,
+      output:    { text: result.output },
+      status:    result.status === 'completed' ? 'completed' : 'failed',
+      durationMs: result.durationMs,
+    });
+
+    if (result.status !== 'completed') {
+      return { status: result.status, stepResults, finalOutput: result.output };
+    }
+
+    prevOutput  = result.output;
+    finalOutput = result.output;
+  }
+
+  return { status: 'completed', stepResults, finalOutput };
+}
+
+// ---------------------------------------------------------------------------
+// Exports
+// ---------------------------------------------------------------------------
+
+module.exports = {
+  executeAgent,
+  executePipeline,
+  MAX_TRANSFER_COUNT,
+  DEFAULT_TIMEOUT_MS,
+};