fix(cras-install): agotar la elevación y verificar de verdad el despliegue

Instalar y Actualizar delegaban en el operador en cuanto algo no era ideal.

Linux: probeLinuxElevation solo probaba `sudo -n`. Si sudo pedía contraseña, el
panel declaraba "sin privilegios" y abortaba, aunque tuviera esa contraseña
guardada y la estuviera usando para abrir la sesión SSH. La política que lo
prohibía era más estricta de lo que su propio motivo exige: lo que hace inseguro
el `echo '{pw}' | sudo -S` de AServers es que la contraseña acaba en el argv del
`sh -c`, legible con `ps` por cualquier usuario del destino. Por el stdin del
canal `exec` no pasa por ningún argv, ningún historial ni ningún proceso
intermedio, y al no concatenarse a un comando tampoco permite inyección. Es la
misma credencial con la que ya se autenticó la sesión, y no llega a install.sh:
la consume el sudo que lo invoca. La cadena queda root -> sudo -n -> sudo -S ->
actualización en sitio -> user-service.

Windows: el sello config\.version se leía UNA sola vez. Como el bootstrap está
acotado a 20s y desempacar un onefile de ~270 MB con Defender escaneando se pasa
de largo, el sello conservaba la versión anterior y una actualización correcta
fallaba con 502. En instalación nueva no se notaba (no hay sello previo), así que
rompía solo las actualizaciones. Ahora reintenta, como ya hacía Linux.

Y la verificación daba por buena cualquier tarea con un State no vacío. `Ready`
es una tarea registrada que NO está corriendo: justo lo que se ve cuando el
agente arrancó y murió. Ahora se comprueba el proceso vivo, y en todos los modos
— antes se salía antes de mirar nada si el arranque no era 'service'.

Las actualizaciones pasan por install.ps1 -UpdateInPlace, y su código 75 se
traduce al 409 amable que ya tenía Linux.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

src/lib/server/api-error.ts

@@ -9,11 +9,20 @@ export function newTraceId(): string {
     return randomUUID();
 }
 
