@alejandrojca/elmulo-reporter 2.0.0-beta.5

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "@alejandrojca/elmulo-reporter",
+  "version": "2.0.0-beta.5",
+  "description": "Reporter independiente para ejecuciones de Cypress con dashboard, historial SQLite y evidencias.",
+  "type": "commonjs",
+  "main": "plugin.cjs",
+  "exports": {
+    ".": "./plugin.cjs",
+    "./cypress": "./plugin.cjs",
+    "./support": "./support.ts",
+    "./cli": "./cli.cjs",
+    "./package.json": "./package.json"
+  },
+  "bin": {
+    "elmulo": "cli.cjs"
+  },
+  "files": [
+    "assets/",
+    "cli.cjs",
+    "core.cjs",
+    "executive-pdf.cjs",
+    "finalize.cjs",
+    "plugin.cjs",
+    "rerun.cjs",
+    "security.cjs",
+    "server.cjs",
+    "support.ts",
+    "VERSION.json",
+    "README.md"
+  ],
+  "scripts": {
+    "test": "node --test test/*.test.cjs",
+    "demo": "node cli.cjs demo",
+    "serve": "node cli.cjs serve",
+    "pack:check": "npm pack --dry-run"
+  },
+  "dependencies": {
+    "pdfkit": "0.17.2",
+    "sql.js": "1.13.0"
+  },
+  "peerDependencies": {
+    "cypress": ">=12"
+  },
+  "peerDependenciesMeta": {
+    "cypress": {
+      "optional": true
+    }
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/alejandrojca/Elmulo-Reporter.git"
+  },
+  "license": "UNLICENSED",
+  "bugs": {
+    "url": "https://github.com/alejandrojca/Elmulo-Reporter/issues"
+  },
+  "homepage": "https://github.com/alejandrojca/Elmulo-Reporter#readme",
+  "devDependencies": {
+    "@napi-rs/canvas": "^0.1.100",
+    "pdfjs-dist": "^4.10.38"
+  }
+}

package/plugin.cjs

