@testrelic/playwright-analytics 2.2.7 → 2.3.1

package/dist/cli.cjs

@@ -1,14 +1,514 @@
 #!/usr/bin/env node
 "use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/report-server-routes.ts
+function sendJson(res, status, body) {
+  res.writeHead(status, { "Content-Type": "application/json" });
+  res.end(JSON.stringify(body));
+}
+function setCorsHeaders(res) {
+  res.setHeader("Access-Control-Allow-Origin", "*");
+  res.setHeader("Access-Control-Allow-Methods", "GET, DELETE, OPTIONS");
+  res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+}
+function readJsonFile(filePath) {
+  try {
+    if (!(0, import_node_fs2.existsSync)(filePath)) return null;
+    return JSON.parse((0, import_node_fs2.readFileSync)(filePath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function getDirSize(dirPath) {
+  let size = 0;
+  try {
+    const entries = (0, import_node_fs2.readdirSync)(dirPath, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = (0, import_node_path2.join)(dirPath, entry.name);
+      if (entry.isFile()) {
+        size += (0, import_node_fs2.statSync)(fullPath).size;
+      } else if (entry.isDirectory()) {
+        size += getDirSize(fullPath);
+      }
+    }
+  } catch {
+  }
+  return size;
+}
+function handleHealth(_req, res, reportDir, startTime) {
+  const index = readJsonFile((0, import_node_path2.join)(reportDir, "index.json"));
+  sendJson(res, 200, {
+    status: "ok",
+    reportMode: "streaming",
+    testCount: index?.length ?? 0,
+    uptime: Math.floor((Date.now() - startTime) / 1e3)
+  });
+}
+function handleSummary(_req, res, reportDir) {
+  const summary = readJsonFile((0, import_node_path2.join)(reportDir, "summary.json"));
+  if (!summary) {
+    sendJson(res, 404, { error: "Summary not found" });
+    return;
+  }
+  sendJson(res, 200, summary);
+}
+function handleTests(req, res, reportDir) {
+  const index = readJsonFile((0, import_node_path2.join)(reportDir, "index.json"));
+  if (!index) {
+    sendJson(res, 404, { error: "Test index not found" });
+    return;
+  }
+  const url = new URL(req.url ?? "/", `http://${req.headers.host}`);
+  const params = url.searchParams;
+  const page = Math.max(1, parseInt(params.get("page") ?? "1", 10) || 1);
+  const pageSize = Math.min(MAX_PAGE_SIZE, Math.max(1, parseInt(params.get("pageSize") ?? "100", 10) || 100));
+  const statusFilter = params.get("status")?.split(",").filter(Boolean) ?? null;
+  const fileFilter = params.get("file") ?? null;
+  const searchQuery = params.get("search")?.toLowerCase() ?? null;
+  const tagFilter = params.get("tag")?.split(",").filter(Boolean) ?? null;
+  const sortField = params.get("sort") ?? "file";
+  const sortOrder = params.get("order") === "desc" ? -1 : 1;
+  let filtered = index;
+  if (statusFilter && statusFilter.length > 0) {
+    filtered = filtered.filter((t) => statusFilter.includes(t.status));
+  }
+  if (fileFilter) {
+    filtered = filtered.filter((t) => t.filePath === fileFilter || t.filePath.startsWith(fileFilter + "/"));
+  }
+  if (searchQuery) {
+    filtered = filtered.filter(
+      (t) => t.title.toLowerCase().includes(searchQuery) || t.filePath.toLowerCase().includes(searchQuery)
+    );
+  }
+  if (tagFilter && tagFilter.length > 0) {
+    filtered = filtered.filter((t) => tagFilter.some((tag) => t.tags.includes(tag)));
+  }
+  filtered = [...filtered].sort((a, b) => {
+    let cmp = 0;
+    switch (sortField) {
+      case "duration":
+        cmp = a.duration - b.duration;
+        break;
+      case "status":
+        cmp = a.status.localeCompare(b.status);
+        break;
+      case "title":
+        cmp = a.title.localeCompare(b.title);
+        break;
+      case "file":
+      default:
+        cmp = a.filePath.localeCompare(b.filePath);
+        break;
+    }
+    return cmp * sortOrder;
+  });
+  const totalItems = filtered.length;
+  const totalPages = Math.max(1, Math.ceil(totalItems / pageSize));
+  const startIdx = (page - 1) * pageSize;
+  const tests = filtered.slice(startIdx, startIdx + pageSize);
+  sendJson(res, 200, {
+    tests,
+    pagination: { page, pageSize, totalItems, totalPages },
+    filters: {
+      status: statusFilter,
+      file: fileFilter,
+      search: searchQuery,
+      tag: tagFilter
+    }
+  });
+}
+function handleTestDetail(_req, res, reportDir, testId) {
+  if (!SAFE_ID_PATTERN.test(testId)) {
+    sendJson(res, 400, { error: "Invalid test ID format" });
+    return;
+  }
+  const filePath = (0, import_node_path2.join)(reportDir, "tests", `${testId}.json`);
+  if (!(0, import_node_fs2.existsSync)(filePath)) {
+    sendJson(res, 404, { error: `Test not found: ${testId}` });
+    return;
+  }
+  try {
+    const data = (0, import_node_fs2.readFileSync)(filePath, "utf-8");
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(data);
+  } catch (err) {
+    sendJson(res, 500, { error: err instanceof Error ? err.message : String(err) });
+  }
+}
+function handleFiles(_req, res, reportDir) {
+  const index = readJsonFile((0, import_node_path2.join)(reportDir, "index.json"));
+  if (!index) {
+    sendJson(res, 404, { error: "Test index not found" });
+    return;
+  }
+  const fileMap = /* @__PURE__ */ new Map();
+  for (const t of index) {
+    if (t.isRetry) continue;
+    let stats = fileMap.get(t.filePath);
+    if (!stats) {
+      stats = { total: 0, passed: 0, failed: 0, flaky: 0, skipped: 0, timedOut: 0 };
+      fileMap.set(t.filePath, stats);
+    }
+    stats.total++;
+    switch (t.status) {
+      case "passed":
+        stats.passed++;
+        break;
+      case "failed":
+        stats.failed++;
+        break;
+      case "flaky":
+        stats.flaky++;
+        break;
+      case "skipped":
+        stats.skipped++;
+        break;
+      case "timedout":
+        stats.timedOut++;
+        break;
+    }
+  }
+  const files = Array.from(fileMap.entries()).map(([filePath, s]) => ({ filePath, ...s })).sort((a, b) => a.filePath.localeCompare(b.filePath));
+  sendJson(res, 200, { files });
+}
+function handleArtifactsList(_req, res, artifactsDir) {
+  if (!(0, import_node_fs2.existsSync)(artifactsDir)) {
+    sendJson(res, 200, { runs: [], totalSizeBytes: 0 });
+    return;
+  }
+  try {
+    const runs = [];
+    let totalSizeBytes = 0;
+    const entries = (0, import_node_fs2.readdirSync)(artifactsDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory() || !TIMESTAMP_PATTERN.test(entry.name)) continue;
+      const runDir = (0, import_node_path2.join)(artifactsDir, entry.name);
+      const size = getDirSize(runDir);
+      const testDirs = (0, import_node_fs2.readdirSync)(runDir, { withFileTypes: true }).filter((e) => e.isDirectory());
+      runs.push({ folderName: entry.name, totalSizeBytes: size, testCount: testDirs.length });
+      totalSizeBytes += size;
+    }
+    runs.sort((a, b) => b.folderName.localeCompare(a.folderName));
+    sendJson(res, 200, { runs, totalSizeBytes });
+  } catch (err) {
+    sendJson(res, 500, { error: err instanceof Error ? err.message : String(err) });
+  }
+}
+function handleArtifactsDeleteAll(_req, res, artifactsDir) {
+  try {
+    let deletedCount = 0;
+    let freedBytes = 0;
+    if ((0, import_node_fs2.existsSync)(artifactsDir)) {
+      const entries = (0, import_node_fs2.readdirSync)(artifactsDir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isDirectory() || !TIMESTAMP_PATTERN.test(entry.name)) continue;
+        const runDir = (0, import_node_path2.join)(artifactsDir, entry.name);
+        const size = getDirSize(runDir);
+        (0, import_node_fs2.rmSync)(runDir, { recursive: true, force: true });
+        freedBytes += size;
+        deletedCount++;
+      }
+    }
+    sendJson(res, 200, { deletedCount, freedBytes });
+  } catch (err) {
+    sendJson(res, 500, { error: err instanceof Error ? err.message : String(err) });
+  }
+}
+function handleArtifactDelete(_req, res, artifactsDir, folderName) {
+  if (!TIMESTAMP_PATTERN.test(folderName)) {
+    sendJson(res, 400, { error: "Invalid folder name" });
+    return;
+  }
+  const runDir = (0, import_node_path2.join)(artifactsDir, folderName);
+  try {
+    const stat = (0, import_node_fs2.statSync)(runDir);
+    if (!stat.isDirectory()) {
+      sendJson(res, 404, { error: "Not found" });
+      return;
+    }
+  } catch {
+    sendJson(res, 404, { error: "Not found" });
+    return;
+  }
+  try {
+    const freedBytes = getDirSize(runDir);
+    (0, import_node_fs2.rmSync)(runDir, { recursive: true, force: true });
+    sendJson(res, 200, { deleted: folderName, freedBytes });
+  } catch (err) {
+    sendJson(res, 500, { error: err instanceof Error ? err.message : String(err) });
+  }
+}
+function handleShutdown(_req, res, server) {
+  sendJson(res, 200, { status: "shutting_down" });
+  server.close();
+}
+function serveStaticFile(_req, res, filePath) {
+  if (!(0, import_node_fs2.existsSync)(filePath)) {
+    sendJson(res, 404, { error: "File not found" });
+    return;
+  }
+  try {
+    const data = (0, import_node_fs2.readFileSync)(filePath);
+    const ext = (0, import_node_path2.extname)(filePath).toLowerCase();
+    const contentType = MIME_TYPES[ext] ?? "application/octet-stream";
+    res.writeHead(200, { "Content-Type": contentType });
+    res.end(data);
+  } catch (err) {
+    sendJson(res, 500, { error: err instanceof Error ? err.message : String(err) });
+  }
+}
+var import_node_fs2, import_node_path2, SAFE_ID_PATTERN, TIMESTAMP_PATTERN, MAX_PAGE_SIZE, MIME_TYPES;
+var init_report_server_routes = __esm({
+  "src/report-server-routes.ts"() {
+    "use strict";
+    import_node_fs2 = require("fs");
+    import_node_path2 = require("path");
+    SAFE_ID_PATTERN = /^[a-f0-9]{12}$/;
+    TIMESTAMP_PATTERN = /^\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}(-\d+)?$/;
+    MAX_PAGE_SIZE = 500;
+    MIME_TYPES = {
+      ".png": "image/png",
+      ".jpg": "image/jpeg",
+      ".jpeg": "image/jpeg",
+      ".gif": "image/gif",
+      ".webp": "image/webp",
+      ".webm": "video/webm",
+      ".mp4": "video/mp4",
+      ".json": "application/json",
+      ".html": "text/html",
+      ".css": "text/css",
+      ".js": "text/javascript",
+      ".svg": "image/svg+xml"
+    };
+  }
+});
+
+// src/report-server.ts
+var report_server_exports = {};
+__export(report_server_exports, {
+  startReportServer: () => startReportServer
+});
+function startReportServer(reportDir, options) {
+  return new Promise((resolve2, reject) => {
+    const startPort = options?.port ?? DEFAULT_PORT;
+    const startTime = Date.now();
+    let inactivityTimer;
+    let currentAttempt = 0;
+    const artifactsDir = (0, import_node_fs3.existsSync)((0, import_node_path3.join)(reportDir, "artifacts")) ? (0, import_node_path3.join)(reportDir, "artifacts") : (0, import_node_fs3.existsSync)((0, import_node_path3.join)(reportDir, "..", "artifacts")) ? (0, import_node_path3.join)(reportDir, "..", "artifacts") : (0, import_node_path3.join)(reportDir, "artifacts");
+    function resetTimer() {
+      clearTimeout(inactivityTimer);
+      inactivityTimer = setTimeout(() => {
+        server.close();
+      }, INACTIVITY_TIMEOUT_MS);
+    }
+    let htmlReportPath = options?.htmlPath ?? null;
+    if (!htmlReportPath) {
+      const parentDir = (0, import_node_path3.dirname)(reportDir);
+      try {
+        const htmlFile = (0, import_node_fs3.readdirSync)(parentDir).find((f) => f.endsWith(".html"));
+        if (htmlFile) htmlReportPath = (0, import_node_path3.join)(parentDir, htmlFile);
+      } catch {
+      }
+    }
+    const server = (0, import_node_http.createServer)((req, res) => {
+      resetTimer();
+      setCorsHeaders(res);
+      if (req.method === "OPTIONS") {
+        res.writeHead(204);
+        res.end();
+        return;
+      }
+      let pathname;
+      try {
+        const url = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
+        pathname = url.pathname;
+      } catch {
+        sendJson(res, 400, { error: "Invalid URL" });
+        return;
+      }
+      if (req.method === "GET" && (pathname === "/" || pathname === "/index.html")) {
+        if (htmlReportPath && (0, import_node_fs3.existsSync)(htmlReportPath)) {
+          serveStaticFile(req, res, htmlReportPath);
+          return;
+        }
+        sendJson(res, 404, { error: "HTML report not found" });
+        return;
+      }
+      if (req.method === "GET" && pathname === "/api/health") {
+        handleHealth(req, res, reportDir, startTime);
+        return;
+      }
+      if (req.method === "GET" && pathname === "/api/summary") {
+        handleSummary(req, res, reportDir);
+        return;
+      }
+      if (req.method === "GET" && pathname === "/api/tests") {
+        handleTests(req, res, reportDir);
+        return;
+      }
+      if (req.method === "GET" && pathname === "/api/files") {
+        handleFiles(req, res, reportDir);
+        return;
+      }
+      const testMatch = pathname.match(/^\/api\/tests\/([a-f0-9]+)$/);
+      if (req.method === "GET" && testMatch) {
+        handleTestDetail(req, res, reportDir, testMatch[1]);
+        return;
+      }
+      if (req.method === "GET" && pathname === "/api/artifacts") {
+        handleArtifactsList(req, res, artifactsDir);
+        return;
+      }
+      if (req.method === "DELETE" && pathname === "/api/artifacts") {
+        handleArtifactsDeleteAll(req, res, artifactsDir);
+        return;
+      }
+      const deleteMatch = pathname.match(/^\/api\/artifacts\/(.+)$/);
+      if (req.method === "DELETE" && deleteMatch) {
+        handleArtifactDelete(req, res, artifactsDir, decodeURIComponent(deleteMatch[1]));
+        return;
+      }
+      if (req.method === "GET" && pathname.startsWith("/artifacts/")) {
+        const relPath = decodeURIComponent(pathname.slice("/artifacts/".length));
+        if (relPath.includes("..") || relPath.includes("\0")) {
+          sendJson(res, 400, { error: "Invalid path" });
+          return;
+        }
+        serveStaticFile(req, res, (0, import_node_path3.join)(artifactsDir, relPath));
+        return;
+      }
+      if (req.method === "POST" && pathname === "/api/shutdown") {
+        handleShutdown(req, res, server);
+        return;
+      }
+      sendJson(res, 404, { error: "Not found" });
+    });
+    function tryListen(port) {
+      const errorHandler = (err) => {
+        if (err.code === "EADDRINUSE" && currentAttempt < MAX_PORT_ATTEMPTS) {
+          currentAttempt++;
+          tryListen(port + 1);
+        } else {
+          reject(err);
+        }
+      };
+      server.once("error", errorHandler);
+      server.listen(port, "127.0.0.1", () => {
+        server.removeListener("error", errorHandler);
+        const addr = server.address();
+        if (!addr || typeof addr === "string") {
+          reject(new Error("Failed to get server address"));
+          return;
+        }
+        resetTimer();
+        resolve2({
+          port: addr.port,
+          dispose: () => new Promise((res) => {
+            clearTimeout(inactivityTimer);
+            server.close(() => res());
+          })
+        });
+      });
+    }
+    tryListen(startPort);
+  });
+}
+var import_node_http, import_node_path3, import_node_fs3, DEFAULT_PORT, MAX_PORT_ATTEMPTS, INACTIVITY_TIMEOUT_MS;
+var init_report_server = __esm({
+  "src/report-server.ts"() {
+    "use strict";
+    import_node_http = require("http");
+    import_node_path3 = require("path");
+    import_node_fs3 = require("fs");
+    init_report_server_routes();
+    DEFAULT_PORT = 9323;
+    MAX_PORT_ATTEMPTS = 10;
+    INACTIVITY_TIMEOUT_MS = 30 * 60 * 1e3;
+  }
+});
+
+// src/browser-open.ts
+var browser_open_exports = {};
+__export(browser_open_exports, {
+  openInBrowser: () => openInBrowser
+});
+function openInBrowser(filePath) {
+  try {
+    const platform = process.platform;
+    let command;
+    if (platform === "darwin") {
+      command = `open "${filePath}"`;
+    } else if (platform === "win32") {
+      command = `start "" "${filePath}"`;
+    } else {
+      command = `xdg-open "${filePath}"`;
+    }
+    (0, import_node_child_process.exec)(command, (err) => {
+      if (err) {
+        process.stderr.write(
+          `[testrelic] Failed to open browser: ${err.message}
+`
+        );
+      }
+    });
+  } catch {
+  }
+}
+var import_node_child_process;
+var init_browser_open = __esm({
+  "src/browser-open.ts"() {
+    "use strict";
+    import_node_child_process = require("child_process");
+  }
+});
 
 // src/merge.ts
 var import_node_crypto = require("crypto");
 var import_node_fs = require("fs");
 var import_node_path = require("path");
 var import_core = require("@testrelic/core");
+function isStreamingDir(path) {
+  try {
+    const stat = (0, import_node_fs.statSync)(path);
+    return stat.isDirectory() && (0, import_node_fs.existsSync)((0, import_node_path.join)(path, "index.json"));
+  } catch {
+    return false;
+  }
+}
+function loadStreamingReport(dir) {
+  const summaryPath = (0, import_node_path.join)(dir, "summary.json");
+  const indexPath = (0, import_node_path.join)(dir, "index.json");
+  let summary;
+  try {
+    summary = JSON.parse((0, import_node_fs.readFileSync)(summaryPath, "utf-8"));
+  } catch (err) {
+    throw (0, import_core.createError)(import_core.ErrorCode.MERGE_READ_FAILED, `Failed to read summary.json from: ${dir}`, err);
+  }
+  let index;
+  try {
+    index = JSON.parse((0, import_node_fs.readFileSync)(indexPath, "utf-8"));
+  } catch (err) {
+    throw (0, import_core.createError)(import_core.ErrorCode.MERGE_READ_FAILED, `Failed to read index.json from: ${dir}`, err);
+  }
+  return { summary, index, dir };
+}
 async function mergeReports(files, options) {
   const reports = [];
+  const streamingReports = [];
   for (const file of files) {
+    if (isStreamingDir(file)) {
+      streamingReports.push(loadStreamingReport(file));
+      continue;
+    }
     let raw;
     try {
       raw = (0, import_node_fs.readFileSync)(file, "utf-8");
@@ -47,7 +547,37 @@ async function mergeReports(files, options) {
     const timeB = "visitedAt" in b ? b.visitedAt : b.timestamp;
     return new Date(timeA).getTime() - new Date(timeB).getTime();
   });
-  const summary = recalculateSummary(reports, allTimelines.length);
+  if (streamingReports.length > 0) {
+    const outputDir = (0, import_node_path.dirname)(options.output);
+    const mergedReportDir = (0, import_node_path.join)(outputDir, ".testrelic-report");
+    const mergedTestsDir = (0, import_node_path.join)(mergedReportDir, "tests");
+    (0, import_node_fs.mkdirSync)(mergedTestsDir, { recursive: true });
+    const seenTestIds = /* @__PURE__ */ new Set();
+    const mergedIndex = [];
+    for (const sr of streamingReports) {
+      const srcTestsDir = (0, import_node_path.join)(sr.dir, "tests");
+      if ((0, import_node_fs.existsSync)(srcTestsDir)) {
+        const testFiles = (0, import_node_fs.readdirSync)(srcTestsDir);
+        for (const f of testFiles) {
+          if (f.endsWith(".json")) {
+            (0, import_node_fs.cpSync)((0, import_node_path.join)(srcTestsDir, f), (0, import_node_path.join)(mergedTestsDir, f));
+          }
+        }
+      }
+      for (const entry of sr.index) {
+        if (!seenTestIds.has(entry.id)) {
+          seenTestIds.add(entry.id);
+          mergedIndex.push(entry);
+        }
+      }
+    }
+    (0, import_node_fs.writeFileSync)((0, import_node_path.join)(mergedReportDir, "index.json"), JSON.stringify(mergedIndex), "utf-8");
+  }
+  const allSummaries = [
+    ...reports.map((r) => r.summary),
+    ...streamingReports.map((sr) => sr.summary)
+  ];
+  const summary = recalculateSummaryFromList(allSummaries, allTimelines.length);
   const startedAt = reports.reduce(
     (earliest, r) => r.startedAt < earliest ? r.startedAt : earliest,
     reports[0]?.startedAt ?? (/* @__PURE__ */ new Date()).toISOString()
@@ -74,7 +604,7 @@ async function mergeReports(files, options) {
   (0, import_node_fs.writeFileSync)(options.output, JSON.stringify(merged, null, 2), "utf-8");
   return merged;
 }
-function recalculateSummary(reports, timelineLength) {
+function recalculateSummaryFromList(summaries, timelineLength) {
   let total = 0;
   let passed = 0;
   let failed = 0;
@@ -86,23 +616,18 @@ function recalculateSummary(reports, timelineLength) {
   let passedAssertions = 0;
   let failedAssertions = 0;
   let totalNavigations = 0;
-  const apiUrlSet = /* @__PURE__ */ new Set();
-  const navUrlSet = /* @__PURE__ */ new Set();
-  const methodCounts = {};
-  const statusRanges = { "2xx": 0, "3xx": 0, "4xx": 0, "5xx": 0, error: 0 };
-  const allResponseTimes = [];
-  for (const report of reports) {
-    total += report.summary.total;
-    passed += report.summary.passed;
-    failed += report.summary.failed;
-    flaky += report.summary.flaky;
-    skipped += report.summary.skipped;
-    timedout += report.summary.timedout ?? 0;
-    totalApiCalls += report.summary.totalApiCalls ?? 0;
-    totalAssertions += report.summary.totalAssertions ?? 0;
-    passedAssertions += report.summary.passedAssertions ?? 0;
-    failedAssertions += report.summary.failedAssertions ?? 0;
-    totalNavigations += report.summary.totalNavigations ?? 0;
+  for (const s of summaries) {
+    total += s.total;
+    passed += s.passed;
+    failed += s.failed;
+    flaky += s.flaky;
+    skipped += s.skipped;
+    timedout += s.timedout ?? 0;
+    totalApiCalls += s.totalApiCalls ?? 0;
+    totalAssertions += s.totalAssertions ?? 0;
+    passedAssertions += s.passedAssertions ?? 0;
+    failedAssertions += s.failedAssertions ?? 0;
+    totalNavigations += s.totalNavigations ?? 0;
   }
   return {
     total,
@@ -112,15 +637,15 @@ function recalculateSummary(reports, timelineLength) {
     skipped,
     timedout,
     totalApiCalls,
-    uniqueApiUrls: apiUrlSet.size,
-    apiCallsByMethod: methodCounts,
-    apiCallsByStatusRange: statusRanges,
+    uniqueApiUrls: 0,
+    apiCallsByMethod: {},
+    apiCallsByStatusRange: { "2xx": 0, "3xx": 0, "4xx": 0, "5xx": 0, error: 0 },
     apiResponseTime: null,
     totalAssertions,
     passedAssertions,
     failedAssertions,
     totalNavigations,
-    uniqueNavigationUrls: navUrlSet.size,
+    uniqueNavigationUrls: 0,
     totalTimelineSteps: timelineLength,
     totalActionSteps: 0,
     actionStepsByCategory: {}
@@ -128,19 +653,27 @@ function recalculateSummary(reports, timelineLength) {
 }
 
 // src/cli.ts
+var import_node_path4 = require("path");
+var import_node_fs4 = require("fs");
 async function main() {
   const args = process.argv.slice(2);
   if (args.length === 0 || args[0] === "--help" || args[0] === "-h") {
     printUsage();
     process.exit(0);
   }
-  if (args[0] !== "merge") {
-    process.stderr.write(`Unknown command: ${args[0]}
+  const command = args[0];
+  if (command === "merge") {
+    await handleMerge(args.slice(1));
+  } else if (command === "serve" || command === "open") {
+    await handleServe(args.slice(1));
+  } else {
+    process.stderr.write(`Unknown command: ${command}
 `);
     printUsage();
     process.exit(1);
   }
-  const mergeArgs = args.slice(1);
+}
+async function handleMerge(mergeArgs) {
   const outputIndex = mergeArgs.findIndex((a) => a === "-o" || a === "--output");
   if (outputIndex === -1 || outputIndex === mergeArgs.length - 1) {
     process.stderr.write("Error: -o <output> is required\n");
@@ -171,14 +704,72 @@ async function main() {
     process.exit(1);
   }
 }
+async function handleServe(serveArgs) {
+  const portIndex = serveArgs.findIndex((a) => a === "--port" || a === "-p");
+  let port;
+  let dir;
+  if (portIndex !== -1 && portIndex < serveArgs.length - 1) {
+    port = parseInt(serveArgs[portIndex + 1], 10);
+    if (isNaN(port) || port < 1 || port > 65535) {
+      process.stderr.write("Error: Invalid port number\n");
+      process.exit(1);
+    }
+    const rest = [...serveArgs.slice(0, portIndex), ...serveArgs.slice(portIndex + 2)];
+    dir = rest[0];
+  } else {
+    dir = serveArgs[0];
+  }
+  if (!dir) {
+    process.stderr.write("Error: Report directory is required\n");
+    process.stderr.write("Usage: testrelic serve <dir> [--port <port>]\n");
+    process.exit(1);
+  }
+  const reportDir = (0, import_node_path4.resolve)(dir);
+  if (!(0, import_node_fs4.existsSync)(reportDir)) {
+    process.stderr.write(`Error: Directory not found: ${reportDir}
+`);
+    process.exit(1);
+  }
+  try {
+    const { startReportServer: startReportServer2 } = await Promise.resolve().then(() => (init_report_server(), report_server_exports));
+    const { openInBrowser: openInBrowser2 } = await Promise.resolve().then(() => (init_browser_open(), browser_open_exports));
+    const handle = await startReportServer2(reportDir, port ? { port } : void 0);
+    const url = `http://127.0.0.1:${handle.port}`;
+    process.stderr.write(`
+  Report server running at: ${url}
+  Press Ctrl+C to stop
+
+`);
+    openInBrowser2(url);
+    process.on("SIGINT", () => {
+      handle.dispose();
+      process.exit(0);
+    });
+    process.on("SIGTERM", () => {
+      handle.dispose();
+      process.exit(0);
+    });
+  } catch (err) {
+    process.stderr.write(
+      `Error: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+    process.exit(1);
+  }
+}
 function printUsage() {
   process.stderr.write(
-    `Usage: testrelic merge <files...> -o <output>
+    `Usage: testrelic <command>
 
-  Merge multiple shard report JSON files into one.
+Commands:
+  merge <files...> -o <output>   Merge multiple shard report JSON files
+  serve <dir> [--port <port>]    Start a local server for a streaming report
+  open <dir> [--port <port>]     Alias for serve
 
-  Example:
-    npx testrelic merge shard-1.json shard-2.json -o merged.json
+Examples:
+  npx testrelic merge shard-1.json shard-2.json -o merged.json
+  npx testrelic serve ./test-results/.testrelic-report
+  npx testrelic serve ./test-results/.testrelic-report --port 9400
 `
   );
 }