+/**
+ * Estados que el panel emite. Es una lista cerrada a propósito (Aduanasoft §5): si un error no
+ * encaja en ninguno, casi siempre es que está mal modelado, no que falte un código.
+ *
+ * Se exporta para que quien construya errores propios —como `AgentControlError`— tipe su estado
+ * con esto y el compilador lo valide donde se crea, en vez de descubrirlo al serializarlo.
+ */
+export type ApiErrorStatus = 400 | 401 | 403 | 404 | 409 | 422 | 500 | 502 | 503;
+
 export function errorJson(
     // 502 para fallos de un servicio del que dependemos (p.ej. Gitea al sincronizar
     // versiones de CRAS): distinguirlo de 503 le dice al operador que el panel está bien y
     // el problema está aguas arriba.
-    code: 400 | 401 | 403 | 404 | 409 | 422 | 500 | 502 | 503,
+    code: ApiErrorStatus,
     message: string,
     traceId: string
 ) {

src/lib/server/cras-install.test.ts

@@ -1,36 +1,69 @@
 /**
  * Instalador remoto de CloudRestoreAS: utilidades de ejecución y quoting.
  *
- * La prueba más importante de este archivo es la de fuga de secretos: el token del panel
+ * La prueba más importante de este archivo es la de fuga de secretos: ni el token del panel ni
- * NUNCA debe aparecer en un comando remoto, porque `ps` y el historial del servidor destino
+ * la contraseña SSH deben aparecer NUNCA en un comando remoto, porque `ps` y el historial del
- * son legibles por otros usuarios. Es exactamente el defecto del instalador de AServers, que
+ * servidor destino son legibles por otros usuarios. Es exactamente el defecto del instalador de
- * hace `echo '{password}' | sudo -S ...`.
+ * AServers, que hace `echo '{password}' | sudo -S ...`.
+ *
+ * Nótese qué prohíbe ese invariante y qué no: prohíbe el secreto en la LÍNEA DE COMANDOS, no
+ * elevar con contraseña. `sudo -S` alimentado por el stdin del canal cumple la regla, y es lo
+ * que permite instalar en /opt sin ir a tocar el sudoers del servidor.
  */
 import { describe, expect, it, vi } from 'vitest';
+
+// La verificación del despliegue asienta cada paso en cras_install_runs, que va a PostgreSQL.
+// Aquí interesa la DECISIÓN (¿esto cuenta como desplegado?), no la bitácora, así que se
+// sustituye el módulo entero en vez de levantar una base.
+vi.mock('./cras-releases', () => ({
+    appendInstallStep: vi.fn(async () => {}),
+    finishInstallRun: vi.fn(async () => {}),
+    getCrasReleaseById: vi.fn(async () => null),
+    listCrasTargetInventory: vi.fn(async () => []),
+    startInstallRun: vi.fn(async () => 1),
+    InstallRunConflictError: class extends Error {}
+}));
+
 import {
     execRemote,
     probeInPlaceUpdate,
     probeLinuxElevation,
+    probeWindowsElevation,
     psEncoded,
     shQuote,
+    verifyWindowsDeployment,
     InstallError
 } from './cras-install';
 
 /** Cliente SFTP falso que expone un `client.exec` controlable, como el real. */
 function fakeSftp(handler: (command: string) => { code?: number; stdout?: string; stderr?: string }) {
     const commands: string[] = [];
+    /** Lo que se escribió en el stdin de cada comando, en el mismo orden que `commands`. */
+    const stdins: (string | null)[] = [];
     const sftp = {
         client: {
             exec(command: string, callback: (err: Error | null, stream?: unknown) => void) {
                 commands.push(command);
+                const index = stdins.push(null) - 1;
                 const result = handler(command);
                 const listeners: Record<string, ((...args: unknown[]) => void)[]> = {};
                 const stderrListeners: ((...args: unknown[]) => void)[] = [];
+                let ended = false;
                 const stream = {
                     on(event: string, fn: (...args: unknown[]) => void) {
                         (listeners[event] ??= []).push(fn);
                         return stream;
                     },
+                    write(chunk: string) {
+                        stdins[index] = (stdins[index] ?? '') + chunk;
+                        return true;
+                    },
+                    end() {
+                        ended = true;
+                    },
+                    get stdinClosed() {
+                        return ended;
+                    },
                     stderr: {
                         on(_event: string, fn: (...args: unknown[]) => void) {
                             stderrListeners.push(fn);
@@ -53,7 +86,7 @@ function fakeSftp(handler: (command: string) => { code?: number; stdout?: string
             }
         }
     };
-    return { sftp, commands };
+    return { sftp, commands, stdins };
 }
 
 describe('shQuote', () => {
@@ -277,22 +310,170 @@ describe('probeLinuxElevation', () => {
         const r = await probeLinuxElevation(sftp as never);
         expect(r.elevation).toBe('ninguna');
         expect(r.prefix).toBe('');
-        expect(r.detail).toMatch(/contraseña, que el panel nunca envía/);
     });
 
-    it('NUNCA construye un prefijo que le pida la contraseña a sudo', async () => {
+    it('sudo con la contraseña del panel: eleva cuando `sudo -n` no puede', async () => {
-        // La política del módulo: ni por argv ni por stdin. El modo sin privilegios existe
+        // El caso que dejaba tirado al operador: la cuenta SÍ está en el sudoers, solo que con
-        // precisamente para no tener que romperla.
+        // contraseña. El panel ya la tiene —es con la que abrió la sesión— y ahora la usa.
-        for (const stderr of ['sudo: a password is required', 'sudo: sorry, you must have a tty']) {
         const { sftp } = sftpFor({
             'id -u': { code: 0, stdout: '1000' },
-                'sudo -n true': { code: 1, stderr },
+            'sudo -n true': { code: 1, stderr: 'sudo: a password is required' },
-                'sudo -n -l': { code: 1 }
+            "sudo -S -k -p '' true": { code: 0 }
+        });
+        const r = await probeLinuxElevation(sftp as never, 'secreto-del-panel');
+        expect(r.elevation).toBe('sudo-con-password');
+        expect(r.prefix).toContain('-S');
+        // El prefijo y su stdin son inseparables: sin esto sudo se queda esperando.
+        expect(r.stdin).toBe('secreto-del-panel\n');
+    });
+
+    it('la contraseña viaja por stdin y NUNCA por la línea de comandos', async () => {
+        // El invariante que hereda del defecto de AServers: `echo '{pw}' | sudo -S` deja la
+        // contraseña en el argv del `sh -c`, legible con `ps` por cualquier usuario del destino.
+        // Lo que se prohíbe es eso, no elevar con contraseña.
+        const PASSWORD = 'clave-que-no-debe-filtrarse';
+        const { sftp, commands, stdins } = sftpFor({
+            'id -u': { code: 0, stdout: '1000' },
+            'sudo -n true': { code: 1, stderr: 'sudo: a password is required' },
+            "sudo -S -k -p '' true": { code: 0 }
+        });
+        const r = await probeLinuxElevation(sftp as never, PASSWORD);
+
+        expect(commands.some((c) => c.includes(PASSWORD))).toBe(false);
+        expect(commands.some((c) => c.includes('echo'))).toBe(false);
+        expect(r.prefix).not.toContain(PASSWORD);
+        // Y sí llegó por el único canal admitido.
+        expect(stdins.some((s) => s?.includes(PASSWORD))).toBe(true);
+    });
+
+    it('requiretty NO gasta un intento de contraseña: sudo rechaza antes de mirar la política', async () => {
+        // Mandarle la contraseña ahí no arreglaría nada y sumaría un fallo al log de auth del
+        // destino, que es justo lo que dispara las alertas de fuerza bruta.
+        const { sftp, commands } = sftpFor({
+            'id -u': { code: 0, stdout: '1000' },
+            'sudo -n true': { code: 1, stderr: 'sudo: sorry, you must have a tty to run sudo' }
+        });
+        const r = await probeLinuxElevation(sftp as never, 'secreto-del-panel');
+        expect(r.elevation).toBe('requiretty');
+        expect(commands.some((c) => c.includes('-S'))).toBe(false);
+    });
+
+    it('contraseña rechazada: lo dice, en vez de culpar a la falta de sudo', async () => {
+        // Los dos remedios son opuestos: meter al usuario en el sudoers, o corregir la
+        // contraseña registrada en el panel. Un mensaje genérico manda a hacer lo que no es.
+        const { sftp } = sftpFor({
+            'id -u': { code: 0, stdout: '1000' },
+            'sudo -n true': { code: 1, stderr: 'sudo: a password is required' },
+            "sudo -S -k -p '' true": { code: 1, stderr: 'sudo: 1 incorrect password attempt' },
+            'sudo -n -l': { code: 1, stdout: '' }
+        });
+        const r = await probeLinuxElevation(sftp as never, 'clave-vieja');
+        expect(r.elevation).toBe('ninguna');
+        expect(r.prefix).toBe('');
+        expect(r.detail).toMatch(/contraseña SSH guardada en el panel/);
+    });
+});
+
+/**
+ * Sonda de elevación en Windows.
+ *
+ * El estado que se añadió —y el motivo de estas pruebas— es "administrador con token filtrado":
+ * una cuenta que SÍ está en Administradores pero a la que OpenSSH entregó el token filtrado por
+ * UAC. Se veía igual que "no eres administrador", y el remedio es el opuesto: ahí la cuenta ya
+ * es la correcta y lo que falta es una política del servidor.
+ */
+describe('probeWindowsElevation', () => {
+    /** El comando va base64/UTF-16LE dentro de -EncodedCommand: hay que decodificarlo. */
+    function fakePsSftp(reply: string) {
+        return fakeSftp((command) => {
+            const encoded = command.split('-EncodedCommand ')[1] ?? '';
+            const script = Buffer.from(encoded, 'base64').toString('utf16le');
+            // Se comprueba que la sonda mire el SID del grupo, que es lo único que distingue el
+            // token filtrado de una cuenta sin privilegios.
+            if (!script.includes('S-1-5-32-544')) return { code: 1, stdout: '' };
+            return { code: 0, stdout: reply };
         });
-            const r = await probeLinuxElevation(sftp as never);
-            expect(r.prefix).not.toMatch(/-S/);
-            expect(r.prefix).not.toMatch(/echo/);
     }
+
+    it('administrador con token completo', async () => {
+        const { sftp } = fakePsSftp('admin');
+        const r = await probeWindowsElevation(sftp as never);
+        expect(r.elevation).toBe('admin');
+        expect(r.detail).toBe('');
+    });
+
+    it('token filtrado por UAC: NO manda a cambiar de cuenta', async () => {
+        const { sftp } = fakePsSftp('token-filtrado');
+        const r = await probeWindowsElevation(sftp as never);
+        expect(r.elevation).toBe('token-filtrado');
+        // El remedio correcto es la política del servidor, no otra cuenta.
+        expect(r.detail).toMatch(/LocalAccountTokenFilterPolicy/);
+        expect(r.detail).toMatch(/No hay que cambiar de cuenta/);
+    });
+
+    it('cuenta sin privilegios: ahí sí hace falta otra cuenta', async () => {
+        const { sftp } = fakePsSftp('limitado');
+        const r = await probeWindowsElevation(sftp as never);
+        expect(r.elevation).toBe('limitado');
+        expect(r.detail).toMatch(/cuenta administradora/);
+    });
+});
+
+/**
+ * Verificación del despliegue en Windows.
+ *
+ * El defecto que cubre: se daba por buena cualquier tarea con un `State` no vacío. `Ready` es una
+ * tarea REGISTRADA QUE NO ESTÁ CORRIENDO —exactamente lo que se ve cuando el agente arrancó y
+ * murió a los pocos segundos—, así que una actualización que dejaba el servidor sin restaurador
+ * se asentaba como completada y nadie se enteraba hasta que alguien pulsaba Verificar.
+ */
+describe('verifyWindowsDeployment', () => {
+    const RELEASE = { version: '1.1.2' } as never;
+
+    /** Responde a cada script de PowerShell según lo que pregunte. */
+    function fakeWindows(opts: { stamp: string; taskState: string; running: boolean }) {
+        return fakeSftp((command) => {
+            const encoded = command.split('-EncodedCommand ')[1] ?? '';
+            const script = Buffer.from(encoded, 'base64').toString('utf16le');
+            if (script.includes('config\\.version')) return { code: 0, stdout: opts.stamp };
+            if (script.includes('Get-Process')) {
+                return { code: 0, stdout: opts.running ? 'corriendo:1' : 'detenido' };
+            }
+            if (script.includes('Get-ScheduledTask')) return { code: 0, stdout: opts.taskState };
+            return { code: 1, stdout: '' };
+        });
+    }
+
+    it('tarea Ready con el proceso muerto NO cuenta como desplegado', async () => {
+        const { sftp } = fakeWindows({ stamp: '1.1.2', taskState: 'Ready', running: false });
+        await expect(
+            verifyWindowsDeployment(sftp as never, 1, RELEASE, 'service', 'C:\\CRAS')
+        ).rejects.toThrow(/el proceso no está corriendo/);
+    });
+
+    it('tarea corriendo y proceso vivo sí cuenta', async () => {
+        const { sftp } = fakeWindows({ stamp: '1.1.2', taskState: 'Running', running: true });
+        await expect(
+            verifyWindowsDeployment(sftp as never, 1, RELEASE, 'service', 'C:\\CRAS')
+        ).resolves.toBeUndefined();
+    });
+
+    it('el proceso se comprueba también fuera del modo servicio', async () => {
+        // Antes se salía antes de mirar nada cuando el arranque no era 'service', así que
+        // actualizar con 'none' dejaba el agente muerto y el run quedaba en verde.
+        const { sftp, commands } = fakeWindows({ stamp: '1.1.2', taskState: '', running: false });
+        await verifyWindowsDeployment(sftp as never, 1, RELEASE, 'none', 'C:\\CRAS');
+        const scripts = commands.map((c) =>
+            Buffer.from(c.split('-EncodedCommand ')[1] ?? '', 'base64').toString('utf16le')
+        );
+        expect(scripts.some((s) => s.includes('Get-Process'))).toBe(true);
+    });
+
+    it('un sello con otra versión es un fallo, no un aviso', async () => {
+        const { sftp } = fakeWindows({ stamp: '1.1.1', taskState: 'Running', running: true });
+        await expect(
+            verifyWindowsDeployment(sftp as never, 1, RELEASE, 'service', 'C:\\CRAS')
+        ).rejects.toThrow(/reporta la versión 1\.1\.1/);
     });
 });
 

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
+ * - **El password de sudo va por el stdin del canal `exec`, nunca por argv.** Es la distinción
- *   instalan en /opt y registran un servicio de sistema se exige root o `sudo -n` (sudo sin
+ *   que importa, y la que el defecto de AServers no hace: lo que expone `echo '{pw}' | sudo -S`
- *   password), y si no hay ninguno se aborta ANTES de subir 270 MB. El modo `user-service`
+ *   es que la contraseña acaba en la línea de comandos del `sh -c` que la ejecuta, visible con
- *   evita el problema en vez de rodearlo: instala bajo el home con un unit de systemd de
+ *   `ps` para cualquier usuario del destino. Escribirla en el stdin del canal no pasa por
- *   usuario, así que no necesita elevación alguna y le bastan las credenciales SSH.
+ *   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í,
+    // ninguna elevación. Los modos de sistema sí, y para ellos se agotan TODAS las vías —
-    // antes de transferir 270 MB, porque fallar después es desperdicio y deja basura en /tmp.
+    // 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 privileged = await probeLinuxElevation(sftp, target.ssh_password);
-    const canElevate = privileged.elevation === 'root' || privileged.elevation === 'sudo-sin-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
+    // Sin ninguna forma de elevar quedan dos vías antes de rendirse. `user-service` instala en el
-    // sudo. `user-service` instala en el home; la actualización en sitio deja el unit como está
+    // home; la actualización en sitio deja el unit como está y solo reemplaza el binario, que es
-    // y solo reemplaza el binario, que es lo único que una actualización necesita de verdad.
+    // 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}`);
+        await appendInstallStep(
-        const install = await execRemote(sftp, installCmd, INSTALL_EXEC_TIMEOUT_MS);
+            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
+ * `sshPassword` es la credencial que el panel ya usó para abrir esta sesión. Se prueba como
- * instalación `user-service` no necesita ninguno, así que quien decide si falta algo es el
+ * último recurso de elevación, y solo por el stdin del canal (ver `execRemote`). Omitirla
- * llamador, no esta función.
+ * 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 (Get-ScheduledTask -TaskName 'CloudRestoreAS' -ErrorAction SilentlyContinue) " +
-                'if($p.IsInRole([Security.Principal.WindowsBuiltInRole]::Administrator)){"admin"}else{"limitado"}'
+                '{"si"} else {"no"}'
         )
     );
-    const autostart = request.autostart ?? 'service';
+    const taskExists = taskProbe.stdout.trim() === 'si';
-    if (autostart === 'service' && admin.stdout.trim() !== 'admin') {
+    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 ' +
+            `No se puede operar la tarea programada de ${target.name}: ${privileged.detail}`
-                'como SYSTEM y requiere elevación; usa una cuenta administradora o instala sin servicio.'
         );
     }
     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,13 +1289,26 @@ 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> {
+    // 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(
@@ -1111,11 +1316,18 @@ async function verifyWindowsDeployment(
                     `{ Get-Content -LiteralPath '${prefix}\\config\\.version' -Raw }`
             )
         );
-    const deployed = stamp.stdout.trim();
+        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`
+    );
 }
 
 // ============================================================================