@@ -0,0 +1,249 @@
+const fs = require("node:fs");
+const path = require("node:path");
+const {
+  createRunId,
+  ensureDir,
+  normalizeCypressResults,
+  safeFileName,
+  stableId,
+  writeJson,
+} = require("./core.cjs");
+const {
+  isAllowedAttachment,
+  sanitizeLogEntry,
+  sanitizeText,
+} = require("./security.cjs");
+const { normalizeRerunArgs } = require("./rerun.cjs");
+
+const MAX_ATTACHMENT_BYTES = 5 * 1024 * 1024;
+
+function registerElmuloReporter(on, config, options = {}) {
+  const captureHttp =
+    options.captureHttp !== false &&
+    String(process.env.ELMULO_CAPTURE_HTTP || "true").toLowerCase() !== "false";
+  config.env = {
+    ...(config.env || {}),
+    elmulo: true,
+    elmuloCaptureHttp: captureHttp,
+  };
+  const projectRoot = config.projectRoot || process.cwd();
+  const outputDir = path.resolve(
+    projectRoot,
+    options.outputDir || process.env.ELMULO_OUTPUT_DIR || "elmulo-results",
+  );
+  let session = null;
+  const executionScript =
+    options.rerunScript ||
+    process.env.npm_lifecycle_event ||
+    process.env.ELMULO_RERUN_SCRIPT ||
+    "";
+  const executionArgs = normalizeRerunArgs(
+    options.rerunArgs ?? process.env.ELMULO_RERUN_ARGS_JSON,
+  );
+
+  function startSession(details = {}) {
+    const startedAt = details.startedTestsAt || new Date().toISOString();
+    const runId = createRunId(startedAt);
+    const runDir = path.join(outputDir, "runs", runId);
+    ensureDir(runDir);
+    session = { runId, runDir, startedAt };
+    writeJson(path.join(runDir, "session.json"), {
+      runId,
+      startedAt,
+      environment:
+        options.environment ||
+        config.env?.ENVIRONMENT ||
+        process.env.CYPRESS_ENVIRONMENT ||
+        "unknown",
+      tagExpression: config.env?.TAGS || process.env.CYPRESS_TAGS || "",
+      lifecycle: "running",
+      reporterVersion: "2.0.0-beta.5",
+      execution: executionScript
+        ? { runner: "npm", script: executionScript, args: executionArgs }
+        : null,
+    });
+    fs.writeFileSync(path.join(outputDir, "latest-run.txt"), runId, "utf8");
+    return session;
+  }
+
+  on("before:run", (details) => {
+    startSession(details);
+  });
+
+  on("after:run", (results) => {
+    if (!session) startSession(results);
+
+    const normalized = normalizeCypressResults(results, {
+      projectRoot,
+      runId: session.runId,
+      startedAt: session.startedAt,
+      environment:
+        options.environment ||
+        config.env?.ENVIRONMENT ||
+        process.env.CYPRESS_ENVIRONMENT ||
+        "unknown",
+      tagExpression: config.env?.TAGS || process.env.CYPRESS_TAGS || "",
+      projectName: config.projectName || "acceptance-tests",
+      execution: executionScript
+        ? { runner: "npm", script: executionScript, args: executionArgs }
+        : null,
+    });
+
+    const logManifestPath = path.join(session.runDir, "logs", "manifest.json");
+    if (fs.existsSync(logManifestPath)) {
+      const manifest = JSON.parse(fs.readFileSync(logManifestPath, "utf8"));
+      const logsByTest = new Map(
+        manifest.map((entry) => [entry.testKey, entry.logs || []]),
+      );
+
+      for (const test of normalized.tests) {
+        const exactKey = test.titlePath.join(" › ");
+        test.logs =
+          logsByTest.get(exactKey) ||
+          logsByTest.get(test.title) ||
+          [];
+      }
+    }
+
+    const httpManifestPath = path.join(session.runDir, "http", "manifest.json");
+    if (fs.existsSync(httpManifestPath)) {
+      const manifest = JSON.parse(fs.readFileSync(httpManifestPath, "utf8"));
+      const httpByTest = new Map(
+        manifest.map((entry) => [entry.testKey, entry.exchanges || []]),
+      );
+      for (const test of normalized.tests) {
+        const exactKey = test.titlePath.join(" › ");
+        test.http =
+          httpByTest.get(exactKey) ||
+          httpByTest.get(test.title) ||
+          [];
+      }
+    }
+
+    const attachmentManifestPath = path.join(
+      session.runDir,
+      "attachments",
+      "manifest.json",
+    );
+    if (fs.existsSync(attachmentManifestPath)) {
+      const manifest = JSON.parse(
+        fs.readFileSync(attachmentManifestPath, "utf8"),
+      );
+      normalized.attachments = manifest;
+      const attachmentsByTest = new Map();
+      for (const attachment of manifest) {
+        if (!attachmentsByTest.has(attachment.testKey)) {
+          attachmentsByTest.set(attachment.testKey, []);
+        }
+        attachmentsByTest.get(attachment.testKey).push(attachment);
+      }
+      for (const test of normalized.tests) {
+        test.attachments =
+          attachmentsByTest.get(test.titlePath.join(" › ")) ||
+          attachmentsByTest.get(test.title) ||
+          [];
+      }
+    }
+
+    writeJson(path.join(session.runDir, "run.raw.json"), normalized);
+    writeJson(path.join(session.runDir, "run.json"), normalized);
+    return null;
+  });
+
+  on("task", {
+    "elmulo:recordLogs"({ testKey, logs }) {
+      if (!session) startSession();
+      const logsDir = path.join(session.runDir, "logs");
+      ensureDir(logsDir);
+      const manifestPath = path.join(logsDir, "manifest.json");
+      const manifest = fs.existsSync(manifestPath)
+        ? JSON.parse(fs.readFileSync(manifestPath, "utf8"))
+        : [];
+      const entry = {
+        testKey: String(testKey || ""),
+        logs: Array.isArray(logs)
+          ? logs.slice(-500).map(sanitizeLogEntry)
+          : [],
+      };
+      const existingIndex = manifest.findIndex(
+        (item) => item.testKey === entry.testKey,
+      );
+      if (existingIndex >= 0) manifest[existingIndex] = entry;
+      else manifest.push(entry);
+      writeJson(manifestPath, manifest);
+      return null;
+    },
+
+    "elmulo:recordHttp"({ testKey, exchanges }) {
+      if (!session) startSession();
+      const httpDir = path.join(session.runDir, "http");
+      ensureDir(httpDir);
+      const manifestPath = path.join(httpDir, "manifest.json");
+      const manifest = fs.existsSync(manifestPath)
+        ? JSON.parse(fs.readFileSync(manifestPath, "utf8"))
+        : [];
+      const entry = {
+        testKey: String(testKey || ""),
+        // Deliberately unredacted: exact values are required for diagnosis.
+        exchanges: Array.isArray(exchanges) ? exchanges : [],
+      };
+      const existingIndex = manifest.findIndex(
+        (item) => item.testKey === entry.testKey,
+      );
+      if (existingIndex >= 0) manifest[existingIndex] = entry;
+      else manifest.push(entry);
+      writeJson(manifestPath, manifest);
+      return null;
+    },
+
+    "elmulo:attach"({ testKey, name, mimeType, content, encoding }) {
+      if (!session) startSession();
+      if (!isAllowedAttachment(mimeType)) {
+        throw new Error(`Tipo de adjunto no permitido: ${mimeType}`);
+      }
+      const attachmentsDir = path.join(session.runDir, "attachments");
+      ensureDir(attachmentsDir);
+      const id = stableId(testKey, name, Date.now().toString()).slice(0, 12);
+      const extension =
+        mimeType === "application/json"
+          ? ".json"
+          : mimeType === "text/plain"
+            ? ".txt"
+            : "";
+      const filename = `${id}-${safeFileName(name)}${extension}`;
+      const filePath = path.join(attachmentsDir, filename);
+      const serializedContent =
+        typeof content === "string"
+          ? sanitizeText(content, MAX_ATTACHMENT_BYTES)
+          : JSON.stringify(content, null, 2);
+      const byteLength = Buffer.byteLength(serializedContent, "utf8");
+      if (byteLength > MAX_ATTACHMENT_BYTES) {
+        throw new Error("El adjunto supera el límite de 5 MB.");
+      }
+      fs.writeFileSync(
+        filePath,
+        serializedContent,
+        encoding === "base64" ? "base64" : "utf8",
+      );
+
+      const manifestPath = path.join(attachmentsDir, "manifest.json");
+      const manifest = fs.existsSync(manifestPath)
+        ? JSON.parse(fs.readFileSync(manifestPath, "utf8"))
+        : [];
+      const attachment = {
+        id,
+        testKey: String(testKey || ""),
+        name: String(name || "Adjunto"),
+        mimeType: mimeType || "text/plain",
+        path: `attachments/${filename}`,
+      };
+      manifest.push(attachment);
+      writeJson(manifestPath, manifest);
+      return attachment;
+    },
+  });
+
+  return config;
+}
+
+module.exports = { registerElmuloReporter };

