allure-report-manager 1.0.1

package/README.md

@@ -0,0 +1,141 @@
+# Allure Results Manager
+
+Dashboard that parses a raw Allure results folder, lists every test case with
+its status grouped by suite, and lets you override a test's status (with a
+reason) — stats recalculate immediately to reflect the override.
+
+## Install
+
+Install it in any project as a dev dependency:
+
+```bash
+npm install --save-dev allure-results-manager
+```
+
+or run it without installing:
+
+```bash
+npx allure-results-manager --results ./allure-results
+```
+
+The Allure 3 CLI (the `allure` npm package, no Java needed) comes bundled as
+a dependency, so **Open Allure Report** works without a global install. If the
+bundled copy can't be found, it falls back to `allure` on `PATH`, which
+must be Allure 3 (`allure --version` → `3.x`), not the Java-based Allure 2
+or the old `allure-commandline` package.
+
+## Run
+
+```bash
+npx allure-results-manager [options]
+```
+
+| Flag | Env var | Default |
+| --- | --- | --- |
+| `-r, --results <dir>` | `ALLURE_RESULTS_PATH` | `./allure-results` |
+| `-o, --report <dir>` | `ALLURE_REPORT_PATH` | `./allure-report` |
+| `-d, --data-dir <dir>` | `ALLURE_MANAGER_DATA_DIR` | `./.allure-results-manager` |
+| `-p, --port <port>` | `ALLURE_MANAGER_PORT` | `4400` |
+| `--host <host>` | `ALLURE_MANAGER_HOST` | `localhost` |
+| `--env-file <file>` | | `./.env` if present |
+| `--open` | | opens the dashboard in your browser |
+
+Flags win over env vars, and env vars win over defaults. Relative paths
+resolve from the directory you run the command in. A `.env` in that
+directory is loaded if present (see `.env.example`). Real environment
+variables take precedence over values in `.env`.
+
+A typical `package.json` script in the consuming project:
+
+```json
+"scripts": {
+  "allure:manage": "allure-results-manager --results ./allure-results --open"
+}
+```
+
+Add `.allure-results-manager/` (the overrides store) and your report folder
+to that project's `.gitignore`, unless you want overrides committed.
+
+### Programmatic use
+
+```js
+const { startServer, createApp } = require("allure-results-manager");
+
+const { url, server } = await startServer({
+  resultsPath: "./allure-results",
+  reportPath: "./allure-report",
+  port: 4400,
+});
+// or mount createApp({...}) inside your own Express/http server.
+```
+
+### Developing this package
+
+```bash
+npm install
+npm start          # runs the CLI against ./allure-results
+npm pack           # builds the tarball to test-install elsewhere
+```
+
+## How it works
+
+- The server scans `ALLURE_RESULTS_PATH` for `*-result.json` files and loads
+  every test case (any status), deduping reruns by `historyId` and keeping
+  the latest attempt.
+- Test cases are grouped into collapsible sections by suite (`subSuite`,
+  falling back to `suite`/`package`), so you can see which section each case
+  belongs to. Sections default to collapsed; click a header to expand it.
+  Each section header shows its own pass/fail/broken/skipped/unknown counts.
+- Each test card shows its status, message/trace, its own recorded steps
+  (nested, with per-step pass/fail status — via **Steps (N)**), and a
+  **Change status** action to set a new status (`passed`, `failed`, `broken`,
+  `skipped`, `unknown`) plus a reason. **Revert to original** clears the
+  override. Fixture (`@Before`/`@After`) steps are intentionally excluded —
+  only the test's own steps are shown.
+- Overrides persist in `.allure-results-manager/overrides.json`, keyed by test id, and are
+  applied on top of the raw Allure status whenever tests are loaded.
+  Setting a status also **rewrites the `status`/`statusDetails` fields of the
+  underlying `*-result.json` file** (everything else — steps, labels,
+  attachments — is left untouched), so `allure generate`/`allure serve` on
+  the same `ALLURE_RESULTS_PATH` will reflect the change too. The
+  `statusDetails.message`/`trace` are replaced with a note recording the new
+  status, reason, and timestamp (with the original trace appended). The
+  test's original status/message/trace are snapshotted in
+  `.allure-results-manager/overrides.json` the first time it's overridden; **Revert to
+  original** restores them in the raw file and clears the override.
+- The stats tiles at the top are computed from the *effective* status
+  (original status with any override applied) across **all** tests,
+  regardless of the current filter/search — so changing a test's status
+  immediately updates the pass/fail/broken/skipped/unknown counts and pass
+  rate. Clicking a status tile (Total/Passed/Failed/Broken/Skipped/Unknown)
+  filters the list to that status and auto-expands the matching sections.
+- The status dropdown and the search box (matches test name) both filter the
+  grouped list; a search or status filter is active auto-expands sections so
+  matches are immediately visible.
+- **Overrides modify the raw results.** `.allure-results-manager/overrides.json` is the source
+  of truth for the original status (used to restore on revert) and is what
+  the dashboard reads to know which tests are overridden, but the raw
+  `*-result.json` file for the test is edited in place too. If
+  `.allure-results-manager/overrides.json` is deleted or lost after a test has been overridden,
+  the original status can no longer be restored automatically.
+- **Open Allure Report** (top-right button) runs `allure generate` against
+  `ALLURE_RESULTS_PATH` into `ALLURE_REPORT_PATH` (the folder is deleted and regenerated fresh each time,
+  and paths such as the project root or the results folder are refused) and opens it in a new tab at `/report/`.
+  Since overrides are written through to the raw result files, the report
+  reflects any status changes made here.
+
+## API
+
+- `GET /api/status` — Allure results path and whether it exists.
+- `GET /api/tests?status=&search=&page=&pageSize=` — flat, paginated list of
+  test cases with effective status and any override (`pageSize` default 50,
+  max 200).
+- `GET /api/tests/grouped?status=&search=` — test cases grouped by suite,
+  each group with its own `stats` block (used by the dashboard).
+- `GET /api/stats` — counts by status, override count, and pass rate across
+  all tests.
+- `PUT /api/tests/:id/status` — body `{ status, reason }`, sets an override.
+- `DELETE /api/tests/:id/status` — clears the override for a test.
+- `GET /api/report/status` — report path and whether it's been generated.
+- `POST /api/report/generate` — runs `allure generate` and returns
+  `{ reportUrl }` to open.

package/bin/allure-results-manager.js

