@saulwade/swl-ses 1.4.0 → 1.4.2

package/scripts/publicar.js

@@ -1,511 +1,511 @@
-#!/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 readline = require('readline');
-
-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');
-
-/**
- * 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 stderr para detección posterior de errores
- * estructurados (ej: EOTP). stdout sigue heredado (live-streaming visible al
- * usuario) y stderr se pipea a un buffer + se ecoa a process.stderr al final.
- *
- * 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', 'inherit', 'pipe'] };
-  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 stderr = res.stderr ? String(res.stderr) : '';
-  // Ecoar stderr al usuario para que vea el diagnóstico de npm aunque se capturó.
-  if (stderr) process.stderr.write(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);
-}
-
-/**
- * Solicita una OTP al usuario via stdin (readline síncrono).
- * Retorna la OTP normalizada (string de 6 dígitos) o null si:
- *   - stdin no es TTY (CI, pipe) → no se puede pedir interactivamente
- *   - el usuario cancela con Ctrl+C / línea vacía
- *   - el formato no es válido (no 6 dígitos)
- *
- * El caller debe manejar el caso null como "fallback a guía manual".
- */
-function solicitarOTPInteractiva() {
-  if (!process.stdin.isTTY) {
-    process.stderr.write('[publicar] stdin no es TTY: no se puede pedir OTP interactivamente.\n');
-    process.stderr.write('[publicar] Configurar NPM_CONFIG_OTP=<otp> antes de invocar este script.\n');
-    return null;
-  }
-
-  const rl = readline.createInterface({ input: process.stdin, output: process.stderr });
-  // questionSync vía promesa NO funciona aquí — el script es síncrono.
-  // Usamos un truco: readline es async-only, así que dejamos al usuario
-  // el manejo bloqueante leyendo línea por línea con readSync vía read-int.
-  // Pero readline no expone modo síncrono. Alternativa: leer de stdin con
-  // fd 0 + readSync. En Windows con TTY funciona; en Linux idem.
-  try {
-    process.stderr.write('\nNPM requiere OTP (2FA). Ingresa el código de 6 dígitos de tu autenticador: ');
-    const otp = leerLineaStdinSync().trim();
-    rl.close();
-    if (!/^\d{6}$/.test(otp)) {
-      process.stderr.write(`\n[publicar] OTP inválida: se esperan 6 dígitos, se recibió: "${otp.slice(0, 20)}"\n`);
-      return null;
-    }
-    return otp;
-  } catch (err) {
-    rl.close();
-    process.stderr.write(`\n[publicar] error leyendo OTP: ${String(err.message).slice(0, 120)}\n`);
-    return null;
-  }
-}
-
-/**
- * Lectura síncrona de una línea de stdin. Necesario porque readline solo
- * expone API asíncrona, pero todo el flujo de publicar.js es síncrono.
- * Lee byte por byte hasta encontrar newline o EOF.
- */
-function leerLineaStdinSync() {
-  const BUFFER_SIZE = 256;
-  const buf = Buffer.alloc(BUFFER_SIZE);
-  let line = '';
-  while (true) {
-    let bytesRead;
-    try {
-      bytesRead = fs.readSync(0, buf, 0, BUFFER_SIZE, null);
-    } catch (err) {
-      // EAGAIN en stdin no-bloqueante: poco común en TTY, pero defensivo.
-      if (err.code === 'EAGAIN') continue;
-      throw err;
-    }
-    if (bytesRead === 0) break; // EOF
-    const chunk = buf.slice(0, bytesRead).toString('utf-8');
-    const nlIdx = chunk.indexOf('\n');
-    if (nlIdx >= 0) {
-      line += chunk.slice(0, nlIdx);
-      break;
-    }
-    line += chunk;
-  }
-  return line.replace(/\r$/, ''); // Windows envía \r\n
-}
-
-/**
- * Ejecuta un `npm publish` con soporte automático de OTP (2FA).
- *
- * Flujo:
- *   1. Si NPM_CONFIG_OTP está definida en el entorno, se usa directamente
- *      (npm la lee automáticamente — no hay que pasarla como flag).
- *   2. Si el publish falla con EOTP/one-time password, se intenta solicitar
- *      la OTP interactivamente y reintentar con --ignore-scripts (los
- *      scripts pre-publish ya pasaron en el primer intento).
- *   3. Si no se puede obtener OTP (no TTY o usuario cancela), 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. Intentar solicitar OTP interactivamente.
-  process.stderr.write('\n[publicar] npm rechazó el publish con EOTP (2FA requerida).\n');
-  const otp = solicitarOTPInteractiva();
-  if (!otp) {
-    process.stderr.write('[publicar] No se obtuvo OTP. Aborta. Reintentar con:\n');
-    process.stderr.write(`  NPM_CONFIG_OTP=<otp> node scripts/publicar.js ${process.argv.slice(2).join(' ')}\n`);
-    return { ok: false, stderr: intento1.stderr };
-  }
-
-  // Reintento con OTP via env + --ignore-scripts (los pre-publish ya pasaron).
-  process.stderr.write('\n[publicar] Reintentando publish con OTP recibida...\n');
-  const envConOTP = { ...(opts.env || process.env), NPM_CONFIG_OTP: otp };
-  const argsConIgnore = args.includes('--ignore-scripts') ? args : [...args, '--ignore-scripts'];
-  const intento2 = npmSpawnCaptureStderr(argsConIgnore, { ...opts, env: envConOTP });
-  if (intento2.status === 0) {
-    return { ok: true, stderr: intento2.stderr };
-  }
-  return { ok: false, stderr: intento2.stderr };
-}
-
-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();
-  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);
-  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 readline = require('readline');
+
+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');
+
+/**
+ * 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 stderr para detección posterior de errores
+ * estructurados (ej: EOTP). stdout sigue heredado (live-streaming visible al
+ * usuario) y stderr se pipea a un buffer + se ecoa a process.stderr al final.
+ *
+ * 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', 'inherit', 'pipe'] };
+  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 stderr = res.stderr ? String(res.stderr) : '';
+  // Ecoar stderr al usuario para que vea el diagnóstico de npm aunque se capturó.
+  if (stderr) process.stderr.write(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);
+}
+
+/**
+ * Solicita una OTP al usuario via stdin (readline síncrono).
+ * Retorna la OTP normalizada (string de 6 dígitos) o null si:
+ *   - stdin no es TTY (CI, pipe) → no se puede pedir interactivamente
+ *   - el usuario cancela con Ctrl+C / línea vacía
+ *   - el formato no es válido (no 6 dígitos)
+ *
+ * El caller debe manejar el caso null como "fallback a guía manual".
+ */
+function solicitarOTPInteractiva() {
+  if (!process.stdin.isTTY) {
+    process.stderr.write('[publicar] stdin no es TTY: no se puede pedir OTP interactivamente.\n');
+    process.stderr.write('[publicar] Configurar NPM_CONFIG_OTP=<otp> antes de invocar este script.\n');
+    return null;
+  }
+
+  const rl = readline.createInterface({ input: process.stdin, output: process.stderr });
+  // questionSync vía promesa NO funciona aquí — el script es síncrono.
+  // Usamos un truco: readline es async-only, así que dejamos al usuario
+  // el manejo bloqueante leyendo línea por línea con readSync vía read-int.
+  // Pero readline no expone modo síncrono. Alternativa: leer de stdin con
+  // fd 0 + readSync. En Windows con TTY funciona; en Linux idem.
+  try {
+    process.stderr.write('\nNPM requiere OTP (2FA). Ingresa el código de 6 dígitos de tu autenticador: ');
+    const otp = leerLineaStdinSync().trim();
+    rl.close();
+    if (!/^\d{6}$/.test(otp)) {
+      process.stderr.write(`\n[publicar] OTP inválida: se esperan 6 dígitos, se recibió: "${otp.slice(0, 20)}"\n`);
+      return null;
+    }
+    return otp;
+  } catch (err) {
+    rl.close();
+    process.stderr.write(`\n[publicar] error leyendo OTP: ${String(err.message).slice(0, 120)}\n`);
+    return null;
+  }
+}
+
+/**
+ * Lectura síncrona de una línea de stdin. Necesario porque readline solo
+ * expone API asíncrona, pero todo el flujo de publicar.js es síncrono.
+ * Lee byte por byte hasta encontrar newline o EOF.
+ */
+function leerLineaStdinSync() {
+  const BUFFER_SIZE = 256;
+  const buf = Buffer.alloc(BUFFER_SIZE);
+  let line = '';
+  while (true) {
+    let bytesRead;
+    try {
+      bytesRead = fs.readSync(0, buf, 0, BUFFER_SIZE, null);
+    } catch (err) {
+      // EAGAIN en stdin no-bloqueante: poco común en TTY, pero defensivo.
+      if (err.code === 'EAGAIN') continue;
+      throw err;
+    }
+    if (bytesRead === 0) break; // EOF
+    const chunk = buf.slice(0, bytesRead).toString('utf-8');
+    const nlIdx = chunk.indexOf('\n');
+    if (nlIdx >= 0) {
+      line += chunk.slice(0, nlIdx);
+      break;
+    }
+    line += chunk;
+  }
+  return line.replace(/\r$/, ''); // Windows envía \r\n
+}
+
+/**
+ * Ejecuta un `npm publish` con soporte automático de OTP (2FA).
+ *
+ * Flujo:
+ *   1. Si NPM_CONFIG_OTP está definida en el entorno, se usa directamente
+ *      (npm la lee automáticamente — no hay que pasarla como flag).
+ *   2. Si el publish falla con EOTP/one-time password, se intenta solicitar
+ *      la OTP interactivamente y reintentar con --ignore-scripts (los
+ *      scripts pre-publish ya pasaron en el primer intento).
+ *   3. Si no se puede obtener OTP (no TTY o usuario cancela), 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. Intentar solicitar OTP interactivamente.
+  process.stderr.write('\n[publicar] npm rechazó el publish con EOTP (2FA requerida).\n');
+  const otp = solicitarOTPInteractiva();
+  if (!otp) {
+    process.stderr.write('[publicar] No se obtuvo OTP. Aborta. Reintentar con:\n');
+    process.stderr.write(`  NPM_CONFIG_OTP=<otp> node scripts/publicar.js ${process.argv.slice(2).join(' ')}\n`);
+    return { ok: false, stderr: intento1.stderr };
+  }
+
+  // Reintento con OTP via env + --ignore-scripts (los pre-publish ya pasaron).
+  process.stderr.write('\n[publicar] Reintentando publish con OTP recibida...\n');
+  const envConOTP = { ...(opts.env || process.env), NPM_CONFIG_OTP: otp };
+  const argsConIgnore = args.includes('--ignore-scripts') ? args : [...args, '--ignore-scripts'];
+  const intento2 = npmSpawnCaptureStderr(argsConIgnore, { ...opts, env: envConOTP });
+  if (intento2.status === 0) {
+    return { ok: true, stderr: intento2.stderr };
+  }
+  return { ok: false, stderr: intento2.stderr };
+}
+
+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();
+  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);
+  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,
+  };
+}