package/rerun.cjs

@@ -0,0 +1,298 @@
+const fs = require("node:fs");
+const path = require("node:path");
+const { spawn } = require("node:child_process");
+
+const TERMINAL_STATUSES = new Set(["completed", "failed"]);
+
+function normalizeRerunArgs(value) {
+  if (value === undefined || value === null || value === "") return null;
+  let parsed = value;
+  if (typeof value === "string") {
+    try {
+      parsed = JSON.parse(value);
+    } catch {
+      throw new Error("ELMULO_RERUN_ARGS_JSON debe contener un array JSON válido.");
+    }
+  }
+  if (!Array.isArray(parsed) || parsed.length > 100) {
+    throw new Error("Los argumentos de reejecución deben ser un array de hasta 100 valores.");
+  }
+  return parsed.map((argument) => {
+    if (!["string", "number", "boolean"].includes(typeof argument)) {
+      throw new Error("Cada argumento de reejecución debe ser texto, número o booleano.");
+    }
+    const normalized = String(argument);
+    if (normalized.includes("\0") || normalized.length > 4_000) {
+      throw new Error("Un argumento histórico no es seguro para reejecutar.");
+    }
+    return normalized;
+  });
+}
+
+function npmCliCandidates(projectRoot, options = {}) {
+  const candidates = [
+    options.npmCliPath,
+    process.env.npm_execpath,
+    path.join(path.dirname(process.execPath), "node_modules", "npm", "bin", "npm-cli.js"),
+    process.env.npm_config_prefix
+      ? path.join(process.env.npm_config_prefix, "node_modules", "npm", "bin", "npm-cli.js")
+      : "",
+  ];
+  const pathEntries = String(process.env.PATH || "").split(path.delimiter).filter(Boolean);
+  const npmNames = process.platform === "win32" ? ["npm.cmd", "npm"] : ["npm"];
+  for (const pathEntry of pathEntries) {
+    for (const npmName of npmNames) {
+      const npmPath = path.join(pathEntry, npmName);
+      if (!fs.existsSync(npmPath)) continue;
+      try {
+        const resolved = fs.realpathSync(npmPath);
+        if (/npm-cli\.(?:c?js)$/i.test(resolved)) candidates.push(resolved);
+      } catch {
+        // Ignore broken PATH entries and continue with deterministic candidates.
+      }
+      candidates.push(
+        path.join(path.dirname(npmPath), "node_modules", "npm", "bin", "npm-cli.js"),
+      );
+    }
+  }
+  candidates.push(
+    path.join(projectRoot, "node_modules", "npm", "bin", "npm-cli.js"),
+  );
+  return candidates.filter(Boolean);
+}
+
+function resolveNpmCli(projectRoot, options = {}) {
+  if (options.npmCliPath) {
+    const configuredPath = path.resolve(options.npmCliPath);
+    if (
+      /npm-cli\.(?:c?js)$/i.test(configuredPath) &&
+      fs.existsSync(configuredPath) &&
+      fs.statSync(configuredPath).isFile()
+    ) {
+      return configuredPath;
+    }
+    throw new Error("La ruta configurada para npm-cli.js no es válida.");
+  }
+  for (const candidate of npmCliCandidates(projectRoot, options)) {
+    const resolved = path.resolve(candidate);
+    if (
+      /npm-cli\.(?:c?js)$/i.test(resolved) &&
+      fs.existsSync(resolved) &&
+      fs.statSync(resolved).isFile()
+    ) {
+      return resolved;
+    }
+  }
+  throw new Error(
+    "No se encontró npm-cli.js. Iniciá Elmulo desde npm o configurá una instalación válida de npm.",
+  );
+}
+
+function readPackageScripts(projectRoot) {
+  const packagePath = path.join(projectRoot, "package.json");
+  if (!fs.existsSync(packagePath)) return {};
+  const packageJson = JSON.parse(fs.readFileSync(packagePath, "utf8"));
+  return packageJson.scripts && typeof packageJson.scripts === "object"
+    ? packageJson.scripts
+    : {};
+}
+
+function executionScriptFor(run, scripts, configuredScript = "") {
+  const environment = String(run.environment || "").trim().toLowerCase();
+  const capturedScript = String(run.execution?.script || "").trim();
+  const preferredScript = String(capturedScript || configuredScript).trim();
+
+  if (preferredScript) {
+    if (!Object.hasOwn(scripts, preferredScript)) {
+      throw new Error(
+        `El script de reejecución "${preferredScript}" ya no existe en package.json.`,
+      );
+    }
+    return preferredScript;
+  }
+
+  if (run.source?.commit === "demo" && Object.hasOwn(scripts, "demo")) {
+    return "demo";
+  }
+
+  const environmentToken = new RegExp(
+    `(^|[-_:])${environment.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}($|[-_:])`,
+    "i",
+  );
+  const candidates = Object.keys(scripts).filter(
+    (name) => /(^|[-_:])report($|[-_:])/i.test(name) && environmentToken.test(name),
+  );
+  if (candidates.length === 1) return candidates[0];
+  if (candidates.length > 1) {
+    throw new Error(
+      "Hay más de un script de reporte compatible. Configurá ELMULO_RERUN_SCRIPT para elegir uno.",
+    );
+  }
+  throw new Error(
+    "Esta corrida no registró el script que la originó y no se encontró uno compatible.",
+  );
+}
+
+function resolveRerunPlan(projectRoot, run, options = {}) {
+  const runId = String(run.id || "");
+  const environment = String(run.environment || "").trim();
+  const tagExpression = String(run.tag_expression ?? run.tagExpression ?? "").trim();
+  if (!/^[a-zA-Z0-9_-]+$/.test(runId)) {
+    throw new Error("La corrida histórica no tiene una identidad válida.");
+  }
+  if (!/^[a-zA-Z0-9_-]+$/.test(environment)) {
+    throw new Error("La corrida histórica no tiene un ambiente reutilizable.");
+  }
+  if (/[\0\r\n]/.test(tagExpression) || tagExpression.length > 4_000) {
+    throw new Error("La expresión de tags histórica no es segura para reejecutar.");
+  }
+
+  const scripts = readPackageScripts(projectRoot);
+  const script = executionScriptFor(
+    run,
+    scripts,
+    options.configuredScript || process.env.ELMULO_RERUN_SCRIPT,
+  );
+  const npmCliPath = resolveNpmCli(projectRoot, options);
+  const command = process.execPath;
+  const args = [npmCliPath, "run", script];
+  const historicalArgs = normalizeRerunArgs(run.execution?.args);
+  if (historicalArgs !== null) {
+    if (historicalArgs.length) args.push("--", ...historicalArgs);
+  } else if (tagExpression) {
+    args.push("--", tagExpression);
+  }
+
+  return {
+    command,
+    args,
+    cwd: projectRoot,
+    script,
+    rerunArgs: historicalArgs,
+    environment,
+    tagExpression,
+    env: {
+      ...process.env,
+      CYPRESS_ENVIRONMENT: environment,
+      CYPRESS_TAGS: tagExpression,
+      ELMULO_RERUN_OF: runId,
+    },
+  };
+}
+
+function publicStatus(status) {
+  if (!status) return null;
+  return {
+    runId: status.runId,
+    status: status.status,
+    script: status.script,
+    environment: status.environment,
+    tagExpression: status.tagExpression,
+    startedAt: status.startedAt,
+    finishedAt: status.finishedAt || null,
+    exitCode: status.exitCode ?? null,
+    error: status.error || "",
+  };
+}
+
+function createRerunManager(projectRoot, options = {}) {
+  const statuses = new Map();
+  let activeRunId = null;
+  const spawnProcess = options.spawnProcess || spawn;
+
+  function describe(run) {
+    const existing = publicStatus(statuses.get(run.id));
+    if (existing) return { available: true, ...existing };
+    try {
+      const plan = resolveRerunPlan(projectRoot, run, options);
+      return {
+        available: true,
+        runId: run.id,
+        status: "idle",
+        script: plan.script,
+        environment: plan.environment,
+        tagExpression: plan.tagExpression,
+      };
+    } catch (error) {
+      return {
+        available: false,
+        runId: run.id,
+        status: "unavailable",
+        reason: error.message,
+      };
+    }
+  }
+
+  function start(run) {
+    const activeStatus = activeRunId ? statuses.get(activeRunId) : null;
+    if (activeStatus && !TERMINAL_STATUSES.has(activeStatus.status)) {
+      throw new Error(
+        `Ya se está reejecutando la corrida ${activeRunId}. Esperá a que termine.`,
+      );
+    }
+
+    const plan = resolveRerunPlan(projectRoot, run, options);
+    const status = {
+      runId: run.id,
+      status: "running",
+      script: plan.script,
+      environment: plan.environment,
+      tagExpression: plan.tagExpression,
+      startedAt: new Date().toISOString(),
+      finishedAt: null,
+      exitCode: null,
+      error: "",
+    };
+    statuses.set(run.id, status);
+    activeRunId = run.id;
+
+    let child;
+    try {
+      child = spawnProcess(plan.command, plan.args, {
+        cwd: plan.cwd,
+        env: plan.env,
+        shell: false,
+        stdio: "ignore",
+        windowsHide: true,
+      });
+    } catch (error) {
+      status.status = "failed";
+      status.error = error.message;
+      status.finishedAt = new Date().toISOString();
+      activeRunId = null;
+      throw error;
+    }
+
+    child.once("error", (error) => {
+      status.status = "failed";
+      status.error = error.message;
+      status.finishedAt = new Date().toISOString();
+      if (activeRunId === run.id) activeRunId = null;
+    });
+    child.once("exit", (exitCode) => {
+      status.exitCode = exitCode;
+      status.status = exitCode === 0 ? "completed" : "failed";
+      status.error = exitCode === 0
+        ? ""
+        : `El script de reporte terminó con código ${exitCode}.`;
+      status.finishedAt = new Date().toISOString();
+      if (activeRunId === run.id) activeRunId = null;
+    });
+
+    return publicStatus(status);
+  }
+
+  function get(runId) {
+    return publicStatus(statuses.get(runId));
+  }
+
+  return { describe, get, start };
+}
+
+module.exports = {
+  createRerunManager,
+  executionScriptFor,
+  normalizeRerunArgs,
+  resolveNpmCli,
+  resolveRerunPlan,
+};

