@saulwade/swl-ses 1.3.8 → 1.4.0

package/gateway/cron/store.js

@@ -0,0 +1,335 @@
+'use strict';
+
+/**
+ * Cron Store — Persistencia de jobs CRON en JSON.
+ *
+ * Almacena jobs en .planning/cron/jobs.json con escritura atómica.
+ * Cada job tiene: id, name, schedule, command, deliver, status, nextRun, lastRunAt.
+ *
+ * @module gateway/cron/store
+ */
+
+const fs   = require('fs');
+const path = require('path');
+
+const { atomicWriteJSON } = require('../../hooks/lib/atomic-write');
+const { parseSchedule, computeNextRun } = require('./jobs');
+
+// ---------------------------------------------------------------------------
+// Constantes
+// ---------------------------------------------------------------------------
+
+const CRON_DIR        = '.planning/cron';
+const JOBS_FILE       = 'jobs.json';
+const LOG_FILE        = 'log.json';
+const AGENT_STATE_FILE = 'agent-state.json';
+const MAX_LOG_ENTRIES = 500;
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function ensureDir(baseDir) {
+  const dir = path.join(baseDir, CRON_DIR);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+function jobsPath(baseDir) {
+  return path.join(ensureDir(baseDir), JOBS_FILE);
+}
+
+function logPath(baseDir) {
+  return path.join(ensureDir(baseDir), LOG_FILE);
+}
+
+function agentStatePath(baseDir) {
+  return path.join(ensureDir(baseDir), AGENT_STATE_FILE);
+}
+
+// ---------------------------------------------------------------------------
+// CRUD de jobs
+// ---------------------------------------------------------------------------
+
+/**
+ * Carga todos los jobs.
+ * @param {string} baseDir
+ * @returns {object[]}
+ */
+function loadJobs(baseDir) {
+  const p = jobsPath(baseDir);
+  try {
+    if (!fs.existsSync(p)) return [];
+    return JSON.parse(fs.readFileSync(p, 'utf8'));
+  } catch (_) {
+    return [];
+  }
+}
+
+/**
+ * Persiste todos los jobs atómicamente.
+ * @param {string} baseDir
+ * @param {object[]} jobs
+ */
+function saveJobs(baseDir, jobs) {
+  atomicWriteJSON(jobsPath(baseDir), jobs);
+}
+
+/**
+ * Agrega un job nuevo.
+ *
+ * @param {string} baseDir
+ * @param {object} opts
+ * @param {string} opts.name     - Nombre descriptivo.
+ * @param {string} opts.schedule - Schedule string (ej: "every 2h", "0 9 * * 1-5").
+ * @param {string} opts.command  - Comando a ejecutar.
+ * @param {string} [opts.deliver='local'] - Destino: "local", "telegram", "discord".
+ * @param {boolean} [opts.enabled=true]
+ * @returns {object} Job creado.
+ */
+function addJob(baseDir, opts) {
+  const jobs = loadJobs(baseDir);
+
+  const parsed = parseSchedule(opts.schedule);
+  const id = `cron-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 6)}`;
+
+  const job = {
+    id,
+    name:           opts.name,
+    schedule:       opts.schedule,
+    parsedSchedule: parsed,
+    command:        opts.command,
+    deliver:        opts.deliver || 'local',
+    status:         opts.enabled !== false ? 'scheduled' : 'paused',
+    nextRun:        null,
+    lastRunAt:      null,
+    createdAt:      new Date().toISOString(),
+    repeat:         parsed.kind === 'once' ? { times: 1, completed: 0 } : null,
+  };
+
+  // Calcular próxima ejecución
+  job.nextRun = computeNextRun(job);
+
+  jobs.push(job);
+  saveJobs(baseDir, jobs);
+  return job;
+}
+
+/**
+ * Elimina un job por ID.
+ * @param {string} baseDir
+ * @param {string} jobId
+ * @returns {boolean}
+ */
+function removeJob(baseDir, jobId) {
+  const jobs = loadJobs(baseDir);
+  const idx = jobs.findIndex(j => j.id === jobId);
+  if (idx < 0) return false;
+  jobs.splice(idx, 1);
+  saveJobs(baseDir, jobs);
+  return true;
+}
+
+/**
+ * Pausa un job.
+ * @param {string} baseDir
+ * @param {string} jobId
+ * @returns {boolean}
+ */
+function pauseJob(baseDir, jobId) {
+  const jobs = loadJobs(baseDir);
+  const job = jobs.find(j => j.id === jobId);
+  if (!job) return false;
+  job.status = 'paused';
+  saveJobs(baseDir, jobs);
+  return true;
+}
+
+/**
+ * Reanuda un job pausado.
+ * @param {string} baseDir
+ * @param {string} jobId
+ * @returns {boolean}
+ */
+function resumeJob(baseDir, jobId) {
+  const jobs = loadJobs(baseDir);
+  const job = jobs.find(j => j.id === jobId);
+  if (!job) return false;
+  job.status = 'scheduled';
+  if (!job.nextRun) job.nextRun = computeNextRun(job);
+  saveJobs(baseDir, jobs);
+  return true;
+}
+
+/**
+ * Marca un job como ejecutado y calcula su próxima ejecución.
+ * @param {string} baseDir
+ * @param {string} jobId
+ * @param {object} [result={}] - Resultado de la ejecución.
+ */
+function markExecuted(baseDir, jobId, result = {}) {
+  const jobs = loadJobs(baseDir);
+  const job = jobs.find(j => j.id === jobId);
+  if (!job) return;
+
+  job.lastRunAt = new Date().toISOString();
+
+  // Actualizar repeticiones
+  if (job.repeat) {
+    job.repeat.completed = (job.repeat.completed || 0) + 1;
+    if (job.repeat.times !== null && job.repeat.completed >= job.repeat.times) {
+      job.status = 'completed';
+      job.nextRun = null;
+    }
+  }
+
+  // Calcular próxima ejecución si aún está activo
+  if (job.status === 'scheduled') {
+    job.nextRun = computeNextRun(job);
+  }
+
+  saveJobs(baseDir, jobs);
+
+  // Registrar en log
+  _appendLog(baseDir, {
+    jobId,
+    jobName: job.name,
+    executedAt: job.lastRunAt,
+    status: result.status || 'completed',
+    output: (result.output || '').substring(0, 1000),
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Log de ejecuciones
+// ---------------------------------------------------------------------------
+
+function _appendLog(baseDir, entry) {
+  const p = logPath(baseDir);
+  let log = [];
+  try {
+    if (fs.existsSync(p)) {
+      log = JSON.parse(fs.readFileSync(p, 'utf8'));
+    }
+  } catch (e) { /* log malformado — resetear */ }
+
+  log.push(entry);
+
+  // Mantener solo las últimas MAX_LOG_ENTRIES entradas
+  if (log.length > MAX_LOG_ENTRIES) {
+    log = log.slice(-MAX_LOG_ENTRIES);
+  }
+
+  atomicWriteJSON(p, log);
+}
+
+/**
+ * Lee el log de ejecuciones.
+ * @param {string} baseDir
+ * @param {number} [limit=20]
+ * @returns {object[]}
+ */
+function readLog(baseDir, limit = 20) {
+  const p = logPath(baseDir);
+  try {
+    if (!fs.existsSync(p)) return [];
+    const log = JSON.parse(fs.readFileSync(p, 'utf8'));
+    return log.slice(-limit);
+  } catch (_) {
+    return [];
+  }
+}
+
+// ---------------------------------------------------------------------------
+// State per agent (portado de rowboat agent-schedule/state-repo.ts)
+// ---------------------------------------------------------------------------
+
+/**
+ * Carga el estado histórico de un agente cron.
+ * Rastrea: lastRunAt, consecutiveErrors, runCount, lastError.
+ *
+ * @param {string} baseDir
+ * @param {string} jobId
+ * @returns {{ lastRunAt: string|null, consecutiveErrors: number, runCount: number, lastError: string|null, lastStatus: string|null }}
+ */
+function getAgentState(baseDir, jobId) {
+  const p = agentStatePath(baseDir);
+  const DEFAULT = { lastRunAt: null, consecutiveErrors: 0, runCount: 0, lastError: null, lastStatus: null };
+  try {
+    if (!fs.existsSync(p)) return { ...DEFAULT };
+    const all = JSON.parse(fs.readFileSync(p, 'utf8'));
+    return all[jobId] ? { ...DEFAULT, ...all[jobId] } : { ...DEFAULT };
+  } catch (_) {
+    return { ...DEFAULT };
+  }
+}
+
+/**
+ * Actualiza el estado de un agente cron tras una ejecución.
+ *
+ * @param {string} baseDir
+ * @param {string} jobId
+ * @param {{ status: 'completed'|'failed'|'skipped', error?: string }} result
+ */
+function updateAgentState(baseDir, jobId, result) {
+  const p = agentStatePath(baseDir);
+  let all = {};
+  try {
+    if (fs.existsSync(p)) all = JSON.parse(fs.readFileSync(p, 'utf8'));
+  } catch (e) { /* agent-state malformado — resetear */ }
+
+  const prev = all[jobId] || { lastRunAt: null, consecutiveErrors: 0, runCount: 0, lastError: null, lastStatus: null };
+
+  all[jobId] = {
+    lastRunAt:         new Date().toISOString(),
+    runCount:          (prev.runCount || 0) + 1,
+    lastStatus:        result.status,
+    lastError:         result.status === 'failed' ? (result.error || 'unknown error') : null,
+    consecutiveErrors: result.status === 'failed'
+      ? (prev.consecutiveErrors || 0) + 1
+      : 0, // reset en éxito
+  };
+
+  atomicWriteJSON(p, all);
+}
+
+/**
+ * Lee el historial resumido de todos los agentes cron.
+ * Útil para diagnóstico: ver qué jobs tienen errores consecutivos.
+ *
+ * @param {string} baseDir
+ * @returns {Array<{ jobId: string, jobName: string, state: object }>}
+ */
+function getAllAgentStates(baseDir) {
+  const p = agentStatePath(baseDir);
+  try {
+    if (!fs.existsSync(p)) return [];
+    const all = JSON.parse(fs.readFileSync(p, 'utf8'));
+    const jobs = loadJobs(baseDir);
+    return Object.entries(all).map(([jobId, state]) => {
+      const job = jobs.find(j => j.id === jobId);
+      return { jobId, jobName: job?.name || jobId, state };
+    });
+  } catch (_) {
+    return [];
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Exports
+// ---------------------------------------------------------------------------
+
+module.exports = {
+  loadJobs,
+  saveJobs,
+  addJob,
+  removeJob,
+  pauseJob,
+  resumeJob,
+  markExecuted,
+  readLog,
+  getAgentState,
+  updateAgentState,
+  getAllAgentStates,
+  CRON_DIR,
+};

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 };