@@ -0,0 +1,95 @@
+#!/usr/bin/env node
+const path = require("path");
+const { parseArgs } = require("util");
+const { spawn } = require("child_process");
+
+const HELP = `Usage: allure-results-manager [options]
+
+Dashboard for reviewing Allure raw results and overriding test statuses.
+
+Options:
+  -r, --results <dir>   Allure raw results folder     (env ALLURE_RESULTS_PATH, default ./allure-results)
+  -o, --report <dir>    Generated HTML report folder  (env ALLURE_REPORT_PATH,  default ./allure-report)
+  -d, --data-dir <dir>  Where overrides are stored    (env ALLURE_MANAGER_DATA_DIR, default ./.allure-results-manager)
+  -p, --port <port>     Port to listen on             (env ALLURE_MANAGER_PORT, default 4400)
+      --host <host>     Host to bind                  (env ALLURE_MANAGER_HOST, default localhost)
+      --env-file <file> Load env vars from this file  (default ./.env if present)
+      --open            Open the dashboard in a browser once started
+  -h, --help            Show this help
+  -v, --version         Show version
+
+Relative paths are resolved from the current working directory.`;
+
+function openBrowser(url) {
+  const [cmd, args] =
+    process.platform === "win32"
+      ? ["cmd", ["/c", "start", "", url]]
+      : process.platform === "darwin"
+        ? ["open", [url]]
+        : ["xdg-open", [url]];
+  spawn(cmd, args, { stdio: "ignore", detached: true }).on("error", () => {}).unref();
+}
+
+async function main() {
+  let parsed;
+  try {
+    parsed = parseArgs({
+      options: {
+        results: { type: "string", short: "r" },
+        report: { type: "string", short: "o" },
+        "data-dir": { type: "string", short: "d" },
+        port: { type: "string", short: "p" },
+        host: { type: "string" },
+        "env-file": { type: "string" },
+        open: { type: "boolean" },
+        help: { type: "boolean", short: "h" },
+        version: { type: "boolean", short: "v" },
+      },
+    });
+  } catch (err) {
+    console.error(`${err.message}\n\n${HELP}`);
+    process.exit(1);
+  }
+  const { values } = parsed;
+
+  if (values.help) {
+    console.log(HELP);
+    return;
+  }
+  if (values.version) {
+    console.log(require("../package.json").version);
+    return;
+  }
+
+  // Load the consuming project's .env without overriding real env vars.
+  require("dotenv").config({
+    path: path.resolve(values["env-file"] || ".env"),
+    quiet: true,
+  });
+
+  const { startServer } = require("../lib/server");
+
+  try {
+    const { url, config } = await startServer({
+      resultsPath: values.results,
+      reportPath: values.report,
+      dataDir: values["data-dir"],
+      port: values.port,
+      host: values.host,
+    });
+    console.log(`Allure Results Manager running at ${url}`);
+    console.log(`Allure results: ${config.resultsPath}`);
+    console.log(`Allure report:  ${config.reportPath}`);
+    console.log(`Overrides:      ${path.join(config.dataDir, "overrides.json")}`);
+    if (values.open) openBrowser(url);
+  } catch (err) {
+    if (err.code === "EADDRINUSE") {
+      console.error(`Port ${err.port} is already in use. Pick another with --port.`);
+    } else {
+      console.error(err.message);
+    }
+    process.exit(1);
+  }
+}
+
+main();

package/dashboard/index.html

