@saulwade/swl-ses 2.2.4 → 2.3.1

package/scripts/publicar.js

@@ -1,497 +1,497 @@
-#!/usr/bin/env node
-// publicar.js — Dual-publish: npmjs.org (canónico) + GitHub Packages (mirror)
-// Uso: node scripts/publicar.js [--solo-github | --solo-npmjs | --dry-run]
-//
-// Tras el rebrand v1.0.0 (rebranding de @saulwadeleon/swl-software-engineering-system):
-//   - npmjs.org    → @saulwade/swl-ses        (canónico, scope sin guion)
-//   - GH Packages  → @saul-wade/swl-ses       (mirror, scope con guion = org GitHub)
-//
-// El package.json del repo declara el nombre canónico (npmjs). Para GitHub
-// Packages se genera un package.json temporal con scope/registry sobreescritos.
-// Exit: 0=éxito, 1=error
-
-'use strict';
-
-const { execFileSync, spawnSync } = require('child_process');
-const fs   = require('fs');
-const path = require('path');
-const os   = require('os');
-
-const {
-  NOMBRE_GITHUB_MIRROR: GITHUB_NAME,
-  REGISTRY_GITHUB:      GITHUB_REGISTRY,
-  REGISTRY_NPMJS:       NPMJS_REGISTRY,
-} = require('./lib/paquetes-conocidos');
-
-const {
-  esDirArtefacto,
-  esArchivoArtefacto,
-} = require('./lib/artefactos-python');
-
-const ROOT     = path.resolve(__dirname, '..');
-const PKG_PATH = path.join(ROOT, 'package.json');
-
-// --- Log de la corrida (.planning/logs/publish-<version>-<ts>.log) -----------
-// Captura stdout+stderr del publish para diagnóstico: npm v10 NO escribe el
-// stdout de un script fallido (prepublishOnly/test:release) en su debug log,
-// así que sin esto el test que rompe el publish queda invisible. Tee: eco a
-// consola + archivo persistente.
-let LOG_PATH = null;
-function iniciarLog(version) {
-  try {
-    const dir = path.join(ROOT, '.planning', 'logs');
-    fs.mkdirSync(dir, { recursive: true });
-    const ts = new Date().toISOString().replace(/[:.]/g, '-');
-    LOG_PATH = path.join(dir, `publish-${version}-${ts}.log`);
-    // Escritura SÍNCRONA (writeFileSync/appendFileSync): un createWriteStream
-    // async + process.exit() inmediato perdía el buffer sin volcarlo a disco
-    // (dejaba el log vacío). appendFileSync vacía en cada llamada.
-    fs.writeFileSync(LOG_PATH, `# publish ${version} — ${new Date().toISOString()}\n# argv: ${process.argv.slice(2).join(' ')}\n\n`);
-  } catch (err) {
-    process.stderr.write(`[publicar] no se pudo abrir log: ${String(err.message).slice(0, 120)}\n`);
-    LOG_PATH = null;
-  }
-}
-function logWrite(text) {
-  if (LOG_PATH && text) { try { fs.appendFileSync(LOG_PATH, text); } catch { /* best-effort */ } }
-}
-function cerrarLog() { /* no-op: appendFileSync ya volcó todo a disco */ }
-
-/**
- * Resuelve el binario de npm a invocar. Usa node + npm-cli.js cuando es
- * posible para evitar shell:true en Windows (mismo enfoque que la lib
- * scripts/lib/npm-version.js).
- */
-const NPM_CLI_JS = (() => {
-  const dir = path.dirname(process.execPath);
-  for (const c of [
-    path.join(dir, 'node_modules', 'npm', 'bin', 'npm-cli.js'),
-    path.join(dir, '..', 'lib', 'node_modules', 'npm', 'bin', 'npm-cli.js'),
-  ]) {
-    try { if (fs.existsSync(c)) return c; } catch { /* continuar */ }
-  }
-  return null;
-})();
-
-function npmExec(args, opts = {}) {
-  const defaults = { cwd: ROOT, stdio: 'inherit', timeout: 300_000 };
-  if (NPM_CLI_JS) {
-    return execFileSync(process.execPath, [NPM_CLI_JS, ...args], { ...defaults, ...opts });
-  }
-  // Fallback a npm/npm.cmd como ejecutable nombrado. NO usamos shell:true:
-  // todos los args son strings ya separados, sin interpolación.
-  const bin = process.platform === 'win32' ? 'npm.cmd' : 'npm';
-  return execFileSync(bin, args, { ...defaults, ...opts });
-}
-
-/**
- * Variante de npmExec que captura stdout+stderr para (a) detección de errores
- * estructurados (ej: EOTP) y (b) persistencia en el log de la corrida
- * (`iniciarLog`). Ambos streams se pipean, se ecoan a consola al terminar y se
- * vuelcan al log — así el stdout del script que rompe el publish (test:release)
- * queda registrado. Trade-off: la salida del prepublish aparece al finalizar el
- * spawn (no en vivo), por eso se imprime un aviso antes.
- *
- * Retorna { status, stderr } sin lanzar — el caller inspecciona el status.
- */
-function npmSpawnCaptureStderr(args, opts = {}) {
-  const defaults = { cwd: ROOT, timeout: 300_000, env: process.env };
-  const merged = { ...defaults, ...opts, stdio: ['inherit', 'pipe', 'pipe'] };
-  process.stderr.write('[publicar] ejecutando npm (incluye prepublish/test:release; salida completa al finalizar y en el log)...\n');
-  let res;
-  if (NPM_CLI_JS) {
-    res = spawnSync(process.execPath, [NPM_CLI_JS, ...args], merged);
-  } else {
-    const bin = process.platform === 'win32' ? 'npm.cmd' : 'npm';
-    res = spawnSync(bin, args, merged);
-  }
-  const stdout = res.stdout ? String(res.stdout) : '';
-  const stderr = res.stderr ? String(res.stderr) : '';
-  // Eco a consola + volcado al log (stdout primero, luego stderr).
-  if (stdout) process.stdout.write(stdout);
-  if (stderr) process.stderr.write(stderr);
-  logWrite(stdout);
-  logWrite(stderr);
-  return { status: res.status, signal: res.signal, stderr, error: res.error };
-}
-
-/**
- * Detecta si un blob de stderr indica que npm requiere una OTP de 2FA.
- * Match defensivo: cubre tanto el código de error explícito (`EOTP`) como el
- * mensaje canónico ("requires a one-time password"), porque npm ha cambiado
- * el formato del mensaje entre versiones (npm 8 vs 10+).
- *
- * Pura — testeable sin dependencias. Exportada para tests.
- */
-function esErrorOTP(stderr) {
-  if (!stderr) return false;
-  const blob = String(stderr);
-  return /\bEOTP\b/.test(blob) || /one-time password/i.test(blob);
-}
-
-/**
- * Ejecuta npm con stdio HEREDADO (interactivo): npm escribe directo a la
- * terminal y lee de stdin, de modo que su flujo de 2FA NATIVO funciona —
- * prompt de OTP TOTP O auth web/passkey ("abrir URL y seleccionar la llave"),
- * según el método 2FA de la cuenta. Retorna el exit status sin lanzar.
- * (A1: soporte passkey/WebAuthn, no solo TOTP.)
- */
-function npmExecInherit(args, opts = {}) {
-  const merged = { cwd: ROOT, timeout: 600_000, env: process.env, ...opts, stdio: 'inherit' };
-  let res;
-  if (NPM_CLI_JS) {
-    res = spawnSync(process.execPath, [NPM_CLI_JS, ...args], merged);
-  } else {
-    const bin = process.platform === 'win32' ? 'npm.cmd' : 'npm';
-    res = spawnSync(bin, args, merged);
-  }
-  return res.status;
-}
-
-/**
- * Ejecuta un `npm publish` con soporte automático de OTP (2FA).
- *
- * Flujo:
- *   1. Si NPM_CONFIG_OTP está definida en el entorno (o hay token Automation),
- *      se usa directamente y el intento 1 publica sin interacción.
- *   2. Si el publish falla con EOTP/one-time password y stdin es TTY, se
- *      reintenta con stdio HEREDADO para que npm conduzca su 2FA NATIVO —
- *      OTP TOTP O passkey/WebAuthn (navegador), según la cuenta — con
- *      --ignore-scripts (los pre-publish ya pasaron en el intento 1).
- *   3. Si stdin no es TTY (CI sin OTP), reporta el error y retorna false.
- *
- * Retorna: { ok: boolean, stderr: string }
- *
- * Exportada para tests.
- */
-function ejecutarPublishConOTP(args, opts = {}) {
-  // Intento 1: con OTP de env si existe, sin ella si no.
-  const intento1 = npmSpawnCaptureStderr(args, opts);
-  if (intento1.status === 0) {
-    return { ok: true, stderr: intento1.stderr };
-  }
-
-  // Si NO es EOTP, no podemos hacer nada — propagamos el fallo.
-  if (!esErrorOTP(intento1.stderr)) {
-    return { ok: false, stderr: intento1.stderr };
-  }
-
-  // Es EOTP — 2FA requerida. npm soporta varios métodos: OTP TOTP (6 dígitos)
-  // O passkey/WebAuthn vía navegador ("abrir URL y seleccionar la llave").
-  // Forzar un prompt de TOTP rompe a los usuarios con passkey (A1). En su lugar
-  // se reintenta con stdio HEREDADO para que npm conduzca su 2FA NATIVO —
-  // funcione cual sea el método configurado en la cuenta.
-  process.stderr.write('\n[publicar] npm rechazó el publish con EOTP (2FA requerida).\n');
-  if (!process.stdin.isTTY) {
-    process.stderr.write('[publicar] stdin no es TTY: no se puede completar 2FA interactivo.\n');
-    process.stderr.write('[publicar] Opciones: exportar NPM_CONFIG_OTP=<otp>, o usar un token Automation (omite 2FA).\n');
-    return { ok: false, stderr: intento1.stderr };
-  }
-  // Reintento interactivo: --ignore-scripts porque los pre-publish ya pasaron en
-  // el intento 1 (el prepack limpió el árbol; no se re-ejecuta test:release).
-  process.stderr.write('\n[publicar] Reintentando con el 2FA interactivo nativo de npm (OTP o passkey)...\n');
-  const argsConIgnore = args.includes('--ignore-scripts') ? args : [...args, '--ignore-scripts'];
-  const status = npmExecInherit(argsConIgnore, opts);
-  return { ok: status === 0, stderr: status === 0 ? '' : 'fallo en reintento interactivo de 2FA' };
-}
-
-function leerPkg() {
-  return JSON.parse(fs.readFileSync(PKG_PATH, 'utf-8'));
-}
-
-/**
- * Clasifica el error de `npm whoami` capturado en stderr para distinguir
- * causas raíz comunes y permitir mensajes accionables al usuario.
- *
- * Tipos retornados:
- *   - 'no-token'  : no hay _authToken configurado para ese registry.
- *   - 'token-401' : token presente pero rechazado (expirado/revocado).
- *   - 'token-403' : token válido pero sin permiso (cuenta sin acceso al scope).
- *   - 'registry-404' : el registry no responde el endpoint whoami (URL incorrecta).
- *   - 'desconocido'  : error de red, npm no en PATH, timeout, etc.
- */
-function clasificarErrorAuth(stderr, mensaje) {
-  const blob = (stderr || '') + '\n' + (mensaje || '');
-  if (/\b401\b/.test(blob))             return 'token-401';
-  if (/\b403\b/.test(blob))             return 'token-403';
-  if (/\b404\b/.test(blob))             return 'registry-404';
-  if (/ENEEDAUTH|need to authorize/i.test(blob)) return 'no-token';
-  return 'desconocido';
-}
-
-function verificarLogin(registry) {
-  try {
-    const result = npmExec(['whoami', `--registry=${registry}`], {
-      stdio: ['pipe', 'pipe', 'pipe'],
-      encoding: 'utf-8',
-      timeout:  15_000,
-    });
-    return { ok: true, usuario: String(result).trim() };
-  } catch (err) {
-    // Capturar stderr del proceso para clasificar la causa raíz.
-    // execFileSync expone stderr en err.stderr cuando stdio fue 'pipe'.
-    const stderrBuf = err.stderr ? String(err.stderr) : '';
-    const motivo = (stderrBuf || String(err.message || err)).split('\n')[0].slice(0, 200);
-    const tipo   = clasificarErrorAuth(stderrBuf, err.message);
-    process.stderr.write(`[verificarLogin ${registry}] ${tipo}: ${motivo}\n`);
-    return { ok: false, tipo, motivo };
-  }
-}
-
-/**
- * Imprime guía accionable según el tipo de fallo de auth y el registry.
- * Se llama desde publicarNpmjs/publicarGitHub cuando verificarLogin falla.
- */
-function imprimirGuiaAuth(registry, pkgName, tipo) {
-  const esGithub = /npm\.pkg\.github\.com/.test(registry);
-  console.error('');
-  switch (tipo) {
-    case 'token-401':
-      console.error('CAUSA: token de autenticación rechazado (HTTP 401 — expirado o revocado).');
-      if (esGithub) {
-        console.error('FIX:   GitHub Packages NO acepta `npm login`. Genera un nuevo PAT en');
-        console.error('       Settings → Developer settings → Personal access tokens (classic)');
-        console.error('       con scopes `read:packages` y `write:packages`, y reemplaza la línea');
-        console.error('       en ~/.npmrc:');
-        console.error('         //npm.pkg.github.com/:_authToken=<NUEVO_TOKEN>');
-      } else {
-        console.error(`FIX:   npm login --registry=${registry}`);
-        console.error('       (abrirá el navegador para autenticar y reescribirá ~/.npmrc).');
-      }
-      break;
-    case 'token-403':
-      console.error('CAUSA: token válido pero la cuenta no tiene permiso al scope del paquete.');
-      console.error(`FIX:   Verifica el dueño del scope con:`);
-      console.error(`         npm owner ls ${pkgName} --registry=${registry}`);
-      console.error('       Si la cuenta autenticada no aparece como owner, autenticate con la');
-      console.error('       cuenta dueña del scope o pide ser agregado como maintainer.');
-      break;
-    case 'registry-404':
-      console.error('CAUSA: el registry no responde el endpoint whoami (URL probablemente incorrecta).');
-      console.error(`FIX:   Verifica que la URL sea exactamente '${registry}' (incluyendo https:// y trailing slash si aplica).`);
-      break;
-    case 'no-token':
-      console.error('CAUSA: no hay token configurado para este registry en ~/.npmrc.');
-      if (esGithub) {
-        console.error('FIX:   GitHub Packages requiere PAT manual. Agrega a ~/.npmrc:');
-        console.error('         //npm.pkg.github.com/:_authToken=<TU_PAT>');
-        console.error('       (NO uses `npm login` con GitHub Packages — devuelve 404/403.)');
-      } else {
-        console.error(`FIX:   npm login --registry=${registry}`);
-      }
-      break;
-    default:
-      console.error('CAUSA: error desconocido al consultar whoami.');
-      console.error('       Verifica conectividad de red y que `npm` esté en PATH.');
-      console.error(`       Para diagnóstico manual:  npm whoami --registry=${registry}`);
-  }
-  console.error('');
-}
-
-function copiarDir(src, dest) {
-  fs.mkdirSync(dest, { recursive: true });
-  const entries = fs.readdirSync(src, { withFileTypes: true });
-  for (const entry of entries) {
-    // Excluir artefactos Python (lista canónica en lib/artefactos-python.js)
-    if (entry.isDirectory() && esDirArtefacto(entry.name)) continue;
-    if (!entry.isDirectory() && esArchivoArtefacto(entry.name)) continue;
-
-    const srcPath  = path.join(src,  entry.name);
-    const destPath = path.join(dest, entry.name);
-    if (entry.isDirectory()) {
-      copiarDir(srcPath, destPath);
-    } else {
-      fs.copyFileSync(srcPath, destPath);
-    }
-  }
-}
-
-function limpiar(tmpDir) {
-  try {
-    fs.rmSync(tmpDir, { recursive: true, force: true });
-  } catch (err) {
-    // En Windows el filesystem puede mantener locks transitorios sobre
-    // archivos recién copiados. La limpieza eventual la hace el SO; no
-    // bloqueamos el flujo, pero anotamos el path para inspección manual.
-    process.stderr.write(`[publicar] no se pudo limpiar tmpDir ${tmpDir}: ${String(err.message).slice(0, 80)}\n`);
-  }
-}
-
-function construirPkgTemporal(pkg, nombre, registry) {
-  const tmpPkg = {
-    ...pkg,
-    name: nombre,
-    publishConfig: { registry, access: 'public' },
-  };
-  // Quitar prepack/prepublishOnly del temp para evitar recursión.
-  // npm publish desde tmpDir invocaría prepack apuntando a un script
-  // que ya no existe en ese path, y prepublishOnly correría el suite
-  // de tests dos veces.
-  if (tmpPkg.scripts) {
-    delete tmpPkg.scripts.prepack;
-    delete tmpPkg.scripts.prepublishOnly;
-  }
-  return tmpPkg;
-}
-
-function copiarArchivosFiles(pkg, tmpDir) {
-  for (const entry of pkg.files || []) {
-    const src = path.join(ROOT, entry);
-    const dest = path.join(tmpDir, entry);
-    if (!fs.existsSync(src)) continue;
-    if (fs.statSync(src).isDirectory()) {
-      copiarDir(src, dest);
-    } else {
-      fs.mkdirSync(path.dirname(dest), { recursive: true });
-      fs.copyFileSync(src, dest);
-    }
-  }
-}
-
-function copiarMetadatos(tmpDir) {
-  // npm incluye README/LICENSE/CHANGELOG automáticamente al publicar.
-  for (const meta of ['README.md', 'LICENSE', 'CHANGELOG.md', 'CHANGELOG-LEGACY.md']) {
-    const src = path.join(ROOT, meta);
-    if (fs.existsSync(src)) {
-      fs.copyFileSync(src, path.join(tmpDir, meta));
-    }
-  }
-}
-
-function prepararDirectorioTemporal(pkg, nombrePersonalizado, registryPersonalizado) {
-  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'swl-ses-publish-'));
-  const tmpPkg = construirPkgTemporal(pkg, nombrePersonalizado, registryPersonalizado);
-  fs.writeFileSync(path.join(tmpDir, 'package.json'), JSON.stringify(tmpPkg, null, 2));
-  copiarArchivosFiles(pkg, tmpDir);
-  copiarMetadatos(tmpDir);
-  return tmpDir;
-}
-
-function publicarNpmjs(pkg, dryRun) {
-  console.log('\n=== 1/2 — npmjs.org (canónico) ===');
-  console.log(`Paquete: ${pkg.name}@${pkg.version}`);
-  console.log(`Registry: ${NPMJS_REGISTRY}`);
-
-  const auth = verificarLogin(NPMJS_REGISTRY);
-  if (!auth.ok) {
-    console.error(`ERROR: No autenticado en npmjs (${auth.tipo}).`);
-    imprimirGuiaAuth(NPMJS_REGISTRY, pkg.name, auth.tipo);
-    return false;
-  }
-  console.log(`Autenticado como: ${auth.usuario}`);
-
-  const args = ['publish', `--registry=${NPMJS_REGISTRY}`, '--access', 'public'];
-  if (dryRun) args.push('--dry-run');
-  const resultado = ejecutarPublishConOTP(args);
-  if (resultado.ok) {
-    console.log(`${dryRun ? '[DRY-RUN] ' : ''}OK: ${pkg.name}@${pkg.version} ${dryRun ? 'se publicaría' : 'publicado'} en npmjs`);
-    return true;
-  }
-  console.error(`ERROR publicando en npmjs (ver stderr arriba para diagnóstico de npm).`);
-  return false;
-}
-
-function publicarGitHub(pkg, dryRun) {
-  console.log('\n=== 2/2 — GitHub Packages (mirror) ===');
-  console.log(`Paquete: ${GITHUB_NAME}@${pkg.version}`);
-  console.log(`Registry: ${GITHUB_REGISTRY}`);
-
-  const auth = verificarLogin(GITHUB_REGISTRY);
-  if (!auth.ok) {
-    console.error(`ERROR: No autenticado en GitHub Packages (${auth.tipo}).`);
-    imprimirGuiaAuth(GITHUB_REGISTRY, GITHUB_NAME, auth.tipo);
-    return false;
-  }
-  console.log(`Autenticado como: ${auth.usuario}`);
-
-  const tmpDir = prepararDirectorioTemporal(pkg, GITHUB_NAME, GITHUB_REGISTRY);
-
-  const args = ['publish', `--registry=${GITHUB_REGISTRY}`];
-  if (dryRun) args.push('--dry-run');
-  const resultado = ejecutarPublishConOTP(args, { cwd: tmpDir });
-  if (resultado.ok) {
-    console.log(`${dryRun ? '[DRY-RUN] ' : ''}OK: ${GITHUB_NAME}@${pkg.version} ${dryRun ? 'se publicaría' : 'publicado'} en GitHub Packages`);
-    if (dryRun) console.log(`Directorio temporal: ${tmpDir}`);
-    limpiar(tmpDir);
-    return true;
-  }
-  console.error(`ERROR publicando en GitHub Packages (ver stderr arriba para diagnóstico de npm).`);
-  limpiar(tmpDir);
-  return false;
-}
-
-function parsearArgs(argv) {
-  return {
-    dryRun:     argv.includes('--dry-run'),
-    soloGithub: argv.includes('--solo-github'),
-    soloNpmjs:  argv.includes('--solo-npmjs'),
-  };
-}
-
-function imprimirEncabezado(version, dryRun) {
-  console.log('╔══════════════════════════════════════════╗');
-  console.log('║  @saulwade/swl-ses — Publicación dual    ║');
-  console.log('╚══════════════════════════════════════════╝');
-  console.log(`Versión: ${version}`);
-  if (dryRun) console.log('Modo: DRY-RUN (sin cambios)');
-}
-
-function avisarSiHayCambiosSinCommit(dryRun) {
-  try {
-    const status = String(execFileSync('git', ['status', '--porcelain'], {
-      cwd: ROOT, encoding: 'utf-8',
-    })).trim();
-    if (status && !dryRun) {
-      console.warn('\nADVERTENCIA: Hay cambios sin commitear.');
-      console.warn('Se recomienda hacer commit antes de publicar.\n');
-    }
-  } catch (err) {
-    // No es repo git, o git no está disponible. No bloquea el publish.
-    process.stderr.write(`[publicar] git status falló (no bloqueante): ${String(err.message).slice(0, 80)}\n`);
-  }
-}
-
-function reportarResultado(pkg, opts, npmjsOk, githubOk) {
-  console.log('\n=== Resultado ===');
-  if (!opts.soloGithub) console.log(`npmjs.org:        ${npmjsOk ? 'OK' : 'FALLÓ'} — ${pkg.name}@${pkg.version}`);
-  if (!opts.soloNpmjs)  console.log(`GitHub Packages:  ${githubOk ? 'OK' : 'FALLÓ'} — ${GITHUB_NAME}@${pkg.version}`);
-  if (!opts.soloNpmjs && !opts.soloGithub && npmjsOk && githubOk) {
-    console.log('\nAmbos paquetes publicados. Los usuarios pueden instalar con:');
-    console.log(`  npx ${pkg.name}@latest doctor                    (canónico, recomendado)`);
-    console.log(`  npx ${GITHUB_NAME}@latest doctor                 (mirror GitHub Packages)`);
-  }
-}
-
-function main() {
-  const opts = parsearArgs(process.argv.slice(2));
-  const pkg  = leerPkg();
-  iniciarLog(pkg.version);
-  imprimirEncabezado(pkg.version, opts.dryRun);
-  avisarSiHayCambiosSinCommit(opts.dryRun);
-
-  const npmjsOk  = opts.soloGithub ? true : publicarNpmjs(pkg, opts.dryRun);
-  const githubOk = opts.soloNpmjs  ? true : publicarGitHub(pkg, opts.dryRun);
-
-  reportarResultado(pkg, opts, npmjsOk, githubOk);
-  if (LOG_PATH) process.stdout.write(`\nLog de la corrida: ${path.relative(ROOT, LOG_PATH).replace(/\\/g, '/')}\n`);
-  cerrarLog();
-  process.exit(npmjsOk && githubOk ? 0 : 1);
-}
-
-// Solo ejecutar el flujo completo cuando el script se invoca como CLI.
-// Cuando se importa como módulo (tests), expone helpers para verificar
-// invariantes de prepararDirectorioTemporal sin hacer publish real.
-if (require.main === module) {
-  main();
-} else {
-  module.exports = {
-    prepararDirectorioTemporal,
-    copiarDir,
-    limpiar,
-    esErrorOTP,
-    ejecutarPublishConOTP,
-    GITHUB_NAME,
-    GITHUB_REGISTRY,
-    NPMJS_REGISTRY,
-  };
-}
+#!/usr/bin/env node
+// publicar.js — Dual-publish: npmjs.org (canónico) + GitHub Packages (mirror)
+// Uso: node scripts/publicar.js [--solo-github | --solo-npmjs | --dry-run]
+//
+// Tras el rebrand v1.0.0 (rebranding de @saulwadeleon/swl-software-engineering-system):
+//   - npmjs.org    → @saulwade/swl-ses        (canónico, scope sin guion)
+//   - GH Packages  → @saul-wade/swl-ses       (mirror, scope con guion = org GitHub)
+//
+// El package.json del repo declara el nombre canónico (npmjs). Para GitHub
+// Packages se genera un package.json temporal con scope/registry sobreescritos.
+// Exit: 0=éxito, 1=error
+
+'use strict';
+
+const { execFileSync, spawnSync } = require('child_process');
+const fs   = require('fs');
+const path = require('path');
+const os   = require('os');
+
+const {
+  NOMBRE_GITHUB_MIRROR: GITHUB_NAME,
+  REGISTRY_GITHUB:      GITHUB_REGISTRY,
+  REGISTRY_NPMJS:       NPMJS_REGISTRY,
+} = require('./lib/paquetes-conocidos');
+
+const {
+  esDirArtefacto,
+  esArchivoArtefacto,
+} = require('./lib/artefactos-python');
+
+const ROOT     = path.resolve(__dirname, '..');
+const PKG_PATH = path.join(ROOT, 'package.json');
+
+// --- Log de la corrida (.planning/logs/publish-<version>-<ts>.log) -----------
+// Captura stdout+stderr del publish para diagnóstico: npm v10 NO escribe el
+// stdout de un script fallido (prepublishOnly/test:release) en su debug log,
+// así que sin esto el test que rompe el publish queda invisible. Tee: eco a
+// consola + archivo persistente.
+let LOG_PATH = null;
+function iniciarLog(version) {
+  try {
+    const dir = path.join(ROOT, '.planning', 'logs');
+    fs.mkdirSync(dir, { recursive: true });
+    const ts = new Date().toISOString().replace(/[:.]/g, '-');
+    LOG_PATH = path.join(dir, `publish-${version}-${ts}.log`);
+    // Escritura SÍNCRONA (writeFileSync/appendFileSync): un createWriteStream
+    // async + process.exit() inmediato perdía el buffer sin volcarlo a disco
+    // (dejaba el log vacío). appendFileSync vacía en cada llamada.
+    fs.writeFileSync(LOG_PATH, `# publish ${version} — ${new Date().toISOString()}\n# argv: ${process.argv.slice(2).join(' ')}\n\n`);
+  } catch (err) {
+    process.stderr.write(`[publicar] no se pudo abrir log: ${String(err.message).slice(0, 120)}\n`);
+    LOG_PATH = null;
+  }
+}
+function logWrite(text) {
+  if (LOG_PATH && text) { try { fs.appendFileSync(LOG_PATH, text); } catch { /* best-effort */ } }
+}
+function cerrarLog() { /* no-op: appendFileSync ya volcó todo a disco */ }
+
+/**
+ * Resuelve el binario de npm a invocar. Usa node + npm-cli.js cuando es
+ * posible para evitar shell:true en Windows (mismo enfoque que la lib
+ * scripts/lib/npm-version.js).
+ */
+const NPM_CLI_JS = (() => {
+  const dir = path.dirname(process.execPath);
+  for (const c of [
+    path.join(dir, 'node_modules', 'npm', 'bin', 'npm-cli.js'),
+    path.join(dir, '..', 'lib', 'node_modules', 'npm', 'bin', 'npm-cli.js'),
+  ]) {
+    try { if (fs.existsSync(c)) return c; } catch { /* continuar */ }
+  }
+  return null;
+})();
+
+function npmExec(args, opts = {}) {
+  const defaults = { cwd: ROOT, stdio: 'inherit', timeout: 300_000 };
+  if (NPM_CLI_JS) {
+    return execFileSync(process.execPath, [NPM_CLI_JS, ...args], { ...defaults, ...opts });
+  }
+  // Fallback a npm/npm.cmd como ejecutable nombrado. NO usamos shell:true:
+  // todos los args son strings ya separados, sin interpolación.
+  const bin = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+  return execFileSync(bin, args, { ...defaults, ...opts });
+}
+
+/**
+ * Variante de npmExec que captura stdout+stderr para (a) detección de errores
+ * estructurados (ej: EOTP) y (b) persistencia en el log de la corrida
+ * (`iniciarLog`). Ambos streams se pipean, se ecoan a consola al terminar y se
+ * vuelcan al log — así el stdout del script que rompe el publish (test:release)
+ * queda registrado. Trade-off: la salida del prepublish aparece al finalizar el
+ * spawn (no en vivo), por eso se imprime un aviso antes.
+ *
+ * Retorna { status, stderr } sin lanzar — el caller inspecciona el status.
+ */
+function npmSpawnCaptureStderr(args, opts = {}) {
+  const defaults = { cwd: ROOT, timeout: 300_000, env: process.env };
+  const merged = { ...defaults, ...opts, stdio: ['inherit', 'pipe', 'pipe'] };
+  process.stderr.write('[publicar] ejecutando npm (incluye prepublish/test:release; salida completa al finalizar y en el log)...\n');
+  let res;
+  if (NPM_CLI_JS) {
+    res = spawnSync(process.execPath, [NPM_CLI_JS, ...args], merged);
+  } else {
+    const bin = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+    res = spawnSync(bin, args, merged);
+  }
+  const stdout = res.stdout ? String(res.stdout) : '';
+  const stderr = res.stderr ? String(res.stderr) : '';
+  // Eco a consola + volcado al log (stdout primero, luego stderr).
+  if (stdout) process.stdout.write(stdout);
+  if (stderr) process.stderr.write(stderr);
+  logWrite(stdout);
+  logWrite(stderr);
+  return { status: res.status, signal: res.signal, stderr, error: res.error };
+}
+
+/**
+ * Detecta si un blob de stderr indica que npm requiere una OTP de 2FA.
+ * Match defensivo: cubre tanto el código de error explícito (`EOTP`) como el
+ * mensaje canónico ("requires a one-time password"), porque npm ha cambiado
+ * el formato del mensaje entre versiones (npm 8 vs 10+).
+ *
+ * Pura — testeable sin dependencias. Exportada para tests.
+ */
+function esErrorOTP(stderr) {
+  if (!stderr) return false;
+  const blob = String(stderr);
+  return /\bEOTP\b/.test(blob) || /one-time password/i.test(blob);
+}
+
+/**
+ * Ejecuta npm con stdio HEREDADO (interactivo): npm escribe directo a la
+ * terminal y lee de stdin, de modo que su flujo de 2FA NATIVO funciona —
+ * prompt de OTP TOTP O auth web/passkey ("abrir URL y seleccionar la llave"),
+ * según el método 2FA de la cuenta. Retorna el exit status sin lanzar.
+ * (A1: soporte passkey/WebAuthn, no solo TOTP.)
+ */
+function npmExecInherit(args, opts = {}) {
+  const merged = { cwd: ROOT, timeout: 600_000, env: process.env, ...opts, stdio: 'inherit' };
+  let res;
+  if (NPM_CLI_JS) {
+    res = spawnSync(process.execPath, [NPM_CLI_JS, ...args], merged);
+  } else {
+    const bin = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+    res = spawnSync(bin, args, merged);
+  }
+  return res.status;
+}
+
+/**
+ * Ejecuta un `npm publish` con soporte automático de OTP (2FA).
+ *
+ * Flujo:
+ *   1. Si NPM_CONFIG_OTP está definida en el entorno (o hay token Automation),
+ *      se usa directamente y el intento 1 publica sin interacción.
+ *   2. Si el publish falla con EOTP/one-time password y stdin es TTY, se
+ *      reintenta con stdio HEREDADO para que npm conduzca su 2FA NATIVO —
+ *      OTP TOTP O passkey/WebAuthn (navegador), según la cuenta — con
+ *      --ignore-scripts (los pre-publish ya pasaron en el intento 1).
+ *   3. Si stdin no es TTY (CI sin OTP), reporta el error y retorna false.
+ *
+ * Retorna: { ok: boolean, stderr: string }
+ *
+ * Exportada para tests.
+ */
+function ejecutarPublishConOTP(args, opts = {}) {
+  // Intento 1: con OTP de env si existe, sin ella si no.
+  const intento1 = npmSpawnCaptureStderr(args, opts);
+  if (intento1.status === 0) {
+    return { ok: true, stderr: intento1.stderr };
+  }
+
+  // Si NO es EOTP, no podemos hacer nada — propagamos el fallo.
+  if (!esErrorOTP(intento1.stderr)) {
+    return { ok: false, stderr: intento1.stderr };
+  }
+
+  // Es EOTP — 2FA requerida. npm soporta varios métodos: OTP TOTP (6 dígitos)
+  // O passkey/WebAuthn vía navegador ("abrir URL y seleccionar la llave").
+  // Forzar un prompt de TOTP rompe a los usuarios con passkey (A1). En su lugar
+  // se reintenta con stdio HEREDADO para que npm conduzca su 2FA NATIVO —
+  // funcione cual sea el método configurado en la cuenta.
+  process.stderr.write('\n[publicar] npm rechazó el publish con EOTP (2FA requerida).\n');
+  if (!process.stdin.isTTY) {
+    process.stderr.write('[publicar] stdin no es TTY: no se puede completar 2FA interactivo.\n');
+    process.stderr.write('[publicar] Opciones: exportar NPM_CONFIG_OTP=<otp>, o usar un token Automation (omite 2FA).\n');
+    return { ok: false, stderr: intento1.stderr };
+  }
+  // Reintento interactivo: --ignore-scripts porque los pre-publish ya pasaron en
+  // el intento 1 (el prepack limpió el árbol; no se re-ejecuta test:release).
+  process.stderr.write('\n[publicar] Reintentando con el 2FA interactivo nativo de npm (OTP o passkey)...\n');
+  const argsConIgnore = args.includes('--ignore-scripts') ? args : [...args, '--ignore-scripts'];
+  const status = npmExecInherit(argsConIgnore, opts);
+  return { ok: status === 0, stderr: status === 0 ? '' : 'fallo en reintento interactivo de 2FA' };
+}
+
+function leerPkg() {
+  return JSON.parse(fs.readFileSync(PKG_PATH, 'utf-8'));
+}
+
+/**
+ * Clasifica el error de `npm whoami` capturado en stderr para distinguir
+ * causas raíz comunes y permitir mensajes accionables al usuario.
+ *
+ * Tipos retornados:
+ *   - 'no-token'  : no hay _authToken configurado para ese registry.
+ *   - 'token-401' : token presente pero rechazado (expirado/revocado).
+ *   - 'token-403' : token válido pero sin permiso (cuenta sin acceso al scope).
+ *   - 'registry-404' : el registry no responde el endpoint whoami (URL incorrecta).
+ *   - 'desconocido'  : error de red, npm no en PATH, timeout, etc.
+ */
+function clasificarErrorAuth(stderr, mensaje) {
+  const blob = (stderr || '') + '\n' + (mensaje || '');
+  if (/\b401\b/.test(blob))             return 'token-401';
+  if (/\b403\b/.test(blob))             return 'token-403';
+  if (/\b404\b/.test(blob))             return 'registry-404';
+  if (/ENEEDAUTH|need to authorize/i.test(blob)) return 'no-token';
+  return 'desconocido';
+}
+
+function verificarLogin(registry) {
+  try {
+    const result = npmExec(['whoami', `--registry=${registry}`], {
+      stdio: ['pipe', 'pipe', 'pipe'],
+      encoding: 'utf-8',
+      timeout:  15_000,
+    });
+    return { ok: true, usuario: String(result).trim() };
+  } catch (err) {
+    // Capturar stderr del proceso para clasificar la causa raíz.
+    // execFileSync expone stderr en err.stderr cuando stdio fue 'pipe'.
+    const stderrBuf = err.stderr ? String(err.stderr) : '';
+    const motivo = (stderrBuf || String(err.message || err)).split('\n')[0].slice(0, 200);
+    const tipo   = clasificarErrorAuth(stderrBuf, err.message);
+    process.stderr.write(`[verificarLogin ${registry}] ${tipo}: ${motivo}\n`);
+    return { ok: false, tipo, motivo };
+  }
+}
+
+/**
+ * Imprime guía accionable según el tipo de fallo de auth y el registry.
+ * Se llama desde publicarNpmjs/publicarGitHub cuando verificarLogin falla.
+ */
+function imprimirGuiaAuth(registry, pkgName, tipo) {
+  const esGithub = /npm\.pkg\.github\.com/.test(registry);
+  console.error('');
+  switch (tipo) {
+    case 'token-401':
+      console.error('CAUSA: token de autenticación rechazado (HTTP 401 — expirado o revocado).');
+      if (esGithub) {
+        console.error('FIX:   GitHub Packages NO acepta `npm login`. Genera un nuevo PAT en');
+        console.error('       Settings → Developer settings → Personal access tokens (classic)');
+        console.error('       con scopes `read:packages` y `write:packages`, y reemplaza la línea');
+        console.error('       en ~/.npmrc:');
+        console.error('         //npm.pkg.github.com/:_authToken=<NUEVO_TOKEN>');
+      } else {
+        console.error(`FIX:   npm login --registry=${registry}`);
+        console.error('       (abrirá el navegador para autenticar y reescribirá ~/.npmrc).');
+      }
+      break;
+    case 'token-403':
+      console.error('CAUSA: token válido pero la cuenta no tiene permiso al scope del paquete.');
+      console.error(`FIX:   Verifica el dueño del scope con:`);
+      console.error(`         npm owner ls ${pkgName} --registry=${registry}`);
+      console.error('       Si la cuenta autenticada no aparece como owner, autenticate con la');
+      console.error('       cuenta dueña del scope o pide ser agregado como maintainer.');
+      break;
+    case 'registry-404':
+      console.error('CAUSA: el registry no responde el endpoint whoami (URL probablemente incorrecta).');
+      console.error(`FIX:   Verifica que la URL sea exactamente '${registry}' (incluyendo https:// y trailing slash si aplica).`);
+      break;
+    case 'no-token':
+      console.error('CAUSA: no hay token configurado para este registry en ~/.npmrc.');
+      if (esGithub) {
+        console.error('FIX:   GitHub Packages requiere PAT manual. Agrega a ~/.npmrc:');
+        console.error('         //npm.pkg.github.com/:_authToken=<TU_PAT>');
+        console.error('       (NO uses `npm login` con GitHub Packages — devuelve 404/403.)');
+      } else {
+        console.error(`FIX:   npm login --registry=${registry}`);
+      }
+      break;
+    default:
+      console.error('CAUSA: error desconocido al consultar whoami.');
+      console.error('       Verifica conectividad de red y que `npm` esté en PATH.');
+      console.error(`       Para diagnóstico manual:  npm whoami --registry=${registry}`);
+  }
+  console.error('');
+}
+
+function copiarDir(src, dest) {
+  fs.mkdirSync(dest, { recursive: true });
+  const entries = fs.readdirSync(src, { withFileTypes: true });
+  for (const entry of entries) {
+    // Excluir artefactos Python (lista canónica en lib/artefactos-python.js)
+    if (entry.isDirectory() && esDirArtefacto(entry.name)) continue;
+    if (!entry.isDirectory() && esArchivoArtefacto(entry.name)) continue;
+
+    const srcPath  = path.join(src,  entry.name);
+    const destPath = path.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      copiarDir(srcPath, destPath);
+    } else {
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
+function limpiar(tmpDir) {
+  try {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  } catch (err) {
+    // En Windows el filesystem puede mantener locks transitorios sobre
+    // archivos recién copiados. La limpieza eventual la hace el SO; no
+    // bloqueamos el flujo, pero anotamos el path para inspección manual.
+    process.stderr.write(`[publicar] no se pudo limpiar tmpDir ${tmpDir}: ${String(err.message).slice(0, 80)}\n`);
+  }
+}
+
+function construirPkgTemporal(pkg, nombre, registry) {
+  const tmpPkg = {
+    ...pkg,
+    name: nombre,
+    publishConfig: { registry, access: 'public' },
+  };
+  // Quitar prepack/prepublishOnly del temp para evitar recursión.
+  // npm publish desde tmpDir invocaría prepack apuntando a un script
+  // que ya no existe en ese path, y prepublishOnly correría el suite
+  // de tests dos veces.
+  if (tmpPkg.scripts) {
+    delete tmpPkg.scripts.prepack;
+    delete tmpPkg.scripts.prepublishOnly;
+  }
+  return tmpPkg;
+}
+
+function copiarArchivosFiles(pkg, tmpDir) {
+  for (const entry of pkg.files || []) {
+    const src = path.join(ROOT, entry);
+    const dest = path.join(tmpDir, entry);
+    if (!fs.existsSync(src)) continue;
+    if (fs.statSync(src).isDirectory()) {
+      copiarDir(src, dest);
+    } else {
+      fs.mkdirSync(path.dirname(dest), { recursive: true });
+      fs.copyFileSync(src, dest);
+    }
+  }
+}
+
+function copiarMetadatos(tmpDir) {
+  // npm incluye README/LICENSE/CHANGELOG automáticamente al publicar.
+  for (const meta of ['README.md', 'LICENSE', 'CHANGELOG.md', 'CHANGELOG-LEGACY.md']) {
+    const src = path.join(ROOT, meta);
+    if (fs.existsSync(src)) {
+      fs.copyFileSync(src, path.join(tmpDir, meta));
+    }
+  }
+}
+
+function prepararDirectorioTemporal(pkg, nombrePersonalizado, registryPersonalizado) {
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'swl-ses-publish-'));
+  const tmpPkg = construirPkgTemporal(pkg, nombrePersonalizado, registryPersonalizado);
+  fs.writeFileSync(path.join(tmpDir, 'package.json'), JSON.stringify(tmpPkg, null, 2));
+  copiarArchivosFiles(pkg, tmpDir);
+  copiarMetadatos(tmpDir);
+  return tmpDir;
+}
+
+function publicarNpmjs(pkg, dryRun) {
+  console.log('\n=== 1/2 — npmjs.org (canónico) ===');
+  console.log(`Paquete: ${pkg.name}@${pkg.version}`);
+  console.log(`Registry: ${NPMJS_REGISTRY}`);
+
+  const auth = verificarLogin(NPMJS_REGISTRY);
+  if (!auth.ok) {
+    console.error(`ERROR: No autenticado en npmjs (${auth.tipo}).`);
+    imprimirGuiaAuth(NPMJS_REGISTRY, pkg.name, auth.tipo);
+    return false;
+  }
+  console.log(`Autenticado como: ${auth.usuario}`);
+
+  const args = ['publish', `--registry=${NPMJS_REGISTRY}`, '--access', 'public'];
+  if (dryRun) args.push('--dry-run');
+  const resultado = ejecutarPublishConOTP(args);
+  if (resultado.ok) {
+    console.log(`${dryRun ? '[DRY-RUN] ' : ''}OK: ${pkg.name}@${pkg.version} ${dryRun ? 'se publicaría' : 'publicado'} en npmjs`);
+    return true;
+  }
+  console.error(`ERROR publicando en npmjs (ver stderr arriba para diagnóstico de npm).`);
+  return false;
+}
+
+function publicarGitHub(pkg, dryRun) {
+  console.log('\n=== 2/2 — GitHub Packages (mirror) ===');
+  console.log(`Paquete: ${GITHUB_NAME}@${pkg.version}`);
+  console.log(`Registry: ${GITHUB_REGISTRY}`);
+
+  const auth = verificarLogin(GITHUB_REGISTRY);
+  if (!auth.ok) {
+    console.error(`ERROR: No autenticado en GitHub Packages (${auth.tipo}).`);
+    imprimirGuiaAuth(GITHUB_REGISTRY, GITHUB_NAME, auth.tipo);
+    return false;
+  }
+  console.log(`Autenticado como: ${auth.usuario}`);
+
+  const tmpDir = prepararDirectorioTemporal(pkg, GITHUB_NAME, GITHUB_REGISTRY);
+
+  const args = ['publish', `--registry=${GITHUB_REGISTRY}`];
+  if (dryRun) args.push('--dry-run');
+  const resultado = ejecutarPublishConOTP(args, { cwd: tmpDir });
+  if (resultado.ok) {
+    console.log(`${dryRun ? '[DRY-RUN] ' : ''}OK: ${GITHUB_NAME}@${pkg.version} ${dryRun ? 'se publicaría' : 'publicado'} en GitHub Packages`);
+    if (dryRun) console.log(`Directorio temporal: ${tmpDir}`);
+    limpiar(tmpDir);
+    return true;
+  }
+  console.error(`ERROR publicando en GitHub Packages (ver stderr arriba para diagnóstico de npm).`);
+  limpiar(tmpDir);
+  return false;
+}
+
+function parsearArgs(argv) {
+  return {
+    dryRun:     argv.includes('--dry-run'),
+    soloGithub: argv.includes('--solo-github'),
+    soloNpmjs:  argv.includes('--solo-npmjs'),
+  };
+}
+
+function imprimirEncabezado(version, dryRun) {
+  console.log('╔══════════════════════════════════════════╗');
+  console.log('║  @saulwade/swl-ses — Publicación dual    ║');
+  console.log('╚══════════════════════════════════════════╝');
+  console.log(`Versión: ${version}`);
+  if (dryRun) console.log('Modo: DRY-RUN (sin cambios)');
+}
+
+function avisarSiHayCambiosSinCommit(dryRun) {
+  try {
+    const status = String(execFileSync('git', ['status', '--porcelain'], {
+      cwd: ROOT, encoding: 'utf-8',
+    })).trim();
+    if (status && !dryRun) {
+      console.warn('\nADVERTENCIA: Hay cambios sin commitear.');
+      console.warn('Se recomienda hacer commit antes de publicar.\n');
+    }
+  } catch (err) {
+    // No es repo git, o git no está disponible. No bloquea el publish.
+    process.stderr.write(`[publicar] git status falló (no bloqueante): ${String(err.message).slice(0, 80)}\n`);
+  }
+}
+
+function reportarResultado(pkg, opts, npmjsOk, githubOk) {
+  console.log('\n=== Resultado ===');
+  if (!opts.soloGithub) console.log(`npmjs.org:        ${npmjsOk ? 'OK' : 'FALLÓ'} — ${pkg.name}@${pkg.version}`);
+  if (!opts.soloNpmjs)  console.log(`GitHub Packages:  ${githubOk ? 'OK' : 'FALLÓ'} — ${GITHUB_NAME}@${pkg.version}`);
+  if (!opts.soloNpmjs && !opts.soloGithub && npmjsOk && githubOk) {
+    console.log('\nAmbos paquetes publicados. Los usuarios pueden instalar con:');
+    console.log(`  npx ${pkg.name}@latest doctor                    (canónico, recomendado)`);
+    console.log(`  npx ${GITHUB_NAME}@latest doctor                 (mirror GitHub Packages)`);
+  }
+}
+
+function main() {
+  const opts = parsearArgs(process.argv.slice(2));
+  const pkg  = leerPkg();
+  iniciarLog(pkg.version);
+  imprimirEncabezado(pkg.version, opts.dryRun);
+  avisarSiHayCambiosSinCommit(opts.dryRun);
+
+  const npmjsOk  = opts.soloGithub ? true : publicarNpmjs(pkg, opts.dryRun);
+  const githubOk = opts.soloNpmjs  ? true : publicarGitHub(pkg, opts.dryRun);
+
+  reportarResultado(pkg, opts, npmjsOk, githubOk);
+  if (LOG_PATH) process.stdout.write(`\nLog de la corrida: ${path.relative(ROOT, LOG_PATH).replace(/\\/g, '/')}\n`);
+  cerrarLog();
+  process.exit(npmjsOk && githubOk ? 0 : 1);
+}
+
+// Solo ejecutar el flujo completo cuando el script se invoca como CLI.
+// Cuando se importa como módulo (tests), expone helpers para verificar
+// invariantes de prepararDirectorioTemporal sin hacer publish real.
+if (require.main === module) {
+  main();
+} else {
+  module.exports = {
+    prepararDirectorioTemporal,
+    copiarDir,
+    limpiar,
+    esErrorOTP,
+    ejecutarPublishConOTP,
+    GITHUB_NAME,
+    GITHUB_REGISTRY,
+    NPMJS_REGISTRY,
+  };
+}