@saulwade/swl-ses 1.3.8 → 1.4.1

package/gateway/index.js

@@ -0,0 +1,320 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Gateway Runner — Orquestador multi-plataforma para SWL-SES.
+ *
+ * Conecta el sistema SWL con plataformas de mensajería externas
+ * (Telegram, Discord, Webhook) para notificaciones bidireccionales.
+ *
+ * Arquitectura:
+ *   Claude Code (SWL) ←→ .planning/comms/ ←→ Gateway ←→ Plataformas
+ *
+ * Flujos:
+ *   SWL → Plataforma: Polling de .planning/comms/ cada N segundos
+ *   Plataforma → SWL: Escribir comandos en .planning/comms/
+ *
+ * Inspirado en Hermes Agent (gateway/run.py).
+ *
+ * Uso:
+ *   node gateway/index.js [baseDir]
+ *   node gateway/index.js --config manifiestos/gateway-config.json
+ *
+ * @module gateway/index
+ */
+
+const fs   = require('fs');
+const path = require('path');
+
+// ---------------------------------------------------------------------------
+// Constantes
+// ---------------------------------------------------------------------------
+
+const DEFAULT_POLL_INTERVAL = 2000; // 2 segundos
+const COMMS_DIR = '.planning/comms';
+
+// ---------------------------------------------------------------------------
+// Carga de configuración
+// ---------------------------------------------------------------------------
+
+/**
+ * Carga la configuración del gateway desde archivo o defaults.
+ * @param {string} baseDir
+ * @returns {object}
+ */
+function loadConfig(baseDir) {
+  const configPath = path.join(baseDir, 'manifiestos', 'gateway-config.json');
+  const defaults = {
+    enabled: false,
+    pollIntervalMs: DEFAULT_POLL_INTERVAL,
+    adapters: {
+      telegram: { enabled: false },
+      discord:  { enabled: false },
+      webhook:  { enabled: false },
+    },
+    notifications: {
+      onSessionComplete: true,
+      onCheckpoint: true,
+      onError: true,
+      onRelease: true,
+      onBuildFail: true,
+    },
+  };
+
+  try {
+    if (fs.existsSync(configPath)) {
+      const loaded = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+      return { ...defaults, ...loaded, adapters: { ...defaults.adapters, ...loaded.adapters } };
+    }
+  } catch (_) {}
+
+  return defaults;
+}
+
+// ---------------------------------------------------------------------------
+// Gateway Runner
+// ---------------------------------------------------------------------------
+
+class GatewayRunner {
+  constructor(baseDir) {
+    this.baseDir  = baseDir;
+    this.config   = loadConfig(baseDir);
+    this.adapters = [];
+    this._pollInterval = null;
+    this._running = false;
+
+    // CommandRelay opt-in — activo si config.relay.enabled === true.
+    // Permite recibir comandos bidireccionales desde canales externos
+    // (ej. Telegram) hacia Claude Code con validaciones de seguridad.
+    try {
+      const CommandRelay = require('./command-relay');
+      this.relay = new CommandRelay(baseDir, this.config);
+    } catch (_) {
+      this.relay = null;
+    }
+  }
+
+  /**
+   * Inicializa y arranca todos los adaptadores habilitados.
+   */
+  async start() {
+    if (!this.config.enabled) {
+      console.log('[gateway] Gateway deshabilitado en configuración. Activar con enabled: true.');
+      return;
+    }
+
+    console.log('[gateway] Iniciando gateway...');
+
+    // Cargar adaptadores habilitados
+    const adapterConfigs = this.config.adapters;
+
+    if (adapterConfigs.telegram?.enabled) {
+      const TelegramAdapter = require('./adapters/telegram');
+      const adapter = new TelegramAdapter(adapterConfigs.telegram);
+      adapter.onMessage((msg) => this._handleIncoming(msg));
+      await adapter.start();
+      if (adapter.running) this.adapters.push(adapter);
+    }
+
+    if (adapterConfigs.discord?.enabled) {
+      const DiscordAdapter = require('./adapters/discord');
+      const adapter = new DiscordAdapter(adapterConfigs.discord);
+      adapter.onMessage((msg) => this._handleIncoming(msg));
+      await adapter.start();
+      if (adapter.running) this.adapters.push(adapter);
+    }
+
+    if (adapterConfigs.webhook?.enabled) {
+      const WebhookAdapter = require('./adapters/webhook');
+      const adapter = new WebhookAdapter(adapterConfigs.webhook);
+      await adapter.start();
+      if (adapter.running) this.adapters.push(adapter);
+    }
+
+    if (adapterConfigs.whatsapp?.enabled) {
+      const WhatsAppAdapter = require('./adapters/whatsapp');
+      const adapter = new WhatsAppAdapter(adapterConfigs.whatsapp);
+      adapter.onMessage((msg) => this._handleIncoming(msg));
+      await adapter.start();
+      if (adapter.running) this.adapters.push(adapter);
+    }
+
+    if (adapterConfigs.slack?.enabled) {
+      const SlackAdapter = require('./adapters/slack');
+      const adapter = new SlackAdapter(adapterConfigs.slack);
+      adapter.onMessage((msg) => this._handleIncoming(msg));
+      await adapter.start();
+      if (adapter.running) this.adapters.push(adapter);
+    }
+
+    if (adapterConfigs.email?.enabled) {
+      const EmailAdapter = require('./adapters/email');
+      const adapter = new EmailAdapter(adapterConfigs.email);
+      await adapter.start();
+      if (adapter.running) this.adapters.push(adapter);
+    }
+
+    if (this.adapters.length === 0) {
+      console.log('[gateway] Ningún adaptador habilitado o disponible.');
+      return;
+    }
+
+    console.log(`[gateway] ${this.adapters.length} adaptador(es) activo(s): ${this.adapters.map(a => a.name).join(', ')}`);
+
+    // Iniciar polling de agent-comms
+    this._running = true;
+    this._pollInterval = setInterval(
+      () => this._pollComms(),
+      this.config.pollIntervalMs || DEFAULT_POLL_INTERVAL,
+    );
+
+    console.log(`[gateway] Polling activo (cada ${this.config.pollIntervalMs || DEFAULT_POLL_INTERVAL}ms).`);
+  }
+
+  /**
+   * Detiene todos los adaptadores y el polling.
+   */
+  async stop() {
+    this._running = false;
+    if (this._pollInterval) {
+      clearInterval(this._pollInterval);
+      this._pollInterval = null;
+    }
+
+    for (const adapter of this.adapters) {
+      await adapter.stop();
+    }
+
+    this.adapters = [];
+    console.log('[gateway] Detenido.');
+  }
+
+  /**
+   * Poll de .planning/comms/ buscando mensajes tipo gateway_notification.
+   * @private
+   */
+  _pollComms() {
+    const commsDir = path.join(this.baseDir, COMMS_DIR);
+    if (!fs.existsSync(commsDir)) return;
+
+    let files;
+    try {
+      files = fs.readdirSync(commsDir)
+        .filter(f => f.startsWith('msg-') && f.endsWith('.json'));
+    } catch (_) {
+      return;
+    }
+
+    for (const file of files) {
+      const filePath = path.join(commsDir, file);
+      let msg;
+      try {
+        msg = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+      } catch (_) {
+        continue;
+      }
+
+      // Solo procesar mensajes de gateway pendientes
+      if (msg.status !== 'pending') continue;
+      if (msg.type !== 'gateway_notification' && msg.type !== 'gateway_command_response') continue;
+
+      // Despachar a adaptador(es) correspondientes
+      const target = msg.to || 'all';
+      this._dispatch(target, msg);
+
+      // Marcar como procesado
+      try {
+        msg.status = 'processed';
+        msg.processedAt = new Date().toISOString();
+        fs.writeFileSync(filePath, JSON.stringify(msg, null, 2), 'utf8');
+      } catch (_) {}
+    }
+  }
+
+  /**
+   * Despacha un mensaje a el/los adaptador(es) objetivo.
+   * @private
+   */
+  _dispatch(target, message) {
+    for (const adapter of this.adapters) {
+      if (target === 'all' || target === adapter.name || target === 'broadcast') {
+        adapter.send(message).catch(err => {
+          console.error(`[gateway] Error despachando a ${adapter.name}: ${err.message}`);
+        });
+      }
+    }
+  }
+
+  /**
+   * Maneja un mensaje entrante de una plataforma.
+   * Escribe en .planning/comms/ para que Claude Code lo procese.
+   * Adicionalmente, si el CommandRelay está habilitado para la plataforma
+   * y el usuario, encola en .planning/inbox/ para consumo vía /swl:inbox.
+   * @private
+   */
+  _handleIncoming(message) {
+    const commsDir = path.join(this.baseDir, COMMS_DIR);
+    if (!fs.existsSync(commsDir)) {
+      fs.mkdirSync(commsDir, { recursive: true });
+    }
+
+    const id = `msg-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 6)}`;
+    const msg = {
+      id,
+      type: 'gateway_command',
+      from: `${message.platform}:${message.userId || 'unknown'}`,
+      to: 'swl-system',
+      payload: {
+        platform: message.platform,
+        chatId:   message.chatId,
+        userId:   message.userId,
+        userName: message.userName,
+        text:     message.text,
+        command:  message.command,
+        args:     message.args,
+      },
+      timestamp: new Date().toISOString(),
+      status: 'pending',
+    };
+
+    const filePath = path.join(commsDir, `${id}.json`);
+    try {
+      fs.writeFileSync(filePath, JSON.stringify(msg, null, 2), 'utf8');
+    } catch (_) {}
+
+    // Relay bidireccional: encolar también en .planning/inbox/ si aplica.
+    if (this.relay && this.relay.habilitado()) {
+      try {
+        this.relay.recibirComando(message);
+      } catch (_) { /* silencioso */ }
+    }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Entrypoint CLI
+// ---------------------------------------------------------------------------
+
+if (require.main === module) {
+  const baseDir = process.argv[2] || process.cwd();
+
+  const gateway = new GatewayRunner(baseDir);
+
+  const cleanup = async () => {
+    await gateway.stop();
+    process.exit(0);
+  };
+  process.on('SIGTERM', cleanup);
+  process.on('SIGINT', cleanup);
+
+  gateway.start().catch(err => {
+    console.error(`[gateway] Error fatal: ${err.message}`);
+    process.exit(1);
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Exports
+// ---------------------------------------------------------------------------
+
+module.exports = { GatewayRunner, loadConfig };

package/gateway/lib/event-channel.js

@@ -0,0 +1,191 @@
+'use strict';
+
+/**
+ * event-channel.js
+ *
+ * Pub/sub event channel para CommandRelay y otros componentes del gateway.
+ *
+ * Patrón adaptado de `temp/obsidian-agent-client-master/src/acp/acp-handler.ts`
+ * (Set<listeners> con callback unsubscribe). Diferencias:
+ *   - Zero-deps Node.js (sin RxJS, sin EventEmitter de node — Set nativo).
+ *   - Backward compat: si no hay listeners, comportamiento idéntico al actual.
+ *   - Tipos de evento explícitos para evitar typos.
+ *
+ * Casos de uso en SWL:
+ *   - CommandRelay emite eventos al recibir/aceptar/rechazar/procesar comandos.
+ *   - Múltiples adaptadores (Telegram, Discord) pueden suscribirse simultáneamente.
+ *   - El consumidor /swl:inbox puede mostrar progreso sin polling.
+ *
+ * Uso:
+ *   const channel = new EventChannel();
+ *   const off = channel.on('cmd:queued', (event) => console.log(event));
+ *   channel.emit({ type: 'cmd:queued', commandId: 'cmd-abc', userId: '123' });
+ *   off();  // unsubscribe
+ *
+ * @module gateway/lib/event-channel
+ */
+
+// ── tipos de evento ──────────────────────────────────────────────────────────
+
+/**
+ * Tipos válidos de evento. Se usan strings para serializar fácilmente
+ * a JSONL si se requiere persistencia (no obligatorio).
+ */
+const EVENTS = Object.freeze({
+  // Lifecycle de comandos en CommandRelay
+  CMD_RECEIVED:  'cmd:received',   // mensaje llegó al relay
+  CMD_REJECTED:  'cmd:rejected',   // rechazado por validación (auth/rate/dedup)
+  CMD_QUEUED:    'cmd:queued',     // encolado en .planning/inbox/
+  CMD_PROCESSED: 'cmd:processed',  // marcado como procesado por consumidor
+
+  // Lifecycle de notificaciones
+  NOTIFICATION_SENT:   'notification:sent',
+  NOTIFICATION_FAILED: 'notification:failed',
+});
+
+// ── implementación ────────────────────────────────────────────────────────────
+
+/**
+ * Canal de eventos pub/sub con escucha por tipo o wildcard.
+ *
+ * Mantiene dos estructuras:
+ *   - listenersByType: Map<eventType, Set<callback>>
+ *   - wildcardListeners: Set<callback>  (escuchan TODOS los eventos)
+ *
+ * Una excepción en un listener NO interrumpe la propagación a los demás —
+ * patrón de aislamiento del mismo origen (acp-handler.ts:47-50).
+ */
+class EventChannel {
+  constructor() {
+    this.listenersByType = new Map();
+    this.wildcardListeners = new Set();
+    this.errorHandler = null;  // opcional: callback para errores en listeners
+  }
+
+  /**
+   * Suscribe un listener a un tipo de evento (o '*' para todos).
+   *
+   * @param {string} eventType - tipo de evento o '*'
+   * @param {function} callback - recibe el objeto event
+   * @returns {function} función de unsubscribe (idempotente)
+   */
+  on(eventType, callback) {
+    if (typeof callback !== 'function') {
+      throw new TypeError('callback debe ser función');
+    }
+    if (typeof eventType !== 'string' || !eventType) {
+      throw new TypeError('eventType debe ser string no vacío');
+    }
+
+    if (eventType === '*') {
+      this.wildcardListeners.add(callback);
+      return () => this.wildcardListeners.delete(callback);
+    }
+
+    if (!this.listenersByType.has(eventType)) {
+      this.listenersByType.set(eventType, new Set());
+    }
+    const set = this.listenersByType.get(eventType);
+    set.add(callback);
+    return () => set.delete(callback);
+  }
+
+  /**
+   * Suscribe un listener que se invoca UNA sola vez y luego se desuscribe.
+   */
+  once(eventType, callback) {
+    const off = this.on(eventType, (event) => {
+      off();
+      callback(event);
+    });
+    return off;
+  }
+
+  /**
+   * Emite un evento a todos los listeners suscriptos al tipo + wildcards.
+   * El evento debe tener al menos `type`. Se enriquece con `ts` (ISO).
+   *
+   * @param {object} event - objeto con `type` y datos arbitrarios
+   * @returns {number} cantidad de listeners notificados
+   */
+  emit(event) {
+    if (!event || typeof event !== 'object') {
+      throw new TypeError('event debe ser objeto');
+    }
+    if (typeof event.type !== 'string' || !event.type) {
+      throw new TypeError('event.type es obligatorio');
+    }
+
+    const enriched = { ts: new Date().toISOString(), ...event };
+    let notified = 0;
+
+    // Listeners específicos del tipo
+    const typedSet = this.listenersByType.get(enriched.type);
+    if (typedSet) {
+      for (const cb of typedSet) {
+        notified++;
+        this._safeInvoke(cb, enriched);
+      }
+    }
+
+    // Listeners wildcard
+    for (const cb of this.wildcardListeners) {
+      notified++;
+      this._safeInvoke(cb, enriched);
+    }
+
+    return notified;
+  }
+
+  /**
+   * Cuenta de listeners para un tipo (o total si no se pasa tipo).
+   */
+  listenerCount(eventType) {
+    if (eventType == null) {
+      let total = this.wildcardListeners.size;
+      for (const set of this.listenersByType.values()) total += set.size;
+      return total;
+    }
+    if (eventType === '*') return this.wildcardListeners.size;
+    const set = this.listenersByType.get(eventType);
+    return (set ? set.size : 0) + this.wildcardListeners.size;
+  }
+
+  /**
+   * Limpia todos los listeners. Útil para tests.
+   */
+  clear() {
+    this.listenersByType.clear();
+    this.wildcardListeners.clear();
+  }
+
+  /**
+   * Asigna un handler para errores en listeners.
+   * Si no se asigna, los errores se silencian (no rompen la propagación).
+   */
+  onError(handler) {
+    if (typeof handler !== 'function') {
+      throw new TypeError('handler debe ser función');
+    }
+    this.errorHandler = handler;
+  }
+
+  // ── internos ────────────────────────────────────────────────────────────────
+
+  _safeInvoke(cb, event) {
+    try {
+      cb(event);
+    } catch (err) {
+      if (this.errorHandler) {
+        try { this.errorHandler(err, event); } catch (_) { /* silencioso */ }
+      }
+    }
+  }
+}
+
+// ── exports ───────────────────────────────────────────────────────────────────
+
+module.exports = {
+  EventChannel,
+  EVENTS,
+};

package/gateway/session.js

@@ -0,0 +1,131 @@
+'use strict';
+
+/**
+ * Gateway Session — Gestión de sesiones por plataforma.
+ *
+ * Mantiene un mapeo entre usuarios de plataformas externas y sesiones SWL.
+ * Permite que un usuario de Telegram tenga una "sesión" persistente con el gateway.
+ *
+ * Persistencia en .planning/gateway-sessions.json.
+ *
+ * @module gateway/session
+ */
+
+const fs   = require('fs');
+const path = require('path');
+
+const { atomicWriteJSON } = require('../hooks/lib/atomic-write');
+
+// ---------------------------------------------------------------------------
+// Constantes
+// ---------------------------------------------------------------------------
+
+const SESSIONS_FILE    = '.planning/gateway-sessions.json';
+const INACTIVITY_MS    = 30 * 60 * 1000; // 30 minutos
+const MAX_SESSIONS     = 100;
+
+// ---------------------------------------------------------------------------
+// API
+// ---------------------------------------------------------------------------
+
+/**
+ * Obtiene o crea una sesión para un usuario de plataforma.
+ *
+ * @param {string} baseDir
+ * @param {string} platformUserId - Identificador único: "telegram:12345"
+ * @returns {object} Sesión con lastActivity actualizada.
+ */
+function getOrCreateSession(baseDir, platformUserId) {
+  const sessions = _loadSessions(baseDir);
+  const now = Date.now();
+
+  let session = sessions[platformUserId];
+
+  if (session) {
+    // Verificar timeout de inactividad
+    if (now - session.lastActivity > INACTIVITY_MS) {
+      // Sesión expirada — crear nueva
+      session = _newSession(platformUserId);
+    } else {
+      session.lastActivity = now;
+    }
+  } else {
+    session = _newSession(platformUserId);
+  }
+
+  sessions[platformUserId] = session;
+
+  // Limitar número total de sesiones (FIFO)
+  const keys = Object.keys(sessions);
+  if (keys.length > MAX_SESSIONS) {
+    // Eliminar las más antiguas
+    const sorted = keys.sort((a, b) => sessions[a].lastActivity - sessions[b].lastActivity);
+    for (let i = 0; i < keys.length - MAX_SESSIONS; i++) {
+      delete sessions[sorted[i]];
+    }
+  }
+
+  _saveSessions(baseDir, sessions);
+  return session;
+}
+
+/**
+ * Lista todas las sesiones activas (no expiradas).
+ *
+ * @param {string} baseDir
+ * @returns {object[]}
+ */
+function listActiveSessions(baseDir) {
+  const sessions = _loadSessions(baseDir);
+  const now = Date.now();
+
+  return Object.entries(sessions)
+    .filter(([, s]) => now - s.lastActivity <= INACTIVITY_MS)
+    .map(([userId, s]) => ({ userId, ...s }));
+}
+
+/**
+ * Invalida una sesión específica.
+ *
+ * @param {string} baseDir
+ * @param {string} platformUserId
+ */
+function invalidateSession(baseDir, platformUserId) {
+  const sessions = _loadSessions(baseDir);
+  delete sessions[platformUserId];
+  _saveSessions(baseDir, sessions);
+}
+
+// ---------------------------------------------------------------------------
+// Helpers internos
+// ---------------------------------------------------------------------------
+
+function _newSession(platformUserId) {
+  const [platform, userId] = platformUserId.split(':');
+  return {
+    id: `gw-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 6)}`,
+    platform,
+    userId,
+    createdAt: Date.now(),
+    lastActivity: Date.now(),
+    context: {},
+  };
+}
+
+function _loadSessions(baseDir) {
+  const p = path.join(baseDir, SESSIONS_FILE);
+  try {
+    if (!fs.existsSync(p)) return {};
+    return JSON.parse(fs.readFileSync(p, 'utf8'));
+  } catch (_) {
+    return {};
+  }
+}
+
+function _saveSessions(baseDir, sessions) {
+  const dir = path.dirname(path.join(baseDir, SESSIONS_FILE));
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  atomicWriteJSON(path.join(baseDir, SESSIONS_FILE), sessions);
+}
+
+module.exports = { getOrCreateSession, listActiveSessions, invalidateSession };