@saulwade/swl-ses 1.0.0

package/scripts/smoke-test.js

@@ -0,0 +1,374 @@
+#!/usr/bin/env node
+"use strict";
+
+/**
+ * Smoke test de instalación limpia.
+ *
+ * Simula el ciclo `install → doctor → uninstall` de un usuario real en un
+ * directorio temporal completamente nuevo (HOME override + CWD aislado).
+ * Atrapa bugs que ni los tests unitarios ni el gate de sincronización
+ * pueden detectar:
+ *
+ *   - Archivos que no llegan al destino aunque estén declarados
+ *   - Archivos que llegan al destino pero con contenido inválido
+ *   - doctor reporta errores después de un install exitoso
+ *   - uninstall deja residuos en el destino
+ *
+ * Este gate previene los bugs v5.7.1 (comando nuevo sin probar end-to-end)
+ * y v5.7.2 (update sin probar con versión cacheada).
+ *
+ * Exit codes: 0 OK, 1 al menos una fase falló.
+ *
+ * Uso: node scripts/smoke-test.js [--keep-tmp]
+ */
+
+const { spawnSync } = require("child_process");
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+
+const RAIZ = path.resolve(__dirname, "..");
+const CLI = path.join(RAIZ, "bin", "swl-ses.js");
+const KEEP_TMP = process.argv.includes("--keep-tmp");
+
+const modulos = JSON.parse(
+  fs.readFileSync(path.join(RAIZ, "manifiestos", "modulos.json"), "utf-8"),
+);
+
+function log(msg) {
+  console.log(msg);
+}
+
+function archivosEsperadosEnPerfil(perfil) {
+  // Perfil "completo" incluye casi todo. Recolectamos los archivos de los módulos
+  // del perfil resuelto según manifiestos/perfiles.json si existe, o tomamos todos.
+  const perfilesPath = path.join(RAIZ, "manifiestos", "perfiles.json");
+  let modulosPerfil = Object.keys(modulos.modulos);
+  if (fs.existsSync(perfilesPath)) {
+    const perfiles = JSON.parse(fs.readFileSync(perfilesPath, "utf-8"));
+    const def = (perfiles.perfiles || perfiles)[perfil];
+    if (def && Array.isArray(def.modulos)) modulosPerfil = def.modulos;
+  }
+  const archivos = new Set();
+  for (const modKey of modulosPerfil) {
+    const mod = modulos.modulos[modKey];
+    if (!mod) continue;
+    // Módulos tipo 'scripts' son herramientas de desarrollo del repo; el instalador
+    // NO los copia al runtime del usuario. Omitir del smoke test.
+    if (mod.tipo === "scripts") continue;
+    for (const a of mod.archivos || []) archivos.add(a);
+  }
+  return archivos;
+}
+
+function correrCli(args, cwd, env) {
+  // process.execPath = ruta absoluta al node que corre este script. Garantiza
+  // que el subproceso use el mismo node (evita problemas de PATH en Windows
+  // cuando `npm run test:release` no propaga la resolución de `node` bare).
+  const r = spawnSync(process.execPath, [CLI, ...args], {
+    cwd,
+    env: { ...process.env, ...env },
+    encoding: "utf-8",
+    timeout: 120000,
+  });
+  return {
+    code: r.status,
+    stdout: r.stdout || "",
+    stderr: r.stderr || "",
+    // Diagnóstico: si spawn falla (ENOENT, permiso, señal), estos campos
+    // explican el exit=null. Sin esto, el smoke test es ciego cuando falla.
+    error: r.error ? (r.error.code || r.error.message) : null,
+    signal: r.signal || null,
+  };
+}
+
+// El instalador traduce los paths del manifest (español) a las convenciones
+// del runtime de destino (Claude Code usa inglés: agents/, skills/, rules/, commands/).
+// Hooks y scripts no se traducen.
+function traducirRuta(rel) {
+  if (rel.startsWith("agentes/")) return rel.replace(/^agentes\//, "agents/");
+  if (rel.startsWith("habilidades/"))
+    return rel.replace(/^habilidades\//, "skills/");
+  if (rel.startsWith("comandos/"))
+    return rel.replace(/^comandos\//, "commands/");
+  if (rel.startsWith("reglas/")) {
+    // El instalador colapsa reglas/lenguajes/LANG/X.md → rules/LANG/X.md
+    return rel
+      .replace(/^reglas\/lenguajes\//, "rules/")
+      .replace(/^reglas\//, "rules/");
+  }
+  if (rel.startsWith("hooks/lib/")) {
+    // El instalador aplana hooks/lib/X.js → hooks/X.js en el destino.
+    return rel.replace(/^hooks\/lib\//, "hooks/");
+  }
+  // Archivos scripts/ declarados en módulos de tipo 'hooks' (ej. hooks-observabilidad,
+  // hooks-multica). El instalador toma path.basename y los coloca en rutas.hooks,
+  // aplanando scripts/lib/X.js y scripts/X.py a hooks/X.*.
+  if (rel.startsWith("scripts/")) {
+    return "hooks/" + path.posix.basename(rel);
+  }
+  return rel; // hooks/ mantiene su path
+}
+
+/**
+ * Convierte manifest/relativo POSIX a ruta absoluta del SO (Windows-safe).
+ * Nunca mezclar path.posix.join + path.join: en Windows fs.existsSync falla
+ * con rutas tipo C:\...\skills/foo\SKILL.md (mezcla de separadores).
+ */
+function rutaAbsolutaEnDestino(destino, traducidoPosix) {
+  const partes = traducidoPosix.split("/").filter(Boolean);
+  return path.join(destino, ...partes);
+}
+
+function verificarArchivosEnDestino(destino, archivosEsperados) {
+  const lista =
+    archivosEsperados instanceof Set
+      ? [...archivosEsperados]
+      : Array.isArray(archivosEsperados)
+        ? [...archivosEsperados]
+        : [...archivosEsperados];
+  const totalEsperados = lista.length;
+
+  const faltantes = [];
+  const presentes = [];
+  for (const rel of lista) {
+    // NOTA: no se excluye ningún prefijo por ruta aquí. Los archivos scripts/*
+    // declarados en módulos tipo 'scripts' (graphify-swl, mcp-swl) ya se filtran
+    // en archivosEsperadosEnPerfil por tipo del módulo, no por ruta. Los archivos
+    // scripts/* declarados en módulos tipo 'hooks' SÍ se copian al destino como
+    // hooks/X (traducirRuta aplana la ruta); deben verificarse.
+    const traducido = traducirRuta(rel);
+    // Habilidades se declaran como directorio; verificar SKILL.md.
+    const conSkillMd =
+      traducido.startsWith("skills/") && !traducido.includes("/SKILL.md")
+        ? `${traducido}/SKILL.md`
+        : traducido;
+    const abs = rutaAbsolutaEnDestino(destino, conSkillMd);
+    if (fs.existsSync(abs)) presentes.push(rel);
+    else faltantes.push(rel);
+  }
+  // Invariante: todo elemento iterado debe quedar clasificado como presente o
+  // faltante. Si falla, es un bug del control de flujo (continue no clasificó).
+  const totalClasificado = presentes.length + faltantes.length;
+  if (totalClasificado !== totalEsperados) {
+    throw new Error(
+      `verificarArchivosEnDestino: invariante roto — ` +
+        `${totalClasificado} clasificados vs ${totalEsperados} esperados`,
+    );
+  }
+  return { presentes, faltantes, totalEsperados };
+}
+
+function faseInstall(tmp, home) {
+  log("\n[FASE 1/3] install --profile completo --global --all-langs");
+  // --all-langs evita el filtrado por stack detectado (tmp está vacío, no detectaría lenguajes).
+  const r = correrCli(
+    [
+      "install",
+      "--target",
+      "claude",
+      "--profile",
+      "completo",
+      "--global",
+      "--force",
+      "--all-langs",
+    ],
+    tmp,
+    { HOME: home, USERPROFILE: home },
+  );
+  if (r.code !== 0) {
+    log(`  [FALLA] install exit=${r.code} signal=${r.signal || '-'} spawnError=${r.error || '-'}`);
+    if (r.error) {
+      log(`  Causa probable: no se pudo lanzar node (${r.error}). Verifica que`);
+      log(`                  process.execPath resuelva correctamente en este entorno.`);
+    }
+    if (r.stderr.trim()) {
+      log("  STDERR:");
+      log(
+        r.stderr
+          .split("\n")
+          .slice(0, 10)
+          .map((l) => "    " + l)
+          .join("\n"),
+      );
+    }
+    return { ok: false };
+  }
+  log("  [OK] install terminó sin errores");
+
+  // Verificar que todos los archivos esperados se copiaron
+  const destino = path.join(home, ".claude");
+  const esperados = archivosEsperadosEnPerfil("completo");
+  const { faltantes, totalEsperados } = verificarArchivosEnDestino(
+    destino,
+    esperados,
+  );
+
+  if (faltantes.length > 0) {
+    log(
+      `  [FALLA] ${faltantes.length}/${totalEsperados} archivos esperados NO llegaron al destino:`,
+    );
+    for (const f of faltantes.slice(0, 5)) log(`           → ${f}`);
+    if (faltantes.length > 5)
+      log(`           → ... ${faltantes.length - 5} más`);
+    return { ok: false };
+  }
+  log(
+    `  [OK] ${totalEsperados}/${totalEsperados} archivos presentes en el destino`,
+  );
+  return { ok: true };
+}
+
+function faseDoctor(tmp, home) {
+  log("\n[FASE 2/3] doctor");
+  const r = correrCli(["doctor"], tmp, { HOME: home, USERPROFILE: home });
+  if (r.code !== 0) {
+    log(`  [FALLA] doctor exit=${r.code} signal=${r.signal || '-'} spawnError=${r.error || '-'}`);
+    if (r.stdout.trim()) {
+      log("  STDOUT tail:");
+      log(
+        r.stdout
+          .split("\n")
+          .slice(-10)
+          .map((l) => "    " + l)
+          .join("\n"),
+      );
+    }
+    return { ok: false };
+  }
+  // Doctor debe reportar "N errores" en su resumen final. Si el patrón no aparece,
+  // el formato cambió, la salida se truncó o doctor falló silenciosamente — tratar
+  // como falla y NO dar falso positivo. Exit=0 sin el patrón esperado es drift.
+  const m = r.stdout.match(/(\d+)\s*errores/);
+  if (!m) {
+    log(
+      `  [FALLA] doctor exit=0 pero el resumen esperado "N errores" no apareció`,
+    );
+    log(
+      `           (formato cambió, stdout se truncó o ejecución no completó)`,
+    );
+    log("  STDOUT tail:");
+    log(
+      r.stdout
+        .split("\n")
+        .slice(-15)
+        .map((l) => "    " + l)
+        .join("\n"),
+    );
+    return { ok: false };
+  }
+  const nErrores = parseInt(m[1], 10);
+  if (!Number.isFinite(nErrores)) {
+    log(`  [FALLA] doctor reportó un contador de errores no numérico: "${m[1]}"`);
+    return { ok: false };
+  }
+  if (nErrores > 0) {
+    log(`  [FALLA] doctor reportó ${nErrores} errores tras install limpio`);
+    log("  STDOUT tail:");
+    log(
+      r.stdout
+        .split("\n")
+        .slice(-15)
+        .map((l) => "    " + l)
+        .join("\n"),
+    );
+    return { ok: false };
+  }
+  log("  [OK] doctor pasó sin errores");
+  return { ok: true };
+}
+
+function faseUninstall(tmp, home) {
+  log("\n[FASE 3/3] uninstall");
+  const r = correrCli(
+    ["uninstall", "--target", "claude", "--global", "--force"],
+    tmp,
+    { HOME: home, USERPROFILE: home },
+  );
+  if (r.code !== 0) {
+    log(`  [FALLA] uninstall exit=${r.code} signal=${r.signal || '-'} spawnError=${r.error || '-'}`);
+    if (r.stderr.trim()) {
+      log("  STDERR:");
+      log(
+        r.stderr
+          .split("\n")
+          .slice(0, 10)
+          .map((l) => "    " + l)
+          .join("\n"),
+      );
+    }
+    return { ok: false };
+  }
+  log("  [OK] uninstall terminó sin errores");
+
+  // Verificar que el destino está limpio (sin agentes ni comandos residuales)
+  const destino = path.join(home, ".claude");
+  const residuos = [];
+  for (const sub of ["agents", "commands", "skills", "hooks"]) {
+    const dir = path.join(destino, sub);
+    if (fs.existsSync(dir)) {
+      const entradas = fs.readdirSync(dir).filter((e) => !e.startsWith("."));
+      if (entradas.length > 0)
+        residuos.push(`${sub}/ (${entradas.length} archivos)`);
+    }
+  }
+  if (residuos.length > 0) {
+    log(
+      `  [ADVERTENCIA] ${residuos.length} directorio(s) con residuos tras uninstall:`,
+    );
+    for (const r of residuos) log(`                 → ${r}`);
+    // Residuos son advertencia, no falla — uninstall puede preservar datos del usuario
+  } else {
+    log("  [OK] Destino limpio, sin residuos");
+  }
+  return { ok: true };
+}
+
+function main() {
+  log("Smoke test de instalación limpia");
+  log("═══════════════════════════════════════════\n");
+
+  const tmpBase = fs.mkdtempSync(path.join(os.tmpdir(), "swl-smoke-"));
+  const home = path.join(tmpBase, "home");
+  const cwd = path.join(tmpBase, "workspace");
+  fs.mkdirSync(home, { recursive: true });
+  fs.mkdirSync(cwd, { recursive: true });
+
+  log(`TMP: ${tmpBase}`);
+
+  let todoOk = true;
+  try {
+    const install = faseInstall(cwd, home);
+    if (!install.ok) todoOk = false;
+
+    // Doctor y uninstall son independientes: una falla en doctor no debe impedir
+    // probar la limpieza del uninstall (objetivo declarado en el encabezado).
+    // Solo si install falló se omiten ambas fases — no hay nada instalado que probar.
+    if (install.ok) {
+      const doctor = faseDoctor(cwd, home);
+      if (!doctor.ok) todoOk = false;
+
+      const uninstall = faseUninstall(cwd, home);
+      if (!uninstall.ok) todoOk = false;
+    }
+  } finally {
+    if (!KEEP_TMP) {
+      try {
+        fs.rmSync(tmpBase, { recursive: true, force: true });
+      } catch {}
+    } else {
+      log(`\n(--keep-tmp) directorio preservado en ${tmpBase}`);
+    }
+  }
+
+  log("\n═══════════════════════════════════════════");
+  if (todoOk) {
+    log("✓ Smoke test OK — sistema instalable y desinstalable limpiamente");
+    process.exit(0);
+  } else {
+    log("✗ Smoke test FALLÓ — revisar fases arriba");
+    process.exit(1);
+  }
+}
+
+main();