@saulwade/swl-ses 1.0.0

package/scripts/lib/autostart-macos.js

@@ -0,0 +1,360 @@
+'use strict';
+
+/**
+ * Generador de LaunchAgent plist para el daemon swl-telegram-bot en macOS.
+ *
+ * SEGURIDAD:
+ *   - NUNCA escribe en ~/Library/LaunchDaemons — eso requiere root.
+ *     Solo LaunchAgents (nivel usuario, sin privilegios de sistema).
+ *   - NUNCA hardcodea rutas absolutas. Resuelve bin/ con __dirname en runtime.
+ *   - NUNCA incluye credenciales en el plist — las credenciales viven en .env.
+ *   - Solo opera en process.platform === 'darwin'. Otros OS reciben error explícito.
+ *
+ * Rollback manual (si algo sale mal):
+ *   launchctl unload -w ~/Library/LaunchAgents/com.swl.telegram-bot.plist
+ *   rm ~/Library/LaunchAgents/com.swl.telegram-bot.plist
+ *
+ * @module scripts/lib/autostart-macos
+ */
+
+const { execFileSync } = require('node:child_process');
+const path = require('node:path');
+const fs   = require('node:fs');
+const os   = require('node:os');
+
+const LABEL_PLIST  = 'com.swl.telegram-bot';
+const NOMBRE_PLIST = `${LABEL_PLIST}.plist`;
+
+// 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}] [macos] ${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 plist XML (caracteres de control, XML especiales,
+ * nuevas líneas).
+ *
+ * Previene que un path manipulado rompa el XML del plist o inyecte etiquetas.
+ *
+ * @param {string} ruta - Ruta a validar.
+ * @returns {boolean} true si la ruta es segura para incluir en el plist.
+ */
+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 ~/Library/LaunchAgents.
+ * @returns {string}
+ */
+function _dirLaunchAgents() {
+  return path.join(os.homedir(), 'Library', 'LaunchAgents');
+}
+
+/**
+ * Ruta del archivo plist instalado.
+ * @returns {string}
+ */
+function _rutaPlistInstalado() {
+  return path.join(_dirLaunchAgents(), NOMBRE_PLIST);
+}
+
+/**
+ * Valida que estamos en macOS.
+ * @returns {{ ok: false, error: string } | null} null si OK, error si no.
+ */
+function _validarPlatform() {
+  if (process.platform !== 'darwin') {
+    return {
+      ok: false,
+      error: `autostart-macos solo aplica en macOS (plataforma detectada: ${process.platform})`,
+    };
+  }
+  return null;
+}
+
+/**
+ * Ejecuta launchctl de forma segura (sin shell).
+ *
+ * @param {string[]} args - Argumentos para launchctl.
+ * @returns {{ ok: boolean, stdout?: string, error?: string }}
+ */
+function _ejecutarLaunchctl(...args) {
+  try {
+    const stdout = execFileSync(
+      'launchctl',
+      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 plist con los paths resueltos en runtime.
+ *
+ * El XML resultante es válido para launchd:
+ *   - RunAtLoad: arranca al cargar el agent (login)
+ *   - KeepAlive: relanza si el proceso muere
+ *   - ProgramArguments: [nodePath, binPath]
+ *   - Stdout/Stderr a archivos de log separados
+ *
+ * @param {string} nodePath - Ruta absoluta al ejecutable node.
+ * @param {string} binPath  - Ruta absoluta al daemon.
+ * @param {string} homeDir  - Directorio home del usuario.
+ * @returns {string} Contenido XML del plist.
+ */
+function generarContenidoPlist(nodePath, binPath, homeDir) {
+  const logDir = path.join(homeDir, '.claude', 'notifications');
+  return [
+    '<?xml version="1.0" encoding="UTF-8"?>',
+    '<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">',
+    '<plist version="1.0">',
+    '<dict>',
+    '  <key>Label</key>',
+    `  <string>${LABEL_PLIST}</string>`,
+    '  <key>ProgramArguments</key>',
+    '  <array>',
+    `    <string>${nodePath}</string>`,
+    `    <string>${binPath}</string>`,
+    '  </array>',
+    '  <key>RunAtLoad</key>',
+    '  <true/>',
+    '  <key>KeepAlive</key>',
+    '  <true/>',
+    '  <key>StandardOutPath</key>',
+    `  <string>${logDir}/bot.stdout.log</string>`,
+    '  <key>StandardErrorPath</key>',
+    `  <string>${logDir}/bot.stderr.log</string>`,
+    '</dict>',
+    '</plist>',
+    '',
+  ].join('\n');
+}
+
+// ---------------------------------------------------------------------------
+// API pública
+// ---------------------------------------------------------------------------
+
+/**
+ * Instala el LaunchAgent plist y lo carga con launchctl.
+ *
+ * Idempotente: si el plist ya existe, lo reemplaza y recarga.
+ *
+ * @returns {{ ok: boolean, mensaje?: string, error?: string }}
+ */
+function install() {
+  const platErr = _validarPlatform();
+  if (platErr) return platErr;
+
+  const rutaDaemon = _rutaDaemon();
+  _log('INFO', `Instalando LaunchAgent "${LABEL_PLIST}" → ${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 (_) {
+    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 plist XML. Previene inyección de etiquetas XML.
+  if (!_validarRutaSegura(nodePath) || !_validarRutaSegura(rutaDaemon)) {
+    const error = 'Ruta con caracteres no permitidos — abortando generación del plist.';
+    _log('ERROR', error);
+    return { ok: false, error };
+  }
+
+  // Generar contenido del plist
+  const homeDir   = os.homedir();
+  const contenido = generarContenidoPlist(nodePath, rutaDaemon, homeDir);
+  const dirAgents = _dirLaunchAgents();
+  const rutaPlist = _rutaPlistInstalado();
+
+  // Crear directorio si no existe (puede no existir en instalaciones limpias)
+  if (!fs.existsSync(dirAgents)) {
+    try {
+      fs.mkdirSync(dirAgents, { recursive: true });
+    } catch (err) {
+      const error = `No se pudo crear ${dirAgents}: ${err.message}`;
+      _log('ERROR', error);
+      return { ok: false, error };
+    }
+  }
+
+  // Si ya existe un plist cargado, descargarlo primero para evitar conflicto
+  const estadoPrev = status();
+  if (estadoPrev.cargado) {
+    _log('INFO', 'Descargando LaunchAgent previo antes de reemplazarlo...');
+    _ejecutarLaunchctl('unload', '-w', rutaPlist);
+  }
+
+  // Escribir el plist
+  try {
+    fs.writeFileSync(rutaPlist, contenido, 'utf8');
+    _log('INFO', `Plist escrito en: ${rutaPlist}`);
+  } catch (err) {
+    const error = `No se pudo escribir el plist: ${err.message}`;
+    _log('ERROR', error);
+    return { ok: false, error };
+  }
+
+  // Cargar con launchctl load -w
+  _log('INFO', 'Ejecutando launchctl load -w...');
+  const loadRes = _ejecutarLaunchctl('load', '-w', rutaPlist);
+  if (!loadRes.ok) {
+    const error = `launchctl load -w falló: ${loadRes.error}`;
+    _log('ERROR', error);
+    return { ok: false, error };
+  }
+
+  // Verificar estado
+  const estadoActual = status();
+  _log('INFO', `LaunchAgent cargado — instalado: ${estadoActual.instalado}, cargado: ${estadoActual.cargado}`);
+
+  return {
+    ok:      true,
+    mensaje: `LaunchAgent "${LABEL_PLIST}" instalado y cargado. Arrancará al próximo login. Cargado ahora: ${estadoActual.cargado}.`,
+  };
+}
+
+/**
+ * Descarga y elimina el LaunchAgent.
+ *
+ * Idempotente: si el plist 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 LaunchAgent "${LABEL_PLIST}"...`);
+
+  const rutaPlist = _rutaPlistInstalado();
+
+  // Si no hay plist instalado, idempotente
+  if (!fs.existsSync(rutaPlist)) {
+    _log('INFO', `El plist "${NOMBRE_PLIST}" no estaba instalado — nada que hacer.`);
+    return { ok: true, mensaje: `no había LaunchAgent "${LABEL_PLIST}" instalado` };
+  }
+
+  // Descargar con launchctl unload -w
+  _log('INFO', 'Ejecutando launchctl unload -w...');
+  const unloadRes = _ejecutarLaunchctl('unload', '-w', rutaPlist);
+  if (!unloadRes.ok) {
+    _log('WARN', `launchctl unload -w reportó: ${unloadRes.error} (continuando con eliminación del archivo)`);
+  }
+
+  // Eliminar el archivo
+  try {
+    fs.unlinkSync(rutaPlist);
+    _log('INFO', `Plist eliminado: ${rutaPlist}`);
+  } catch (err) {
+    const error = `No se pudo eliminar el plist: ${err.message}`;
+    _log('ERROR', error);
+    return { ok: false, error };
+  }
+
+  return { ok: true, mensaje: `LaunchAgent "${LABEL_PLIST}" descargado y eliminado.` };
+}
+
+/**
+ * Consulta el estado del LaunchAgent.
+ *
+ * @returns {{ instalado: boolean, cargado: boolean, error?: string }}
+ */
+function status() {
+  const platErr = _validarPlatform();
+  if (platErr) return { instalado: false, cargado: false, error: platErr.error };
+
+  const rutaPlist = _rutaPlistInstalado();
+  const instalado = fs.existsSync(rutaPlist);
+
+  // Verificar si está cargado en launchd con list | grep
+  let cargado = false;
+  try {
+    const stdout = execFileSync(
+      'launchctl',
+      ['list'],
+      { encoding: 'utf8', timeout: 10_000 }
+    );
+    cargado = stdout.includes(LABEL_PLIST);
+  } catch (_) {
+    cargado = false;
+  }
+
+  return { instalado, cargado };
+}
+
+module.exports = {
+  install,
+  uninstall,
+  status,
+  // Exportar para tests
+  generarContenidoPlist,
+  _rutaDaemon,
+  _dirLaunchAgents,
+  _validarRutaSegura,
+};

package/scripts/lib/autostart-windows.js

@@ -0,0 +1,307 @@
+'use strict';
+
+/**
+ * Generador de Scheduled Task de Windows para el daemon swl-telegram-bot.
+ *
+ * SEGURIDAD:
+ *   - NUNCA usa shell:true ni execSync con string. Solo execFileSync con array.
+ *   - NUNCA incluye credenciales en el task — las credenciales viven en .env.
+ *   - RunLevel Limited (sin elevación). Si el usuario necesita admin, que lo
+ *     gestione él; el daño de un task con privilegios elevados es irreversible.
+ *   - Solo opera en process.platform === 'win32'. Otros OS reciben error explícito.
+ *
+ * Rollback manual (si algo sale mal):
+ *   powershell.exe -NoProfile -Command "Unregister-ScheduledTask -TaskName SWL-Telegram-Bot -Confirm:$false"
+ *
+ * @module scripts/lib/autostart-windows
+ */
+
+const { execFileSync } = require('node:child_process');
+const path = require('node:path');
+const fs   = require('node:fs');
+const os   = require('node:os');
+
+// Nombre canónico del Scheduled Task
+const TASK_NAME = 'SWL-Telegram-Bot';
+
+// 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}] [windows] ${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);
+}
+
+// Regex para validar USERNAME seguro — solo caracteres alfanuméricos y separadores comunes.
+// Exportada para tests unitarios de REM-3.
+const _RX_USUARIO_SEGURO = /^[A-Za-z0-9._\-\\$ ]+$/;
+
+/**
+ * REM-3: Resuelve el nombre de usuario para el trigger AtLogOn del Scheduled Task.
+ *
+ * Valida el valor de las variables de entorno USERNAME/USER contra un regex seguro.
+ * Si el valor contiene caracteres peligrosos (que podrían inyectarse en el script
+ * de PowerShell), usa '$env:USERNAME' como fallback — PowerShell resuelve la variable
+ * en tiempo de ejecución sin concatenación en el código generado.
+ *
+ * @param {string|undefined} [username] - Valor de USERNAME (por defecto process.env.USERNAME).
+ * @param {string|undefined} [user]     - Valor de USER (por defecto process.env.USER).
+ * @returns {string} Nombre de usuario validado o '$env:USERNAME'.
+ */
+function _resolverUsuario(username, user) {
+  const raw = (username !== undefined ? username : process.env.USERNAME)
+           || (user !== undefined ? user : process.env.USER);
+  return (raw && _RX_USUARIO_SEGURO.test(raw)) ? raw : '$env:USERNAME';
+}
+
+/**
+ * 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');
+}
+
+/**
+ * Valida que estamos en Windows.
+ * @returns {{ ok: false, error: string } | null} null si OK, error si no.
+ */
+function _validarPlatform() {
+  if (process.platform !== 'win32') {
+    return {
+      ok: false,
+      error: `autostart-windows solo aplica en Windows (plataforma detectada: ${process.platform})`,
+    };
+  }
+  return null;
+}
+
+/**
+ * Ejecuta un comando de PowerShell de forma segura:
+ * - Sin shell:true
+ * - Con array de argumentos (sin concatenación de strings)
+ * - Timeout de 30s
+ *
+ * @param {string} scriptBlock - Script PowerShell a ejecutar.
+ * @returns {{ ok: boolean, stdout?: string, error?: string }}
+ */
+function _ejecutarPowerShell(scriptBlock) {
+  try {
+    const stdout = execFileSync(
+      'powershell.exe',
+      [
+        '-NoProfile',
+        '-NonInteractive',
+        '-ExecutionPolicy', 'Bypass',
+        '-Command', scriptBlock,
+      ],
+      {
+        encoding: 'utf8',
+        timeout:  30_000,
+        // NUNCA shell: true — previene inyección de comandos
+      }
+    );
+    return { ok: true, stdout: (stdout || '').trim() };
+  } catch (err) {
+    return { ok: false, error: (err.stderr || err.message || '').trim() };
+  }
+}
+
+// ---------------------------------------------------------------------------
+// API pública
+// ---------------------------------------------------------------------------
+
+/**
+ * Instala el Scheduled Task de Windows para arrancar el daemon al logon.
+ *
+ * Parámetros del task:
+ *   - Name:            SWL-Telegram-Bot
+ *   - Trigger:         AtLogOn del usuario actual
+ *   - Action:          node.exe <ruta-absoluta-a-bin/swl-telegram-bot.js>
+ *   - Principal:       Interactive, RunLevel Limited (sin elevación)
+ *   - StartWhenAvailable, RestartCount=3, RestartInterval=PT2M
+ *   - AllowStartIfOnBatteries, sin timeout de idle
+ *
+ * Idempotente: si el task ya existe, lo reemplaza silenciosamente.
+ *
+ * @returns {{ ok: boolean, mensaje?: string, error?: string }}
+ */
+function install() {
+  const platErr = _validarPlatform();
+  if (platErr) return platErr;
+
+  const rutaDaemon = _rutaDaemon();
+  _log('INFO', `Instalando Scheduled Task "${TASK_NAME}" → ${rutaDaemon}`);
+
+  // Verificar que node está disponible
+  let nodeExe;
+  try {
+    nodeExe = execFileSync('where.exe', ['node'], { encoding: 'utf8', timeout: 5000 }).trim().split('\n')[0].trim();
+  } catch (_) {
+    const error = 'node.exe no encontrado en PATH. Instala Node.js antes de activar el autostart.';
+    _log('ERROR', error);
+    return { ok: false, error };
+  }
+
+  if (!nodeExe) {
+    const error = 'node.exe no encontrado en PATH. Instala Node.js antes de activar el autostart.';
+    _log('ERROR', error);
+    return { ok: false, error };
+  }
+
+  // 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 };
+  }
+
+  // Construir el script de PowerShell con parámetros en variables separadas
+  // Nunca concatenar dentro del script — los valores ya están en variables escapadas
+  const nodePath    = nodeExe.replace(/'/g, "''");   // Escape de comillas simples en PS
+  const daemonPath  = rutaDaemon.replace(/'/g, "''");
+
+  // REM-3: validar USERNAME antes de interpolarlo en el script de PowerShell.
+  // _resolverUsuario usa un regex para rechazar caracteres peligrosos y cae a
+  // '$env:USERNAME' si el valor es sospechoso.
+  const usuario = _resolverUsuario();
+
+  const psScript = `
+$action   = New-ScheduledTaskAction -Execute '${nodePath}' -Argument '"${daemonPath}"'
+$trigger  = New-ScheduledTaskTrigger -AtLogOn -User '${usuario}'
+$settings = New-ScheduledTaskSettingsSet \`
+  -StartWhenAvailable \`
+  -RestartCount 3 \`
+  -RestartInterval (New-TimeSpan -Minutes 2) \`
+  -AllowStartIfOnBatteries \`
+  -DontStopIfGoingOnBatteries \`
+  -ExecutionTimeLimit ([TimeSpan]::Zero)
+$principal = New-ScheduledTaskPrincipal -LogonType Interactive -RunLevel Limited
+Register-ScheduledTask \`
+  -TaskName '${TASK_NAME}' \`
+  -Action   $action \`
+  -Trigger  $trigger \`
+  -Settings $settings \`
+  -Principal $principal \`
+  -Force
+`.trim();
+
+  _log('INFO', 'Registrando Scheduled Task vía PowerShell (RunLevel: Limited, sin elevación)...');
+  const resultado = _ejecutarPowerShell(psScript);
+
+  if (!resultado.ok) {
+    _log('ERROR', `Register-ScheduledTask falló: ${resultado.error}`);
+    return { ok: false, error: `Register-ScheduledTask falló: ${resultado.error}` };
+  }
+
+  // Verificar que quedó registrado
+  const verificacion = status();
+  if (!verificacion.instalado) {
+    const error = 'El task fue registrado pero status() no lo detecta. Verifica manualmente en Programador de tareas.';
+    _log('WARN', error);
+    return { ok: false, error };
+  }
+
+  _log('INFO', `Scheduled Task "${TASK_NAME}" instalado — estado: ${verificacion.estado}`);
+  return {
+    ok:      true,
+    mensaje: `Scheduled Task "${TASK_NAME}" registrado. Arrancará al próximo logon. Estado actual: ${verificacion.estado}.`,
+  };
+}
+
+/**
+ * Desinstala el Scheduled Task de Windows.
+ *
+ * Idempotente: si el task 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 Scheduled Task "${TASK_NAME}"...`);
+
+  // Verificar si existe primero para mensaje idempotente
+  const estadoActual = status();
+  if (!estadoActual.instalado) {
+    _log('INFO', `El task "${TASK_NAME}" no estaba instalado — nada que hacer.`);
+    return { ok: true, mensaje: `no había task "${TASK_NAME}" instalado` };
+  }
+
+  const psScript = `
+Unregister-ScheduledTask -TaskName '${TASK_NAME}' -Confirm:$false -ErrorAction SilentlyContinue
+`.trim();
+
+  const resultado = _ejecutarPowerShell(psScript);
+
+  if (!resultado.ok) {
+    // Algunos errores de Unregister son falsos positivos (el task ya se borró)
+    // Verificar el estado real antes de reportar error
+    const estadoPost = status();
+    if (!estadoPost.instalado) {
+      _log('INFO', `Task eliminado (PowerShell reportó: ${resultado.error})`);
+      return { ok: true, mensaje: `Scheduled Task "${TASK_NAME}" eliminado.` };
+    }
+    _log('ERROR', `Unregister-ScheduledTask falló: ${resultado.error}`);
+    return { ok: false, error: `Unregister-ScheduledTask falló: ${resultado.error}` };
+  }
+
+  _log('INFO', `Scheduled Task "${TASK_NAME}" eliminado correctamente.`);
+  return { ok: true, mensaje: `Scheduled Task "${TASK_NAME}" eliminado.` };
+}
+
+/**
+ * Consulta el estado del Scheduled Task de Windows.
+ *
+ * @returns {{ instalado: boolean, estado: 'Ready'|'Running'|'Disabled'|null, error?: string }}
+ */
+function status() {
+  const platErr = _validarPlatform();
+  if (platErr) return { instalado: false, estado: null, error: platErr.error };
+
+  const psScript = `
+$task = Get-ScheduledTask -TaskName '${TASK_NAME}' -ErrorAction SilentlyContinue
+if ($task) { $task.State } else { 'NOT_FOUND' }
+`.trim();
+
+  const resultado = _ejecutarPowerShell(psScript);
+
+  if (!resultado.ok) {
+    return { instalado: false, estado: null, error: resultado.error };
+  }
+
+  const estado = resultado.stdout;
+
+  if (estado === 'NOT_FOUND' || estado === '') {
+    return { instalado: false, estado: null };
+  }
+
+  // Mapear estados de Windows a los esperados
+  const estadosValidos = ['Ready', 'Running', 'Disabled'];
+  const estadoNorm = estadosValidos.find(e => e.toLowerCase() === estado.toLowerCase()) || estado;
+
+  return { instalado: true, estado: estadoNorm };
+}
+
+module.exports = { install, uninstall, status, _resolverUsuario };