@@ -0,0 +1,527 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8" />
+<meta name="viewport" content="width=device-width, initial-scale=1.0" />
+<title>Allure Results Manager</title>
+<style>
+  :root {
+    --bg: #0f1115;
+    --panel: #171a21;
+    --panel-border: #262b36;
+    --text: #e6e9ef;
+    --muted: #8891a3;
+    --accent: #4f8cff;
+    --danger: #e5484d;
+    --danger-bg: rgba(229, 72, 77, 0.12);
+    --success: #3ecf8e;
+    --success-bg: rgba(62, 207, 142, 0.12);
+    --warn: #f5a623;
+    --warn-bg: rgba(245, 166, 35, 0.12);
+    --neutral: #8891a3;
+    --neutral-bg: rgba(136, 145, 163, 0.12);
+    --radius: 10px;
+  }
+  * { box-sizing: border-box; }
+  body {
+    margin: 0;
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
+    background: var(--bg);
+    color: var(--text);
+  }
+  header {
+    padding: 20px 28px;
+    border-bottom: 1px solid var(--panel-border);
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    flex-wrap: wrap;
+    gap: 12px;
+  }
+  header h1 { font-size: 18px; margin: 0; font-weight: 600; }
+  header h1 span { color: var(--muted); font-weight: 400; }
+  #status-bar {
+    display: flex;
+    gap: 16px;
+    font-size: 13px;
+    color: var(--muted);
+    flex-wrap: wrap;
+  }
+  .status-dot { display: inline-block; width: 8px; height: 8px; border-radius: 50%; margin-right: 6px; }
+  .dot-ok { background: var(--success); }
+  .dot-bad { background: var(--danger); }
+  main { padding: 24px 28px; max-width: 1100px; margin: 0 auto; }
+
+  .stats {
+    display: flex;
+    gap: 10px;
+    flex-wrap: wrap;
+    margin-bottom: 18px;
+  }
+  .stat-tile {
+    background: var(--panel);
+    border: 1px solid var(--panel-border);
+    border-radius: var(--radius);
+    padding: 10px 16px;
+    min-width: 96px;
+  }
+  .stat-tile.clickable { cursor: pointer; }
+  .stat-tile.clickable:hover { border-color: var(--accent); }
+  .stat-tile.active { border-color: var(--accent); background: rgba(79, 140, 255, 0.08); }
+  .stat-tile .value { font-size: 20px; font-weight: 700; }
+  .stat-tile .label { font-size: 11px; text-transform: uppercase; letter-spacing: 0.04em; color: var(--muted); margin-top: 2px; }
+  .stat-total .value { color: var(--text); }
+  .stat-passed .value { color: var(--success); }
+  .stat-failed .value { color: var(--danger); }
+  .stat-broken .value { color: var(--warn); }
+  .stat-skipped .value { color: var(--neutral); }
+  .stat-unknown .value { color: var(--neutral); }
+  .stat-overridden .value { color: var(--accent); }
+
+  .toolbar { display: flex; justify-content: space-between; align-items: center; margin-bottom: 16px; gap: 12px; flex-wrap: wrap; }
+  .toolbar .counts { font-size: 13px; color: var(--muted); }
+  .toolbar .controls { display: flex; gap: 8px; align-items: center; }
+  select, button.refresh, #search-box {
+    background: var(--panel);
+    border: 1px solid var(--panel-border);
+    color: var(--text);
+    padding: 8px 14px;
+    border-radius: var(--radius);
+    cursor: pointer;
+    font-size: 13px;
+  }
+  #search-box { cursor: text; width: 220px; font-family: inherit; }
+  #search-box::placeholder { color: var(--muted); }
+  button.refresh:hover, select:hover, #search-box:focus { border-color: var(--accent); outline: none; }
+
+  .card {
+    background: var(--panel);
+    border: 1px solid var(--panel-border);
+    border-radius: var(--radius);
+    padding: 16px 18px;
+    margin-bottom: 12px;
+  }
+  .card-head { display: flex; justify-content: space-between; align-items: flex-start; gap: 12px; }
+  .card-title { font-size: 14px; font-weight: 600; margin: 0 0 4px; }
+  .card-suite { font-size: 12px; color: var(--muted); }
+  .badge {
+    font-size: 11px;
+    font-weight: 600;
+    text-transform: uppercase;
+    letter-spacing: 0.03em;
+    padding: 3px 8px;
+    border-radius: 999px;
+    white-space: nowrap;
+  }
+  .badge-passed { background: var(--success-bg); color: var(--success); }
+  .badge-failed { background: var(--danger-bg); color: var(--danger); }
+  .badge-broken { background: var(--warn-bg); color: var(--warn); }
+  .badge-skipped, .badge-unknown { background: var(--neutral-bg); color: var(--neutral); }
+  .original-status { font-size: 11px; color: var(--muted); text-decoration: line-through; margin-right: 6px; }
+  .message {
+    margin-top: 10px;
+    font-size: 12px;
+    font-family: "SFMono-Regular", Consolas, monospace;
+    background: #0b0d11;
+    border: 1px solid var(--panel-border);
+    border-radius: 8px;
+    padding: 10px 12px;
+    color: #c9cdd6;
+    white-space: pre-wrap;
+    max-height: 140px;
+    overflow-y: auto;
+  }
+  .override-note { margin-top: 10px; font-size: 13px; color: var(--accent); }
+  .steps {
+    margin-top: 10px;
+    background: #0b0d11;
+    border: 1px solid var(--panel-border);
+    border-radius: 8px;
+    padding: 10px 14px;
+    max-height: 260px;
+    overflow-y: auto;
+  }
+  .steps ul { list-style: none; margin: 0; padding-left: 16px; }
+  .steps > ul { padding-left: 0; }
+  .steps li { margin: 4px 0; font-size: 12.5px; }
+  .step-row { display: flex; align-items: center; gap: 8px; }
+  .step-dot { flex: 0 0 auto; width: 7px; height: 7px; border-radius: 50%; }
+  .step-dot-passed { background: var(--success); }
+  .step-dot-failed { background: var(--danger); }
+  .step-dot-broken { background: var(--warn); }
+  .step-dot-skipped, .step-dot-unknown { background: var(--neutral); }
+  .step-name { color: var(--text); }
+  .step-attachment { color: var(--muted); font-size: 11px; margin-left: 15px; }
+  .steps-empty { color: var(--muted); font-size: 12px; }
+  .hidden { display: none; }
+  .actions { display: flex; gap: 8px; margin-top: 12px; }
+  .actions button {
+    border: none;
+    border-radius: 8px;
+    padding: 7px 14px;
+    font-size: 13px;
+    cursor: pointer;
+    font-weight: 600;
+  }
+  .btn-edit { background: var(--accent); color: #04122c; }
+  .btn-steps { background: transparent; color: var(--text); border: 1px solid var(--panel-border) !important; }
+  .btn-revert { background: transparent; color: var(--muted); border: 1px solid var(--panel-border) !important; }
+  .empty { text-align: center; color: var(--muted); padding: 60px 0; }
+
+  .section { margin-bottom: 18px; }
+  .section-header {
+    display: flex; align-items: center; justify-content: space-between; gap: 12px;
+    background: var(--panel); border: 1px solid var(--panel-border); border-radius: var(--radius);
+    padding: 12px 16px; cursor: pointer; user-select: none;
+  }
+  .section-header:hover { border-color: var(--accent); }
+  .section-title { display: flex; align-items: center; gap: 10px; }
+  .section-chevron { color: var(--muted); font-size: 11px; transition: transform 0.15s ease; }
+  .section-chevron.collapsed { transform: rotate(-90deg); }
+  .section-name { font-size: 14px; font-weight: 600; }
+  .section-breadcrumb { font-size: 11px; color: var(--muted); }
+  .section-counts { display: flex; gap: 8px; align-items: center; font-size: 12px; }
+  .section-count { color: var(--muted); }
+  .section-count b { color: var(--text); }
+  .section-body { padding-top: 12px; }
+  .section-body.collapsed { display: none; }
+
+  .modal-backdrop {
+    position: fixed; inset: 0; background: rgba(0,0,0,0.5);
+    display: flex; align-items: center; justify-content: center;
+    z-index: 10;
+  }
+  .modal {
+    background: var(--panel); border: 1px solid var(--panel-border);
+    border-radius: var(--radius); padding: 24px; width: 480px; max-width: 94vw;
+    max-height: 88vh; overflow-y: auto;
+  }
+  .modal h2 { margin: 0 0 12px; font-size: 16px; }
+  .modal label { font-size: 12px; color: var(--muted); display: block; margin: 10px 0 4px; }
+  .modal input, .modal textarea, .modal select {
+    width: 100%; background: #0b0d11; border: 1px solid var(--panel-border);
+    color: var(--text); border-radius: 8px; padding: 8px 10px; font-size: 13px;
+    font-family: inherit;
+  }
+  .modal textarea { min-height: 100px; resize: vertical; }
+  .modal-actions { display: flex; justify-content: flex-end; gap: 8px; margin-top: 16px; }
+  .modal-actions button { border: none; border-radius: 8px; padding: 8px 16px; font-size: 13px; cursor: pointer; font-weight: 600; }
+  .btn-save { background: var(--accent); color: #04122c; }
+  .btn-cancel { background: transparent; color: var(--muted); border: 1px solid var(--panel-border) !important; }
+</style>
+</head>
+<body>
+
+<header>
+  <h1>Allure Results Manager <span>&mdash; test case status &amp; stats</span></h1>
+  <div id="status-bar">Loading status&hellip;</div>
+  <button class="refresh" id="btn-open-report" onclick="openAllureReport()">Open Allure Report</button>
+</header>
+
+<main>
+  <div class="stats" id="stats"></div>
+  <div class="toolbar">
+    <div class="counts" id="counts"></div>
+    <div class="controls">
+      <input id="search-box" type="search" placeholder="Search by test name&hellip;" oninput="onSearchInput()" />
+      <select id="filter-status" onchange="onFilterChange()">
+        <option value="">All statuses</option>
+        <option value="passed">Passed</option>
+        <option value="failed">Failed</option>
+        <option value="broken">Broken</option>
+        <option value="skipped">Skipped</option>
+        <option value="unknown">Unknown</option>
+      </select>
+      <button class="refresh" onclick="loadAll()">Refresh</button>
+    </div>
+  </div>
+  <div id="list"></div>
+</main>
+
+<div id="modal-root"></div>
+
+<script>
+let currentTests = [];
+let lastStats = null;
+const state = { status: '', search: '' };
+const expandedSections = new Set();
+let searchDebounce = null;
+
+async function loadStatus() {
+  const res = await fetch('/api/status');
+  const s = await res.json();
+  const bar = document.getElementById('status-bar');
+  bar.innerHTML = `
+    <span><span class="status-dot ${s.allureResultsExists ? 'dot-ok' : 'dot-bad'}"></span>Allure results ${s.allureResultsExists ? 'found' : 'missing'}: ${escapeHtml(s.allureResultsPath)}</span>
+  `;
+}
+
+function escapeHtml(str) {
+  return String(str || '').replace(/[&<>"']/g, (c) => ({
+    '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;'
+  }[c]));
+}
+
+function renderStats(stats) {
+  const tiles = [
+    { key: '', label: 'Total', value: stats.total, cls: 'stat-total', clickable: true },
+    { key: 'passed', label: 'Passed', value: stats.byStatus.passed || 0, cls: 'stat-passed', clickable: true },
+    { key: 'failed', label: 'Failed', value: stats.byStatus.failed || 0, cls: 'stat-failed', clickable: true },
+    { key: 'broken', label: 'Broken', value: stats.byStatus.broken || 0, cls: 'stat-broken', clickable: true },
+    { key: 'skipped', label: 'Skipped', value: stats.byStatus.skipped || 0, cls: 'stat-skipped', clickable: true },
+    { key: 'unknown', label: 'Unknown', value: stats.byStatus.unknown || 0, cls: 'stat-unknown', clickable: true },
+    { key: null, label: 'Overridden', value: stats.overridden, cls: 'stat-overridden', clickable: false },
+    { key: null, label: 'Pass rate', value: stats.passRate + '%', cls: 'stat-passed', clickable: false },
+  ];
+  document.getElementById('stats').innerHTML = tiles.map(t => {
+    const active = t.clickable && state.status === t.key;
+    const classes = ['stat-tile', t.cls, t.clickable ? 'clickable' : '', active ? 'active' : ''].filter(Boolean).join(' ');
+    const click = t.clickable ? ` onclick="onStatClick('${t.key}')"` : '';
+    return `
+      <div class="${classes}"${click}>
+        <div class="value">${t.value}</div>
+        <div class="label">${t.label}</div>
+      </div>
+    `;
+  }).join('');
+}
+
+function onStatClick(status) {
+  state.status = status;
+  document.getElementById('filter-status').value = status;
+  if (lastStats) renderStats(lastStats);
+  refreshTests();
+}
+
+function renderSteps(steps) {
+  if (!steps || steps.length === 0) {
+    return '<div class="steps-empty">No steps recorded.</div>';
+  }
+  return `<ul>${renderStepItems(steps)}</ul>`;
+}
+
+function renderStepItems(steps) {
+  return steps.map((step) => `
+    <li>
+      <div class="step-row">
+        <span class="step-dot step-dot-${step.status}"></span>
+        <span class="step-name">${escapeHtml(step.name)}</span>
+      </div>
+      ${(step.attachments || []).map(a => `<div class="step-attachment">&#128206; ${escapeHtml(a)}</div>`).join('')}
+      ${step.steps && step.steps.length ? `<ul>${renderStepItems(step.steps)}</ul>` : ''}
+    </li>
+  `).join('');
+}
+
+function toggleSteps(id) {
+  const el = document.getElementById(`steps-${id}`);
+  if (!el) return;
+  el.classList.toggle('hidden');
+  if (!el.classList.contains('hidden') && !el.dataset.rendered) {
+    const test = currentTests.find(t => t.id === id);
+    el.innerHTML = renderSteps(test.steps);
+    el.dataset.rendered = '1';
+  }
+}
+
+function renderCard(test) {
+  const wasOverridden = !!test.override;
+  const stepCount = (test.steps || []).length;
+  return `
+    <div class="card" data-id="${escapeHtml(test.id)}">
+      <div class="card-head">
+        <div>
+          <p class="card-title">${escapeHtml(test.name)}</p>
+          <div class="card-suite">${escapeHtml(test.suite || test.fullName)}</div>
+        </div>
+        <div style="display:flex; gap:6px; align-items:center;">
+          ${wasOverridden ? `<span class="original-status">${escapeHtml(test.originalStatus)}</span>` : ''}
+          <span class="badge badge-${test.status}">${escapeHtml(test.status)}</span>
+        </div>
+      </div>
+      ${test.statusMessage ? `<div class="message">${escapeHtml(test.statusMessage)}</div>` : ''}
+      ${wasOverridden ? `<div class="override-note">Status overridden${test.override.reason ? ': ' + escapeHtml(test.override.reason) : ''}</div>` : ''}
+      <div class="actions">
+        <button class="btn-edit" onclick="openEdit('${escapeHtml(test.id)}')">Change status</button>
+        <button class="btn-steps" onclick="toggleSteps('${escapeHtml(test.id)}')">Steps (${stepCount})</button>
+        ${wasOverridden ? `<button class="btn-revert" onclick="revert('${escapeHtml(test.id)}')">Revert to original</button>` : ''}
+      </div>
+      <div class="steps hidden" id="steps-${escapeHtml(test.id)}"></div>
+    </div>
+  `;
+}
+
+function sectionCountsHtml(stats) {
+  const parts = [
+    ['passed', stats.byStatus.passed || 0],
+    ['failed', stats.byStatus.failed || 0],
+    ['broken', stats.byStatus.broken || 0],
+    ['skipped', stats.byStatus.skipped || 0],
+    ['unknown', stats.byStatus.unknown || 0],
+  ].filter(([, count]) => count > 0);
+  return parts.map(([status, count]) => `<span class="section-count">${count} <b class="badge badge-${status}" style="padding:1px 6px;">${status}</b></span>`).join('');
+}
+
+function renderSection(group) {
+  const collapsed = !state.search && !state.status && !expandedSections.has(group.key);
+  const breadcrumb = [group.parentSuite, group.suite].filter(Boolean).filter(v => v !== group.subSuite).join(' / ');
+  return `
+    <div class="section">
+      <div class="section-header" data-key="${escapeHtml(group.key)}" onclick="toggleSection(this)">
+        <div class="section-title">
+          <span class="section-chevron ${collapsed ? 'collapsed' : ''}">&#9660;</span>
+          <div>
+            <div class="section-name">${escapeHtml(group.subSuite || group.suite || group.key)} <span style="color:var(--muted); font-weight:400;">(${group.stats.total})</span></div>
+            ${breadcrumb ? `<div class="section-breadcrumb">${escapeHtml(breadcrumb)}</div>` : ''}
+          </div>
+        </div>
+        <div class="section-counts">${sectionCountsHtml(group.stats)}</div>
+      </div>
+      <div class="section-body ${collapsed ? 'collapsed' : ''}">
+        ${group.tests.map(renderCard).join('')}
+      </div>
+    </div>
+  `;
+}
+
+function toggleSection(header) {
+  const key = header.dataset.key;
+  if (expandedSections.has(key)) {
+    expandedSections.delete(key);
+  } else {
+    expandedSections.add(key);
+  }
+  header.querySelector('.section-chevron').classList.toggle('collapsed');
+  header.nextElementSibling.classList.toggle('collapsed');
+}
+
+function renderList(data) {
+  const list = document.getElementById('list');
+  const counts = document.getElementById('counts');
+
+  counts.textContent = data.total === 0
+    ? 'No test cases found'
+    : `Showing ${data.total} test case(s) across ${data.groups.length} section(s)${state.status ? ' — filtered by ' + state.status : ''}`;
+
+  list.innerHTML = data.groups.length === 0
+    ? '<div class="empty">No test cases match this filter.</div>'
+    : data.groups.map(renderSection).join('');
+}
+
+async function fetchGroupedTests() {
+  const params = new URLSearchParams();
+  if (state.status) params.set('status', state.status);
+  if (state.search) params.set('search', state.search);
+  const res = await fetch(`/api/tests/grouped?${params.toString()}`);
+  return res.json();
+}
+
+async function refreshTests() {
+  const data = await fetchGroupedTests();
+  currentTests = data.groups.flatMap(g => g.tests);
+  renderList(data);
+}
+
+async function loadAll() {
+  await loadStatus();
+  const [testsData, statsRes] = await Promise.all([fetchGroupedTests(), fetch('/api/stats')]);
+  currentTests = testsData.groups.flatMap(g => g.tests);
+  lastStats = await statsRes.json();
+  renderStats(lastStats);
+  renderList(testsData);
+}
+
+function onFilterChange() {
+  state.status = document.getElementById('filter-status').value;
+  if (lastStats) renderStats(lastStats);
+  refreshTests();
+}
+
+function onSearchInput() {
+  clearTimeout(searchDebounce);
+  searchDebounce = setTimeout(() => {
+    state.search = document.getElementById('search-box').value;
+    refreshTests();
+  }, 250);
+}
+
+function closeModal() {
+  document.getElementById('modal-root').innerHTML = '';
+}
+
+function openEdit(id) {
+  const test = currentTests.find(t => t.id === id);
+  const options = ['passed', 'failed', 'broken', 'skipped', 'unknown']
+    .map(s => `<option value="${s}" ${s === test.status ? 'selected' : ''}>${s}</option>`)
+    .join('');
+
+  document.getElementById('modal-root').innerHTML = `
+    <div class="modal-backdrop">
+      <div class="modal">
+        <h2>Change status: ${escapeHtml(test.name)}</h2>
+        <label>Status</label>
+        <select id="edit-status">${options}</select>
+        <label>Reason</label>
+        <textarea id="edit-reason" placeholder="Why is this status being changed?">${escapeHtml(test.override ? test.override.reason : '')}</textarea>
+        <div class="modal-actions">
+          <button class="btn-cancel" onclick="closeModal()">Cancel</button>
+          <button class="btn-save" onclick="submitEdit('${escapeHtml(id)}')">Save</button>
+        </div>
+      </div>
+    </div>
+  `;
+}
+
+async function submitEdit(id) {
+  const status = document.getElementById('edit-status').value;
+  const reason = document.getElementById('edit-reason').value;
+
+  const res = await fetch(`/api/tests/${encodeURIComponent(id)}/status`, {
+    method: 'PUT',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ status, reason })
+  });
+  const data = await res.json().catch(() => ({}));
+  if (!res.ok) {
+    alert(data.error || 'Failed to update status');
+    return;
+  }
+  closeModal();
+  await loadAll();
+}
+
+async function revert(id) {
+  const res = await fetch(`/api/tests/${encodeURIComponent(id)}/status`, { method: 'DELETE' });
+  if (!res.ok) {
+    const data = await res.json().catch(() => ({}));
+    alert(data.error || 'Failed to revert status');
+    return;
+  }
+  await loadAll();
+}
+
+async function openAllureReport() {
+  const btn = document.getElementById('btn-open-report');
+  const original = btn.textContent;
+  btn.disabled = true;
+  btn.textContent = 'Generating report…';
+  try {
+    const res = await fetch('/api/report/generate', { method: 'POST' });
+    const data = await res.json().catch(() => ({}));
+    if (!res.ok) {
+      alert(data.error || 'Failed to generate Allure report');
+      return;
+    }
+    window.open(data.reportUrl, '_blank');
+  } catch (err) {
+    alert('Failed to generate Allure report');
+  } finally {
+    btn.disabled = false;
+    btn.textContent = original;
+  }
+}
+
+loadAll();
+</script>
+</body>
+</html>

package/index.js

@@ -0,0 +1,15 @@
+const { createApp, startServer } = require("./lib/server");
+const { resolveConfig } = require("./lib/config");
+const { createStore } = require("./lib/store");
+const { loadAllTests, STATUSES } = require("./lib/allure");
+const { computeStats } = require("./lib/stats");
+
+module.exports = {
+  createApp,
+  startServer,
+  resolveConfig,
+  createStore,
+  loadAllTests,
+  computeStats,
+  STATUSES,
+};

package/lib/allure-cli.js

@@ -0,0 +1,53 @@
+const fs = require("fs");
+const path = require("path");
+const { execFile } = require("child_process");
+
+/**
+ * Finds the `cli.js` of the bundled `allure` (Allure 3) dependency. The
+ * package doesn't export `./package.json`, so walk up from its resolved entry
+ * point to the package root.
+ */
+function findBundledCli() {
+  let entry;
+  try {
+    entry = require.resolve("allure");
+  } catch (err) {
+    return null;
+  }
+
+  let dir = path.dirname(entry);
+  while (dir !== path.dirname(dir)) {
+    const pkgFile = path.join(dir, "package.json");
+    if (fs.existsSync(pkgFile)) {
+      try {
+        const pkg = JSON.parse(fs.readFileSync(pkgFile, "utf8"));
+        if (pkg.name === "allure") {
+          const bin = typeof pkg.bin === "string" ? pkg.bin : pkg.bin && pkg.bin.allure;
+          const cli = bin && path.join(dir, bin);
+          return cli && fs.existsSync(cli) ? cli : null;
+        }
+      } catch (err) {
+        return null;
+      }
+    }
+    dir = path.dirname(dir);
+  }
+  return null;
+}
+
+/**
+ * Runs the Allure CLI, preferring the bundled Allure 3 and falling back to
+ * whatever `allure` is on PATH.
+ */
+function runAllure(args, callback) {
+  const bundled = findBundledCli();
+  if (bundled) {
+    return execFile(process.execPath, [bundled, ...args], callback);
+  }
+  // PATH fallback needs a shell to resolve allure.cmd on Windows; quote args
+  // so paths with spaces survive.
+  const quoted = args.map((a) => `"${String(a).replace(/"/g, '\\"')}"`);
+  return execFile("allure", quoted, { shell: true }, callback);
+}
+
+module.exports = { findBundledCli, runAllure };