package/security.cjs

@@ -0,0 +1,56 @@
+const DEFAULT_MAX_TEXT_LENGTH = 20_000;
+const SECRET_PATTERN =
+  /((?:authorization|api[-_]?key|token|secret|password|passwd|cookie|set-cookie)\s*[:=]\s*)([^\s,;]+)/gi;
+const BEARER_PATTERN = /\b(Bearer\s+)[A-Za-z0-9._~+/=-]+/gi;
+const CARD_PATTERN = /\b(?:\d[ -]*?){13,19}\b/g;
+
+function redactSecrets(value) {
+  return String(value ?? "")
+    .replace(BEARER_PATTERN, "$1[REDACTADO]")
+    .replace(SECRET_PATTERN, "$1[REDACTADO]")
+    .replace(CARD_PATTERN, (candidate) => {
+      const digits = candidate.replace(/\D/g, "");
+      return digits.length >= 13 ? `[TARJETA ****${digits.slice(-4)}]` : candidate;
+    });
+}
+
+function sanitizeText(value, maxLength = DEFAULT_MAX_TEXT_LENGTH) {
+  return redactSecrets(value)
+    .replace(/\u0000/g, "")
+    .slice(0, maxLength);
+}
+
+function sanitizeLogEntry(entry = {}) {
+  return {
+    name: sanitizeText(entry.name || "command", 120),
+    message: sanitizeText(entry.message || "", 8_000),
+    timestamp: Number.isFinite(Date.parse(entry.timestamp || ""))
+      ? new Date(entry.timestamp).toISOString()
+      : new Date().toISOString(),
+  };
+}
+
+function normalizeActor(value) {
+  return sanitizeText(value || "Usuario local", 120).trim() || "Usuario local";
+}
+
+function isAllowedAttachment(mimeType) {
+  return new Set([
+    "application/json",
+    "application/pdf",
+    "image/jpeg",
+    "image/png",
+    "text/csv",
+    "text/plain",
+    "video/mp4",
+  ]).has(String(mimeType || "").toLowerCase());
+}
+
+module.exports = {
+  DEFAULT_MAX_TEXT_LENGTH,
+  isAllowedAttachment,
+  normalizeActor,
+  redactSecrets,
+  sanitizeLogEntry,
+  sanitizeText,
+};