qdd-framework 2.10.0-rc.2 → 2.10.0-rc.21

package/README.md

@@ -10,9 +10,12 @@
 ## 🚀 Instalación Rápida
 
 ```bash
-npm install -g qdd-framework
+npm install -g qdd-framework --allow-scripts=qdd-framework
 ```
 
+npm 12 no corre los scripts de instalación sin esa bandera. Si instalas sin ella, la primera vez que uses `qdd` se baja su
+binario desde el release de GitHub de esa versión, fuera del bloqueo de npm.
+
 > **Conflicto con el paquete `qdd` de npm:** existe un paquete ajeno llamado `qdd` (no pertenece a QDD Framework) que también instala un comando `qdd`. Si lo tienes instalado globalmente, desinstálalo antes (`npm uninstall -g qdd`) para que `qdd` apunte a QDD Framework. Desde v1.9.22 su presencia ya no rompe la instalación (antes fallaba con `EISDIR`).
 
 ---
@@ -33,7 +36,7 @@ qdd audit     # corre las pruebas y las reglas de QDD; funciona desde cualquier
 - `qdd doctor`: Diagnóstico determinista de salud del entorno.
 - `qdd report`: Reporte ejecutivo consolidado en formato Texto, Markdown o JSON para CI/CD.
 - `qdd evolution`: Recomienda la siguiente mejora del proyecto.
-- `qdd dashboard`: Centro de Comando Web interactivo con streaming en tiempo real (SSE) y ejecución de agentes.
+- `qdd dashboard` (obsoleto; el panel que sigue es `qdd-tareas`): Centro de Comando Web interactivo con streaming en tiempo real (SSE) y ejecución de agentes.
 - `qdd run`: Pipeline secuencial de comandos con rollback, o modo supervisor con auto-reparación (`qdd run --keep-alive`).
 
 ---

package/bin/qdd.js

@@ -2,26 +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}`);
+// 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;
+}
 
-const result = spawnSync(binaryPath, process.argv.slice(2), {
-  stdio: 'inherit'
-});
+function versionDelPaquete() {
+  try {
+    return require('../package.json').version;
+  } catch (_) {
+    return '';
+  }
+}
 
-// 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 se está actualizando: inténtalo de nuevo en un momento.');
-  console.error('[QDD] Si sigue así, reinstala el paquete con: npm install -g qdd-framework');
-  process.exit(75);
+function binarioActual() {
+  return rutaDelBinario({ platform: process.platform, env: process.env, dir: __dirname, version: versionDelPaquete(), existe: fs.existsSync });
 }
 
-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');
-  process.exit(1);
+// 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() {
+  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'] });
+}
+
+function main() {
+  bajarAlPrimerUso();
+  const binaryPath = binarioActual();
+
+  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);
+  }
+
+  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

@@ -9,6 +9,8 @@ const VERSION = 'v' + pkg.version;
 const REPO = 'trdago/qdd-framework';
 // TOPE_VERSION_MS: el antivirus puede demorar la primera ejecución de un binario recién descargado.
 const TOPE_VERSION_MS = 60000;
+// TOPE_TURNO_MS: un turno más viejo que esto quedó abandonado; bajar el binario tarda mucho menos.
+const TOPE_TURNO_MS = 5 * 60 * 1000;
 
 const platformMap = {
   win32: 'windows',
@@ -69,10 +71,17 @@ 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 });
   }
 
+  if (process.argv.includes('--primer-uso')) {
+    pedirTurno(path.join(binDir, '.bajando'));
+  }
+
   const binarioLocal = resolverBinarioLocal(__dirname, binaryName);
   if (binarioLocal) {
     console.log(`[QDD] Binario local detectado en ${binarioLocal}. Usando copia local para desarrollo...`);
@@ -82,13 +91,76 @@ 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.
+function tomarTurno(ruta) {
+  try {
+    fs.closeSync(fs.openSync(ruta, 'wx'));
+    return true;
+  } catch (err) {
+    if (err.code !== 'EEXIST') {
+      throw err;
+    }
+  }
+  if (Date.now() - fs.statSync(ruta).mtimeMs < TOPE_TURNO_MS) {
+    return false;
+  }
+  fs.rmSync(ruta, { force: true });
+  return tomarTurno(ruta);
+}
+
+// pedirTurno sale con 75, el «todavía no» de los pedidos, si otro qdd ya lo está bajando.
+function pedirTurno(ruta) {
+  try {
+    if (!tomarTurno(ruta)) {
+      console.error('[QDD] Otro proceso ya está bajando el binario.');
+      process.exit(75);
+    }
+  } catch (err) {
+    fallar(`no se pudo escribir en la carpeta del paquete: ${err.message}`);
+  }
+  process.on('exit', () => fs.rmSync(ruta, { force: true }));
+}
+
+// carpetaDeDescarga es propia de este proceso: un postinstall y un primer uso pueden correr a la vez.
+function carpetaDeDescarga() {
+  try {
+    const carpeta = fs.mkdtempSync(path.join(__dirname, 'descarga-'));
+    process.on('exit', () => fs.rmSync(carpeta, { recursive: true, force: true }));
+    return carpeta;
+  } catch (err) {
+    return fallar(`no se pudo escribir en la carpeta del paquete: ${err.message}`);
+  }
 }
 
 // 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 downloadDest = path.join(__dirname, `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}`);
@@ -121,9 +193,9 @@ function descargarDesdeRelease({ os, arch, ext, binaryName, binDir }) {
   function extractBinary() {
     console.log('[QDD] Extrayendo...');
     try {
-      const bin = instalarDescarga({ os, paquete: downloadDest, carpeta: __dirname, 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}`);
     }
@@ -140,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);
@@ -150,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;
 }
@@ -164,7 +324,7 @@ function codigoDeFalla(env) {
 
 function fallar(motivo) {
   console.error(`[QDD] La instalación falló: ${motivo}`);
-  console.error('[QDD] Para reintentar: npm install -g qdd-framework');
+  console.error('[QDD] Para reintentar: npm install -g qdd-framework --allow-scripts=qdd-framework');
   process.exit(codigoDeFalla(process.env));
 }
 
@@ -178,7 +338,7 @@ function actualizarConsola(bin) {
   }
 }
 
-module.exports = { esArchivo, estaDentroDeNodeModules, resolverBinarioLocal, comandoExtraer, instalarDescarga, codigoDeFalla };
+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.10.0-rc.2",
+  "version": "2.10.0-rc.21",
   "description": "Quality-Driven Development Framework",
   "bin": {
     "qdd": "bin/qdd.js"