fix/instalacion-desatendida (#23)

Reviewed-on: #23
Co-authored-by: hreyes <hreyes@aduanasoft.com.mx>
Co-committed-by: hreyes <hreyes@aduanasoft.com.mx>

src/lib/server/cras-install.ts

@@ -12,11 +12,20 @@
  *   subido por SFTP, no como argumento: `ps` y el historial del destino son legibles por
  *   otros usuarios. AServers hace `echo '{password}' | sudo -S ...`, que expone el password
  *   y además permite inyección de comandos.
- * - **Nunca se le pasa el password a sudo**, ni por argv ni por stdin. Para los modos que
- *   instalan en /opt y registran un servicio de sistema se exige root o `sudo -n` (sudo sin
- *   password), y si no hay ninguno se aborta ANTES de subir 270 MB. El modo `user-service`
- *   evita el problema en vez de rodearlo: instala bajo el home con un unit de systemd de
- *   usuario, así que no necesita elevación alguna y le bastan las credenciales SSH.
+ * - **El password de sudo va por el stdin del canal `exec`, nunca por argv.** Es la distinción
+ *   que importa, y la que el defecto de AServers no hace: lo que expone `echo '{pw}' | sudo -S`
+ *   es que la contraseña acaba en la línea de comandos del `sh -c` que la ejecuta, visible con
+ *   `ps` para cualquier usuario del destino. Escribirla en el stdin del canal no pasa por
+ *   ningún argv, ningún historial ni ningún proceso intermedio, y al no concatenarse a un
+ *   comando tampoco abre la puerta a inyección. Es la MISMA credencial con la que ya se
+ *   autenticó la sesión SSH, así que no amplía la superficie: el residuo que queda es que vive
+ *   en memoria del proceso del panel (ya vivía) y que sudo asienta el intento en el log de auth
+ *   del destino. A cambio, instalar en /opt con servicio de sistema deja de exigir que alguien
+ *   toque el sudoers del servidor.
+ * - **La elevación se agota en orden, y solo entonces se rinde:** root → `sudo -n` →
+ *   `sudo -S` con la credencial del panel → actualización en sitio (que no eleva nada) →
+ *   `user-service` bajo el home. Abortar antes de agotarlas devolvía al operador a la consola
+ *   del servidor, que es justo lo que este módulo existe para evitar.
  * - **El sha256 se verifica en el destino** antes de extraer, no solo al cachear: así se
  *   detecta una transferencia corrupta.
  * - **El progreso se persiste paso a paso** en cras_install_runs.steps para que la UI lo
@@ -54,6 +63,13 @@ const EXEC_TIMEOUT_MS = 120_000;
 /** El bootstrap del binario corre con `timeout 20` del lado del destino; se da margen. */
 const INSTALL_EXEC_TIMEOUT_MS = 300_000;
 
+/**
+ * Prefijo de elevación cuando sudo pide contraseña. La contraseña NO va aquí: viaja por el stdin
+ * del canal (`-S`), y este prefijo es lo único que se concatena al comando, así que el argv del
+ * destino nunca la contiene. Ver `probeLinuxElevation` para el porqué de `-k` y `-p ''`.
+ */
+const SUDO_PASSWORD_PREFIX = "sudo -S -k -p '' ";
+
 export class InstallError extends Error {
     constructor(
         public status: number,
@@ -76,11 +92,19 @@ export interface ExecResult {
  * `ssh2-sftp-client` envuelve un `ssh2.Client` y lo expone en `.client`, pero sus tipos no
  * lo declaran; de ahí el cast. Se reutiliza esa conexión en lugar de abrir una segunda para
  * no autenticarse dos veces por instalación.
+ *
+ * `stdin` es el canal por el que viaja la contraseña de sudo (ver `probeLinuxElevation`). Es un
+ * parámetro aparte —y no algo que el llamador pueda concatenar a `command`— justamente para que
+ * un secreto no pueda acabar en la línea de comandos: el argv del destino es legible por
+ * cualquier usuario con `ps`. Nada de lo que se escriba aquí se registra en logs ni en los pasos
+ * del run. Se cierra el canal inmediatamente después de escribir: sudo consume su línea y el
+ * proceso real no hereda nada del resto.
  */
 export function execRemote(
     sftp: SftpClient,
     command: string,
-    timeoutMs = EXEC_TIMEOUT_MS
+    timeoutMs = EXEC_TIMEOUT_MS,
+    stdin?: string
 ): Promise<ExecResult> {
     const conn = (sftp as unknown as { client: SshClient }).client;
     if (!conn || typeof conn.exec !== 'function') {
@@ -103,6 +127,12 @@ export function execRemote(
                 reject(new InstallError(502, `No se pudo ejecutar en el destino: ${err.message}`));
                 return;
             }
+            // Solo se toca stdin cuando hay algo que mandar: cerrarlo siempre cambiaría el
+            // contrato de las decenas de comandos que hoy lo dejan abierto.
+            if (stdin !== undefined) {
+                stream.write(stdin);
+                stream.end();
+            }
             let stdout = '';
             let stderr = '';
             let code = -1;
@@ -500,15 +530,19 @@ async function installLinux(
     const systemEvidence = await assertSystemMatches(sftp, 'linux');
 
     // El modo `user-service` instala en el home con un unit de usuario, así que no necesita
-    // ninguna elevación. Los modos de sistema sí: ahí la falta de privilegios se aborta aquí,
-    // antes de transferir 270 MB, porque fallar después es desperdicio y deja basura en /tmp.
+    // ninguna elevación. Los modos de sistema sí, y para ellos se agotan TODAS las vías —
+    // incluida la contraseña SSH que el panel ya tiene— antes de rendirse. Lo que no se hace es
+    // fallar después de transferir 270 MB: la decisión se toma aquí, con la sesión abierta.
     const autostartMode = request.autostart ?? 'service';
-    const privileged = await probeLinuxElevation(sftp);
-    const canElevate = privileged.elevation === 'root' || privileged.elevation === 'sudo-sin-password';
+    const privileged = await probeLinuxElevation(sftp, target.ssh_password);
+    const canElevate =
+        privileged.elevation === 'root' ||
+        privileged.elevation === 'sudo-sin-password' ||
+        privileged.elevation === 'sudo-con-password';
 
-    // Sin elevación quedan dos vías antes de rendirse, y ambas evitan pedirle la contraseña a
-    // sudo. `user-service` instala en el home; la actualización en sitio deja el unit como está
-    // y solo reemplaza el binario, que es lo único que una actualización necesita de verdad.
+    // Sin ninguna forma de elevar quedan dos vías antes de rendirse. `user-service` instala en el
+    // home; la actualización en sitio deja el unit como está y solo reemplaza el binario, que es
+    // lo único que una actualización necesita de verdad.
     let inPlaceUpdate = false;
     if (!canElevate && autostartMode !== 'user-service') {
         if (request.mode !== 'update') {
@@ -621,8 +655,21 @@ async function installLinux(
             `${privileged.prefix}env PREFIX=${shQuote(installPath)} ` +
             `./install.sh${installerFlags} --panel-env-file ${shQuote(remoteEnv)}`;
 
-        await appendInstallStep(runId, 'ejecutar-instalador', true, `install.sh${installerFlags}`);
-        const install = await execRemote(sftp, installCmd, INSTALL_EXEC_TIMEOUT_MS);
+        await appendInstallStep(
+            runId,
+            'ejecutar-instalador',
+            true,
+            `install.sh${installerFlags} (elevación: ${privileged.label || 'ninguna'})`
+        );
+        // `privileged.stdin` solo trae algo en la vía `sudo -S`, y es lo que sudo consume antes
+        // de ceder el canal. install.sh no lee stdin —sus bucles `read` leen de archivo y su
+        // bootstrap se protege con `</dev/null`—, así que no hay quién se coma la línea de más.
+        const install = await execRemote(
+            sftp,
+            installCmd,
+            INSTALL_EXEC_TIMEOUT_MS,
+            privileged.stdin
+        );
         // 75 = EX_TEMPFAIL, que install.sh reserva para "hay una restauración en curso". Es un
         // conflicto de estado, no un fallo: hay que reintentar, no investigar. Con el 502 genérico
         // parecía que la instalación se había roto, y el operador iría a buscar la causa equivocada.
@@ -659,11 +706,25 @@ async function installLinux(
  * agregar NOPASSWD no sirve de nada —sudo rechaza antes de mirar la política— y el consejo de
  * "configura NOPASSWD" manda al operador a hacer algo inútil. Es un fallo de sudo, no de permisos.
  */
-export type LinuxElevation = 'root' | 'sudo-sin-password' | 'requiretty' | 'ninguna';
+export type LinuxElevation =
+    | 'root'
+    | 'sudo-sin-password'
+    | 'sudo-con-password'
+    | 'requiretty'
+    | 'ninguna';
 
 export interface LinuxPrivilege {
     /** Prefijo a poner delante de los comandos que requieren root. Vacío si no hay elevación. */
     prefix: string;
+    /**
+     * Lo que hay que escribir en el stdin del comando cuando se usa `prefix`. Solo lo llena
+     * `sudo-con-password`, y es la contraseña SSH del destino.
+     *
+     * Viaja junto al prefijo, y no como algo que cada llamador recuerde por su cuenta, porque
+     * son inseparables: usar el prefijo sin alimentar el stdin deja a sudo esperando una
+     * contraseña que no llega hasta agotar el timeout del comando.
+     */
+    stdin?: string;
     label: string;
     elevation: LinuxElevation;
     /** Qué falta exactamente, en términos accionables. Vacío cuando sí hay elevación. */
@@ -684,11 +745,18 @@ function isRequireTty(stderr: string): boolean {
  * Sonda de elevación. La comparten el instalador y la pantalla de Verificar para que no puedan
  * contradecirse: antes cada uno tenía su propia copia y ya diferían en la etiqueta.
  *
- * Nunca se le pasa el password a sudo. La vía sin privilegios no es un error aquí: el modo de
- * instalación `user-service` no necesita ninguno, así que quien decide si falta algo es el
- * llamador, no esta función.
+ * `sshPassword` es la credencial que el panel ya usó para abrir esta sesión. Se prueba como
+ * último recurso de elevación, y solo por el stdin del canal (ver `execRemote`). Omitirla
+ * degrada la sonda a las vías sin secreto, que es lo que quiere la pantalla de Verificar: ahí
+ * interesa el estado real del servidor, no elevar nada.
+ *
+ * La vía sin privilegios no es un error aquí: el modo de instalación `user-service` no necesita
+ * ninguno, así que quien decide si falta algo es el llamador, no esta función.
  */
-export async function probeLinuxElevation(sftp: SftpClient): Promise<LinuxPrivilege> {
+export async function probeLinuxElevation(
+    sftp: SftpClient,
+    sshPassword?: string
+): Promise<LinuxPrivilege> {
     const id = await execRemote(sftp, 'id -u');
     if (id.code === 0 && id.stdout.trim() === '0') {
         return { prefix: '', label: 'root', elevation: 'root', detail: '' };
@@ -715,6 +783,32 @@ export async function probeLinuxElevation(sftp: SftpClient): Promise<LinuxPrivil
         };
     }
 
+    // Sudo pide contraseña, y el panel tiene una: la misma con la que abrió esta sesión SSH.
+    // Se prueba DESPUÉS de `sudo -n` (que no gasta ningún intento) y DESPUÉS de descartar
+    // requiretty (donde sudo rechaza antes de mirar la política, así que la contraseña no
+    // arreglaría nada y solo sumaría un fallo al log de auth del destino).
+    //
+    // `-k` invalida el sello de sudo antes de correr: sin él, una sesión reciente haría pasar la
+    // sonda sin haber comprobado nada, y el comando real fallaría más tarde ya con 270 MB
+    // subidos. `-p ''` deja el prompt vacío para que no se cuele en el stderr que se asienta.
+    if (sshPassword) {
+        const withPassword = await execRemote(
+            sftp,
+            `${SUDO_PASSWORD_PREFIX}true`,
+            EXEC_TIMEOUT_MS,
+            `${sshPassword}\n`
+        );
+        if (withPassword.code === 0) {
+            return {
+                prefix: SUDO_PASSWORD_PREFIX,
+                stdin: `${sshPassword}\n`,
+                label: 'sudo con la contraseña del panel',
+                elevation: 'sudo-con-password',
+                detail: ''
+            };
+        }
+    }
+
     // `sudo -n true` da falso negativo cuando existe una regla NOPASSWD acotada a comandos
     // concretos: `true` no está en ella, pero el comando real sí podría estarlo. Listar las
     // reglas lo distingue, y de paso le dice al operador qué SÍ tiene concedido.
@@ -727,7 +821,11 @@ export async function probeLinuxElevation(sftp: SftpClient): Promise<LinuxPrivil
         detail: scoped
             ? 'tiene reglas NOPASSWD pero acotadas a otros comandos: ' +
               truncate(list.stdout.replace(/\s+/g, ' '))
-            : 'no es root y su sudo pide contraseña, que el panel nunca envía.'
+            : sshPassword
+              ? 'no es root, y su sudo tampoco aceptó la contraseña SSH guardada en el panel: ' +
+                'o el usuario no está en el sudoers, o la contraseña registrada ya no es la ' +
+                'vigente en el servidor.'
+              : 'no es root y su sudo pide contraseña.'
     };
 }
 
@@ -894,7 +992,9 @@ async function verifyLinuxDeployment(
         sftp,
         userMode
             ? 'XDG_RUNTIME_DIR=/run/user/$(id -u) systemctl --user is-active cloudrestoreas'
-            : `${privileged.prefix}systemctl is-active cloudrestoreas`
+            : `${privileged.prefix}systemctl is-active cloudrestoreas`,
+        EXEC_TIMEOUT_MS,
+        userMode ? undefined : privileged.stdin
     );
     const state = active.stdout.trim() || active.stderr.trim();
     if (state !== 'active') {
@@ -941,6 +1041,65 @@ async function verifyLinuxDeployment(
 // Windows
 // ============================================================================
 
+export type WindowsElevation = 'admin' | 'token-filtrado' | 'limitado';
+
+export interface WindowsPrivilege {
+    elevation: WindowsElevation;
+    label: string;
+    /** Qué falta exactamente, en términos accionables. Vacío cuando sí hay elevación. */
+    detail: string;
+}
+
+/**
+ * Sonda de elevación en Windows.
+ *
+ * Distingue tres estados donde antes había dos, y la distinción que se añade es la que importa:
+ * una cuenta que ESTÁ en Administradores puede recibir de OpenSSH el token **filtrado** por UAC,
+ * y entonces `IsInRole(Administrator)` responde que no. El panel reportaba eso como "el usuario
+ * SSH no es Administrador" y mandaba a cambiar de cuenta — pero la cuenta ya era la correcta, y
+ * cambiarla no arregla nada. Lo que falta ahí es una política del servidor.
+ *
+ * La pertenencia al grupo se lee del token (SID S-1-5-32-544). En un token filtrado el grupo
+ * sigue presente, marcado como deny-only, que es justo lo que permite separar los dos casos.
+ */
+export async function probeWindowsElevation(sftp: SftpClient): Promise<WindowsPrivilege> {
+    const probe = await execRemote(
+        sftp,
+        psEncoded(
+            '$id=[Security.Principal.WindowsIdentity]::GetCurrent();' +
+                '$p=[Security.Principal.WindowsPrincipal]$id;' +
+                "$sid=New-Object Security.Principal.SecurityIdentifier 'S-1-5-32-544';" +
+                '$inGroup=[bool]($id.Groups | Where-Object { $_ -eq $sid });' +
+                'if($p.IsInRole([Security.Principal.WindowsBuiltInRole]::Administrator)){"admin"}' +
+                'elseif($inGroup){"token-filtrado"}else{"limitado"}'
+        )
+    );
+
+    switch (probe.stdout.trim()) {
+        case 'admin':
+            return { elevation: 'admin', label: 'administrador', detail: '' };
+        case 'token-filtrado':
+            return {
+                elevation: 'token-filtrado',
+                label: 'administrador con token filtrado por UAC',
+                detail:
+                    'la cuenta SÍ pertenece a Administradores, pero la sesión SSH recibió el token ' +
+                    'filtrado por UAC, así que no puede mandar sobre una tarea que corre como ' +
+                    'SYSTEM. No hay que cambiar de cuenta: hay que permitir la elevación remota en ' +
+                    'el servidor, poniendo LocalAccountTokenFilterPolicy=1 (DWORD) en ' +
+                    'HKLM\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Policies\\System.'
+            };
+        default:
+            return {
+                elevation: 'limitado',
+                label: 'sin privilegios',
+                detail:
+                    'la cuenta SSH no pertenece a Administradores del destino, y la tarea programada ' +
+                    'corre como SYSTEM. Hace falta una cuenta administradora.'
+            };
+    }
+}
+
 async function installWindows(
     sftp: SftpClient,
     runId: number,
@@ -954,26 +1113,35 @@ async function installWindows(
     // --- Precondiciones ------------------------------------------------------
     const systemEvidence = await assertSystemMatches(sftp, 'windows');
 
-    const admin = await execRemote(
+    const privileged = await probeWindowsElevation(sftp);
+    const autostart = request.autostart ?? 'service';
+
+    // La elevación hace falta para MANDAR sobre la tarea, que corre como SYSTEM: registrarla en
+    // una instalación nueva, o pararla y arrancarla en una actualización. Se comprueba si existe
+    // en lugar de deducirlo del modo, porque un servidor puede tener la tarea puesta aunque esta
+    // corrida pida otro arranque, y ahí igual hay que poder detenerla.
+    const taskProbe = await execRemote(
         sftp,
         psEncoded(
-            '$p=[Security.Principal.WindowsPrincipal][Security.Principal.WindowsIdentity]::GetCurrent();' +
-                'if($p.IsInRole([Security.Principal.WindowsBuiltInRole]::Administrator)){"admin"}else{"limitado"}'
+            "if (Get-ScheduledTask -TaskName 'CloudRestoreAS' -ErrorAction SilentlyContinue) " +
+                '{"si"} else {"no"}'
         )
     );
-    const autostart = request.autostart ?? 'service';
-    if (autostart === 'service' && admin.stdout.trim() !== 'admin') {
+    const taskExists = taskProbe.stdout.trim() === 'si';
+    const needsElevation = autostart === 'service' || taskExists;
+
+    if (needsElevation && privileged.elevation !== 'admin') {
         throw new InstallError(
             409,
-            'El usuario SSH no es Administrador en el destino. La tarea programada ONSTART corre ' +
-                'como SYSTEM y requiere elevación; usa una cuenta administradora o instala sin servicio.'
+            `No se puede operar la tarea programada de ${target.name}: ${privileged.detail}`
         );
     }
     await appendInstallStep(
         runId,
         'precondiciones',
         true,
-        `${systemEvidence}, privilegios=${admin.stdout.trim()}`
+        `${systemEvidence}, privilegios=${privileged.label}` +
+            (taskExists ? ', tarea CloudRestoreAS ya registrada' : '')
     );
 
     if (request.mode === 'update') {
@@ -1067,7 +1235,18 @@ async function installWindows(
             );
         }
 
-        const flag = autostart === 'none' ? '' : autostart === 'service' ? ' -Service' : ' -Desktop';
+        // Actualizar va SIEMPRE por -UpdateInPlace, sea cual sea el arranque configurado: no
+        // vuelve a registrar la tarea (así no pisa ajustes que el operador haya hecho sobre ella),
+        // se salta el bootstrap —una segunda instancia purgaría el Temp\ de la que está viva— y
+        // trae respaldo con reversión automática si el binario nuevo no levanta.
+        const inPlaceUpdate = request.mode === 'update';
+        const flag = inPlaceUpdate
+            ? ' -UpdateInPlace'
+            : autostart === 'none'
+              ? ''
+              : autostart === 'service'
+                ? ' -Service'
+                : ' -Desktop';
         await appendInstallStep(runId, 'ejecutar-instalador', true, `install.ps1${flag}`);
         const install = await execRemote(
             sftp,
@@ -1077,6 +1256,17 @@ async function installWindows(
             ),
             INSTALL_EXEC_TIMEOUT_MS
         );
+        // 75 = EX_TEMPFAIL, igual que en install.sh: hay una restauración en curso. Es un
+        // conflicto de estado, no un fallo; con el 502 genérico el operador salía a buscar una
+        // avería que no existe.
+        if (install.code === 75) {
+            throw new InstallError(
+                409,
+                `${target.name} está restaurando un respaldo ahora mismo, así que no se actualizó ` +
+                    'para no interrumpirlo —eso dejaría ese respaldo vetado y la base en ' +
+                    'SINGLE_USER—. Reintenta cuando termine.'
+            );
+        }
         if (install.code !== 0) {
             throw new InstallError(
                 502,
@@ -1084,7 +1274,9 @@ async function installWindows(
             );
         }
 
-        await verifyWindowsDeployment(sftp, runId, release, autostart, installPath);
+        await verifyWindowsDeployment(
+            sftp, runId, release, autostart, installPath, inPlaceUpdate
+        );
     } finally {
         await cleanupStaging(
             sftp,
@@ -1097,25 +1289,45 @@ async function installWindows(
     }
 }
 
-async function verifyWindowsDeployment(
+export async function verifyWindowsDeployment(
     sftp: SftpClient,
     runId: number,
     release: CrasRelease,
     autostart: AutostartMode,
-    prefix: string
+    prefix: string,
+    inPlaceUpdate = false
 ): Promise<void> {
-    const stamp = await execRemote(
-        sftp,
-        psEncoded(
-            `if (Test-Path '${prefix}\\config\\.version') ` +
-                `{ Get-Content -LiteralPath '${prefix}\\config\\.version' -Raw }`
-        )
-    );
-    const deployed = stamp.stdout.trim();
+    // El sello config\.version lo escribe el bootstrap del binario.
+    //
+    // Al actualizar en sitio NO se corre el bootstrap, así que el sello lo escribe el propio
+    // agente al reiniciarse y durante unos segundos sigue teniendo la versión ANTERIOR. Leerlo
+    // una sola vez convertía una actualización correcta en un fallo "reporta 1.1.1, se esperaba
+    // 1.1.2" con el binario ya bien instalado y corriendo. Y en Windows pica más que en Linux:
+    // desempacar un onefile de ~270 MB con Defender escaneando cada archivo se pasa de largo del
+    // margen. Se sondea hasta que coincida, o hasta agotar los intentos.
+    let deployed = '';
+    const stampAttempts = inPlaceUpdate ? 15 : 3;
+    for (let attempt = 0; attempt < stampAttempts; attempt += 1) {
+        if (attempt > 0) await new Promise((resolve) => setTimeout(resolve, 2000));
+        const stamp = await execRemote(
+            sftp,
+            psEncoded(
+                `if (Test-Path '${prefix}\\config\\.version') ` +
+                    `{ Get-Content -LiteralPath '${prefix}\\config\\.version' -Raw }`
+            )
+        );
+        deployed = stamp.stdout.trim();
+        // Vacío = todavía no lo escribió, y eso ya se toleraba antes.
+        if (!deployed || deployed === release.version) break;
+    }
     if (deployed && deployed !== release.version) {
         throw new InstallError(
             502,
-            `El binario desplegado reporta la versión ${deployed}, se esperaba ${release.version}`
+            `El binario desplegado reporta la versión ${deployed}, se esperaba ${release.version}. ` +
+                (inPlaceUpdate
+                    ? 'El sello no cambió tras reiniciar el agente, así que el proceso puede seguir ' +
+                      'ejecutando el binario anterior.'
+                    : '')
         );
     }
     await appendInstallStep(
@@ -1125,7 +1337,31 @@ async function verifyWindowsDeployment(
         deployed ? `config\\.version = ${deployed}` : 'sello aún no escrito (se creará al arrancar)'
     );
 
-    if (autostart !== 'service') return;
+    // El proceso vivo es la evidencia que manda, y se comprueba en TODOS los modos. Antes se
+    // salía aquí cuando el arranque no era 'service', así que una actualización que dejaba el
+    // servidor sin agente se asentaba como completada y nadie se enteraba hasta que alguien
+    // pulsaba Verificar. install.ps1 ya garantiza el rearranque; esto lo confirma desde fuera.
+    const proc = await execRemote(
+        sftp,
+        psEncoded(
+            "$p = Get-Process -Name 'CloudRestoreAS' -ErrorAction SilentlyContinue; " +
+                'if ($p) { "corriendo:" + $p.Count } else { "detenido" }'
+        )
+    );
+    const running = proc.stdout.trim().startsWith('corriendo');
+
+    if (autostart !== 'service') {
+        // Sin tarea que consultar, el proceso es lo único que hay. En 'desktop' el agente arranca
+        // al iniciar sesión, así que no tenerlo vivo ahora no es un fallo; en el resto sí importa
+        // y se asienta tal cual para que la bitácora no mienta.
+        await appendInstallStep(
+            runId,
+            'verificar-proceso',
+            running || autostart === 'desktop',
+            running ? 'CloudRestoreAS en ejecución' : 'CloudRestoreAS no está en ejecución'
+        );
+        return;
+    }
 
     const task = await execRemote(
         sftp,
@@ -1140,7 +1376,23 @@ async function verifyWindowsDeployment(
             'La tarea programada CloudRestoreAS no quedó registrada en el destino.'
         );
     }
-    await appendInstallStep(runId, 'verificar-servicio', true, `tarea CloudRestoreAS: ${state}`);
+    // `Ready` es una tarea registrada que NO está corriendo: es exactamente lo que se ve cuando
+    // el agente arrancó y murió a los pocos segundos. Aceptar cualquier estado no vacío hacía
+    // pasar por buena una instalación que dejaba el servidor sin restaurador.
+    if (!running) {
+        throw new InstallError(
+            502,
+            `La tarea CloudRestoreAS quedó registrada (estado: ${state}) pero el proceso no está ` +
+                `corriendo, así que el agente no levantó. Revisa ${prefix}\\config\\logs en el ` +
+                'servidor.'
+        );
+    }
+    await appendInstallStep(
+        runId,
+        'verificar-servicio',
+        true,
+        `tarea CloudRestoreAS: ${state}, proceso en ejecución`
+    );
 }
 
 // ============================================================================