package/lib/allure.js

@@ -0,0 +1,106 @@
+const fs = require("fs");
+const path = require("path");
+const crypto = require("crypto");
+
+const STATUSES = ["passed", "failed", "broken", "skipped", "unknown"];
+
+function stableId(result) {
+  if (result.historyId) return result.historyId;
+  const basis = result.fullName || result.name || result.uuid || "";
+  return crypto.createHash("md5").update(basis).digest("hex");
+}
+
+function readResultFile(filePath) {
+  try {
+    const raw = fs.readFileSync(filePath, "utf8");
+    return JSON.parse(raw);
+  } catch (err) {
+    return null;
+  }
+}
+
+function labelValue(labels, name) {
+  const label = (labels || []).find((l) => l.name === name);
+  return label ? label.value : null;
+}
+
+function normalizeSteps(steps) {
+  return (steps || []).map((step) => ({
+    name: step.name || "",
+    status: step.status || "unknown",
+    start: step.start || null,
+    stop: step.stop || null,
+    attachments: (step.attachments || []).map((a) => a.name || a.source),
+    steps: normalizeSteps(step.steps),
+  }));
+}
+
+function toTestCase(result, filePath) {
+  const statusDetails = result.statusDetails || {};
+  const labels = result.labels || [];
+
+  return {
+    id: stableId(result),
+    uuid: result.uuid,
+    historyId: result.historyId || null,
+    name: result.name || result.fullName || "Unnamed test",
+    fullName: result.fullName || result.name || "",
+    parentSuite: labelValue(labels, "parentSuite"),
+    suite: labelValue(labels, "suite"),
+    subSuite: labelValue(labels, "subSuite"),
+    package: labelValue(labels, "package"),
+    severity: labelValue(labels, "severity"),
+    status: result.status || "unknown",
+    statusMessage: statusDetails.message || "",
+    statusTrace: statusDetails.trace || "",
+    steps: normalizeSteps(result.steps),
+    description: result.description || "",
+    start: result.start || null,
+    stop: result.stop || null,
+    resultFilePath: filePath,
+  };
+}
+
+/**
+ * Scans an Allure raw results directory and returns every test case
+ * (any status), deduped by historyId so reruns keep only the latest.
+ */
+function loadAllTests(resultsDir) {
+  if (!resultsDir || !fs.existsSync(resultsDir)) {
+    return [];
+  }
+
+  const resultFiles = fs
+    .readdirSync(resultsDir)
+    .filter((f) => f.endsWith("-result.json"));
+
+  const byId = new Map();
+
+  for (const file of resultFiles) {
+    const filePath = path.join(resultsDir, file);
+    const result = readResultFile(filePath);
+    if (!result) continue;
+
+    const test = toTestCase(result, filePath);
+    const existing = byId.get(test.id);
+    if (!existing || (test.stop || 0) > (existing.stop || 0)) {
+      byId.set(test.id, test);
+    }
+  }
+
+  return Array.from(byId.values()).sort((a, b) => (b.stop || 0) - (a.stop || 0));
+}
+
+/**
+ * Overwrites the `status`/`statusDetails` fields of a raw *-result.json file
+ * in place, preserving everything else (steps, labels, attachments, etc.).
+ */
+function writeResultStatus(filePath, { status, message, trace }) {
+  const raw = fs.readFileSync(filePath, "utf8");
+  const data = JSON.parse(raw);
+  data.status = status;
+  data.statusDetails = { ...(data.statusDetails || {}), message, trace };
+  fs.writeFileSync(filePath, JSON.stringify(data, null, 2));
+}
+
+module.exports = { loadAllTests, writeResultStatus, stableId, STATUSES };

