@saulwade/swl-ses 1.3.7 → 1.4.0

package/gateway/command-relay.js

@@ -0,0 +1,271 @@
+'use strict';
+
+/**
+ * Command Relay — Componente que recibe comandos entrantes desde cualquier
+ * adaptador del gateway (Telegram, Discord, Webhook, etc.) y los encola en
+ * `.planning/inbox/` para su procesamiento por Claude Code.
+ *
+ * Complementa a GatewayRunner._handleIncoming() añadiendo:
+ *   - Whitelist estricta de usuarios (allowedUsers)
+ *   - Whitelist de plataformas con relay habilitado
+ *   - Sanitización de texto (previene payload injection)
+ *   - Audit trail en .planning/inbox/audit.jsonl
+ *   - Rate limiting por usuario (opcional)
+ *   - Dedup por content hash en ventana corta
+ *
+ * Inspirado en Claude-Code-Remote (smart-injector.js) pero portable
+ * Windows/Linux/macOS: no depende de AppleScript ni tmux. El consumo se
+ * realiza vía el comando /swl:inbox o un daemon tmux opt-in.
+ *
+ * Uso (desde gateway/index.js):
+ *   const relay = new CommandRelay(baseDir, config);
+ *   relay.recibirComando(message);
+ *
+ * @module gateway/command-relay
+ */
+
+const fs     = require('fs');
+const path   = require('path');
+const crypto = require('crypto');
+const { atomicWriteJSON } = require('../hooks/lib/atomic-write');
+const { EventChannel, EVENTS } = require('./lib/event-channel');
+
+const INBOX_DIR = '.planning/inbox';
+const AUDIT_FILE = 'audit.jsonl';
+const MAX_TEXT_LEN = 4000;
+const DEDUP_WINDOW_MS = 30 * 1000; // 30 segundos
+
+// Patrones prohibidos en el texto (prevención de payload injection básica)
+const PATRONES_PROHIBIDOS = [
+  /<\s*script/i,
+  /javascript:/i,
+  /data:text\/html/i,
+  // Referencias directas a archivos sensibles
+  /\.env\b/,
+  /id_rsa\b/,
+  /\.ssh\/\b/,
+];
+
+class CommandRelay {
+  /**
+   * @param {string} baseDir - Raíz del proyecto
+   * @param {object} config  - Configuración del gateway (gateway-config.json)
+   */
+  constructor(baseDir, config = {}) {
+    this.baseDir = baseDir;
+    this.relayConfig = config.relay || {};
+    this._dedupCache = new Map(); // hash → ts
+    this._rateCache  = new Map(); // userId → { ts, count }
+    this.events = new EventChannel();  // pub/sub: cmd:received|rejected|queued|processed
+  }
+
+  /**
+   * Suscribir a eventos del relay. Retorna función de unsubscribe.
+   * Tipos disponibles en EVENTS (gateway/lib/event-channel.js):
+   *   'cmd:received' | 'cmd:rejected' | 'cmd:queued' | 'cmd:processed' | '*'
+   */
+  on(eventType, callback) {
+    return this.events.on(eventType, callback);
+  }
+
+  /**
+   * Verifica si el relay está habilitado globalmente.
+   */
+  habilitado() {
+    return this.relayConfig.enabled === true;
+  }
+
+  /**
+   * Verifica si un usuario está autorizado para enviar comandos.
+   * @param {string} platform - nombre del adaptador (telegram, discord, etc.)
+   * @param {string} userId - ID del usuario en esa plataforma
+   */
+  usuarioAutorizado(platform, userId) {
+    if (!this.habilitado()) return false;
+    const platforms = this.relayConfig.platforms || {};
+    const pconf = platforms[platform];
+    if (!pconf || pconf.enabled !== true) return false;
+    const allowed = pconf.allowedUsers || [];
+    if (allowed.length === 0) return false; // sin whitelist, bloquear
+    return allowed.includes(String(userId));
+  }
+
+  /**
+   * Sanitiza un texto entrante. Retorna null si es inválido.
+   */
+  sanitizar(texto) {
+    if (typeof texto !== 'string') return null;
+    const t = texto.trim();
+    if (!t) return null;
+    if (t.length > MAX_TEXT_LEN) return null;
+    for (const re of PATRONES_PROHIBIDOS) {
+      if (re.test(t)) return null;
+    }
+    return t;
+  }
+
+  /**
+   * Rate limit simple: máx N mensajes por usuario cada M segundos.
+   */
+  dentroDeRateLimit(userId) {
+    const lim = this.relayConfig.rateLimit || { maxPerMinute: 10 };
+    const ventanaMs = 60 * 1000;
+    const ahora = Date.now();
+    const estado = this._rateCache.get(userId) || { resetAt: ahora + ventanaMs, count: 0 };
+    if (ahora > estado.resetAt) {
+      estado.resetAt = ahora + ventanaMs;
+      estado.count = 0;
+    }
+    estado.count += 1;
+    this._rateCache.set(userId, estado);
+    return estado.count <= (lim.maxPerMinute || 10);
+  }
+
+  /**
+   * Dedup por hash de contenido en ventana corta.
+   */
+  esDuplicado(platform, userId, texto) {
+    const hash = crypto.createHash('sha1')
+      .update(`${platform}:${userId}:${texto}`)
+      .digest('hex');
+    const ahora = Date.now();
+    // Limpiar entradas viejas
+    for (const [h, ts] of this._dedupCache.entries()) {
+      if (ahora - ts > DEDUP_WINDOW_MS) this._dedupCache.delete(h);
+    }
+    if (this._dedupCache.has(hash)) return true;
+    this._dedupCache.set(hash, ahora);
+    return false;
+  }
+
+  /**
+   * Recibe un comando entrante y lo encola en .planning/inbox/ si pasa
+   * todas las validaciones. Retorna { success: boolean, reason?: string, id?: string }.
+   */
+  recibirComando(message) {
+    if (!this.habilitado()) {
+      return { success: false, reason: 'relay-disabled' };
+    }
+
+    const platform = message.platform || 'unknown';
+    const userId   = String(message.userId || 'unknown');
+    const userName = message.userName || 'unknown';
+
+    this.events.emit({ type: EVENTS.CMD_RECEIVED, platform, userId, userName, textoPreview: (message.text || '').slice(0, 80) });
+
+    if (!this.usuarioAutorizado(platform, userId)) {
+      this._auditar({ platform, userId, userName, accion: 'rechazado', razon: 'usuario-no-autorizado', textoPreview: (message.text || '').slice(0, 80) });
+      this.events.emit({ type: EVENTS.CMD_REJECTED, platform, userId, userName, reason: 'user-not-authorized' });
+      return { success: false, reason: 'user-not-authorized' };
+    }
+
+    const texto = this.sanitizar(message.text || message.args || '');
+    if (!texto) {
+      this._auditar({ platform, userId, userName, accion: 'rechazado', razon: 'texto-invalido' });
+      this.events.emit({ type: EVENTS.CMD_REJECTED, platform, userId, userName, reason: 'invalid-text' });
+      return { success: false, reason: 'invalid-text' };
+    }
+
+    if (!this.dentroDeRateLimit(userId)) {
+      this._auditar({ platform, userId, userName, accion: 'rechazado', razon: 'rate-limit', textoPreview: texto.slice(0, 80) });
+      this.events.emit({ type: EVENTS.CMD_REJECTED, platform, userId, userName, reason: 'rate-limit-exceeded' });
+      return { success: false, reason: 'rate-limit-exceeded' };
+    }
+
+    if (this.esDuplicado(platform, userId, texto)) {
+      this._auditar({ platform, userId, userName, accion: 'dedup', textoPreview: texto.slice(0, 80) });
+      this.events.emit({ type: EVENTS.CMD_REJECTED, platform, userId, userName, reason: 'duplicate' });
+      return { success: false, reason: 'duplicate' };
+    }
+
+    // Encolar
+    const id = `cmd-${Date.now().toString(36)}-${crypto.randomBytes(3).toString('hex')}`;
+    const inboxDir = path.join(this.baseDir, INBOX_DIR);
+    if (!fs.existsSync(inboxDir)) fs.mkdirSync(inboxDir, { recursive: true });
+
+    const cmd = {
+      id,
+      platform,
+      userId,
+      userName,
+      texto,
+      recibidoEn: new Date().toISOString(),
+      estado: 'pending',
+      chatId: message.chatId || null,
+      comando: message.command || null,
+    };
+
+    try {
+      atomicWriteJSON(path.join(inboxDir, `${id}.json`), cmd);
+      this._auditar({ platform, userId, userName, accion: 'encolado', id, textoPreview: texto.slice(0, 80) });
+      this.events.emit({ type: EVENTS.CMD_QUEUED, id, platform, userId, userName, textoPreview: texto.slice(0, 80) });
+      return { success: true, id };
+    } catch (err) {
+      this._auditar({ platform, userId, userName, accion: 'error-escritura', razon: err.message });
+      this.events.emit({ type: EVENTS.CMD_REJECTED, platform, userId, userName, reason: 'write-error', error: err.message });
+      return { success: false, reason: 'write-error' };
+    }
+  }
+
+  /**
+   * Lista comandos pendientes en el inbox.
+   * @param {object} [opts]
+   * @param {number} [opts.limit=20]
+   * @returns {Array<object>}
+   */
+  listarPendientes(opts = {}) {
+    const limit = opts.limit || 20;
+    const inboxDir = path.join(this.baseDir, INBOX_DIR);
+    if (!fs.existsSync(inboxDir)) return [];
+    const archivos = fs.readdirSync(inboxDir)
+      .filter(f => f.startsWith('cmd-') && f.endsWith('.json'));
+    const items = [];
+    for (const a of archivos.sort()) {
+      try {
+        const obj = JSON.parse(fs.readFileSync(path.join(inboxDir, a), 'utf8'));
+        if (obj.estado === 'pending') items.push(obj);
+      } catch (err) {
+        // Archivo malformado o concurrencia con marcarProcesado: ignorar este
+        // archivo y continuar con el resto del inbox. No bloquear la lista.
+      }
+      if (items.length >= limit) break;
+    }
+    return items;
+  }
+
+  /**
+   * Marca un comando como procesado.
+   */
+  marcarProcesado(id, resultado = {}) {
+    const inboxDir = path.join(this.baseDir, INBOX_DIR);
+    const filePath = path.join(inboxDir, `${id}.json`);
+    if (!fs.existsSync(filePath)) return false;
+    try {
+      const obj = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+      obj.estado = 'processed';
+      obj.procesadoEn = new Date().toISOString();
+      obj.resultado = resultado;
+      atomicWriteJSON(filePath, obj);
+      this._auditar({ platform: obj.platform, userId: obj.userId, accion: 'procesado', id });
+      this.events.emit({ type: EVENTS.CMD_PROCESSED, id, platform: obj.platform, userId: obj.userId, resultado });
+      return true;
+    } catch (_) {
+      return false;
+    }
+  }
+
+  /**
+   * Escribe una entrada al audit trail del inbox.
+   * @private
+   */
+  _auditar(entrada) {
+    try {
+      const inboxDir = path.join(this.baseDir, INBOX_DIR);
+      if (!fs.existsSync(inboxDir)) fs.mkdirSync(inboxDir, { recursive: true });
+      const linea = JSON.stringify({ ts: new Date().toISOString(), ...entrada }) + '\n';
+      fs.appendFileSync(path.join(inboxDir, AUDIT_FILE), linea);
+    } catch (_) { /* silencioso */ }
+  }
+}
+
+module.exports = CommandRelay;

