@testrelic/playwright-analytics 2.4.10 → 2.4.11-next.12

package/dist/cli.cjs

@@ -0,0 +1,868 @@
+#!/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/jsonl-stream.ts
+async function readJsonlPage(filePath, page, pageSize, knownTotal) {
+  const skip = (page - 1) * pageSize;
+  const items = [];
+  let lineCount = 0;
+  const rl = (0, import_node_readline.createInterface)({
+    input: (0, import_node_fs2.createReadStream)(filePath, { encoding: "utf-8" }),
+    crlfDelay: Infinity
+  });
+  for await (const line of rl) {
+    if (line.length === 0) continue;
+    if (lineCount >= skip && items.length < pageSize) {
+      try {
+        items.push(JSON.parse(line));
+      } catch {
+      }
+    }
+    lineCount++;
+    if (items.length >= pageSize && knownTotal !== void 0) {
+      break;
+    }
+  }
+  const total = knownTotal ?? lineCount;
+  const totalPages = Math.max(1, Math.ceil(total / pageSize));
+  return { items, total, page, pageSize, totalPages };
+}
+var import_node_fs2, import_node_path2, import_node_os, import_node_crypto2, import_node_readline, TESTRELIC_TMP_DIR;
+var init_jsonl_stream = __esm({
+  "src/jsonl-stream.ts"() {
+    "use strict";
+    import_node_fs2 = require("fs");
+    import_node_path2 = require("path");
+    import_node_os = require("os");
+    import_node_crypto2 = require("crypto");
+    import_node_readline = require("readline");
+    TESTRELIC_TMP_DIR = (0, import_node_path2.join)((0, import_node_os.tmpdir)(), "testrelic-data");
+  }
+});
+
+// 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_fs3.existsSync)(filePath)) return null;
+    return JSON.parse((0, import_node_fs3.readFileSync)(filePath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function getDirSize(dirPath) {
+  let size = 0;
+  try {
+    const entries = (0, import_node_fs3.readdirSync)(dirPath, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = (0, import_node_path3.join)(dirPath, entry.name);
+      if (entry.isFile()) {
+        size += (0, import_node_fs3.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_path3.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_path3.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_path3.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 metaPath = (0, import_node_path3.join)(reportDir, "tests", testId, "meta.json");
+  const legacyPath = (0, import_node_path3.join)(reportDir, "tests", `${testId}.json`);
+  const filePath = (0, import_node_fs3.existsSync)(metaPath) ? metaPath : (0, import_node_fs3.existsSync)(legacyPath) ? legacyPath : null;
+  if (!filePath) {
+    sendJson(res, 404, { error: `Test not found: ${testId}` });
+    return;
+  }
+  try {
+    const data = (0, import_node_fs3.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) });
+  }
+}
+async function handleTestDataFile(req, res, reportDir, testId, dataType) {
+  if (!SAFE_ID_PATTERN.test(testId)) {
+    sendJson(res, 400, { error: "Invalid test ID format" });
+    return;
+  }
+  const fileNames = {
+    "network": "network.jsonl",
+    "console": "console.jsonl",
+    "api-calls": "api-calls.jsonl"
+  };
+  const jsonlPath = (0, import_node_path3.join)(reportDir, "tests", testId, fileNames[dataType]);
+  if (!(0, import_node_fs3.existsSync)(jsonlPath)) {
+    sendJson(res, 200, { items: [], total: 0, page: 1, pageSize: 50, totalPages: 0 });
+    return;
+  }
+  try {
+    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") ?? "50", 10) || 50));
+    let knownTotal;
+    const metaPath = (0, import_node_path3.join)(reportDir, "tests", testId, "meta.json");
+    if ((0, import_node_fs3.existsSync)(metaPath)) {
+      try {
+        const meta = JSON.parse((0, import_node_fs3.readFileSync)(metaPath, "utf-8"));
+        switch (dataType) {
+          case "network":
+            knownTotal = meta.networkRequestsCount;
+            break;
+          case "console":
+            knownTotal = meta.consoleLogsCount;
+            break;
+          case "api-calls":
+            knownTotal = meta.apiCallsCount;
+            break;
+        }
+      } catch {
+      }
+    }
+    const result = await readJsonlPage(jsonlPath, page, pageSize, knownTotal);
+    sendJson(res, 200, result);
+  } catch (err) {
+    sendJson(res, 500, { error: err instanceof Error ? err.message : String(err) });
+  }
+}
+function handleFiles(_req, res, reportDir) {
+  const index = readJsonFile((0, import_node_path3.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_fs3.existsSync)(artifactsDir)) {
+    sendJson(res, 200, { runs: [], totalSizeBytes: 0 });
+    return;
+  }
+  try {
+    const runs = [];
+    let totalSizeBytes = 0;
+    const entries = (0, import_node_fs3.readdirSync)(artifactsDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory() || !TIMESTAMP_PATTERN.test(entry.name)) continue;
+      const runDir = (0, import_node_path3.join)(artifactsDir, entry.name);
+      const size = getDirSize(runDir);
+      const testDirs = (0, import_node_fs3.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_fs3.existsSync)(artifactsDir)) {
+      const entries = (0, import_node_fs3.readdirSync)(artifactsDir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isDirectory() || !TIMESTAMP_PATTERN.test(entry.name)) continue;
+        const runDir = (0, import_node_path3.join)(artifactsDir, entry.name);
+        const size = getDirSize(runDir);
+        (0, import_node_fs3.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_path3.join)(artifactsDir, folderName);
+  try {
+    const stat = (0, import_node_fs3.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_fs3.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_fs3.existsSync)(filePath)) {
+    sendJson(res, 404, { error: "File not found" });
+    return;
+  }
+  try {
+    const data = (0, import_node_fs3.readFileSync)(filePath);
+    const ext = (0, import_node_path3.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_fs3, import_node_path3, 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_fs3 = require("fs");
+    import_node_path3 = require("path");
+    init_jsonl_stream();
+    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_fs4.existsSync)((0, import_node_path4.join)(reportDir, "artifacts")) ? (0, import_node_path4.join)(reportDir, "artifacts") : (0, import_node_fs4.existsSync)((0, import_node_path4.join)(reportDir, "..", "artifacts")) ? (0, import_node_path4.join)(reportDir, "..", "artifacts") : (0, import_node_path4.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_path4.dirname)(reportDir);
+      try {
+        const htmlFile = (0, import_node_fs4.readdirSync)(parentDir).find((f) => f.endsWith(".html"));
+        if (htmlFile) htmlReportPath = (0, import_node_path4.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_fs4.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 testDataMatch = pathname.match(/^\/api\/tests\/([a-f0-9]+)\/(network|console|api-calls)$/);
+      if (req.method === "GET" && testDataMatch) {
+        handleTestDataFile(req, res, reportDir, testDataMatch[1], testDataMatch[2]);
+        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_path4.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_path4, import_node_fs4, 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_path4 = require("path");
+    import_node_fs4 = 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");
+    } catch (err) {
+      throw (0, import_core.createError)(
+        import_core.ErrorCode.MERGE_READ_FAILED,
+        `Failed to read file: ${file}`,
+        err
+      );
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch (err) {
+      throw (0, import_core.createError)(
+        import_core.ErrorCode.MERGE_INVALID_SCHEMA,
+        `Invalid JSON in file: ${file}`,
+        err
+      );
+    }
+    if (!(0, import_core.isValidTestRunReport)(parsed)) {
+      throw (0, import_core.createError)(
+        import_core.ErrorCode.MERGE_INVALID_SCHEMA,
+        `Invalid report schema in file: ${file}`
+      );
+    }
+    reports.push(parsed);
+  }
+  const shardRunIds = reports.map((r) => r.testRunId);
+  const allTimelines = [];
+  for (const report of reports) {
+    allTimelines.push(...report.timeline);
+  }
+  allTimelines.sort((a, b) => {
+    const timeA = "visitedAt" in a ? a.visitedAt : a.timestamp;
+    const timeB = "visitedAt" in b ? b.visitedAt : b.timestamp;
+    return new Date(timeA).getTime() - new Date(timeB).getTime();
+  });
+  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()
+  );
+  const completedAt = reports.reduce(
+    (latest, r) => r.completedAt > latest ? r.completedAt : latest,
+    reports[0]?.completedAt ?? (/* @__PURE__ */ new Date()).toISOString()
+  );
+  const totalDuration = new Date(completedAt).getTime() - new Date(startedAt).getTime();
+  const merged = {
+    schemaVersion: reports[0]?.schemaVersion ?? "1.0.0",
+    testRunId: options.testRunId ?? (0, import_node_crypto.randomUUID)(),
+    startedAt,
+    completedAt,
+    totalDuration,
+    summary,
+    ci: reports.find((r) => r.ci !== null)?.ci ?? null,
+    metadata: reports.find((r) => r.metadata !== null)?.metadata ?? null,
+    timeline: allTimelines,
+    shardRunIds
+  };
+  const dir = (0, import_node_path.dirname)(options.output);
+  (0, import_node_fs.mkdirSync)(dir, { recursive: true });
+  (0, import_node_fs.writeFileSync)(options.output, JSON.stringify(merged, null, 2), "utf-8");
+  return merged;
+}
+function recalculateSummaryFromList(summaries, timelineLength) {
+  let total = 0;
+  let passed = 0;
+  let failed = 0;
+  let flaky = 0;
+  let skipped = 0;
+  let timedout = 0;
+  let totalApiCalls = 0;
+  let totalAssertions = 0;
+  let passedAssertions = 0;
+  let failedAssertions = 0;
+  let 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,
+    passed,
+    failed,
+    flaky,
+    skipped,
+    timedout,
+    totalApiCalls,
+    uniqueApiUrls: 0,
+    apiCallsByMethod: {},
+    apiCallsByStatusRange: { "2xx": 0, "3xx": 0, "4xx": 0, "5xx": 0, error: 0 },
+    apiResponseTime: null,
+    totalAssertions,
+    passedAssertions,
+    failedAssertions,
+    totalNavigations,
+    uniqueNavigationUrls: 0,
+    totalTimelineSteps: timelineLength,
+    totalActionSteps: 0,
+    actionStepsByCategory: {}
+  };
+}
+
+// src/cli.ts
+var import_node_path5 = require("path");
+var import_node_fs5 = 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);
+  }
+  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);
+  }
+}
+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");
+    printUsage();
+    process.exit(1);
+  }
+  const output = mergeArgs[outputIndex + 1];
+  const files = [
+    ...mergeArgs.slice(0, outputIndex),
+    ...mergeArgs.slice(outputIndex + 2)
+  ];
+  if (files.length === 0) {
+    process.stderr.write("Error: No input files specified\n");
+    printUsage();
+    process.exit(1);
+  }
+  try {
+    const merged = await mergeReports(files, { output });
+    process.stderr.write(
+      `Merged ${files.length} reports (${merged.summary.total} tests) \u2192 ${output}
+`
+    );
+  } catch (err) {
+    process.stderr.write(
+      `Error: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+    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_path5.resolve)(dir);
+  if (!(0, import_node_fs5.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 <command>
+
+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
+
+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
+`
+  );
+}
+main();