package/lib/config.js

@@ -0,0 +1,30 @@
+const path = require("path");
+
+const DEFAULT_PORT = 4400;
+
+/**
+ * Resolves runtime options. Precedence: explicit options (CLI flags or the
+ * programmatic API) > environment variables > defaults. Relative paths are
+ * resolved against `cwd` (the consuming project), never against this package,
+ * since it usually lives inside someone else's node_modules.
+ */
+function resolveConfig(options = {}, env = process.env) {
+  const cwd = path.resolve(options.cwd || process.cwd());
+  const pick = (...values) => values.find((v) => v !== undefined && v !== null && v !== "");
+
+  const port = parseInt(pick(options.port, env.ALLURE_MANAGER_PORT, DEFAULT_PORT), 10);
+  if (!Number.isInteger(port) || port < 0 || port > 65535) {
+    throw new Error(`Invalid port: ${pick(options.port, env.ALLURE_MANAGER_PORT)}`);
+  }
+
+  return {
+    cwd,
+    port,
+    host: pick(options.host, env.ALLURE_MANAGER_HOST, "localhost"),
+    resultsPath: path.resolve(cwd, pick(options.resultsPath, env.ALLURE_RESULTS_PATH, "allure-results")),
+    reportPath: path.resolve(cwd, pick(options.reportPath, env.ALLURE_REPORT_PATH, "allure-report")),
+    dataDir: path.resolve(cwd, pick(options.dataDir, env.ALLURE_MANAGER_DATA_DIR, ".allure-results-manager")),
+  };
+}
+
+module.exports = { resolveConfig, DEFAULT_PORT };