package/gateway/cron/jobs.js

@@ -0,0 +1,263 @@
+'use strict';
+
+/**
+ * Cron Jobs — Parse de schedules y gestión de estado de jobs.
+ *
+ * Soporta 4 formatos de schedule (adoptados de Hermes Agent cron/jobs.py):
+ *   1. Duración única:     "30m", "2h", "1d"         → ejecutar una vez en N minutos
+ *   2. Intervalo recurrente: "every 30m", "every 2h"  → ejecutar cada N minutos
+ *   3. Expresión cron:     "0 9 * * 1-5"              → cron estándar (5 campos)
+ *   4. Timestamp ISO:      "2026-04-15T09:00"          → una vez a hora exacta
+ *
+ * Grace windows (adoptados de Hermes):
+ *   - Jobs one-shot: 120s de tolerancia para creación retrasada
+ *   - Jobs recurrentes: grace = period/2, clamped [120s, 7200s]
+ *
+ * @module gateway/cron/jobs
+ */
+
+// ---------------------------------------------------------------------------
+// Constantes
+// ---------------------------------------------------------------------------
+
+const ONESHOT_GRACE_SECONDS = 120;
+const MIN_GRACE_SECONDS     = 120;
+const MAX_GRACE_SECONDS     = 7200; // 2 horas
+
+/** Regex para parse de duraciones: "30m", "2h", "1d" */
+const DURATION_RE = /^(\d+)\s*(m|min|h|hr|d)$/i;
+
+/** Regex para intervalo recurrente: "every 30m", "every 2h" */
+const INTERVAL_RE = /^every\s+(\d+)\s*(m|min|h|hr|d)$/i;
+
+/** Regex para expresión cron: "0 9 * * 1-5" (5 campos) */
+const CRON_RE = /^(\S+\s+){4}\S+$/;
+
+/** Multiplicadores de duración a minutos */
+const DURATION_MULTIPLIERS = {
+  m: 1, min: 1,
+  h: 60, hr: 60,
+  d: 1440,
+};
+
+// ---------------------------------------------------------------------------
+// Parse de schedules
+// ---------------------------------------------------------------------------
+
+/**
+ * Parsea un string de schedule en un objeto estructurado.
+ *
+ * @param {string} schedule - String del schedule.
+ * @returns {{ kind: 'once'|'interval'|'cron', minutes?: number, runAt?: string, expr?: string }}
+ * @throws {Error} Si el formato no es reconocido.
+ */
+function parseSchedule(schedule) {
+  if (!schedule || typeof schedule !== 'string') {
+    throw new Error(`Schedule inválido: "${schedule}"`);
+  }
+
+  const s = schedule.trim();
+
+  // 1. Intervalo recurrente: "every 30m"
+  const intervalMatch = s.match(INTERVAL_RE);
+  if (intervalMatch) {
+    const value = parseInt(intervalMatch[1], 10);
+    const unit  = intervalMatch[2].toLowerCase();
+    const mult  = DURATION_MULTIPLIERS[unit] || DURATION_MULTIPLIERS[unit.charAt(0)];
+    return { kind: 'interval', minutes: value * mult };
+  }
+
+  // 2. Duración única: "30m", "2h"
+  const durationMatch = s.match(DURATION_RE);
+  if (durationMatch) {
+    const value = parseInt(durationMatch[1], 10);
+    const unit  = durationMatch[2].toLowerCase();
+    const mult  = DURATION_MULTIPLIERS[unit] || DURATION_MULTIPLIERS[unit.charAt(0)];
+    const runAt = new Date(Date.now() + value * mult * 60000);
+    return { kind: 'once', minutes: value * mult, runAt: runAt.toISOString() };
+  }
+
+  // 3. Timestamp ISO: "2026-04-15T09:00", "2026-04-15T09:00:00Z"
+  if (/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}/.test(s)) {
+    const dt = new Date(s);
+    if (isNaN(dt.getTime())) throw new Error(`Timestamp ISO inválido: "${s}"`);
+    return { kind: 'once', runAt: dt.toISOString() };
+  }
+
+  // 4. Expresión cron: "0 9 * * 1-5"
+  if (CRON_RE.test(s)) {
+    return { kind: 'cron', expr: s };
+  }
+
+  throw new Error(`Formato de schedule no reconocido: "${s}". Formatos válidos: "30m", "every 2h", "0 9 * * 1-5", "2026-04-15T09:00"`);
+}
+
+// ---------------------------------------------------------------------------
+// Cálculo de próxima ejecución
+// ---------------------------------------------------------------------------
+
+/**
+ * Calcula la próxima ejecución de un job.
+ *
+ * @param {object} job - Objeto del job con schedule parseado y lastRunAt.
+ * @returns {string|null} ISO timestamp de la próxima ejecución, o null si completado.
+ */
+function computeNextRun(job) {
+  const schedule = job.parsedSchedule || parseSchedule(job.schedule);
+  const now = new Date();
+
+  switch (schedule.kind) {
+    case 'once': {
+      // Si ya se ejecutó, no hay próxima
+      if (job.lastRunAt) return null;
+      return schedule.runAt;
+    }
+    case 'interval': {
+      const intervalMs = schedule.minutes * 60000;
+      if (job.lastRunAt) {
+        return new Date(new Date(job.lastRunAt).getTime() + intervalMs).toISOString();
+      }
+      // Primera ejecución: ahora + intervalo
+      return new Date(now.getTime() + intervalMs).toISOString();
+    }
+    case 'cron': {
+      // Cálculo simplificado de next cron (sin dependencia croniter)
+      // Para cron complejo, usar computeNextCronRun()
+      return _computeSimpleCronNext(schedule.expr, now);
+    }
+    default:
+      return null;
+  }
+}
+
+/**
+ * Calcula grace seconds para un job según su periodicidad.
+ * Jobs más frecuentes tienen grace más corto; diarios más largo.
+ *
+ * @param {object} job
+ * @returns {number} Segundos de tolerancia.
+ */
+function computeGraceSeconds(job) {
+  const schedule = job.parsedSchedule || parseSchedule(job.schedule);
+
+  if (schedule.kind === 'once') return ONESHOT_GRACE_SECONDS;
+
+  if (schedule.kind === 'interval') {
+    const periodSeconds = schedule.minutes * 60;
+    const grace = Math.floor(periodSeconds / 2);
+    return Math.max(MIN_GRACE_SECONDS, Math.min(grace, MAX_GRACE_SECONDS));
+  }
+
+  // Cron: asumir grace de 2 minutos por defecto
+  return MIN_GRACE_SECONDS;
+}
+
+/**
+ * Verifica si un job es elegible para ejecución.
+ *
+ * @param {object} job
+ * @param {Date} [now=new Date()]
+ * @returns {boolean}
+ */
+function isEligible(job, now = new Date()) {
+  if (job.status !== 'scheduled') return false;
+  if (!job.nextRun) return false;
+
+  // Verificar límite de repeticiones
+  if (job.repeat && job.repeat.times !== null && job.repeat.times !== undefined) {
+    if ((job.repeat.completed || 0) >= job.repeat.times) return false;
+  }
+
+  const nextRunDate = new Date(job.nextRun);
+  const graceMs     = computeGraceSeconds(job) * 1000;
+
+  // Elegible si: nextRun ya pasó pero dentro de la ventana de grace
+  // (now - grace) <= nextRun <= now
+  // Un job con nextRun más allá del grace se considera perdido (fast-forward)
+  const nextRunMs = nextRunDate.getTime();
+  const nowMs     = now.getTime();
+  return nextRunMs <= nowMs && nextRunMs >= (nowMs - graceMs);
+}
+
+// ---------------------------------------------------------------------------
+// Cron simple (sin dependencia externa)
+// ---------------------------------------------------------------------------
+
+/**
+ * Cálculo simplificado de próxima ejecución cron.
+ * Soporta: minuto, hora, día del mes, mes, día de la semana.
+ * Para expresiones complejas (rangos, listas), busca fuerza bruta en 48h.
+ *
+ * @param {string} expr - Expresión cron de 5 campos.
+ * @param {Date} from - Fecha desde la cual buscar.
+ * @returns {string|null} ISO timestamp o null si no se encuentra en 48h.
+ */
+function _computeSimpleCronNext(expr, from) {
+  const fields = expr.split(/\s+/);
+  if (fields.length !== 5) return null;
+
+  const [minF, hourF, domF, monF, dowF] = fields;
+
+  // Buscar en los próximos 2880 minutos (48 horas)
+  const candidate = new Date(from);
+  candidate.setSeconds(0, 0);
+  candidate.setMinutes(candidate.getMinutes() + 1); // Empezar desde el próximo minuto
+
+  for (let i = 0; i < 2880; i++) {
+    if (_cronFieldMatches(minF, candidate.getMinutes()) &&
+        _cronFieldMatches(hourF, candidate.getHours()) &&
+        _cronFieldMatches(domF, candidate.getDate()) &&
+        _cronFieldMatches(monF, candidate.getMonth() + 1) &&
+        _cronFieldMatches(dowF, candidate.getDay())) {
+      return candidate.toISOString();
+    }
+    candidate.setMinutes(candidate.getMinutes() + 1);
+  }
+
+  return null; // No encontrado en 48h
+}
+
+/**
+ * Verifica si un valor coincide con un campo cron.
+ * Soporta: *, N, N-M, N/step, listas (N,M,O).
+ */
+function _cronFieldMatches(field, value) {
+  if (field === '*') return true;
+
+  // Lista: "1,3,5"
+  if (field.includes(',')) {
+    return field.split(',').some(f => _cronFieldMatches(f.trim(), value));
+  }
+
+  // Step: "*/5" o "1-10/2"
+  if (field.includes('/')) {
+    const [range, step] = field.split('/');
+    const stepN = parseInt(step, 10);
+    if (range === '*') return value % stepN === 0;
+    const [start] = range.split('-').map(Number);
+    return value >= start && (value - start) % stepN === 0;
+  }
+
+  // Rango: "1-5"
+  if (field.includes('-')) {
+    const [start, end] = field.split('-').map(Number);
+    return value >= start && value <= end;
+  }
+
+  // Valor exacto
+  return parseInt(field, 10) === value;
+}
+
+// ---------------------------------------------------------------------------
+// Exports
+// ---------------------------------------------------------------------------
+
+module.exports = {
+  parseSchedule,
+  computeNextRun,
+  computeGraceSeconds,
+  isEligible,
+  ONESHOT_GRACE_SECONDS,
+  MIN_GRACE_SECONDS,
+  MAX_GRACE_SECONDS,
+};