@saulwade/swl-ses 1.0.0

package/scripts/lib/audit-query.js

@@ -0,0 +1,221 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * audit-query.js — Consultor del audit trail de SWL.
+ *
+ * Lee .planning/audit.jsonl y filtra/formatea las entradas de auditoría.
+ * Útil para revisar actividad de la sesión, auditar errores, y cumplimiento.
+ *
+ * Uso:
+ *   node scripts/lib/audit-query.js [opciones]
+ *
+ * Opciones:
+ *   --tool=Bash,Agent      Filtrar por herramienta (lista separada por comas)
+ *   --estado=ERROR         Filtrar por estado: OK o ERROR
+ *   --session=ses-xxx      Filtrar por session_id (coincidencia parcial)
+ *   --from=2026-04-09      Filtrar desde esta fecha (YYYY-MM-DD) — inclusive
+ *   --to=2026-04-10        Filtrar hasta esta fecha (YYYY-MM-DD) — inclusive
+ *   --limit=50             Máximo de entradas a mostrar (default: 50, 0 = sin límite)
+ *   --json                 Salida en JSON en lugar de tabla formateada
+ *   --stats                Solo mostrar estadísticas, no entradas individuales
+ *
+ * Ejemplos:
+ *   node scripts/lib/audit-query.js --tool=Agent --estado=ERROR
+ *   node scripts/lib/audit-query.js --from=2026-04-09 --limit=100
+ *   node scripts/lib/audit-query.js --stats
+ *   node scripts/lib/audit-query.js --json | jq '.[] | .tool'
+ *
+ * @module scripts/lib/audit-query
+ */
+
+const fs   = require('fs');
+const path = require('path');
+
+const AUDIT_FILE = path.join(process.cwd(), '.planning', 'audit.jsonl');
+
+// ---------------------------------------------------------------------------
+// Parseo de argumentos
+// ---------------------------------------------------------------------------
+
+/**
+ * Parsea argumentos de línea de comandos en formato --clave=valor.
+ * @returns {object}
+ */
+function parsearArgs() {
+  const args = process.argv.slice(2);
+  const opts = { limit: 50, json: false, stats: false };
+
+  for (const arg of args) {
+    if (arg === '--json')  { opts.json  = true; continue; }
+    if (arg === '--stats') { opts.stats = true; continue; }
+
+    const eqIdx = arg.indexOf('=');
+    if (eqIdx < 0) continue;
+
+    const clave = arg.slice(2, eqIdx).trim();
+    const valor = arg.slice(eqIdx + 1).trim();
+
+    switch (clave) {
+      case 'tool':    opts.tools   = valor.split(',').map(s => s.trim()); break;
+      case 'estado':  opts.estado  = valor; break;
+      case 'session': opts.session = valor; break;
+      case 'from':    opts.from    = valor; break;
+      case 'to':      opts.to      = valor; break;
+      case 'limit':   opts.limit   = parseInt(valor, 10) || 50; break;
+    }
+  }
+
+  return opts;
+}
+
+// ---------------------------------------------------------------------------
+// Carga y filtrado
+// ---------------------------------------------------------------------------
+
+/**
+ * Carga y parsea todas las entradas del archivo de auditoría.
+ * @returns {object[]} Array de objetos (omite líneas con JSON inválido).
+ */
+function cargar() {
+  if (!fs.existsSync(AUDIT_FILE)) return [];
+
+  return fs.readFileSync(AUDIT_FILE, 'utf8')
+    .split('\n')
+    .filter(Boolean)
+    .map(linea => {
+      try { return JSON.parse(linea); } catch (_) { return null; }
+    })
+    .filter(Boolean);
+}
+
+/**
+ * Aplica los filtros de opciones al array de entradas.
+ *
+ * @param {object[]} entradas
+ * @param {object} opts
+ * @returns {object[]}
+ */
+function filtrar(entradas, opts) {
+  return entradas.filter(e => {
+    if (opts.tools   && !opts.tools.includes(e.tool))                   return false;
+    if (opts.estado  && e.estado !== opts.estado.toUpperCase())          return false;
+    if (opts.session && !String(e.session_id).includes(opts.session))    return false;
+    if (opts.from    && e.timestamp.slice(0, 10) < opts.from)            return false;
+    if (opts.to      && e.timestamp.slice(0, 10) > opts.to)              return false;
+    return true;
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Formateo de salida
+// ---------------------------------------------------------------------------
+
+/**
+ * Genera estadísticas agregadas de las entradas.
+ * @param {object[]} entradas
+ * @returns {object}
+ */
+function generarEstadisticas(entradas) {
+  const porTool   = {};
+  const porEstado = { OK: 0, ERROR: 0 };
+  let   primero   = null;
+  let   ultimo    = null;
+
+  for (const e of entradas) {
+    porTool[e.tool] = (porTool[e.tool] || 0) + 1;
+    if (e.estado === 'ERROR') porEstado.ERROR++;
+    else porEstado.OK++;
+    if (!primero || e.timestamp < primero) primero = e.timestamp;
+    if (!ultimo  || e.timestamp > ultimo)  ultimo  = e.timestamp;
+  }
+
+  const topTools = Object.entries(porTool)
+    .sort((a, b) => b[1] - a[1])
+    .slice(0, 10);
+
+  return { total: entradas.length, porEstado, topTools, primero, ultimo };
+}
+
+/**
+ * Imprime estadísticas formateadas.
+ * @param {object} stats
+ */
+function imprimirEstadisticas(stats) {
+  if (stats.total === 0) {
+    process.stdout.write('\n(sin entradas de auditoría)\n\n');
+    return;
+  }
+
+  const tasaError = stats.total > 0
+    ? ((stats.porEstado.ERROR / stats.total) * 100).toFixed(1)
+    : '0.0';
+
+  process.stdout.write('\nEstadísticas del Audit Trail SWL\n');
+  process.stdout.write('─'.repeat(50) + '\n');
+  process.stdout.write(`  Total entradas:   ${stats.total}\n`);
+  process.stdout.write(`  OK:               ${stats.porEstado.OK}\n`);
+  process.stdout.write(`  ERRORES:          ${stats.porEstado.ERROR} (${tasaError}%)\n`);
+  if (stats.primero) process.stdout.write(`  Primer registro:  ${stats.primero.slice(0, 19).replace('T', ' ')}\n`);
+  if (stats.ultimo)  process.stdout.write(`  Último registro:  ${stats.ultimo.slice(0, 19).replace('T', ' ')}\n`);
+  process.stdout.write('\nTop herramientas:\n');
+  for (const [tool, count] of stats.topTools) {
+    const pct = ((count / stats.total) * 100).toFixed(1);
+    const bar = '█'.repeat(Math.round(count / stats.total * 20));
+    process.stdout.write(`  ${tool.padEnd(20)} ${String(count).padStart(5)}  ${bar} ${pct}%\n`);
+  }
+  process.stdout.write('\n');
+}
+
+/**
+ * Imprime las entradas en formato tabla legible.
+ * @param {object[]} entradas
+ */
+function imprimirTabla(entradas) {
+  if (entradas.length === 0) {
+    process.stdout.write('\n(sin entradas que coincidan con los filtros)\n\n');
+    return;
+  }
+
+  const errores = entradas.filter(e => e.estado === 'ERROR').length;
+
+  process.stdout.write(`\nAudit Trail SWL — ${entradas.length} entradas (${errores} errores)\n`);
+  process.stdout.write('─'.repeat(100) + '\n');
+  process.stdout.write(
+    'Timestamp'.padEnd(21) +
+    'Tool'.padEnd(12) +
+    'Estado'.padEnd(9) +
+    'Resumen de input\n'
+  );
+  process.stdout.write('─'.repeat(100) + '\n');
+
+  for (const e of entradas) {
+    const ts     = e.timestamp.slice(0, 19).replace('T', ' ');
+    const tool   = String(e.tool).slice(0, 11).padEnd(12);
+    const estado = (e.estado === 'ERROR' ? '✗ ERROR' : '✓ OK').padEnd(9);
+    const input  = String(e.input_resumen || '').slice(0, 56);
+    process.stdout.write(`${ts.padEnd(21)}${tool}${estado}${input}\n`);
+  }
+
+  process.stdout.write('─'.repeat(100) + '\n');
+  process.stdout.write(`Total: ${entradas.length}  OK: ${entradas.length - errores}  ERROR: ${errores}\n\n`);
+}
+
+// ---------------------------------------------------------------------------
+// Entrypoint
+// ---------------------------------------------------------------------------
+
+const opts      = parsearArgs();
+const todas     = cargar();
+const filtradas = filtrar(todas, opts);
+
+// Aplicar límite (0 = sin límite)
+const limitadas = opts.limit > 0 ? filtradas.slice(-opts.limit) : filtradas;
+
+if (opts.json) {
+  process.stdout.write(JSON.stringify(limitadas, null, 2) + '\n');
+} else if (opts.stats) {
+  imprimirEstadisticas(generarEstadisticas(filtradas));
+} else {
+  imprimirTabla(limitadas);
+}

package/scripts/lib/autostart-linux.js

@@ -0,0 +1,347 @@
+'use strict';
+
+/**
+ * Generador de unit systemd --user para el daemon swl-telegram-bot.
+ *
+ * SEGURIDAD:
+ *   - NUNCA usa sudo ni systemctl --system. Solo --user (sin root).
+ *   - NUNCA hardcodea rutas absolutas. Resuelve bin/ con __dirname en runtime.
+ *   - NUNCA incluye credenciales en el unit — las credenciales viven en .env.
+ *   - Solo opera en process.platform === 'linux'. Otros OS reciben error explícito.
+ *
+ * Rollback manual (si algo sale mal):
+ *   systemctl --user disable --now swl-telegram-bot
+ *   rm ~/.config/systemd/user/swl-telegram-bot.service
+ *   systemctl --user daemon-reload
+ *
+ * @module scripts/lib/autostart-linux
+ */
+
+const { execFileSync } = require('node:child_process');
+const path = require('node:path');
+const fs   = require('node:fs');
+const os   = require('node:os');
+
+const NOMBRE_SERVICIO = 'swl-telegram-bot';
+const ARCHIVO_UNIT    = `${NOMBRE_SERVICIO}.service`;
+
+// Ruta del log de autostart — diagnóstico humano sin secrets
+const RUTA_LOG_AUTOSTART = path.join(
+  os.homedir(), '.claude', 'notifications', 'autostart.log'
+);
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Escribe una línea al log de autostart.
+ * @param {string} nivel
+ * @param {string} mensaje
+ */
+function _log(nivel, mensaje) {
+  const linea = `[${new Date().toISOString()}] [${nivel}] [linux] ${mensaje}\n`;
+  try {
+    const dir = path.dirname(RUTA_LOG_AUTOSTART);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.appendFileSync(RUTA_LOG_AUTOSTART, linea, 'utf8');
+  } catch (_) {}
+  process.stderr.write(linea);
+}
+
+/**
+ * REM-6: Valida que una ruta no contiene caracteres peligrosos que podrían
+ * inyectarse en el contenido del unit systemd (caracteres de control, XML
+ * especiales, nuevas líneas).
+ *
+ * Previene que un path manipulado rompa el INI del unit o inyecte directivas.
+ *
+ * @param {string} ruta - Ruta a validar.
+ * @returns {boolean} true si la ruta es segura para incluir en el unit.
+ */
+function _validarRutaSegura(ruta) {
+  if (typeof ruta !== 'string' || ruta.trim() === '') return false;
+  // Rechazar caracteres de control (incluye \n, \r, \t) y caracteres XML especiales
+  // que podrían romper el formato INI del unit o el XML de un plist.
+  // eslint-disable-next-line no-control-regex
+  const RX_PELIGROSOS = /[\x00-\x1F\x7F<>&"']/;
+  return !RX_PELIGROSOS.test(ruta);
+}
+
+/**
+ * Construye la ruta absoluta al daemon bin/swl-telegram-bot.js
+ * a partir de __dirname (scripts/lib/), NO hardcodeada.
+ *
+ * @returns {string} Ruta absoluta resuelta con path.resolve.
+ */
+function _rutaDaemon() {
+  return path.resolve(__dirname, '..', '..', 'bin', 'swl-telegram-bot.js');
+}
+
+/**
+ * Ruta del directorio de units systemd --user.
+ * @returns {string}
+ */
+function _dirSystemdUser() {
+  return path.join(os.homedir(), '.config', 'systemd', 'user');
+}
+
+/**
+ * Ruta del archivo .service instalado.
+ * @returns {string}
+ */
+function _rutaUnitInstalado() {
+  return path.join(_dirSystemdUser(), ARCHIVO_UNIT);
+}
+
+/**
+ * Valida que estamos en Linux.
+ * @returns {{ ok: false, error: string } | null} null si OK, error si no.
+ */
+function _validarPlatform() {
+  if (process.platform !== 'linux') {
+    return {
+      ok: false,
+      error: `autostart-linux solo aplica en Linux (plataforma detectada: ${process.platform})`,
+    };
+  }
+  return null;
+}
+
+/**
+ * Ejecuta un comando systemctl --user de forma segura (sin shell).
+ *
+ * @param {string[]} args - Argumentos para systemctl.
+ * @returns {{ ok: boolean, stdout?: string, error?: string }}
+ */
+function _ejecutarSystemctl(...args) {
+  try {
+    const stdout = execFileSync(
+      'systemctl',
+      ['--user', ...args],
+      {
+        encoding: 'utf8',
+        timeout:  30_000,
+        // NUNCA shell: true
+      }
+    );
+    return { ok: true, stdout: (stdout || '').trim() };
+  } catch (err) {
+    return { ok: false, error: (err.stderr || err.message || '').trim() };
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Generador de template
+// ---------------------------------------------------------------------------
+
+/**
+ * Genera el contenido del unit systemd con los paths resueltos en runtime.
+ *
+ * El contenido parsea correctamente como INI (WantedBy=default.target,
+ * no multi-user.target — ese requeriría root).
+ *
+ * @param {string} nodePath  - Ruta absoluta al ejecutable node.
+ * @param {string} binPath   - Ruta absoluta al daemon.
+ * @param {string} homeDir   - Directorio home del usuario.
+ * @returns {string}
+ */
+function generarContenidoUnit(nodePath, binPath, homeDir) {
+  const logDir = path.join(homeDir, '.claude', 'notifications');
+  return [
+    '[Unit]',
+    'Description=SWL Telegram Bot Daemon',
+    'After=network-online.target',
+    '',
+    '[Service]',
+    'Type=simple',
+    `ExecStart=${nodePath} ${binPath}`,
+    'Restart=on-failure',
+    'RestartSec=5s',
+    `StandardOutput=append:${logDir}/bot.stdout.log`,
+    `StandardError=append:${logDir}/bot.stderr.log`,
+    '',
+    '[Install]',
+    'WantedBy=default.target',
+    '',
+  ].join('\n');
+}
+
+// ---------------------------------------------------------------------------
+// API pública
+// ---------------------------------------------------------------------------
+
+/**
+ * Instala el unit systemd --user y lo habilita para arrancar al inicio.
+ *
+ * Idempotente: si el unit ya existe, lo reemplaza y recarga el daemon.
+ *
+ * @returns {{ ok: boolean, mensaje?: string, error?: string }}
+ */
+function install() {
+  const platErr = _validarPlatform();
+  if (platErr) return platErr;
+
+  const rutaDaemon = _rutaDaemon();
+  _log('INFO', `Instalando unit systemd --user "${NOMBRE_SERVICIO}" → ${rutaDaemon}`);
+
+  // Verificar que el daemon existe
+  if (!fs.existsSync(rutaDaemon)) {
+    const error = `El daemon no existe: ${rutaDaemon}. Verifica la instalación de swl-ses.`;
+    _log('ERROR', error);
+    return { ok: false, error };
+  }
+
+  // Resolver el ejecutable de node
+  let nodePath;
+  try {
+    nodePath = execFileSync('which', ['node'], { encoding: 'utf8', timeout: 5000 }).trim();
+  } catch (_) {
+    // Fallback al execPath del proceso actual
+    nodePath = process.execPath;
+  }
+
+  if (!nodePath || !fs.existsSync(nodePath)) {
+    const error = `node no encontrado en PATH. Instala Node.js antes de activar el autostart. Intentado: ${nodePath}`;
+    _log('ERROR', error);
+    return { ok: false, error };
+  }
+
+  // REM-6: validar que los paths no tienen caracteres peligrosos antes de
+  // incluirlos en el unit. Previene inyección en el INI del unit.
+  if (!_validarRutaSegura(nodePath) || !_validarRutaSegura(rutaDaemon)) {
+    const error = 'Ruta con caracteres no permitidos — abortando generación del unit.';
+    _log('ERROR', error);
+    return { ok: false, error };
+  }
+
+  // Generar contenido del unit
+  const homeDir    = os.homedir();
+  const contenido  = generarContenidoUnit(nodePath, rutaDaemon, homeDir);
+  const dirUnit    = _dirSystemdUser();
+  const rutaUnit   = _rutaUnitInstalado();
+
+  // Crear directorio si no existe
+  if (!fs.existsSync(dirUnit)) {
+    try {
+      fs.mkdirSync(dirUnit, { recursive: true });
+    } catch (err) {
+      const error = `No se pudo crear ${dirUnit}: ${err.message}`;
+      _log('ERROR', error);
+      return { ok: false, error };
+    }
+  }
+
+  // Escribir el unit
+  try {
+    fs.writeFileSync(rutaUnit, contenido, 'utf8');
+    _log('INFO', `Unit escrito en: ${rutaUnit}`);
+  } catch (err) {
+    const error = `No se pudo escribir el unit: ${err.message}`;
+    _log('ERROR', error);
+    return { ok: false, error };
+  }
+
+  // daemon-reload PRIMERO, luego enable --now
+  _log('INFO', 'Ejecutando systemctl --user daemon-reload...');
+  const reloadRes = _ejecutarSystemctl('daemon-reload');
+  if (!reloadRes.ok) {
+    _log('WARN', `daemon-reload reportó: ${reloadRes.error} (continuando igualmente)`);
+  }
+
+  _log('INFO', 'Ejecutando systemctl --user enable --now...');
+  const enableRes = _ejecutarSystemctl('enable', '--now', NOMBRE_SERVICIO);
+  if (!enableRes.ok) {
+    const error = `systemctl --user enable --now falló: ${enableRes.error}`;
+    _log('ERROR', error);
+    return { ok: false, error };
+  }
+
+  // Verificar estado
+  const estadoActual = status();
+  _log('INFO', `Servicio habilitado — activo: ${estadoActual.activo}, habilitado: ${estadoActual.habilitado}`);
+
+  return {
+    ok:      true,
+    mensaje: `Unit systemd "${NOMBRE_SERVICIO}" instalado y habilitado. Arrancará al próximo inicio de sesión. Activo ahora: ${estadoActual.activo}.`,
+  };
+}
+
+/**
+ * Deshabilita y elimina el unit systemd --user.
+ *
+ * Idempotente: si el unit no existe, devuelve ok:true con mensaje informativo.
+ *
+ * @returns {{ ok: boolean, mensaje?: string, error?: string }}
+ */
+function uninstall() {
+  const platErr = _validarPlatform();
+  if (platErr) return platErr;
+
+  _log('INFO', `Desinstalando unit systemd --user "${NOMBRE_SERVICIO}"...`);
+
+  const rutaUnit = _rutaUnitInstalado();
+
+  // Si no hay unit instalado, idempotente
+  if (!fs.existsSync(rutaUnit)) {
+    _log('INFO', `El unit "${ARCHIVO_UNIT}" no estaba instalado — nada que hacer.`);
+    return { ok: true, mensaje: `no había unit "${NOMBRE_SERVICIO}" instalado` };
+  }
+
+  // Deshabilitar y detener (--now)
+  _log('INFO', 'Ejecutando systemctl --user disable --now...');
+  const disableRes = _ejecutarSystemctl('disable', '--now', NOMBRE_SERVICIO);
+  if (!disableRes.ok) {
+    // No es fatal — el archivo puede existir aunque el servicio no esté activo
+    _log('WARN', `disable --now reportó: ${disableRes.error} (continuando con eliminación del archivo)`);
+  }
+
+  // Eliminar el archivo
+  try {
+    fs.unlinkSync(rutaUnit);
+    _log('INFO', `Unit eliminado: ${rutaUnit}`);
+  } catch (err) {
+    const error = `No se pudo eliminar el unit: ${err.message}`;
+    _log('ERROR', error);
+    return { ok: false, error };
+  }
+
+  // daemon-reload para que systemd no lo busque más
+  _ejecutarSystemctl('daemon-reload');
+
+  return { ok: true, mensaje: `Unit systemd "${NOMBRE_SERVICIO}" deshabilitado y eliminado.` };
+}
+
+/**
+ * Consulta el estado del servicio systemd --user.
+ *
+ * @returns {{ instalado: boolean, activo: boolean, habilitado: boolean, error?: string }}
+ */
+function status() {
+  const platErr = _validarPlatform();
+  if (platErr) return { instalado: false, activo: false, habilitado: false, error: platErr.error };
+
+  const rutaUnit = _rutaUnitInstalado();
+  const instalado = fs.existsSync(rutaUnit);
+
+  const activoRes   = _ejecutarSystemctl('is-active', NOMBRE_SERVICIO);
+  const habilitadoRes = _ejecutarSystemctl('is-enabled', NOMBRE_SERVICIO);
+
+  const activo    = activoRes.ok && activoRes.stdout === 'active';
+  const habilitado = habilitadoRes.ok && habilitadoRes.stdout === 'enabled';
+
+  return { instalado, activo, habilitado };
+}
+
+module.exports = {
+  install,
+  uninstall,
+  status,
+  // Exportar para tests
+  generarContenidoUnit,
+  _rutaDaemon,
+  _dirSystemdUser,
+  _validarRutaSegura,
+};