@saulwade/swl-ses 2.2.4 → 2.3.1

package/scripts/lib/gate-licencias.js

@@ -1,212 +1,212 @@
-'use strict';
-
-/**
- * gate-licencias.js — Clasificación de licencias del árbol runtime (Fase 14, ADR-0038).
- *
- * Gate de cadena de suministro: detecta licencias copyleft contaminantes en las
- * dependencias de producción antes de un release. Zero-dependencies — lee
- * `package-lock.json` (v3) y clasifica cada dependencia prod contra listas SPDX.
- *
- * Modo de uso en /swl:release: WARN-ONLY (D-14-02). Reporta hallazgos pero NUNCA
- * bloquea el release en v1 — la promoción a blocking exigiría calibración + ADR
- * posterior (mismo patrón que los gates G0/G2/G3).
- *
- * Clasificación de expresiones SPDX:
- *   - OR  → el consumidor ELIGE un término → clasifica por el MEJOR (menos restrictivo).
- *   - AND → ambos términos APLICAN → clasifica por el PEOR (más restrictivo).
- *
- * Severidad (de menor a mayor restricción): permisiva < débil < fuerte; "desconocida"
- * es categoría propia (metadata ausente o no catalogada), no un error.
- *
- * Origen: Fase 14 — cadena de suministro en release (P4, ADR-0038).
- */
-
-const fs = require('fs');
-const path = require('path');
-
-// Listas SPDX (normalizadas a mayúsculas). El matching es por PREFIJO de la
-// familia para tolerar variantes `-only` / `-or-later` (ej. GPL-3.0-or-later).
-const FAMILIAS_FUERTES = ['GPL', 'AGPL', 'SSPL', 'OSL', 'EUPL', 'CDDL'];
-const FAMILIAS_DEBILES = ['LGPL', 'MPL', 'EPL', 'CPL', 'MS-RL'];
-const PERMISIVAS = new Set([
-  'MIT', 'ISC', 'APACHE-2.0', 'APACHE 2.0', 'BSD', 'BSD-2-CLAUSE', 'BSD-3-CLAUSE',
-  '0BSD', 'UNLICENSE', 'CC0-1.0', 'WTFPL', 'BLUEOAK-1.0.0', 'ZLIB', 'PYTHON-2.0',
-  'APACHE-2.0 WITH LLVM-EXCEPTION',
-]);
-
-// Orden de severidad para resolver expresiones OR/AND. NOTA: `desconocida: 0`
-// NO es un grado ordinal de copyleft — es categoría especial. En `clasificarExprOr`
-// las "desconocidas" se filtran ANTES del reduce cuando hay algún término
-// catalogado, por lo que su valor 0 nunca contamina la elección del mejor/peor.
-const SEVERIDAD = { desconocida: 0, permisiva: 1, debil: 2, fuerte: 3 };
-
-// Cota de profundidad de recursión para licencias anidadas (array de arrays);
-// un package.json malicioso con anidamiento profundo no debe tumbar la auditoría.
-const MAX_PROFUNDIDAD_LICENCIA = 10;
-
-/**
- * Normaliza un identificador de licencia simple (sin operadores) a su clasificación.
- * @param {string} idRaw
- * @returns {'fuerte'|'debil'|'permisiva'|'desconocida'}
- */
-function clasificarSimple(idRaw) {
-  if (typeof idRaw !== 'string') return 'desconocida';
-  const id = idRaw.trim().toUpperCase().replace(/^\(/, '').replace(/\)$/, '').trim();
-  if (!id) return 'desconocida';
-  // Familias copyleft por prefijo (cubre -ONLY / -OR-LATER / versiones).
-  for (const fam of FAMILIAS_FUERTES) {
-    if (id === fam || id.startsWith(fam + '-') || id.startsWith(fam + ' ')) return 'fuerte';
-  }
-  for (const fam of FAMILIAS_DEBILES) {
-    if (id === fam || id.startsWith(fam + '-') || id.startsWith(fam + ' ')) return 'debil';
-  }
-  if (PERMISIVAS.has(id)) return 'permisiva';
-  return 'desconocida';
-}
-
-/**
- * Clasifica una licencia npm: string SPDX (con OR/AND), objeto legacy {type},
- * arreglo legacy de objetos, o ausente.
- *
- * @param {string|object|Array|undefined|null} valor
- * @param {number} [_depth=0]  profundidad interna de recursión (cota anti-DoS)
- * @returns {'fuerte'|'debil'|'permisiva'|'desconocida'}
- */
-function clasificarLicencia(valor, _depth = 0) {
-  if (valor == null) return 'desconocida';
-  if (_depth > MAX_PROFUNDIDAD_LICENCIA) return 'desconocida'; // anidamiento abusivo
-
-  // Objeto legacy { type: 'MIT' }
-  if (typeof valor === 'object' && !Array.isArray(valor)) {
-    return clasificarLicencia(valor.type, _depth + 1);
-  }
-  // Arreglo legacy [{ type }] → tratar como OR (el consumidor elige)
-  if (Array.isArray(valor)) {
-    const cls = valor.map((v) => clasificarLicencia(v && v.type ? v.type : v, _depth + 1));
-    return cls.reduce((mejor, c) => (SEVERIDAD[c] < SEVERIDAD[mejor] ? c : mejor), 'fuerte');
-  }
-  if (typeof valor !== 'string') return 'desconocida';
-
-  const expr = valor.trim();
-  if (!expr) return 'desconocida';
-
-  // Expresión AND: ambas aplican → el PEOR término manda.
-  if (/\bAND\b/i.test(expr)) {
-    const partes = expr.replace(/[()]/g, ' ').split(/\bAND\b/i).map((s) => s.trim()).filter(Boolean);
-    return partes
-      .map((p) => clasificarExprOr(p))
-      .reduce((peor, c) => (SEVERIDAD[c] > SEVERIDAD[peor] ? c : peor), 'desconocida');
-  }
-  return clasificarExprOr(expr);
-}
-
-/**
- * Resuelve una expresión que puede contener OR (el MEJOR término manda) o un
- * identificador simple.
- * @param {string} expr
- * @returns {'fuerte'|'debil'|'permisiva'|'desconocida'}
- */
-function clasificarExprOr(expr) {
-  if (/\bOR\b/i.test(expr)) {
-    const partes = expr.replace(/[()]/g, ' ').split(/\bOR\b/i).map((s) => s.trim()).filter(Boolean);
-    // mejor = menor severidad, pero ignorando "desconocida" si hay algo catalogado
-    const clasifs = partes.map((p) => clasificarSimple(p));
-    const catalogadas = clasifs.filter((c) => c !== 'desconocida');
-    const pool = catalogadas.length ? catalogadas : clasifs;
-    return pool.reduce((mejor, c) => (SEVERIDAD[c] < SEVERIDAD[mejor] ? c : mejor), 'fuerte');
-  }
-  return clasificarSimple(expr);
-}
-
-/**
- * Resuelve la licencia de un paquete: primero el campo del lockfile, con fallback
- * al package.json instalado en node_modules/<ruta>.
- *
- * @param {string} baseDir
- * @param {string} rutaNodeModules  clave del lockfile, ej. "node_modules/foo"
- * @param {object} entradaLock
- * @returns {string|object|undefined}
- */
-function resolverLicencia(baseDir, rutaNodeModules, entradaLock) {
-  if (entradaLock && entradaLock.license != null) return entradaLock.license;
-  if (entradaLock && entradaLock.licenses != null) return entradaLock.licenses; // legacy array
-  // Fallback: leer el package.json instalado.
-  try {
-    const pkgPath = path.join(baseDir, rutaNodeModules, 'package.json');
-    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
-    return pkg.license != null ? pkg.license : pkg.licenses;
-  } catch {
-    return undefined;
-  }
-}
-
-/**
- * Evalúa las licencias del árbol de producción a partir de package-lock.json.
- * Excluye entradas marcadas `dev: true` y la raíz "".
- *
- * @param {string} baseDir  raíz del proyecto (contiene package-lock.json)
- * @returns {{hallazgos: Array<{paquete:string, version:string, licencia:string, clasificacion:string}>, resumen: {fuerte:number, debil:number, permisiva:number, desconocida:number}}}
- */
-function evaluarLicencias(baseDir) {
-  const resumen = { fuerte: 0, debil: 0, permisiva: 0, desconocida: 0 };
-  const hallazgos = [];
-
-  const lockPath = path.join(baseDir, 'package-lock.json');
-  let lock;
-  try {
-    lock = JSON.parse(fs.readFileSync(lockPath, 'utf8'));
-  } catch (err) {
-    // Sin lockfile (ENOENT) → resultado vacío, no es error. Pero un lockfile
-    // corrupto (SyntaxError) o sin permisos (EACCES) SÍ se propaga: enmascararlo
-    // como "sin deps copyleft" daría un falso OK. El caller (verificar-release)
-    // lo captura y reporta como gate "no disponible".
-    if (err.code === 'ENOENT') return { hallazgos, resumen };
-    throw err;
-  }
-
-  const packages = lock.packages || {};
-  for (const [ruta, entrada] of Object.entries(packages)) {
-    if (!ruta || !ruta.startsWith('node_modules/')) continue; // raíz "" y workspaces fuera
-    if (entrada && entrada.dev) continue; // solo árbol prod
-    const licValor = resolverLicencia(baseDir, ruta, entrada);
-    const clasificacion = clasificarLicencia(licValor);
-    const licenciaStr = typeof licValor === 'string'
-      ? licValor
-      : (licValor && licValor.type) ? licValor.type
-      : (licValor == null ? '(ninguna)' : JSON.stringify(licValor));
-    hallazgos.push({
-      paquete: ruta.replace(/^node_modules\//, '').replace(/\/node_modules\//g, ' > '),
-      version: (entrada && entrada.version) || '?',
-      licencia: licenciaStr,
-      clasificacion,
-    });
-    resumen[clasificacion]++;
-  }
-
-  return { hallazgos, resumen };
-}
-
-// --- CLI ---------------------------------------------------------------------
-
-if (require.main === module) {
-  const res = evaluarLicencias(process.cwd());
-  console.log('Gate de licencias (árbol prod):');
-  console.log(`  permisiva: ${res.resumen.permisiva} | débil: ${res.resumen.debil} | fuerte: ${res.resumen.fuerte} | desconocida: ${res.resumen.desconocida}`);
-  const alertas = res.hallazgos.filter((h) => h.clasificacion !== 'permisiva');
-  if (alertas.length) {
-    console.log('\nHallazgos no permisivos (WARN — no bloquea el release):');
-    for (const h of alertas) {
-      console.log(`  [${h.clasificacion.toUpperCase()}] ${h.paquete}@${h.version} — ${h.licencia}`);
-    }
-  } else {
-    console.log('  Todas las dependencias de producción son permisivas.');
-  }
-}
-
-module.exports = {
-  clasificarLicencia,
-  evaluarLicencias,
-  resolverLicencia,
-  FAMILIAS_FUERTES,
-  FAMILIAS_DEBILES,
-};
+'use strict';
+
+/**
+ * gate-licencias.js — Clasificación de licencias del árbol runtime (Fase 14, ADR-0038).
+ *
+ * Gate de cadena de suministro: detecta licencias copyleft contaminantes en las
+ * dependencias de producción antes de un release. Zero-dependencies — lee
+ * `package-lock.json` (v3) y clasifica cada dependencia prod contra listas SPDX.
+ *
+ * Modo de uso en /swl:release: WARN-ONLY (D-14-02). Reporta hallazgos pero NUNCA
+ * bloquea el release en v1 — la promoción a blocking exigiría calibración + ADR
+ * posterior (mismo patrón que los gates G0/G2/G3).
+ *
+ * Clasificación de expresiones SPDX:
+ *   - OR  → el consumidor ELIGE un término → clasifica por el MEJOR (menos restrictivo).
+ *   - AND → ambos términos APLICAN → clasifica por el PEOR (más restrictivo).
+ *
+ * Severidad (de menor a mayor restricción): permisiva < débil < fuerte; "desconocida"
+ * es categoría propia (metadata ausente o no catalogada), no un error.
+ *
+ * Origen: Fase 14 — cadena de suministro en release (P4, ADR-0038).
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// Listas SPDX (normalizadas a mayúsculas). El matching es por PREFIJO de la
+// familia para tolerar variantes `-only` / `-or-later` (ej. GPL-3.0-or-later).
+const FAMILIAS_FUERTES = ['GPL', 'AGPL', 'SSPL', 'OSL', 'EUPL', 'CDDL'];
+const FAMILIAS_DEBILES = ['LGPL', 'MPL', 'EPL', 'CPL', 'MS-RL'];
+const PERMISIVAS = new Set([
+  'MIT', 'ISC', 'APACHE-2.0', 'APACHE 2.0', 'BSD', 'BSD-2-CLAUSE', 'BSD-3-CLAUSE',
+  '0BSD', 'UNLICENSE', 'CC0-1.0', 'WTFPL', 'BLUEOAK-1.0.0', 'ZLIB', 'PYTHON-2.0',
+  'APACHE-2.0 WITH LLVM-EXCEPTION',
+]);
+
+// Orden de severidad para resolver expresiones OR/AND. NOTA: `desconocida: 0`
+// NO es un grado ordinal de copyleft — es categoría especial. En `clasificarExprOr`
+// las "desconocidas" se filtran ANTES del reduce cuando hay algún término
+// catalogado, por lo que su valor 0 nunca contamina la elección del mejor/peor.
+const SEVERIDAD = { desconocida: 0, permisiva: 1, debil: 2, fuerte: 3 };
+
+// Cota de profundidad de recursión para licencias anidadas (array de arrays);
+// un package.json malicioso con anidamiento profundo no debe tumbar la auditoría.
+const MAX_PROFUNDIDAD_LICENCIA = 10;
+
+/**
+ * Normaliza un identificador de licencia simple (sin operadores) a su clasificación.
+ * @param {string} idRaw
+ * @returns {'fuerte'|'debil'|'permisiva'|'desconocida'}
+ */
+function clasificarSimple(idRaw) {
+  if (typeof idRaw !== 'string') return 'desconocida';
+  const id = idRaw.trim().toUpperCase().replace(/^\(/, '').replace(/\)$/, '').trim();
+  if (!id) return 'desconocida';
+  // Familias copyleft por prefijo (cubre -ONLY / -OR-LATER / versiones).
+  for (const fam of FAMILIAS_FUERTES) {
+    if (id === fam || id.startsWith(fam + '-') || id.startsWith(fam + ' ')) return 'fuerte';
+  }
+  for (const fam of FAMILIAS_DEBILES) {
+    if (id === fam || id.startsWith(fam + '-') || id.startsWith(fam + ' ')) return 'debil';
+  }
+  if (PERMISIVAS.has(id)) return 'permisiva';
+  return 'desconocida';
+}
+
+/**
+ * Clasifica una licencia npm: string SPDX (con OR/AND), objeto legacy {type},
+ * arreglo legacy de objetos, o ausente.
+ *
+ * @param {string|object|Array|undefined|null} valor
+ * @param {number} [_depth=0]  profundidad interna de recursión (cota anti-DoS)
+ * @returns {'fuerte'|'debil'|'permisiva'|'desconocida'}
+ */
+function clasificarLicencia(valor, _depth = 0) {
+  if (valor == null) return 'desconocida';
+  if (_depth > MAX_PROFUNDIDAD_LICENCIA) return 'desconocida'; // anidamiento abusivo
+
+  // Objeto legacy { type: 'MIT' }
+  if (typeof valor === 'object' && !Array.isArray(valor)) {
+    return clasificarLicencia(valor.type, _depth + 1);
+  }
+  // Arreglo legacy [{ type }] → tratar como OR (el consumidor elige)
+  if (Array.isArray(valor)) {
+    const cls = valor.map((v) => clasificarLicencia(v && v.type ? v.type : v, _depth + 1));
+    return cls.reduce((mejor, c) => (SEVERIDAD[c] < SEVERIDAD[mejor] ? c : mejor), 'fuerte');
+  }
+  if (typeof valor !== 'string') return 'desconocida';
+
+  const expr = valor.trim();
+  if (!expr) return 'desconocida';
+
+  // Expresión AND: ambas aplican → el PEOR término manda.
+  if (/\bAND\b/i.test(expr)) {
+    const partes = expr.replace(/[()]/g, ' ').split(/\bAND\b/i).map((s) => s.trim()).filter(Boolean);
+    return partes
+      .map((p) => clasificarExprOr(p))
+      .reduce((peor, c) => (SEVERIDAD[c] > SEVERIDAD[peor] ? c : peor), 'desconocida');
+  }
+  return clasificarExprOr(expr);
+}
+
+/**
+ * Resuelve una expresión que puede contener OR (el MEJOR término manda) o un
+ * identificador simple.
+ * @param {string} expr
+ * @returns {'fuerte'|'debil'|'permisiva'|'desconocida'}
+ */
+function clasificarExprOr(expr) {
+  if (/\bOR\b/i.test(expr)) {
+    const partes = expr.replace(/[()]/g, ' ').split(/\bOR\b/i).map((s) => s.trim()).filter(Boolean);
+    // mejor = menor severidad, pero ignorando "desconocida" si hay algo catalogado
+    const clasifs = partes.map((p) => clasificarSimple(p));
+    const catalogadas = clasifs.filter((c) => c !== 'desconocida');
+    const pool = catalogadas.length ? catalogadas : clasifs;
+    return pool.reduce((mejor, c) => (SEVERIDAD[c] < SEVERIDAD[mejor] ? c : mejor), 'fuerte');
+  }
+  return clasificarSimple(expr);
+}
+
+/**
+ * Resuelve la licencia de un paquete: primero el campo del lockfile, con fallback
+ * al package.json instalado en node_modules/<ruta>.
+ *
+ * @param {string} baseDir
+ * @param {string} rutaNodeModules  clave del lockfile, ej. "node_modules/foo"
+ * @param {object} entradaLock
+ * @returns {string|object|undefined}
+ */
+function resolverLicencia(baseDir, rutaNodeModules, entradaLock) {
+  if (entradaLock && entradaLock.license != null) return entradaLock.license;
+  if (entradaLock && entradaLock.licenses != null) return entradaLock.licenses; // legacy array
+  // Fallback: leer el package.json instalado.
+  try {
+    const pkgPath = path.join(baseDir, rutaNodeModules, 'package.json');
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+    return pkg.license != null ? pkg.license : pkg.licenses;
+  } catch {
+    return undefined;
+  }
+}
+
+/**
+ * Evalúa las licencias del árbol de producción a partir de package-lock.json.
+ * Excluye entradas marcadas `dev: true` y la raíz "".
+ *
+ * @param {string} baseDir  raíz del proyecto (contiene package-lock.json)
+ * @returns {{hallazgos: Array<{paquete:string, version:string, licencia:string, clasificacion:string}>, resumen: {fuerte:number, debil:number, permisiva:number, desconocida:number}}}
+ */
+function evaluarLicencias(baseDir) {
+  const resumen = { fuerte: 0, debil: 0, permisiva: 0, desconocida: 0 };
+  const hallazgos = [];
+
+  const lockPath = path.join(baseDir, 'package-lock.json');
+  let lock;
+  try {
+    lock = JSON.parse(fs.readFileSync(lockPath, 'utf8'));
+  } catch (err) {
+    // Sin lockfile (ENOENT) → resultado vacío, no es error. Pero un lockfile
+    // corrupto (SyntaxError) o sin permisos (EACCES) SÍ se propaga: enmascararlo
+    // como "sin deps copyleft" daría un falso OK. El caller (verificar-release)
+    // lo captura y reporta como gate "no disponible".
+    if (err.code === 'ENOENT') return { hallazgos, resumen };
+    throw err;
+  }
+
+  const packages = lock.packages || {};
+  for (const [ruta, entrada] of Object.entries(packages)) {
+    if (!ruta || !ruta.startsWith('node_modules/')) continue; // raíz "" y workspaces fuera
+    if (entrada && entrada.dev) continue; // solo árbol prod
+    const licValor = resolverLicencia(baseDir, ruta, entrada);
+    const clasificacion = clasificarLicencia(licValor);
+    const licenciaStr = typeof licValor === 'string'
+      ? licValor
+      : (licValor && licValor.type) ? licValor.type
+      : (licValor == null ? '(ninguna)' : JSON.stringify(licValor));
+    hallazgos.push({
+      paquete: ruta.replace(/^node_modules\//, '').replace(/\/node_modules\//g, ' > '),
+      version: (entrada && entrada.version) || '?',
+      licencia: licenciaStr,
+      clasificacion,
+    });
+    resumen[clasificacion]++;
+  }
+
+  return { hallazgos, resumen };
+}
+
+// --- CLI ---------------------------------------------------------------------
+
+if (require.main === module) {
+  const res = evaluarLicencias(process.cwd());
+  console.log('Gate de licencias (árbol prod):');
+  console.log(`  permisiva: ${res.resumen.permisiva} | débil: ${res.resumen.debil} | fuerte: ${res.resumen.fuerte} | desconocida: ${res.resumen.desconocida}`);
+  const alertas = res.hallazgos.filter((h) => h.clasificacion !== 'permisiva');
+  if (alertas.length) {
+    console.log('\nHallazgos no permisivos (WARN — no bloquea el release):');
+    for (const h of alertas) {
+      console.log(`  [${h.clasificacion.toUpperCase()}] ${h.paquete}@${h.version} — ${h.licencia}`);
+    }
+  } else {
+    console.log('  Todas las dependencias de producción son permisivas.');
+  }
+}
+
+module.exports = {
+  clasificarLicencia,
+  evaluarLicencias,
+  resolverLicencia,
+  FAMILIAS_FUERTES,
+  FAMILIAS_DEBILES,
+};