qdd-framework 2.9.10 → 2.10.0-rc.10

package/bin/qdd.js

@@ -2,40 +2,69 @@
 
 const { spawnSync } = require('child_process');
 const path = require('path');
-const os = require('os');
 const fs = require('fs');
 
-const binaryExt = os.platform() === 'win32' ? '.exe' : '';
-const binaryPath = path.join(__dirname, `qdd${binaryExt}`);
-const instalador = path.join(__dirname, '..', 'install.js');
+// rutaDelBinario: en Windows, qdd.exe vive fuera del paquete, en la carpeta de su versión (install.js, FND-142). Una
+// instalación anterior a ese cambio, o sin LOCALAPPDATA, lo tiene dentro del paquete.
+function rutaDelBinario({ platform, env, dir, version, existe }) {
+  const nombre = platform === 'win32' ? 'qdd.exe' : 'qdd';
+  const enElPaquete = path.join(dir, nombre);
+  if (platform !== 'win32' || !env.LOCALAPPDATA || !version) {
+    return enElPaquete;
+  }
+  const porVersion = path.join(env.LOCALAPPDATA, 'qdd', 'bin', version, nombre);
+  return existe(porVersion) ? porVersion : enElPaquete;
+}
+
+function versionDelPaquete() {
+  try {
+    return require('../package.json').version;
+  } catch (_) {
+    return '';
+  }
+}
+
+function binarioActual() {
+  return rutaDelBinario({ platform: process.platform, env: process.env, dir: __dirname, version: versionDelPaquete(), existe: fs.existsSync });
+}
 
 // Con npm 12, quien instala sin --allow-scripts=qdd-framework no corrió el postinstall (FND-143): el primer qdd baja el
 // binario con el mismo instalador. Lo que escribe va a stderr: otro programa puede estar leyendo la salida de qdd.
 function bajarAlPrimerUso() {
-  if (fs.existsSync(binaryPath) || !fs.existsSync(instalador)) {
+  const instalador = path.join(__dirname, '..', 'install.js');
+  if (fs.existsSync(binarioActual()) || !fs.existsSync(instalador)) {
     return;
   }
   console.error('[QDD] qdd no tiene su binario: lo bajo ahora, porque npm no corrió su instalación.');
   spawnSync(process.execPath, [instalador, '--primer-uso'], { stdio: ['ignore', 2, 'inherit'] });
 }
 
-bajarAlPrimerUso();
+function main() {
+  bajarAlPrimerUso();
+  const binaryPath = binarioActual();
 
-const result = spawnSync(binaryPath, process.argv.slice(2), {
-  stdio: 'inherit'
-});
+  const result = spawnSync(binaryPath, process.argv.slice(2), {
+    stdio: 'inherit'
+  });
 
-// Sin binario, lo más probable es que npm esté reinstalando qdd: 75 es «todavía no» para los pedidos del panel (FND-135).
-if (result.error && result.error.code === 'ENOENT') {
-  console.error('[QDD] qdd no tiene su binario: se está actualizando, o npm bloqueó su instalación (npm 12 lo hace por defecto).');
-  console.error('[QDD] Si sigue así, reinstala el paquete con: npm install -g qdd-framework --allow-scripts=qdd-framework');
-  process.exit(75);
-}
+  // Sin binario, lo más probable es que npm esté reinstalando qdd: 75 es «todavía no» para los pedidos del panel (FND-135).
+  if (result.error && result.error.code === 'ENOENT') {
+    console.error('[QDD] qdd no tiene su binario: se está actualizando, o npm bloqueó su instalación (npm 12 lo hace por defecto).');
+    console.error('[QDD] Si sigue así, reinstala el paquete con: npm install -g qdd-framework --allow-scripts=qdd-framework');
+    process.exit(75);
+  }
+
+  if (result.error) {
+    console.error(`[QDD] No se pudo ejecutar el binario nativo ${binaryPath}: ${result.error.message}`);
+    console.error('[QDD] Reinstala el paquete con: npm install -g qdd-framework --allow-scripts=qdd-framework');
+    process.exit(1);
+  }
 
-if (result.error) {
-  console.error(`[QDD] No se pudo ejecutar el binario nativo ${binaryPath}: ${result.error.message}`);
-  console.error('[QDD] Reinstala el paquete con: npm install -g qdd-framework --allow-scripts=qdd-framework');
-  process.exit(1);
+  process.exit(result.status === null ? 1 : result.status);
 }
 
-process.exit(result.status === null ? 1 : result.status);
+module.exports = { rutaDelBinario };
+
+if (require.main === module) {
+  main();
+}

package/install.js

@@ -71,6 +71,9 @@ function main() {
   const binaryName = `qdd${binaryExt}`;
   const binDir = path.join(__dirname, 'bin');
 
+  const carpeta = carpetaDeVersiones({ os, env: process.env });
+  const destino = destinoDelBinario({ carpeta, version: pkg.version, binDir, binaryName });
+
   if (!fs.existsSync(binDir)) {
     fs.mkdirSync(binDir, { recursive: true });
   }
@@ -88,7 +91,28 @@ function main() {
     process.exit(0);
   }
 
-  descargarDesdeRelease({ os, arch, ext, binaryName, binDir });
+  // Reinstalar la misma versión: su binario puede estar corriendo y no hace falta tocarlo.
+  if (carpeta && respondeBinario(destino)) {
+    console.log(`[QDD] La versión ${pkg.version} ya está en ${destino}.`);
+    terminarInstalacion({ bin: destino, carpeta });
+    return;
+  }
+
+  if (process.env.QDD_INSTALL_BINARIO) {
+    instalarBinarioIndicado({ origen: process.env.QDD_INSTALL_BINARIO, destino, carpeta });
+    return;
+  }
+
+  descargarDesdeRelease({ os, arch, ext, binaryName, binDir, destino, carpeta });
+}
+
+// QDD_INSTALL_BINARIO instala ese binario en vez de descargarlo: es como el CI prueba el paquete antes de publicarlo.
+function instalarBinarioIndicado({ origen, destino, carpeta }) {
+  try {
+    terminarInstalacion({ bin: instalarCopia(origen, destino), carpeta });
+  } catch (err) {
+    fallar(`no se pudo instalar ${origen}: ${err.message}`);
+  }
 }
 
 // tomarTurno: varios qdd sin binario a la vez (un panel, por ejemplo) no bajan cada uno el suyo.
@@ -133,10 +157,10 @@ function carpetaDeDescarga() {
 }
 
 // 2. Descarga desde GitHub Releases
-function descargarDesdeRelease({ os, arch, ext, binaryName, binDir }) {
+function descargarDesdeRelease({ os, arch, ext, binaryName, binDir, destino, carpeta }) {
   const url = `https://github.com/${REPO}/releases/download/${VERSION}/qdd_${os}_${arch}.${ext}`;
-  const carpeta = carpetaDeDescarga();
-  const downloadDest = path.join(carpeta, `qdd-download.${ext}`);
+  const descarga = carpetaDeDescarga();
+  const downloadDest = path.join(descarga, `qdd-download.${ext}`);
 
   console.log(`[QDD] Descargando binario nativo para ${os}-${arch}...`);
   console.log(`[QDD] URL: ${url}`);
@@ -169,9 +193,9 @@ function descargarDesdeRelease({ os, arch, ext, binaryName, binDir }) {
   function extractBinary() {
     console.log('[QDD] Extrayendo...');
     try {
-      const bin = instalarDescarga({ os, paquete: downloadDest, carpeta, binaryName, binDir, env: process.env });
+      const bin = instalarDescarga({ os, paquete: downloadDest, carpeta: descarga, binaryName, binDir, env: process.env, destino });
       console.log('[QDD] ¡Instalación nativa completada exitosamente!');
-      actualizarConsola(bin);
+      terminarInstalacion({ bin, carpeta });
     } catch (err) {
       fallar(`no se pudo instalar el binario: ${err.message}`);
     }
@@ -188,8 +212,96 @@ function comandoExtraer(os, paquete, destino, env) {
   return { programa: 'tar', args: ['-xzf', paquete, '-C', destino] };
 }
 
-// instalarDescarga deja el binario en bin/ solo si responde; si algo falla, lanza el error y el binario anterior sigue ahí.
-function instalarDescarga({ os, paquete, carpeta, binaryName, binDir, env }) {
+// En Windows, npm no puede reemplazar un qdd.exe en uso, y siempre hay uno: el panel y los pedidos corren desde él (issue
+// #107, FND-142). Por eso ahí el binario vive fuera del paquete, en %LOCALAPPDATA%\qdd\bin\<versión>\qdd.exe: lo que
+// corre se queda con su versión y npm no se topa con nada. bin\actual.txt dice cuál es la instalada: lo que corre lo
+// mira para saber que tiene que cerrarse. Linux y macOS pueden reemplazar un binario en uso: siguen con él en el paquete.
+function carpetaDeVersiones({ os, env }) {
+  if (os !== 'windows' || !env.LOCALAPPDATA) {
+    return '';
+  }
+  return path.join(env.LOCALAPPDATA, 'qdd', 'bin');
+}
+
+function destinoDelBinario({ carpeta, version, binDir, binaryName }) {
+  if (!carpeta) {
+    return path.join(binDir, binaryName);
+  }
+  return path.join(carpeta, version, binaryName);
+}
+
+function respondeBinario(ruta) {
+  try {
+    execFileSync(ruta, ['--version'], { stdio: 'pipe', timeout: TOPE_VERSION_MS });
+    return true;
+  } catch (_) {
+    return false;
+  }
+}
+
+// moverBinario copia si el destino está en otro volumen: el prefijo de npm y %LOCALAPPDATA% pueden estarlo.
+function moverBinario(origen, destino, renombrar = fs.renameSync) {
+  try {
+    renombrar(origen, destino);
+    return;
+  } catch (err) {
+    if (err.code !== 'EXDEV') {
+      throw err;
+    }
+  }
+  copiarBinario(origen, destino);
+  fs.rmSync(origen, { force: true });
+}
+
+// copiarBinario nunca deja un binario a medias con el nombre final.
+function copiarBinario(origen, destino) {
+  const temporal = destino + '.nuevo';
+  fs.copyFileSync(origen, temporal);
+  fs.renameSync(temporal, destino);
+}
+
+function instalarCopia(origen, destino) {
+  execFileSync(origen, ['--version'], { stdio: 'pipe', timeout: TOPE_VERSION_MS });
+  fs.mkdirSync(path.dirname(destino), { recursive: true });
+  copiarBinario(origen, destino);
+  return destino;
+}
+
+// registrarVersion avisa a lo que corre que hay otra versión y borra las viejas: quedan esta y la anterior. Lo que no se
+// puede borrar sigue corriendo: se borrará en otra actualización.
+function registrarVersion({ carpeta, version, borrar = fs.rmSync }) {
+  const puntero = path.join(carpeta, 'actual.txt');
+  const anterior = esArchivo(puntero) ? fs.readFileSync(puntero, 'utf8').trim() : '';
+  if (anterior !== version) {
+    fs.writeFileSync(puntero, version);
+  }
+  for (const nombre of fs.readdirSync(carpeta)) {
+    if (!/^\d+\.\d+\.\d+/.test(nombre) || nombre === version || nombre === anterior) {
+      continue;
+    }
+    try {
+      borrar(path.join(carpeta, nombre), { recursive: true, force: true });
+    } catch (_) {
+      console.log(`[QDD] La versión ${nombre} sigue en uso: se borrará más adelante.`);
+    }
+  }
+}
+
+// terminarInstalacion: primero el panel, y al final el puntero, porque lo que corre se cierra apenas cambia.
+function terminarInstalacion({ bin, carpeta }) {
+  actualizarConsola(bin);
+  if (!carpeta) {
+    return;
+  }
+  try {
+    registrarVersion({ carpeta, version: pkg.version });
+  } catch (err) {
+    console.error('[QDD] No se pudo registrar la versión instalada:', err.message);
+  }
+}
+
+// instalarDescarga deja el binario en su destino solo si responde; si algo falla, lanza el error y el binario anterior sigue ahí.
+function instalarDescarga({ os, paquete, carpeta, binaryName, binDir, env, destino = path.join(binDir, binaryName) }) {
   const { programa, args } = comandoExtraer(os, paquete, carpeta, env);
   execFileSync(programa, args, { stdio: 'pipe' });
   const extraido = path.join(carpeta, binaryName);
@@ -198,8 +310,8 @@ function instalarDescarga({ os, paquete, carpeta, binaryName, binDir, env }) {
   }
   fs.chmodSync(extraido, 0o755);
   execFileSync(extraido, ['--version'], { stdio: 'pipe', timeout: TOPE_VERSION_MS });
-  const destino = path.join(binDir, binaryName);
-  fs.renameSync(extraido, destino);
+  fs.mkdirSync(path.dirname(destino), { recursive: true });
+  moverBinario(extraido, destino);
   fs.rmSync(paquete, { force: true });
   return destino;
 }
@@ -226,7 +338,7 @@ function actualizarConsola(bin) {
   }
 }
 
-module.exports = { esArchivo, estaDentroDeNodeModules, resolverBinarioLocal, comandoExtraer, instalarDescarga, codigoDeFalla, tomarTurno };
+module.exports = { esArchivo, estaDentroDeNodeModules, resolverBinarioLocal, comandoExtraer, instalarDescarga, codigoDeFalla, carpetaDeVersiones, destinoDelBinario, respondeBinario, moverBinario, instalarCopia, registrarVersion, tomarTurno };
 
 if (require.main === module) {
   main();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qdd-framework",
-  "version": "2.9.10",
+  "version": "2.10.0-rc.10",
   "description": "Quality-Driven Development Framework",
   "bin": {
     "qdd": "bin/qdd.js"