package/lib/server.js

@@ -0,0 +1,270 @@
+const path = require("path");
+const fs = require("fs");
+const express = require("express");
+
+const { loadAllTests, writeResultStatus, STATUSES } = require("./allure");
+const { createStore } = require("./store");
+const { computeStats } = require("./stats");
+const { resolveConfig } = require("./config");
+const { runAllure } = require("./allure-cli");
+
+const DEFAULT_PAGE_SIZE = 50;
+const MAX_PAGE_SIZE = 200;
+const DASHBOARD_DIR = path.join(__dirname, "..", "dashboard");
+
+function isSameOrAncestor(candidate, target) {
+  const rel = path.relative(candidate, target);
+  return rel === "" || (!rel.startsWith("..") && !path.isAbsolute(rel));
+}
+
+/**
+ * The report dir is deleted before every regeneration, so refuse paths where
+ * that would wipe something that isn't a report (the project root, the
+ * results folder, or a parent of either).
+ */
+function unsafeReportPathReason(config) {
+  const { reportPath, resultsPath, cwd, dataDir } = config;
+  if (reportPath === path.parse(reportPath).root) return "it is a filesystem root";
+  if (isSameOrAncestor(reportPath, cwd)) return "it is the project directory or one of its parents";
+  if (isSameOrAncestor(reportPath, resultsPath)) return "it contains the Allure results folder";
+  if (isSameOrAncestor(reportPath, dataDir)) return "it contains the overrides data folder";
+  return null;
+}
+
+/**
+ * Builds the Express app. `options` accepts { resultsPath, reportPath,
+ * dataDir, port, host, cwd }; anything omitted falls back to env vars, then
+ * defaults relative to `cwd`.
+ */
+function createApp(options = {}) {
+  const config = resolveConfig(options);
+  const { resultsPath, reportPath } = config;
+  const { getOverride, setOverride, clearOverride } = createStore(config.dataDir);
+
+  const app = express();
+  app.locals.config = config;
+  app.use(express.json());
+  app.use(express.static(DASHBOARD_DIR));
+
+  function loadMergedTests() {
+    const tests = loadAllTests(resultsPath);
+    return tests.map((test) => {
+      const override = getOverride(test.id);
+      return {
+        ...test,
+        originalStatus: test.status,
+        status: override ? override.status : test.status,
+        override,
+      };
+    });
+  }
+
+  function applySearch(tests, search) {
+    if (!search) return tests;
+    const needle = search.trim().toLowerCase();
+    if (!needle) return tests;
+    return tests.filter((t) => (t.name || "").toLowerCase().includes(needle));
+  }
+
+  app.get("/api/status", (req, res) => {
+    res.json({
+      allureResultsPath: resultsPath,
+      allureResultsExists: fs.existsSync(resultsPath),
+      statuses: STATUSES,
+    });
+  });
+
+  app.get("/api/tests", (req, res) => {
+    let tests = loadMergedTests();
+
+    if (req.query.status) {
+      tests = tests.filter((t) => t.status === req.query.status);
+    }
+    tests = applySearch(tests, req.query.search);
+
+    let pageSize = parseInt(req.query.pageSize, 10);
+    if (!Number.isInteger(pageSize) || pageSize < 1) pageSize = DEFAULT_PAGE_SIZE;
+    pageSize = Math.min(pageSize, MAX_PAGE_SIZE);
+
+    const total = tests.length;
+    const totalPages = Math.max(1, Math.ceil(total / pageSize));
+
+    let page = parseInt(req.query.page, 10);
+    if (!Number.isInteger(page) || page < 1) page = 1;
+    page = Math.min(page, totalPages);
+
+    const start = (page - 1) * pageSize;
+    const items = tests.slice(start, start + pageSize);
+
+    res.json({ items, page, pageSize, total, totalPages });
+  });
+
+  app.get("/api/stats", (req, res) => {
+    res.json(computeStats(loadMergedTests()));
+  });
+
+  app.get("/api/tests/grouped", (req, res) => {
+    let tests = loadMergedTests();
+
+    if (req.query.status) {
+      tests = tests.filter((t) => t.status === req.query.status);
+    }
+    tests = applySearch(tests, req.query.search);
+
+    const groupsByKey = new Map();
+    for (const test of tests) {
+      const key = test.subSuite || test.suite || test.package || "Ungrouped";
+      if (!groupsByKey.has(key)) {
+        groupsByKey.set(key, {
+          key,
+          parentSuite: test.parentSuite,
+          suite: test.suite,
+          subSuite: test.subSuite,
+          tests: [],
+        });
+      }
+      groupsByKey.get(key).tests.push(test);
+    }
+
+    const groups = Array.from(groupsByKey.values())
+      .sort((a, b) => a.key.localeCompare(b.key))
+      .map((group) => ({ ...group, stats: computeStats(group.tests) }));
+
+    res.json({ groups, total: tests.length });
+  });
+
+  app.put("/api/tests/:id/status", (req, res) => {
+    const { id } = req.params;
+    const { status, reason } = req.body || {};
+
+    if (!STATUSES.includes(status)) {
+      return res.status(400).json({
+        error: `status must be one of: ${STATUSES.join(", ")}`,
+      });
+    }
+
+    const tests = loadAllTests(resultsPath);
+    const test = tests.find((t) => t.id === id);
+    if (!test) {
+      return res.status(404).json({ error: "Test not found in current Allure results" });
+    }
+
+    const existing = getOverride(id);
+    const original = (existing && existing.original) || {
+      status: test.status,
+      statusMessage: test.statusMessage,
+      statusTrace: test.statusTrace,
+    };
+
+    const override = setOverride(id, { status, reason, original });
+
+    const note = `Status overridden to "${status}" via Allure Results Manager on ${override.updatedAt}${
+      reason ? `. Reason: ${reason}` : "."
+    }`;
+    writeResultStatus(test.resultFilePath, {
+      status,
+      message: note,
+      trace: original.statusTrace
+        ? `${note}\n\nOriginal trace:\n${original.statusTrace}`
+        : note,
+    });
+
+    res.json({ override, stats: computeStats(loadMergedTests()) });
+  });
+
+  app.delete("/api/tests/:id/status", (req, res) => {
+    const { id } = req.params;
+    const override = getOverride(id);
+
+    if (override && override.original) {
+      const tests = loadAllTests(resultsPath);
+      const test = tests.find((t) => t.id === id);
+      if (test) {
+        writeResultStatus(test.resultFilePath, {
+          status: override.original.status,
+          message: override.original.statusMessage,
+          trace: override.original.statusTrace,
+        });
+      }
+    }
+
+    clearOverride(id);
+    res.json({ stats: computeStats(loadMergedTests()) });
+  });
+
+  app.get("/api/report/status", (req, res) => {
+    res.json({
+      reportPath,
+      reportExists: fs.existsSync(path.join(reportPath, "index.html")),
+    });
+  });
+
+  app.post("/api/report/generate", (req, res) => {
+    if (!fs.existsSync(resultsPath)) {
+      return res.status(400).json({ error: "Allure results path does not exist" });
+    }
+
+    const unsafeReason = unsafeReportPathReason(config);
+    if (unsafeReason) {
+      return res.status(400).json({
+        error: `Refusing to use "${reportPath}" as the report folder because ${unsafeReason}; it is deleted before each regeneration. Point --report / ALLURE_REPORT_PATH at a dedicated folder.`,
+      });
+    }
+
+    runAllure(["--version"], (versionErr, versionStdout, versionStderr) => {
+      if (versionErr) {
+        return res.status(500).json({
+          error:
+            "Failed to run the Allure CLI. Reinstall allure-results-manager (it bundles Allure 3), or install it globally with: npm install -g allure",
+          details: (versionStderr || versionErr.message || "").trim(),
+        });
+      }
+
+      const majorVersion = parseInt((versionStdout || "").trim().split(".")[0], 10);
+      if (majorVersion !== 3) {
+        return res.status(409).json({
+          error: `Allure CLI on PATH is version ${versionStdout.trim() || "unknown"}, but Allure 3 is required. Another install (often a Java-based Allure 2 from Homebrew/Scoop/apt, or a leftover allure-commandline package) is shadowing the npm-installed "allure" binary. Run "npm install -g allure" and remove the conflicting one from PATH.`,
+        });
+      }
+
+      // Regenerate from scratch so stale pages from a previous run's report
+      // (which the CLI doesn't clean up on its own) don't linger.
+      fs.rmSync(reportPath, { recursive: true, force: true });
+
+      runAllure(["generate", resultsPath, "--output", reportPath], (err, stdout, stderr) => {
+        if (err) {
+          return res.status(500).json({
+            error: "Failed to generate the Allure report.",
+            details: (stderr || err.message || "").trim(),
+          });
+        }
+        res.json({ ok: true, reportUrl: "/report/index.html" });
+      });
+    });
+  });
+
+  app.use("/report", express.static(reportPath));
+
+  return app;
+}
+
+/**
+ * Creates the app and starts listening. Resolves with { app, server, url,
+ * config }; rejects if the port can't be bound (e.g. already in use).
+ */
+function startServer(options = {}) {
+  const app = createApp(options);
+  const { port, host } = app.locals.config;
+
+  return new Promise((resolve, reject) => {
+    const server = app.listen(port, host);
+    server.once("error", reject);
+    server.once("listening", () => {
+      const address = server.address();
+      const url = `http://${host}:${address.port}`;
+      resolve({ app, server, url, config: app.locals.config });
+    });
+  });
+}
+
+module.exports = { createApp, startServer };

package/lib/stats.js

@@ -0,0 +1,23 @@
+const { STATUSES } = require("./allure");
+
+/**
+ * Computes pass/fail/etc counts over a list of merged test cases
+ * (each with an effective `status`, i.e. after overrides are applied).
+ */
+function computeStats(tests) {
+  const byStatus = Object.fromEntries(STATUSES.map((s) => [s, 0]));
+  let overridden = 0;
+
+  for (const test of tests) {
+    if (byStatus[test.status] === undefined) byStatus[test.status] = 0;
+    byStatus[test.status] += 1;
+    if (test.override) overridden += 1;
+  }
+
+  const total = tests.length;
+  const passRate = total ? Math.round(((byStatus.passed || 0) / total) * 1000) / 10 : 0;
+
+  return { total, byStatus, overridden, passRate };
+}
+
+module.exports = { computeStats };

package/lib/store.js

@@ -0,0 +1,59 @@
+const fs = require("fs");
+const path = require("path");
+
+/**
+ * Override store backed by `<dataDir>/overrides.json`. The data dir lives in
+ * the consuming project (not inside this package) so overrides survive
+ * reinstalls of node_modules.
+ */
+function createStore(dataDir) {
+  const overridesFile = path.join(dataDir, "overrides.json");
+
+  function ensureStore() {
+    if (!fs.existsSync(dataDir)) fs.mkdirSync(dataDir, { recursive: true });
+    if (!fs.existsSync(overridesFile)) fs.writeFileSync(overridesFile, "{}");
+  }
+
+  function loadOverrides() {
+    ensureStore();
+    try {
+      return JSON.parse(fs.readFileSync(overridesFile, "utf8"));
+    } catch (err) {
+      return {};
+    }
+  }
+
+  function saveOverrides(overrides) {
+    fs.writeFileSync(overridesFile, JSON.stringify(overrides, null, 2));
+  }
+
+  function getOverride(id) {
+    const overrides = loadOverrides();
+    return overrides[id] || null;
+  }
+
+  function setOverride(id, { status, reason, original }) {
+    const overrides = loadOverrides();
+    const existing = overrides[id];
+    overrides[id] = {
+      status,
+      reason: reason || "",
+      updatedAt: new Date().toISOString(),
+      // Snapshot of the raw result's status/message/trace before the first
+      // override, so "Revert to original" can restore the raw file too.
+      original: (existing && existing.original) || original || null,
+    };
+    saveOverrides(overrides);
+    return overrides[id];
+  }
+
+  function clearOverride(id) {
+    const overrides = loadOverrides();
+    delete overrides[id];
+    saveOverrides(overrides);
+  }
+
+  return { overridesFile, loadOverrides, getOverride, setOverride, clearOverride };
+}
+
+module.exports = { createStore };

package/package.json

@@ -0,0 +1,33 @@
+{  "name": "allure-report-manager",
+  "version": "1.0.1",
+  "description": "Parses an Allure raw results folder, lists every test case with its status, and lets you override a test's status and reason with stats recalculated live",
+  "main": "index.js",
+  "bin": {
+    "allure-results-manager": "bin/allure-results-manager.js"
+  },
+  "files": [
+    "bin/",
+    "lib/",
+    "dashboard/",
+    "index.js",
+    "README.md"
+  ],
+  "scripts": {
+    "start": "node bin/allure-results-manager.js"
+  },
+  "keywords": [
+    "allure",
+    "allure-report",
+    "test-results",
+    "dashboard",
+    "qa"
+  ],
+  "engines": {
+    "node": ">=18.3"
+  },
+  "dependencies": {
+    "allure": "^3.18.0",
+    "dotenv": "^16.4.5",
+    "express": "^4.19.2"
+  }
+}