@testrelic/maestro-analytics 1.1.0 → 1.2.0-next.52

package/dist/cli.cjs

@@ -190,6 +190,37 @@ function mergeCloudConfig(fileConfig, reporterOptions) {
 }
 
 // src/config.ts
+var DEFAULT_REDACT_HEADERS = [
+  "authorization",
+  "cookie",
+  "set-cookie",
+  "x-api-key"
+];
+var DEFAULT_REDACT_BODY_FIELDS = [
+  "password",
+  "secret",
+  "token",
+  "apiKey",
+  "api_key"
+];
+var DEFAULT_MAX_BODY_BYTES = 1024 * 1024;
+function resolveNetworkCapture(options) {
+  const o = options ?? {};
+  const envEnabled = process.env.TESTRELIC_CAPTURE_NETWORK === "1" || process.env.TESTRELIC_CAPTURE_NETWORK?.toLowerCase() === "true";
+  return Object.freeze({
+    enabled: o.enabled ?? envEnabled ?? false,
+    proxyPort: o.proxyPort ?? (process.env.TESTRELIC_PROXY_PORT ? Number.parseInt(process.env.TESTRELIC_PROXY_PORT, 10) : 8080),
+    proxyHost: o.proxyHost ?? process.env.TESTRELIC_PROXY_HOST ?? "127.0.0.1",
+    harPath: o.harPath ?? process.env.TESTRELIC_HAR_PATH ?? null,
+    outputDir: o.outputDir ?? null,
+    skipCertInstall: o.skipCertInstall ?? false,
+    includeUrls: Object.freeze(o.includeUrls ? [...o.includeUrls] : []),
+    excludeUrls: Object.freeze(o.excludeUrls ? [...o.excludeUrls] : []),
+    redactHeaders: Object.freeze(o.redactHeaders ? [...o.redactHeaders] : [...DEFAULT_REDACT_HEADERS]),
+    redactBodyFields: Object.freeze(o.redactBodyFields ? [...o.redactBodyFields] : [...DEFAULT_REDACT_BODY_FIELDS]),
+    maxBodyBytes: o.maxBodyBytes ?? DEFAULT_MAX_BODY_BYTES
+  });
+}
 var DANGEROUS_KEYS2 = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
 function hasPrototypePollution(obj) {
   if (typeof obj !== "object" || obj === null) return false;
@@ -237,6 +268,7 @@ function resolveConfig(options) {
   target.quiet = options?.quiet ?? false;
   target.reportMode = options?.reportMode ?? "batch";
   target.cloud = resolveCloudFromMerge(options?.cloud ?? null);
+  target.network = resolveNetworkCapture(options?.network);
   return Object.freeze(target);
 }
 function resolveCloudFromMerge(reporterOptions) {
@@ -251,14 +283,323 @@ function resolveCloudFromMerge(reporterOptions) {
 }
 
 // src/maestro-runner.ts
+var import_node_child_process3 = require("child_process");
+var import_node_fs4 = require("fs");
+var import_node_path4 = require("path");
+var import_node_os3 = require("os");
+var import_node_crypto2 = require("crypto");
+
+// src/network-proxy.ts
 var import_node_child_process = require("child_process");
 var import_node_fs2 = require("fs");
 var import_node_path2 = require("path");
+var import_node_url = require("url");
 var import_node_os = require("os");
 var import_node_crypto = require("crypto");
+var import_meta = {};
+function resolveAddonPath() {
+  const candidates = [];
+  try {
+    const here = (0, import_node_path2.dirname)((0, import_node_url.fileURLToPath)(import_meta.url));
+    candidates.push((0, import_node_path2.join)(here, "proxy-addon", "testrelic_capture.py"));
+    candidates.push((0, import_node_path2.join)(here, "..", "src", "proxy-addon", "testrelic_capture.py"));
+  } catch {
+  }
+  const maybeDirname = globalThis.__dirname;
+  if (maybeDirname) {
+    candidates.push((0, import_node_path2.join)(maybeDirname, "proxy-addon", "testrelic_capture.py"));
+  }
+  for (const c of candidates) {
+    if ((0, import_node_fs2.existsSync)(c)) return (0, import_node_path2.resolve)(c);
+  }
+  return null;
+}
+function generateRunDir(base) {
+  if (base) {
+    (0, import_node_fs2.mkdirSync)(base, { recursive: true });
+    return base;
+  }
+  const id = (0, import_node_crypto.randomBytes)(6).toString("hex");
+  const dir = (0, import_node_path2.join)((0, import_node_os.tmpdir)(), `testrelic-maestro-network-${id}`);
+  (0, import_node_fs2.mkdirSync)(dir, { recursive: true });
+  return dir;
+}
+async function isMitmdumpAvailable() {
+  return new Promise((resolvePromise) => {
+    const child = (0, import_node_child_process.spawn)("mitmdump", ["--version"], { shell: true });
+    let resolved = false;
+    const settle = (ok) => {
+      if (resolved) return;
+      resolved = true;
+      resolvePromise(ok);
+    };
+    child.on("error", () => settle(false));
+    child.on("close", (code) => settle(code === 0));
+    setTimeout(() => {
+      try {
+        child.kill();
+      } catch {
+      }
+      settle(false);
+    }, 5e3);
+  });
+}
+async function startNetworkProxy(options) {
+  const { config, verbose = true } = options;
+  if (!config.enabled) return null;
+  if (!await isMitmdumpAvailable()) {
+    if (verbose) {
+      process.stderr.write(
+        "\u26A0  TestRelic: --capture-network requested but `mitmdump` is not on PATH.\n   Install mitmproxy (`brew install mitmproxy` / `pipx install mitmproxy`)\n   or supply --har-path to import a HAR file instead.\n"
+      );
+    }
+    return null;
+  }
+  const addon = resolveAddonPath();
+  if (!addon) {
+    if (verbose) {
+      process.stderr.write("\u26A0  TestRelic: network-capture addon not found in package; skipping capture.\n");
+    }
+    return null;
+  }
+  const outputDir = generateRunDir(options.outputDir ?? config.outputDir ?? void 0);
+  const outputPath = (0, import_node_path2.join)(outputDir, "network.jsonl");
+  const args = [
+    "--listen-host",
+    config.proxyHost,
+    "--listen-port",
+    String(config.proxyPort),
+    "-s",
+    addon,
+    "--set",
+    `testrelic_output=${outputPath}`,
+    "--set",
+    `testrelic_redact_headers=${config.redactHeaders.join(",")}`,
+    "--set",
+    `testrelic_redact_body_fields=${config.redactBodyFields.join(",")}`,
+    "--set",
+    `testrelic_max_body_bytes=${config.maxBodyBytes}`,
+    // Reduce noise; the addon writes its own log lines on warn.
+    "--set",
+    "console_eventlog_verbosity=warn",
+    "--set",
+    "termlog_verbosity=warn"
+  ];
+  let child;
+  try {
+    child = (0, import_node_child_process.spawn)("mitmdump", args, {
+      stdio: ["ignore", "pipe", "pipe"],
+      shell: true
+    });
+  } catch (err) {
+    if (verbose) {
+      process.stderr.write(`\u26A0  TestRelic: failed to spawn mitmdump: ${err.message}
+`);
+    }
+    return null;
+  }
+  child.stdout?.on("data", (chunk) => {
+    if (verbose) process.stderr.write(`[mitmdump] ${chunk.toString("utf-8")}`);
+  });
+  child.stderr?.on("data", (chunk) => {
+    if (verbose) process.stderr.write(`[mitmdump] ${chunk.toString("utf-8")}`);
+  });
+  await new Promise((r) => setTimeout(r, 750));
+  const stop = () => new Promise((resolvePromise) => {
+    if (child.killed || child.exitCode !== null) {
+      resolvePromise();
+      return;
+    }
+    let settled = false;
+    const settle = () => {
+      if (settled) return;
+      settled = true;
+      resolvePromise();
+    };
+    child.once("close", settle);
+    child.once("exit", settle);
+    try {
+      child.kill("SIGINT");
+    } catch {
+      try {
+        child.kill();
+      } catch {
+      }
+    }
+    setTimeout(() => {
+      if (!settled) {
+        try {
+          child.kill("SIGKILL");
+        } catch {
+        }
+        settle();
+      }
+    }, 4e3);
+  });
+  return {
+    outputPath,
+    outputDir,
+    host: config.proxyHost,
+    port: config.proxyPort,
+    stop
+  };
+}
+
+// src/device-proxy-setup.ts
+var import_node_child_process2 = require("child_process");
+var import_node_path3 = require("path");
+var import_node_os2 = require("os");
+var import_node_fs3 = require("fs");
+var NOOP_HANDLE = { teardown: async () => {
+} };
+function commandExists(cmd) {
+  const result = (0, import_node_child_process2.spawnSync)(cmd, ["--version"], { shell: true, stdio: "ignore" });
+  return result.error === void 0 || result.error.code !== "ENOENT";
+}
+function logHint(quiet, msg) {
+  if (!quiet) process.stderr.write(`${msg}
+`);
+}
+function logManualInstructions(quiet, platform, proxyHost, proxyPort) {
+  if (quiet) return;
+  if (platform === "android") {
+    process.stderr.write(
+      `\u2139  TestRelic: real-device Android capture \u2014 set the device proxy manually:
+    Settings \u2192 Wi-Fi \u2192 (long-press your network) \u2192 Modify \u2192 Proxy: Manual
+    Host: ${proxyHost}    Port: ${proxyPort}
+    Then install mitmproxy CA: open http://mitm.it from the device after the proxy is reachable.
+`
+    );
+  } else if (platform === "ios") {
+    process.stderr.write(
+      `\u2139  TestRelic: real-device iOS capture \u2014 set the device proxy manually:
+    Settings \u2192 Wi-Fi \u2192 (i) on your network \u2192 Configure Proxy \u2192 Manual
+    Server: ${proxyHost}    Port: ${proxyPort}
+    Then install + TRUST the mitmproxy CA:
+      1. Open http://mitm.it from Safari on the device \u2192 install profile.
+      2. Settings \u2192 General \u2192 About \u2192 Certificate Trust Settings \u2192 enable mitmproxy.
+`
+    );
+  }
+}
+async function adb(args, deviceId) {
+  return new Promise((resolvePromise) => {
+    const full = deviceId ? ["-s", deviceId, ...args] : args;
+    const child = (0, import_node_child_process2.spawn)("adb", full, { shell: true, stdio: ["ignore", "pipe", "pipe"] });
+    let out = "";
+    let err = "";
+    child.stdout?.on("data", (c) => {
+      out += c.toString();
+    });
+    child.stderr?.on("data", (c) => {
+      err += c.toString();
+    });
+    child.on("error", () => resolvePromise({ code: 127, stdout: out, stderr: err || "adb not on PATH" }));
+    child.on("close", (code) => resolvePromise({ code: code ?? 1, stdout: out, stderr: err }));
+  });
+}
+async function setUpAndroidEmulator(opts) {
+  const { deviceId, proxyHost, proxyPort, quiet, skipCertInstall } = opts;
+  if (!commandExists("adb")) {
+    logHint(quiet, "\u26A0  TestRelic: `adb` not on PATH; skipping automatic Android proxy setup. See manual instructions:");
+    logManualInstructions(quiet, "android", proxyHost, proxyPort);
+    return NOOP_HANDLE;
+  }
+  const setResult = await adb(["shell", "settings", "put", "global", "http_proxy", `${proxyHost}:${proxyPort}`], deviceId);
+  if (setResult.code !== 0) {
+    logHint(quiet, `\u26A0  TestRelic: adb set proxy failed: ${setResult.stderr.trim() || "unknown error"}`);
+    logManualInstructions(quiet, "android", proxyHost, proxyPort);
+    return NOOP_HANDLE;
+  }
+  logHint(quiet, `\u2139  TestRelic: Android proxy set to ${proxyHost}:${proxyPort} on ${deviceId ?? "default device"}.`);
+  if (!skipCertInstall) {
+    logHint(
+      quiet,
+      "\u2139  TestRelic: if HTTPS calls fail, install the mitmproxy CA on the emulator:\n       open http://mitm.it from Chrome on the emulator and follow prompts,\n       OR for a system-level install:\n       adb root && adb remount && adb push <mitm-ca>.0 /system/etc/security/cacerts/ && adb reboot\n   Set --skip-cert-install to silence this hint."
+    );
+  }
+  const teardown = async () => {
+    await adb(["shell", "settings", "put", "global", "http_proxy", ":0"], deviceId);
+  };
+  return { teardown };
+}
+async function xcrun(args) {
+  return new Promise((resolvePromise) => {
+    const child = (0, import_node_child_process2.spawn)("xcrun", args, { shell: true, stdio: ["ignore", "pipe", "pipe"] });
+    let out = "";
+    let err = "";
+    child.stdout?.on("data", (c) => {
+      out += c.toString();
+    });
+    child.stderr?.on("data", (c) => {
+      err += c.toString();
+    });
+    child.on("error", () => resolvePromise({ code: 127, stdout: out, stderr: err || "xcrun not on PATH" }));
+    child.on("close", (code) => resolvePromise({ code: code ?? 1, stdout: out, stderr: err }));
+  });
+}
+async function setUpIosSimulator(opts) {
+  const { proxyHost, proxyPort, quiet, skipCertInstall } = opts;
+  if (process.platform !== "darwin") {
+    logHint(quiet, "\u26A0  TestRelic: iOS simulator capture requires macOS; the host is not Darwin. Skipping setup.");
+    logManualInstructions(quiet, "ios", proxyHost, proxyPort);
+    return NOOP_HANDLE;
+  }
+  if (!commandExists("xcrun")) {
+    logHint(quiet, "\u26A0  TestRelic: `xcrun` not on PATH; skipping automatic iOS simulator setup.");
+    logManualInstructions(quiet, "ios", proxyHost, proxyPort);
+    return NOOP_HANDLE;
+  }
+  if (!skipCertInstall) {
+    const caCandidate = (0, import_node_path3.join)(process.env.HOME ?? "", ".mitmproxy", "mitmproxy-ca-cert.pem");
+    if ((0, import_node_fs3.existsSync)(caCandidate)) {
+      const udid = opts.deviceId ?? "booted";
+      const res = await xcrun(["simctl", "keychain", udid, "add-root-cert", caCandidate]);
+      if (res.code === 0) {
+        logHint(quiet, `\u2139  TestRelic: installed mitmproxy CA on iOS simulator (${udid}).`);
+      } else {
+        logHint(quiet, `\u26A0  TestRelic: failed to add-root-cert via simctl: ${res.stderr.trim()}`);
+        logManualInstructions(quiet, "ios", proxyHost, proxyPort);
+      }
+    } else {
+      logHint(
+        quiet,
+        `\u26A0  TestRelic: mitmproxy CA not found at ${caCandidate}. Run mitmdump once to generate it,
+   then re-run with --capture-network. Falling back to manual instructions:`
+      );
+      logManualInstructions(quiet, "ios", proxyHost, proxyPort);
+    }
+  }
+  logHint(
+    quiet,
+    `\u2139  TestRelic: in the iOS simulator, configure Wi-Fi \u2192 (i) \u2192 Manual proxy:
+       Server: ${proxyHost}    Port: ${proxyPort}
+   (We do not set host-wide \`networksetup\` proxy automatically; see docs.)`
+  );
+  return NOOP_HANDLE;
+}
+async function setUpDeviceProxy(options) {
+  switch (options.platform) {
+    case "android":
+      return setUpAndroidEmulator(options);
+    case "ios":
+      return setUpIosSimulator(options);
+    case "web":
+      logHint(options.quiet, "\u2139  TestRelic: --capture-network ignored for Maestro web flows (browser already handles HTTP).");
+      return NOOP_HANDLE;
+    case "unknown":
+    default:
+      logHint(options.quiet, "\u26A0  TestRelic: target platform unknown; printing manual proxy setup instructions:");
+      logManualInstructions(options.quiet, "android", options.proxyHost, options.proxyPort);
+      logManualInstructions(options.quiet, "ios", options.proxyHost, options.proxyPort);
+      return NOOP_HANDLE;
+  }
+}
+
+// src/maestro-runner.ts
 function generateTempDir() {
-  const id = (0, import_node_crypto.randomBytes)(8).toString("hex");
-  return (0, import_node_path2.join)((0, import_node_os.tmpdir)(), `testrelic-maestro-${id}`);
+  const id = (0, import_node_crypto2.randomBytes)(8).toString("hex");
+  return (0, import_node_path4.join)((0, import_node_os3.tmpdir)(), `testrelic-maestro-${id}`);
 }
 function buildMaestroArgs(options, tempDir) {
   const args = [];
@@ -269,9 +610,9 @@ function buildMaestroArgs(options, tempDir) {
     args.push("--device", options.device);
   }
   args.push("test");
-  const junitPath = (0, import_node_path2.join)(tempDir, "report.xml");
-  const testOutputDir = (0, import_node_path2.join)(tempDir, "artifacts");
-  const debugOutputDir = (0, import_node_path2.join)(tempDir, "debug");
+  const junitPath = (0, import_node_path4.join)(tempDir, "report.xml");
+  const testOutputDir = (0, import_node_path4.join)(tempDir, "artifacts");
+  const debugOutputDir = (0, import_node_path4.join)(tempDir, "debug");
   args.push("--format", "junit");
   args.push("--output", junitPath);
   args.push("--test-output-dir", testOutputDir);
@@ -302,60 +643,124 @@ function buildMaestroArgs(options, tempDir) {
   args.push(...options.flowPaths);
   return args;
 }
-async function runMaestro(options) {
-  const tempDir = options.outputDir ? (0, import_node_path2.resolve)(options.outputDir) : generateTempDir();
-  (0, import_node_fs2.mkdirSync)((0, import_node_path2.join)(tempDir, "artifacts"), { recursive: true });
-  (0, import_node_fs2.mkdirSync)((0, import_node_path2.join)(tempDir, "debug"), { recursive: true });
-  const args = buildMaestroArgs(options, tempDir);
-  const junitPath = (0, import_node_path2.join)(tempDir, "report.xml");
-  const testOutputDir = (0, import_node_path2.join)(tempDir, "artifacts");
-  const debugOutputDir = (0, import_node_path2.join)(tempDir, "debug");
+function normalisePlatform(p) {
+  switch ((p ?? "").toLowerCase()) {
+    case "android":
+      return "android";
+    case "ios":
+      return "ios";
+    case "web":
+      return "web";
+    default:
+      return "unknown";
+  }
+}
+function runMaestroProc(args, junitPath, testOutputDir, debugOutputDir, networkJsonlDir, quiet, onClose) {
   return new Promise((resolvePromise) => {
     const stdoutChunks = [];
     const stderrChunks = [];
-    const proc = (0, import_node_child_process.spawn)("maestro", args, {
+    const proc = (0, import_node_child_process3.spawn)("maestro", args, {
       stdio: ["inherit", "pipe", "pipe"],
       shell: true
     });
     proc.stdout.on("data", (chunk) => {
       stdoutChunks.push(chunk);
-      if (!options.quiet) process.stdout.write(chunk);
+      if (!quiet) process.stdout.write(chunk);
     });
     proc.stderr.on("data", (chunk) => {
       stderrChunks.push(chunk);
-      if (!options.quiet) process.stderr.write(chunk);
+      if (!quiet) process.stderr.write(chunk);
     });
-    proc.on("close", (code) => {
+    proc.on("close", async (code) => {
+      try {
+        await onClose();
+      } catch {
+      }
       resolvePromise({
         exitCode: code ?? 1,
         junitPath,
         testOutputDir,
         debugOutputDir,
         stdout: Buffer.concat(stdoutChunks).toString("utf-8"),
-        stderr: Buffer.concat(stderrChunks).toString("utf-8")
+        stderr: Buffer.concat(stderrChunks).toString("utf-8"),
+        networkJsonlDir
       });
     });
-    proc.on("error", (err) => {
+    proc.on("error", async (err) => {
+      try {
+        await onClose();
+      } catch {
+      }
       resolvePromise({
         exitCode: 127,
         junitPath,
         testOutputDir,
         debugOutputDir,
         stdout: "",
-        stderr: `Failed to start maestro CLI: ${err.message}`
+        stderr: `Failed to start maestro CLI: ${err.message}`,
+        networkJsonlDir
       });
     });
   });
 }
+async function runMaestro(options, extras = {}) {
+  const tempDir = options.outputDir ? (0, import_node_path4.resolve)(options.outputDir) : generateTempDir();
+  (0, import_node_fs4.mkdirSync)((0, import_node_path4.join)(tempDir, "artifacts"), { recursive: true });
+  (0, import_node_fs4.mkdirSync)((0, import_node_path4.join)(tempDir, "debug"), { recursive: true });
+  const args = buildMaestroArgs(options, tempDir);
+  const junitPath = (0, import_node_path4.join)(tempDir, "report.xml");
+  const testOutputDir = (0, import_node_path4.join)(tempDir, "artifacts");
+  const debugOutputDir = (0, import_node_path4.join)(tempDir, "debug");
+  let proxyHandle = null;
+  let deviceHandle = null;
+  const networkConfig = extras.network;
+  if (networkConfig?.enabled) {
+    const networkDir = (0, import_node_path4.join)(tempDir, "network");
+    proxyHandle = await startNetworkProxy({
+      config: networkConfig,
+      outputDir: networkDir,
+      verbose: !options.quiet
+    });
+    if (proxyHandle) {
+      deviceHandle = await setUpDeviceProxy({
+        platform: normalisePlatform(options.platform),
+        deviceId: options.device,
+        proxyHost: proxyHandle.host,
+        proxyPort: proxyHandle.port,
+        skipCertInstall: networkConfig.skipCertInstall,
+        quiet: options.quiet
+      });
+    }
+  }
+  const networkJsonlDir = proxyHandle?.outputDir ?? null;
+  const cleanup = async () => {
+    if (proxyHandle) {
+      await new Promise((r) => setTimeout(r, 500));
+    }
+    if (deviceHandle) {
+      try {
+        await deviceHandle.teardown();
+      } catch {
+      }
+    }
+    if (proxyHandle) {
+      try {
+        await proxyHandle.stop();
+      } catch {
+      }
+    }
+  };
+  return runMaestroProc(args, junitPath, testOutputDir, debugOutputDir, networkJsonlDir, options.quiet, cleanup);
+}
 
 // src/report-orchestrator.ts
-var import_node_fs15 = require("fs");
-var import_node_path13 = require("path");
-var import_node_crypto3 = require("crypto");
+var import_node_fs18 = require("fs");
+var import_node_path16 = require("path");
+var import_node_crypto4 = require("crypto");
 
 // src/parsers/junit-parser.ts
 var import_fast_xml_parser = require("fast-xml-parser");
-var import_node_fs3 = require("fs");
+var import_node_fs5 = require("fs");
 var parser = new import_fast_xml_parser.XMLParser({
   ignoreAttributes: false,
   attributeNamePrefix: "@_",
@@ -453,13 +858,13 @@ function parseJUnitXml(xmlContent) {
   return { testSuites: suites, totalTests, totalFailures, totalErrors, totalSkipped, totalTime };
 }
 function parseJUnitFile(filePath) {
-  const content = (0, import_node_fs3.readFileSync)(filePath, "utf-8");
+  const content = (0, import_node_fs5.readFileSync)(filePath, "utf-8");
   return parseJUnitXml(content);
 }
 
 // src/parsers/command-parser.ts
-var import_node_fs4 = require("fs");
-var import_node_path3 = require("path");
+var import_node_fs6 = require("fs");
+var import_node_path5 = require("path");
 var INTERACTION_COMMANDS = /* @__PURE__ */ new Set([
   "tapOn",
   "doubleTapOn",
@@ -524,6 +929,9 @@ var AI_COMMANDS = /* @__PURE__ */ new Set([
   "assertNoDefectsWithAI",
   "extractTextWithAI"
 ]);
+var REDACTED_DETAIL_COMMANDS = /* @__PURE__ */ new Set(["inputText", "pasteText"]);
+var MAX_SCRIPT_DETAIL_LENGTH = 200;
+var MAX_AI_PROMPT_LENGTH = 400;
 function categorizeCommand(command) {
   if (AI_COMMANDS.has(command)) return "ai";
   if (ASSERTION_COMMANDS.has(command)) return "assertion";
@@ -564,22 +972,165 @@ function extractMaestroSelector(params) {
   if (typeof params.path === "string") return params.path;
   return void 0;
 }
+function truncate(value, max) {
+  if (value.length <= max) return value;
+  return `${value.slice(0, max)}\u2026`;
+}
+function redactText(value) {
+  if (value.length === 0) return "";
+  return `[REDACTED ${value.length} chars]`;
+}
+function stringifyPoint(point) {
+  if (!point || typeof point !== "object") return void 0;
+  const p = point;
+  if (typeof p.x === "number" && typeof p.y === "number") return `${p.x},${p.y}`;
+  return void 0;
+}
+function extractCommandDetails(commandName, params) {
+  const details = {};
+  switch (commandName) {
+    case "inputText":
+    case "pasteText": {
+      const text = params.text ?? params.value;
+      if (typeof text === "string") {
+        details.text = REDACTED_DETAIL_COMMANDS.has(commandName) ? redactText(text) : text;
+      }
+      break;
+    }
+    case "swipe":
+    case "scroll":
+    case "scrollUntilVisible": {
+      if (typeof params.direction === "string") details.direction = params.direction;
+      const startPoint = stringifyPoint(params.start ?? params.startRelative);
+      const endPoint = stringifyPoint(params.end ?? params.endRelative);
+      if (startPoint) details.start = startPoint;
+      if (endPoint) details.end = endPoint;
+      if (typeof params.duration === "number") details.swipeDurationMs = params.duration;
+      if (typeof params.timeout === "number") details.timeoutMs = params.timeout;
+      break;
+    }
+    case "setLocation": {
+      if (typeof params.latitude === "number") details.latitude = params.latitude;
+      if (typeof params.longitude === "number") details.longitude = params.longitude;
+      break;
+    }
+    case "pressKey":
+    case "back": {
+      if (typeof params.key === "string") details.key = params.key;
+      else if (typeof params.code === "string") details.key = params.code;
+      break;
+    }
+    case "setOrientation": {
+      if (typeof params.orientation === "string") details.orientation = params.orientation;
+      break;
+    }
+    case "setAirplaneMode":
+    case "toggleAirplaneMode": {
+      if (typeof params.value === "string" || typeof params.value === "boolean") {
+        details.value = params.value;
+      }
+      break;
+    }
+    case "setPermissions": {
+      if (params.permissions && typeof params.permissions === "object") {
+        details.permissions = params.permissions;
+      }
+      break;
+    }
+    case "addMedia": {
+      if (Array.isArray(params.mediaPaths)) details.mediaPaths = params.mediaPaths;
+      else if (typeof params.path === "string") details.mediaPaths = [params.path];
+      break;
+    }
+    case "launchApp":
+    case "killApp":
+    case "stopApp":
+    case "clearState": {
+      const appId = params.appId ?? params.packageName ?? params.bundleId;
+      if (typeof appId === "string") details.appId = appId;
+      if (params.arguments) details.arguments = params.arguments;
+      break;
+    }
+    case "openLink": {
+      if (typeof params.url === "string") details.url = params.url;
+      else if (typeof params.link === "string") details.url = params.link;
+      break;
+    }
+    case "runScript":
+    case "evalScript": {
+      if (typeof params.path === "string") details.path = params.path;
+      if (typeof params.script === "string") details.script = truncate(params.script, MAX_SCRIPT_DETAIL_LENGTH);
+      if (typeof params.sourceDescription === "string") details.sourceDescription = params.sourceDescription;
+      break;
+    }
+    case "assertWithAI":
+    case "assertNoDefectsWithAI":
+    case "extractTextWithAI": {
+      const prompt = params.assertion ?? params.prompt ?? params.question;
+      if (typeof prompt === "string") details.prompt = truncate(prompt, MAX_AI_PROMPT_LENGTH);
+      break;
+    }
+    case "extendedWaitUntil":
+    case "waitForAnimationToEnd": {
+      if (typeof params.timeout === "number") details.timeoutMs = params.timeout;
+      break;
+    }
+    case "repeat":
+    case "retry": {
+      if (typeof params.times === "number") details.times = params.times;
+      if (typeof params.maxRetries === "number") details.maxRetries = params.maxRetries;
+      if (typeof params.condition === "object" && params.condition) details.condition = params.condition;
+      break;
+    }
+    case "runFlow": {
+      if (typeof params.file === "string") details.file = params.file;
+      if (typeof params.flowId === "string") details.flowId = params.flowId;
+      break;
+    }
+    default:
+      for (const key of ["text", "value", "url"]) {
+        const v = params[key];
+        if (typeof v === "string" || typeof v === "number" || typeof v === "boolean") {
+          details[key] = v;
+          break;
+        }
+      }
+  }
+  return Object.keys(details).length > 0 ? details : void 0;
+}
+function extractChildCommands(params, raw, baseTimestamp) {
+  const candidates = [params.commands, raw.commands, raw.subSteps, raw.children];
+  for (const c of candidates) {
+    if (Array.isArray(c) && c.length > 0) {
+      return c.map(
+        (entry, i) => parseRawCommand(entry, i, baseTimestamp)
+      );
+    }
+  }
+  return [];
+}
 function parseRawCommand(raw, index, baseTimestamp) {
   let command;
   let selector;
+  let details;
+  let children = [];
   if (typeof raw.command === "object" && raw.command !== null && !Array.isArray(raw.command)) {
     const commandObj = raw.command;
     const rawKey = Object.keys(commandObj)[0] ?? `step-${index}`;
     command = normalizeMaestroCommandName(rawKey);
     const params = commandObj[rawKey] ?? {};
     selector = extractMaestroSelector(params);
+    details = extractCommandDetails(command, params);
+    children = extractChildCommands(params, raw, baseTimestamp);
   } else {
     command = raw.command ?? raw.commandName ?? raw.name ?? `step-${index}`;
     selector = raw.selector ?? void 0;
+    children = extractChildCommands({}, raw, baseTimestamp);
   }
   const meta = raw.metadata ?? {};
   const status = mapStatus(meta.status ?? raw.status);
   const duration = meta.duration ?? raw.duration ?? raw.durationMs ?? 0;
+  const sequenceNumber = typeof meta.sequenceNumber === "number" ? meta.sequenceNumber : void 0;
   let timestamp;
   if (typeof meta.timestamp === "number") {
     timestamp = new Date(meta.timestamp).toISOString();
@@ -594,7 +1145,10 @@ function parseRawCommand(raw, index, baseTimestamp) {
     duration,
     timestamp,
     ...selector ? { selector } : {},
-    ...error ? { error } : {}
+    ...error ? { error } : {},
+    ...details ? { details } : {},
+    ...sequenceNumber !== void 0 ? { sequenceNumber } : {},
+    ...children.length > 0 ? { children } : {}
   };
 }
 function mapStatus(status) {
@@ -625,24 +1179,24 @@ function parseCommandsJson(jsonContent, baseTimestamp) {
 }
 function parseCommandsFile(filePath, baseTimestamp) {
   try {
-    const content = (0, import_node_fs4.readFileSync)(filePath, "utf-8");
+    const content = (0, import_node_fs6.readFileSync)(filePath, "utf-8");
     return parseCommandsJson(content, baseTimestamp);
   } catch {
     return [];
   }
 }
 function discoverCommandFiles(artifactsDir) {
-  if (!(0, import_node_fs4.existsSync)(artifactsDir)) return [];
+  if (!(0, import_node_fs6.existsSync)(artifactsDir)) return [];
   try {
-    return (0, import_node_fs4.readdirSync)(artifactsDir, { recursive: true }).map(String).filter((f) => (0, import_node_path3.basename)(f).startsWith("commands") && f.endsWith(".json")).map((f) => (0, import_node_path3.join)(artifactsDir, f));
+    return (0, import_node_fs6.readdirSync)(artifactsDir, { recursive: true }).map(String).filter((f) => (0, import_node_path5.basename)(f).startsWith("commands") && f.endsWith(".json")).map((f) => (0, import_node_path5.join)(artifactsDir, f));
   } catch {
     return [];
   }
 }
 
 // src/parsers/flow-parser.ts
-var import_node_fs5 = require("fs");
-var import_node_path4 = require("path");
+var import_node_fs7 = require("fs");
+var import_node_path6 = require("path");
 var import_yaml = require("yaml");
 function extractSubflowRefs(body) {
   const refs = [];
@@ -736,21 +1290,21 @@ function parseFlowYaml(content, filePath) {
   };
 }
 function parseFlowFile(filePath) {
-  const content = (0, import_node_fs5.readFileSync)(filePath, "utf-8");
+  const content = (0, import_node_fs7.readFileSync)(filePath, "utf-8");
   return parseFlowYaml(content, filePath);
 }
 function discoverFlowFiles(dir) {
-  if (!(0, import_node_fs5.existsSync)(dir)) return [];
+  if (!(0, import_node_fs7.existsSync)(dir)) return [];
   const results = [];
   function walk(currentDir) {
     try {
-      const entries = (0, import_node_fs5.readdirSync)(currentDir, { withFileTypes: true });
+      const entries = (0, import_node_fs7.readdirSync)(currentDir, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = (0, import_node_path4.join)(currentDir, entry.name);
+        const fullPath = (0, import_node_path6.join)(currentDir, entry.name);
         if (entry.isDirectory()) {
           walk(fullPath);
         } else if (entry.isFile()) {
-          const ext = (0, import_node_path4.extname)(entry.name).toLowerCase();
+          const ext = (0, import_node_path6.extname)(entry.name).toLowerCase();
           if (ext === ".yaml" || ext === ".yml") {
             results.push(fullPath);
           }
@@ -764,9 +1318,9 @@ function discoverFlowFiles(dir) {
 }
 
 // src/parsers/log-parser.ts
-var import_node_fs6 = require("fs");
-var import_node_path5 = require("path");
-var import_node_fs7 = require("fs");
+var import_node_fs8 = require("fs");
+var import_node_path7 = require("path");
+var import_node_fs9 = require("fs");
 var LOG_LINE_REGEX = /^(\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:?\d{2})?)\s+(\w+)\s+(.+)$/;
 var TIMESTAMP_ONLY_REGEX = /^\[?(\d{2}:\d{2}:\d{2}(?:\.\d+)?)\]?\s+(\w+)\s+(.+)$/;
 function parseLevel(raw) {
@@ -816,7 +1370,7 @@ function parseLogContent(content) {
 }
 function parseLogFile(filePath) {
   try {
-    const content = (0, import_node_fs6.readFileSync)(filePath, "utf-8");
+    const content = (0, import_node_fs8.readFileSync)(filePath, "utf-8");
     return parseLogContent(content);
   } catch {
     return [];
@@ -838,17 +1392,17 @@ function detectPlatformFromLogs(entries) {
   return "unknown";
 }
 function discoverLogFiles(dir) {
-  if (!(0, import_node_fs6.existsSync)(dir)) return [];
+  if (!(0, import_node_fs8.existsSync)(dir)) return [];
   try {
-    return (0, import_node_fs7.readdirSync)(dir, { recursive: true }).map(String).filter((f) => (0, import_node_path5.basename)(f) === "maestro.log" || f.endsWith(".log")).map((f) => (0, import_node_path5.join)(dir, f));
+    return (0, import_node_fs9.readdirSync)(dir, { recursive: true }).map(String).filter((f) => (0, import_node_path7.basename)(f) === "maestro.log" || f.endsWith(".log")).map((f) => (0, import_node_path7.join)(dir, f));
   } catch {
     return [];
   }
 }
 
 // src/parsers/ai-report-parser.ts
-var import_node_fs8 = require("fs");
-var import_node_path6 = require("path");
+var import_node_fs10 = require("fs");
+var import_node_path8 = require("path");
 var DEFECT_SECTION_REGEX = /(?:defect|issue|bug|error|warning|problem)/i;
 var SEVERITY_CRITICAL_REGEX = /(?:critical|severe|major|blocker)/i;
 var SEVERITY_WARNING_REGEX = /(?:warning|moderate|minor)/i;
@@ -935,38 +1489,250 @@ function parseAiReportHtml(htmlContent) {
 }
 function parseAiReportFile(filePath) {
   try {
-    const content = (0, import_node_fs8.readFileSync)(filePath, "utf-8");
+    const content = (0, import_node_fs10.readFileSync)(filePath, "utf-8");
     return parseAiReportHtml(content);
   } catch {
     return { defects: [], totalDefects: 0, hasIssues: false, rawHtml: null };
   }
 }
 function discoverAiReports(dir) {
-  if (!(0, import_node_fs8.existsSync)(dir)) return [];
+  if (!(0, import_node_fs10.existsSync)(dir)) return [];
   try {
-    return (0, import_node_fs8.readdirSync)(dir, { recursive: true }).map(String).filter((f) => {
-      const name = (0, import_node_path6.basename)(f).toLowerCase();
-      const ext = (0, import_node_path6.extname)(f).toLowerCase();
+    return (0, import_node_fs10.readdirSync)(dir, { recursive: true }).map(String).filter((f) => {
+      const name = (0, import_node_path8.basename)(f).toLowerCase();
+      const ext = (0, import_node_path8.extname)(f).toLowerCase();
       return ext === ".html" && (name.includes("insight") || name.includes("ai") || name.includes("analysis"));
-    }).map((f) => (0, import_node_path6.join)(dir, f));
+    }).map((f) => (0, import_node_path8.join)(dir, f));
+  } catch {
+    return [];
+  }
+}
+
+// src/parsers/network-parser.ts
+var import_node_fs11 = require("fs");
+var import_node_path9 = require("path");
+
+// src/api-redactor.ts
+var REDACTED = "[REDACTED]";
+function redactHeaders(headers, redactList) {
+  if (!headers) return null;
+  const lower = new Set(redactList.map((h) => h.toLowerCase()));
+  const out = {};
+  for (const [k, v] of Object.entries(headers)) {
+    out[k] = lower.has(k.toLowerCase()) ? REDACTED : v;
+  }
+  return out;
+}
+function redactJsonBody(value, fields) {
+  if (value === null || typeof value !== "object") return value;
+  if (Array.isArray(value)) return value.map((v) => redactJsonBody(v, fields));
+  const out = {};
+  for (const [k, v] of Object.entries(value)) {
+    out[k] = fields.has(k) ? REDACTED : redactJsonBody(v, fields);
+  }
+  return out;
+}
+function redactBody(body, fields) {
+  if (!body || fields.length === 0) return body;
+  try {
+    const parsed = JSON.parse(body);
+    const redacted = redactJsonBody(parsed, new Set(fields));
+    return JSON.stringify(redacted);
+  } catch {
+    return body;
+  }
+}
+function redactApiCall(call, redactHeadersList, redactBodyFields) {
+  return {
+    ...call,
+    requestHeaders: redactHeaders(call.requestHeaders, redactHeadersList),
+    responseHeaders: redactHeaders(call.responseHeaders, redactHeadersList),
+    requestBody: redactBody(call.requestBody, redactBodyFields),
+    responseBody: call.isBinary ? call.responseBody : redactBody(call.responseBody, redactBodyFields)
+  };
+}
+function matchesUrlFilter(url, include, exclude) {
+  const matches = (pat) => typeof pat === "string" ? url.includes(pat) : pat.test(url);
+  if (exclude.some(matches)) return false;
+  if (include.length === 0) return true;
+  return include.some(matches);
+}
+
+// src/parsers/network-parser.ts
+function parseJsonlLine(line2) {
+  const trimmed = line2.trim();
+  if (!trimmed) return null;
+  try {
+    const obj = JSON.parse(trimmed);
+    if (typeof obj.url !== "string" || typeof obj.method !== "string") return null;
+    return {
+      id: obj.id ?? `api-call-${Date.now()}`,
+      timestamp: obj.timestamp ?? (/* @__PURE__ */ new Date()).toISOString(),
+      method: obj.method,
+      url: obj.url,
+      requestHeaders: obj.requestHeaders ?? null,
+      requestBody: obj.requestBody ?? null,
+      responseStatusCode: obj.responseStatusCode ?? null,
+      responseStatusText: obj.responseStatusText ?? null,
+      responseHeaders: obj.responseHeaders ?? null,
+      responseBody: obj.responseBody ?? null,
+      responseTimeMs: typeof obj.responseTimeMs === "number" ? obj.responseTimeMs : 0,
+      isBinary: obj.isBinary ?? false,
+      error: obj.error ?? null
+    };
+  } catch {
+    return null;
+  }
+}
+function parseNetworkJsonl(content, config) {
+  const records = [];
+  for (const line2 of content.split(/\r?\n/)) {
+    const rec = parseJsonlLine(line2);
+    if (!rec) continue;
+    if (!matchesUrlFilter(rec.url, config.includeUrls, config.excludeUrls)) continue;
+    records.push(redactApiCall(rec, config.redactHeaders, config.redactBodyFields));
+  }
+  return records;
+}
+function parseNetworkJsonlFile(filePath, config) {
+  try {
+    return parseNetworkJsonl((0, import_node_fs11.readFileSync)(filePath, "utf-8"), config);
+  } catch {
+    return [];
+  }
+}
+function discoverNetworkJsonlFiles(dir) {
+  if (!(0, import_node_fs11.existsSync)(dir)) return [];
+  try {
+    return (0, import_node_fs11.readdirSync)(dir, { recursive: true }).map(String).filter((f) => f.endsWith(".jsonl")).map((f) => (0, import_node_path9.join)(dir, f));
+  } catch {
+    return [];
+  }
+}
+function harHeadersToRecord(headers) {
+  if (!headers || headers.length === 0) return null;
+  const out = {};
+  for (const h of headers) {
+    if (typeof h.name === "string" && typeof h.value === "string") out[h.name] = h.value;
+  }
+  return Object.keys(out).length > 0 ? out : null;
+}
+function harBodyToString(postData) {
+  if (!postData) return null;
+  if (typeof postData.text === "string") return postData.text;
+  if (Array.isArray(postData.params)) {
+    return postData.params.map((p) => `${encodeURIComponent(p.name)}=${encodeURIComponent(p.value ?? "")}`).join("&");
+  }
+  return null;
+}
+function isBinaryMime(mime) {
+  if (!mime) return false;
+  return /^(image|audio|video|application\/(octet-stream|pdf|zip|protobuf))/.test(mime);
+}
+function harEntryToRecord(entry, index) {
+  const req = entry.request;
+  const res = entry.response;
+  if (!req?.method || !req.url) return null;
+  const content = res?.content;
+  const isBinary = isBinaryMime(content?.mimeType);
+  return {
+    id: `har-call-${index}`,
+    timestamp: entry.startedDateTime ?? (/* @__PURE__ */ new Date()).toISOString(),
+    method: req.method,
+    url: req.url,
+    requestHeaders: harHeadersToRecord(req.headers),
+    requestBody: harBodyToString(req.postData),
+    responseStatusCode: typeof res?.status === "number" && res.status > 0 ? res.status : null,
+    responseStatusText: res?.statusText ?? null,
+    responseHeaders: harHeadersToRecord(res?.headers),
+    responseBody: content?.text ?? null,
+    responseTimeMs: typeof entry.time === "number" ? entry.time : 0,
+    isBinary,
+    error: null
+  };
+}
+function parseHar(content, config) {
+  let parsed;
+  try {
+    parsed = JSON.parse(content);
+  } catch {
+    return [];
+  }
+  const entries = parsed.log?.entries ?? [];
+  const records = [];
+  entries.forEach((entry, i) => {
+    const rec = harEntryToRecord(entry, i);
+    if (!rec) return;
+    if (!matchesUrlFilter(rec.url, config.includeUrls, config.excludeUrls)) return;
+    records.push(redactApiCall(rec, config.redactHeaders, config.redactBodyFields));
+  });
+  return records;
+}
+function parseHarFile(filePath, config) {
+  try {
+    return parseHar((0, import_node_fs11.readFileSync)(filePath, "utf-8"), config);
   } catch {
     return [];
   }
 }
+function bindApiCallsToFlows(calls, flows) {
+  const buckets = /* @__PURE__ */ new Map();
+  for (const f of flows) buckets.set(f.testId, []);
+  if (calls.length === 0 || flows.length === 0) return buckets;
+  const windows = flows.map((f) => ({
+    testId: f.testId,
+    startMs: Date.parse(f.startedAt),
+    endMs: Date.parse(f.completedAt)
+  }));
+  for (const call of calls) {
+    const t = Date.parse(call.timestamp);
+    if (!Number.isFinite(t)) continue;
+    const hit = windows.find((w) => Number.isFinite(w.startMs) && Number.isFinite(w.endMs) && t >= w.startMs && t <= w.endMs);
+    if (hit) {
+      buckets.get(hit.testId).push(call);
+      continue;
+    }
+    let best = null;
+    for (const w of windows) {
+      if (!Number.isFinite(w.startMs) || !Number.isFinite(w.endMs)) continue;
+      const dist = t < w.startMs ? w.startMs - t : t - w.endMs;
+      if (!best || dist < best.dist) best = { testId: w.testId, dist };
+    }
+    if (best) buckets.get(best.testId).push(call);
+  }
+  return buckets;
+}
+function collectNetworkByFlow(jsonlDir, config, flows) {
+  if (!config.enabled && !config.harPath) return /* @__PURE__ */ new Map();
+  const all = [];
+  if (jsonlDir) {
+    for (const file of discoverNetworkJsonlFiles(jsonlDir)) {
+      all.push(...parseNetworkJsonlFile(file, config));
+    }
+  }
+  if (config.harPath && (0, import_node_fs11.existsSync)(config.harPath)) {
+    all.push(...parseHarFile(config.harPath, config));
+  }
+  if (all.length === 0) return /* @__PURE__ */ new Map();
+  return bindApiCallsToFlows(all, flows);
+}
+function reindexFlowCalls(calls) {
+  return calls.map((c, i) => ({ ...c, id: `api-call-${i}` }));
+}
 
 // src/artifact-collector.ts
-var import_node_fs9 = require("fs");
-var import_node_path7 = require("path");
+var import_node_fs12 = require("fs");
+var import_node_path10 = require("path");
 var IMAGE_EXTENSIONS = /* @__PURE__ */ new Set([".png", ".jpg", ".jpeg", ".webp"]);
 var VIDEO_EXTENSIONS = /* @__PURE__ */ new Set([".mp4", ".webm", ".mov"]);
 function walkDir(dir) {
   const results = [];
-  if (!(0, import_node_fs9.existsSync)(dir)) return results;
+  if (!(0, import_node_fs12.existsSync)(dir)) return results;
   function recurse(current) {
     try {
-      const entries = (0, import_node_fs9.readdirSync)(current, { withFileTypes: true });
+      const entries = (0, import_node_fs12.readdirSync)(current, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = (0, import_node_path7.join)(current, entry.name);
+        const fullPath = (0, import_node_path10.join)(current, entry.name);
         if (entry.isDirectory()) {
           recurse(fullPath);
         } else if (entry.isFile()) {
@@ -993,8 +1759,8 @@ function collectArtifacts(testOutputDir, debugOutputDir) {
   for (const filePath of allFiles) {
     if (seen.has(filePath)) continue;
     seen.add(filePath);
-    const name = (0, import_node_path7.basename)(filePath).toLowerCase();
-    const ext = (0, import_node_path7.extname)(filePath).toLowerCase();
+    const name = (0, import_node_path10.basename)(filePath).toLowerCase();
+    const ext = (0, import_node_path10.extname)(filePath).toLowerCase();
     if (IMAGE_EXTENSIONS.has(ext)) {
       screenshotPaths.push(filePath);
       continue;
@@ -1055,24 +1821,106 @@ function mapCommandCategory(category) {
       return "custom_step";
   }
 }
-function commandToAction(cmd) {
+function buildStepTitle(cmd) {
+  const d = cmd.details;
+  if (d) {
+    switch (cmd.command) {
+      case "inputText":
+      case "pasteText":
+        if (typeof d.text === "string") return `${cmd.command} \u2192 ${d.text}`;
+        break;
+      case "swipe":
+      case "scroll":
+      case "scrollUntilVisible":
+        if (typeof d.direction === "string") return `${cmd.command} ${d.direction}`;
+        break;
+      case "setLocation":
+        if (typeof d.latitude === "number" && typeof d.longitude === "number") {
+          return `setLocation ${d.latitude},${d.longitude}`;
+        }
+        break;
+      case "pressKey":
+        if (typeof d.key === "string") return `pressKey ${d.key}`;
+        break;
+      case "setOrientation":
+        if (typeof d.orientation === "string") return `setOrientation ${d.orientation}`;
+        break;
+      case "launchApp":
+      case "killApp":
+      case "stopApp":
+      case "clearState":
+        if (typeof d.appId === "string") return `${cmd.command} ${d.appId}`;
+        break;
+      case "openLink":
+        if (typeof d.url === "string") return `openLink ${d.url}`;
+        break;
+      case "runScript":
+      case "evalScript":
+        if (typeof d.path === "string") return `${cmd.command} ${d.path}`;
+        if (typeof d.sourceDescription === "string") return `${cmd.command} ${d.sourceDescription}`;
+        break;
+      case "assertWithAI":
+      case "assertNoDefectsWithAI":
+      case "extractTextWithAI":
+        if (typeof d.prompt === "string") return `${cmd.command} \u2192 ${d.prompt}`;
+        break;
+      case "retry":
+        if (typeof d.maxRetries === "number") return `retry \xD7 ${d.maxRetries}`;
+        break;
+      case "repeat":
+        if (typeof d.times === "number") return `repeat \xD7 ${d.times}`;
+        break;
+      case "runFlow":
+        if (typeof d.file === "string") return `runFlow ${d.file}`;
+        break;
+    }
+  }
+  return cmd.selector ? `${cmd.command} \u2192 ${cmd.selector}` : cmd.command;
+}
+function commandToAction(cmd, flowStartedMs) {
+  const cmdMs = Date.parse(cmd.timestamp);
+  const videoOffset = Number.isFinite(cmdMs) && Number.isFinite(flowStartedMs) ? Math.max(0, (cmdMs - flowStartedMs) / 1e3) : null;
+  const children = (cmd.children ?? []).map((c) => commandToAction(c, flowStartedMs));
   return {
-    title: cmd.selector ? `${cmd.command} \u2192 ${cmd.selector}` : cmd.command,
+    title: buildStepTitle(cmd),
     category: mapCommandCategory(cmd.category),
     status: cmd.status === "failed" ? "failed" : "passed",
     duration: cmd.duration,
     timestamp: cmd.timestamp,
-    videoOffset: null,
+    videoOffset,
     error: cmd.error ?? null,
-    children: []
+    children
   };
 }
-function buildTestResult(flow) {
+function sortActions(a, b) {
+  const ta = Date.parse(a.timestamp);
+  const tb = Date.parse(b.timestamp);
+  if (Number.isFinite(ta) && Number.isFinite(tb) && ta !== tb) return ta - tb;
+  return 0;
+}
+function buildTestResult(flow, apiCalls) {
+  const flowStartedMs = Date.parse(flow.startedAt);
+  const orderedCommands = [...flow.commands].sort((a, b) => {
+    const ta = Date.parse(a.timestamp);
+    const tb = Date.parse(b.timestamp);
+    if (Number.isFinite(ta) && Number.isFinite(tb) && ta !== tb) return ta - tb;
+    const sa = a.sequenceNumber ?? 0;
+    const sb = b.sequenceNumber ?? 0;
+    return sa - sb;
+  });
+  const orderedAssertions = [...flow.assertions].sort((a, b) => {
+    const ta = Date.parse(a.timestamp);
+    const tb = Date.parse(b.timestamp);
+    if (Number.isFinite(ta) && Number.isFinite(tb) && ta !== tb) return ta - tb;
+    const sa = a.sequenceNumber ?? 0;
+    const sb = b.sequenceNumber ?? 0;
+    return sa - sb;
+  });
   const actions = [
-    ...flow.commands.map(commandToAction),
-    ...flow.assertions.map(commandToAction)
+    ...orderedCommands.map((c) => commandToAction(c, flowStartedMs)),
+    ...orderedAssertions.map((c) => commandToAction(c, flowStartedMs))
   ];
-  actions.sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
+  actions.sort(sortActions);
   const artifacts = flow.screenshotPaths.length > 0 || flow.videoPath ? {
     screenshot: flow.screenshotPaths[0] ?? void 0,
     video: flow.videoPath ?? void 0
@@ -1100,14 +1948,16 @@ function buildTestResult(flow) {
     actualStatus: flow.status,
     artifacts,
     networkRequests: null,
-    apiCalls: null,
+    apiCalls: apiCalls.length > 0 ? [...apiCalls] : null,
     apiAssertions: null,
     actions: actions.length > 0 ? actions : null,
     consoleLogs: null
   };
 }
-function buildTimelineEntry(flow) {
-  const testResult = buildTestResult(flow);
+function buildTimelineEntry(flow, apiCallsByFlow) {
+  const testId = `${flow.flowFile}::${flow.flowName}`;
+  const apiCalls = apiCallsByFlow?.get(testId) ?? [];
+  const testResult = buildTestResult(flow, apiCalls);
   return {
     url: flow.appId ?? "maestro-flow",
     navigationType: "page_load",
@@ -1120,8 +1970,8 @@ function buildTimelineEntry(flow) {
     tests: [testResult]
   };
 }
-function buildTimeline(flows) {
-  return flows.map(buildTimelineEntry);
+function buildTimeline(flows, apiCallsByFlow) {
+  return flows.map((f) => buildTimelineEntry(f, apiCallsByFlow));
 }
 
 // src/summary-builder.ts
@@ -1132,6 +1982,58 @@ var EMPTY_STATUS_RANGE = {
   "5xx": 0,
   error: 0
 };
+function statusBucket(code) {
+  if (code === null) return "error";
+  if (code >= 200 && code < 300) return "2xx";
+  if (code >= 300 && code < 400) return "3xx";
+  if (code >= 400 && code < 500) return "4xx";
+  if (code >= 500 && code < 600) return "5xx";
+  return "error";
+}
+function percentile(sorted, p) {
+  if (sorted.length === 0) return null;
+  const idx = Math.min(sorted.length - 1, Math.floor(p / 100 * sorted.length));
+  return sorted[idx];
+}
+function buildApiStats(calls) {
+  if (calls.length === 0) {
+    return {
+      totalApiCalls: 0,
+      uniqueApiUrls: 0,
+      apiCallsByMethod: {},
+      apiCallsByStatusRange: { ...EMPTY_STATUS_RANGE },
+      apiResponseTime: null
+    };
+  }
+  const byMethod = {};
+  const byStatus = { ...EMPTY_STATUS_RANGE };
+  const urls = /* @__PURE__ */ new Set();
+  const times = [];
+  for (const c of calls) {
+    byMethod[c.method] = (byMethod[c.method] ?? 0) + 1;
+    byStatus[statusBucket(c.responseStatusCode)] += 1;
+    urls.add(c.url);
+    if (Number.isFinite(c.responseTimeMs) && c.responseTimeMs > 0) {
+      times.push(c.responseTimeMs);
+    }
+  }
+  times.sort((a, b) => a - b);
+  const apiResponseTime = times.length > 0 ? {
+    p50: percentile(times, 50) ?? 0,
+    p95: percentile(times, 95) ?? 0,
+    p99: percentile(times, 99) ?? 0,
+    avg: times.reduce((s, n) => s + n, 0) / times.length,
+    min: times[0],
+    max: times[times.length - 1]
+  } : null;
+  return {
+    totalApiCalls: calls.length,
+    uniqueApiUrls: urls.size,
+    apiCallsByMethod: byMethod,
+    apiCallsByStatusRange: byStatus,
+    apiResponseTime
+  };
+}
 function buildSummary(timeline) {
   let total = 0;
   let passed = 0;
@@ -1146,6 +2048,7 @@ function buildSummary(timeline) {
   let totalActionSteps = 0;
   const actionCategoryCounts = {};
   const uniqueUrls = /* @__PURE__ */ new Set();
+  const allApiCalls = [];
   for (const entry of timeline) {
     uniqueUrls.add(entry.url);
     for (const test of entry.tests) {
@@ -1180,8 +2083,12 @@ function buildSummary(timeline) {
           }
         }
       }
+      if (test.apiCalls && test.apiCalls.length > 0) {
+        allApiCalls.push(...test.apiCalls);
+      }
     }
   }
+  const apiStats = buildApiStats(allApiCalls);
   return {
     total,
     passed,
@@ -1189,11 +2096,7 @@ function buildSummary(timeline) {
     flaky,
     skipped,
     timedout,
-    totalApiCalls: 0,
-    uniqueApiUrls: 0,
-    apiCallsByMethod: {},
-    apiCallsByStatusRange: EMPTY_STATUS_RANGE,
-    apiResponseTime: null,
+    ...apiStats,
     totalAssertions,
     passedAssertions,
     failedAssertions,
@@ -1206,8 +2109,8 @@ function buildSummary(timeline) {
 }
 
 // src/html-report.ts
-var import_node_fs10 = require("fs");
-var import_node_path8 = require("path");
+var import_node_fs13 = require("fs");
+var import_node_path11 = require("path");
 
 // src/html-css.ts
 var CSS = `
@@ -2469,13 +3372,13 @@ function renderHtmlDocument(reportJson) {
 
 // src/html-report.ts
 function generateHtmlReport(report, aiDefects, screenshotPaths, outputPath) {
-  const htmlPath = (0, import_node_path8.resolve)(outputPath);
-  const htmlDir = (0, import_node_path8.dirname)(htmlPath);
-  if (!(0, import_node_fs10.existsSync)(htmlDir)) (0, import_node_fs10.mkdirSync)(htmlDir, { recursive: true });
+  const htmlPath = (0, import_node_path11.resolve)(outputPath);
+  const htmlDir = (0, import_node_path11.dirname)(htmlPath);
+  if (!(0, import_node_fs13.existsSync)(htmlDir)) (0, import_node_fs13.mkdirSync)(htmlDir, { recursive: true });
   const payload = { report, aiDefects, screenshotPaths };
   const reportJson = JSON.stringify(payload);
   const html = renderHtmlDocument(reportJson);
-  (0, import_node_fs10.writeFileSync)(htmlPath, html, "utf-8");
+  (0, import_node_fs13.writeFileSync)(htmlPath, html, "utf-8");
 }
 
 // src/console-summary.ts
@@ -2538,7 +3441,7 @@ function printConsoleSummary(summary, outputPath, htmlReportPath, quiet, aiDefec
 }
 
 // src/browser-open.ts
-var import_node_child_process2 = require("child_process");
+var import_node_child_process4 = require("child_process");
 function openInBrowser(filePath) {
   const platform = process.platform;
   let command;
@@ -2549,14 +3452,14 @@ function openInBrowser(filePath) {
   } else {
     command = `xdg-open "${filePath}"`;
   }
-  (0, import_node_child_process2.exec)(command, () => {
+  (0, import_node_child_process4.exec)(command, () => {
   });
 }
 
 // src/cloud-client.ts
-var import_node_fs13 = require("fs");
-var import_node_path11 = require("path");
-var import_node_crypto2 = require("crypto");
+var import_node_fs16 = require("fs");
+var import_node_path14 = require("path");
+var import_node_crypto3 = require("crypto");
 
 // src/cloud-auth.ts
 var import_core3 = require("@testrelic/core");
@@ -2587,7 +3490,7 @@ async function healthCheck(endpoint) {
   }
 }
 async function sleep(ms) {
-  return new Promise((resolve5) => setTimeout(resolve5, ms));
+  return new Promise((resolve6) => setTimeout(resolve6, ms));
 }
 async function parseCloudError(response) {
   try {
@@ -2737,13 +3640,13 @@ async function resolveRepo(endpoint, accessToken, gitId, displayName, timeout, b
 }
 
 // src/git-metadata.ts
-var import_node_child_process3 = require("child_process");
-var import_node_fs11 = require("fs");
-var import_node_path9 = require("path");
+var import_node_child_process5 = require("child_process");
+var import_node_fs14 = require("fs");
+var import_node_path12 = require("path");
 var GIT_TIMEOUT_MS = 5e3;
 function execGit(command, cwd) {
   try {
-    const result = (0, import_node_child_process3.execSync)(command, {
+    const result = (0, import_node_child_process5.execSync)(command, {
       cwd,
       timeout: GIT_TIMEOUT_MS,
       encoding: "utf-8",
@@ -2788,7 +3691,7 @@ function deriveRepoDisplayName(normalizedUrl) {
 }
 function readPackageJsonName(dirPath) {
   try {
-    const raw = (0, import_node_fs11.readFileSync)((0, import_node_path9.join)(dirPath, "package.json"), "utf-8");
+    const raw = (0, import_node_fs14.readFileSync)((0, import_node_path12.join)(dirPath, "package.json"), "utf-8");
     const pkg = JSON.parse(raw);
     return typeof pkg.name === "string" && pkg.name.length > 0 ? pkg.name : null;
   } catch {
@@ -2798,25 +3701,25 @@ function readPackageJsonName(dirPath) {
 function deriveNonGitProjectId(dirPath) {
   const pkgName = readPackageJsonName(dirPath);
   if (pkgName) return pkgName;
-  return `local/${(0, import_node_path9.basename)(dirPath)}`;
+  return `local/${(0, import_node_path12.basename)(dirPath)}`;
 }
 
 // src/cloud-queue.ts
-var import_node_fs12 = require("fs");
-var import_node_path10 = require("path");
+var import_node_fs15 = require("fs");
+var import_node_path13 = require("path");
 var import_core4 = require("@testrelic/core");
 var QUEUE_ENTRY_VERSION = "1.0.0";
 var FLUSH_BATCH_SIZE = 10;
 function writeToQueue(queueDirectory, runId, type, reason, targetEndpoint, method, payload, headers) {
   try {
-    (0, import_node_fs12.mkdirSync)(queueDirectory, { recursive: true });
+    (0, import_node_fs15.mkdirSync)(queueDirectory, { recursive: true });
     const timestamp = Date.now();
     const filename = `${timestamp}-${runId}-${type}.json`;
-    const filePath = (0, import_node_path10.join)(queueDirectory, filename);
+    const filePath = (0, import_node_path13.join)(queueDirectory, filename);
     const entry = { version: QUEUE_ENTRY_VERSION, queuedAt: new Date(timestamp).toISOString(), reason, retryCount: 0, targetEndpoint, method, payload, headers };
     const tmpPath = filePath + ".tmp";
-    (0, import_node_fs12.writeFileSync)(tmpPath, JSON.stringify(entry, null, 2), "utf-8");
-    (0, import_node_fs12.renameSync)(tmpPath, filePath);
+    (0, import_node_fs15.writeFileSync)(tmpPath, JSON.stringify(entry, null, 2), "utf-8");
+    (0, import_node_fs15.renameSync)(tmpPath, filePath);
   } catch (err) {
     const code = err.code;
     if (code === "ENOSPC") {
@@ -2829,7 +3732,7 @@ function writeToQueue(queueDirectory, runId, type, reason, targetEndpoint, metho
 async function flushQueue(queueDirectory, endpoint, accessToken) {
   let files;
   try {
-    files = (0, import_node_fs12.readdirSync)(queueDirectory).filter((f) => f.endsWith(".json") && !f.endsWith(".tmp")).sort();
+    files = (0, import_node_fs15.readdirSync)(queueDirectory).filter((f) => f.endsWith(".json") && !f.endsWith(".tmp")).sort();
   } catch {
     return;
   }
@@ -2840,14 +3743,14 @@ async function flushQueue(queueDirectory, endpoint, accessToken) {
   }
   for (const batch of batches) {
     for (const file of batch) {
-      const filePath = (0, import_node_path10.join)(queueDirectory, file);
+      const filePath = (0, import_node_path13.join)(queueDirectory, file);
       try {
-        const stat = (0, import_node_fs12.statSync)(filePath);
+        const stat = (0, import_node_fs15.statSync)(filePath);
         if (!stat.isFile()) continue;
-        const raw = (0, import_node_fs12.readFileSync)(filePath, "utf-8");
+        const raw = (0, import_node_fs15.readFileSync)(filePath, "utf-8");
         const entry = JSON.parse(raw);
         if (!(0, import_core4.isValidQueueEntry)(entry)) {
-          (0, import_node_fs12.unlinkSync)(filePath);
+          (0, import_node_fs15.unlinkSync)(filePath);
           continue;
         }
         const queueEntry = entry;
@@ -2857,7 +3760,7 @@ async function flushQueue(queueDirectory, endpoint, accessToken) {
           body: JSON.stringify(queueEntry.payload)
         });
         if (response.ok) {
-          (0, import_node_fs12.unlinkSync)(filePath);
+          (0, import_node_fs15.unlinkSync)(filePath);
         } else {
           return;
         }
@@ -2869,21 +3772,21 @@ async function flushQueue(queueDirectory, endpoint, accessToken) {
 }
 function cleanupExpiredQueue(queueDirectory, maxAge) {
   try {
-    const files = (0, import_node_fs12.readdirSync)(queueDirectory).filter((f) => f.endsWith(".json") && !f.endsWith(".tmp"));
+    const files = (0, import_node_fs15.readdirSync)(queueDirectory).filter((f) => f.endsWith(".json") && !f.endsWith(".tmp"));
     const now = Date.now();
     for (const file of files) {
-      const filePath = (0, import_node_path10.join)(queueDirectory, file);
+      const filePath = (0, import_node_path13.join)(queueDirectory, file);
       try {
-        const raw = (0, import_node_fs12.readFileSync)(filePath, "utf-8");
+        const raw = (0, import_node_fs15.readFileSync)(filePath, "utf-8");
         const entry = JSON.parse(raw);
         const queuedAt = entry.queuedAt;
         if (typeof queuedAt === "string") {
           const queuedTime = new Date(queuedAt).getTime();
-          if (now - queuedTime > maxAge) (0, import_node_fs12.unlinkSync)(filePath);
+          if (now - queuedTime > maxAge) (0, import_node_fs15.unlinkSync)(filePath);
         }
       } catch {
         try {
-          (0, import_node_fs12.unlinkSync)(filePath);
+          (0, import_node_fs15.unlinkSync)(filePath);
         } catch {
         }
       }
@@ -3026,7 +3929,7 @@ var CloudClient = class {
     }
     if (this.flushPromise) {
       try {
-        await Promise.race([this.flushPromise, new Promise((resolve5) => setTimeout(resolve5, FLUSH_TIMEOUT_MS))]);
+        await Promise.race([this.flushPromise, new Promise((resolve6) => setTimeout(resolve6, FLUSH_TIMEOUT_MS))]);
       } catch {
       }
       this.flushPromise = null;
@@ -3084,10 +3987,10 @@ var CloudClient = class {
   }
   readRepoCache(gitId) {
     if (!this.config) return null;
-    const cachePath = (0, import_node_path11.join)(this.config.queueDirectory, "..", "cache", "repo.json");
+    const cachePath = (0, import_node_path14.join)(this.config.queueDirectory, "..", "cache", "repo.json");
     try {
-      if (!(0, import_node_fs13.existsSync)(cachePath)) return null;
-      const raw = (0, import_node_fs13.readFileSync)(cachePath, "utf-8");
+      if (!(0, import_node_fs16.existsSync)(cachePath)) return null;
+      const raw = (0, import_node_fs16.readFileSync)(cachePath, "utf-8");
       const cache = JSON.parse(raw);
       if (cache.gitId !== gitId) return null;
       if (Date.now() - cache.resolvedAt > PROJECT_CACHE_TTL_MS) return null;
@@ -3100,20 +4003,20 @@ var CloudClient = class {
   }
   writeRepoCache(gitId, repoId, displayName) {
     if (!this.config) return;
-    const cacheDir = (0, import_node_path11.join)(this.config.queueDirectory, "..", "cache");
-    const cachePath = (0, import_node_path11.join)(cacheDir, "repo.json");
+    const cacheDir = (0, import_node_path14.join)(this.config.queueDirectory, "..", "cache");
+    const cachePath = (0, import_node_path14.join)(cacheDir, "repo.json");
     try {
-      (0, import_node_fs13.mkdirSync)(cacheDir, { recursive: true });
+      (0, import_node_fs16.mkdirSync)(cacheDir, { recursive: true });
       const cache = { repoId, gitId, displayName, resolvedAt: Date.now(), apiKeyHash: this.hashApiKey() ?? "" };
       const tmpPath = cachePath + ".tmp";
-      (0, import_node_fs13.writeFileSync)(tmpPath, JSON.stringify(cache, null, 2), "utf-8");
-      (0, import_node_fs13.renameSync)(tmpPath, cachePath);
+      (0, import_node_fs16.writeFileSync)(tmpPath, JSON.stringify(cache, null, 2), "utf-8");
+      (0, import_node_fs16.renameSync)(tmpPath, cachePath);
     } catch {
     }
   }
   hashApiKey() {
     if (!this.config?.apiKey) return null;
-    return (0, import_node_crypto2.createHash)("sha256").update(this.config.apiKey).digest("hex").substring(0, 16);
+    return (0, import_node_crypto3.createHash)("sha256").update(this.config.apiKey).digest("hex").substring(0, 16);
   }
   startBackgroundFlush() {
     if (!this.config || !this.authState.accessToken) return;
@@ -3122,7 +4025,7 @@ var CloudClient = class {
     const endpoint = this.config.endpoint;
     this.flushPromise = Promise.race([
       flushQueue(queueDir, endpoint, accessToken),
-      new Promise((resolve5) => setTimeout(resolve5, FLUSH_TIMEOUT_MS))
+      new Promise((resolve6) => setTimeout(resolve6, FLUSH_TIMEOUT_MS))
     ]).catch(() => {
     });
   }
@@ -3179,7 +4082,7 @@ function buildUploadPayload(report, repoGitId, git, ci, tests) {
   return payload;
 }
 async function sleep2(ms) {
-  return new Promise((resolve5) => setTimeout(resolve5, ms));
+  return new Promise((resolve6) => setTimeout(resolve6, ms));
 }
 async function retryWithBackoff(url, init, onTokenRefresh) {
   for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
@@ -3255,8 +4158,8 @@ async function uploadBatchRun(endpoint, accessToken, payload, onTokenRefresh) {
 }
 
 // src/cloud-artifact-upload.ts
-var import_node_fs14 = require("fs");
-var import_node_path12 = require("path");
+var import_node_fs17 = require("fs");
+var import_node_path15 = require("path");
 var import_node_stream = require("stream");
 var UPLOAD_CONCURRENCY = 5;
 var RETRY_DELAYS_MS2 = [1e3, 3e3, 9e3];
@@ -3275,7 +4178,7 @@ var activeUploads = 0;
 var pendingUploads = [];
 async function acquireSlot() {
   if (activeUploads >= UPLOAD_CONCURRENCY) {
-    await new Promise((resolve5) => pendingUploads.push(resolve5));
+    await new Promise((resolve6) => pendingUploads.push(resolve6));
   }
   activeUploads++;
 }
@@ -3284,7 +4187,7 @@ function releaseSlot() {
   if (pendingUploads.length > 0) pendingUploads.shift()();
 }
 async function sleep3(ms) {
-  return new Promise((resolve5) => setTimeout(resolve5, ms));
+  return new Promise((resolve6) => setTimeout(resolve6, ms));
 }
 function getContentType(filePath) {
   const ext = filePath.substring(filePath.lastIndexOf(".")).toLowerCase();
@@ -3292,14 +4195,14 @@ function getContentType(filePath) {
 }
 function getFileSize(filePath) {
   try {
-    return (0, import_node_fs14.statSync)(filePath).size;
+    return (0, import_node_fs17.statSync)(filePath).size;
   } catch {
     return 0;
   }
 }
 async function requestUploadUrl(endpoint, accessToken, request, sizeBytes, contentType) {
   const url = `${endpoint}/artifacts/upload-url`;
-  const body = JSON.stringify({ runId: request.runId, testId: request.testId, fileName: (0, import_node_path12.basename)(request.filePath), contentType, type: request.type, sizeBytes });
+  const body = JSON.stringify({ runId: request.runId, testId: request.testId, fileName: (0, import_node_path15.basename)(request.filePath), contentType, type: request.type, sizeBytes });
   for (let attempt = 0; attempt < MAX_RETRIES2; attempt++) {
     try {
       const response = await fetch(url, { method: "POST", headers: { "Content-Type": "application/json", "Authorization": `Bearer ${accessToken}` }, body });
@@ -3322,7 +4225,7 @@ async function requestUploadUrl(endpoint, accessToken, request, sizeBytes, conte
 async function putFileToPresignedUrl(presignedUrl, filePath, contentType, sizeBytes) {
   for (let attempt = 0; attempt < MAX_RETRIES2; attempt++) {
     try {
-      const nodeStream = (0, import_node_fs14.createReadStream)(filePath);
+      const nodeStream = (0, import_node_fs17.createReadStream)(filePath);
       const webStream = import_node_stream.Readable.toWeb(nodeStream);
       const response = await fetch(presignedUrl, {
         method: "PUT",
@@ -3615,35 +4518,35 @@ async function finalizeAndUpload(cloudClient, cloudConfig, testRunId, report, co
 // src/report-orchestrator.ts
 function matchVideoToFlow(flowFile, videoPaths, flowRecordingPath) {
   if (videoPaths.length === 0) return null;
-  const flowBase = (0, import_node_path13.basename)(flowFile, (0, import_node_path13.extname)(flowFile)).toLowerCase();
+  const flowBase = (0, import_node_path16.basename)(flowFile, (0, import_node_path16.extname)(flowFile)).toLowerCase();
   const exact = videoPaths.find(
-    (v) => (0, import_node_path13.basename)(v, (0, import_node_path13.extname)(v)).toLowerCase() === flowBase
+    (v) => (0, import_node_path16.basename)(v, (0, import_node_path16.extname)(v)).toLowerCase() === flowBase
   );
   if (exact) return exact;
   const forward = videoPaths.find(
-    (v) => (0, import_node_path13.basename)(v).toLowerCase().includes(flowBase)
+    (v) => (0, import_node_path16.basename)(v).toLowerCase().includes(flowBase)
   );
   if (forward) return forward;
   const reverse = videoPaths.find((v) => {
-    const videoBase = (0, import_node_path13.basename)(v, (0, import_node_path13.extname)(v)).toLowerCase();
+    const videoBase = (0, import_node_path16.basename)(v, (0, import_node_path16.extname)(v)).toLowerCase();
     return videoBase.length >= 3 && (flowBase.startsWith(videoBase) || flowBase.includes(videoBase));
   });
   if (reverse) return reverse;
   if (flowRecordingPath) {
-    const recBase = (0, import_node_path13.basename)(flowRecordingPath, (0, import_node_path13.extname)(flowRecordingPath)).toLowerCase();
-    const byRec = videoPaths.find((v) => (0, import_node_path13.basename)(v, (0, import_node_path13.extname)(v)).toLowerCase() === recBase);
+    const recBase = (0, import_node_path16.basename)(flowRecordingPath, (0, import_node_path16.extname)(flowRecordingPath)).toLowerCase();
+    const byRec = videoPaths.find((v) => (0, import_node_path16.basename)(v, (0, import_node_path16.extname)(v)).toLowerCase() === recBase);
     if (byRec) return byRec;
-    const byRecPartial = videoPaths.find((v) => (0, import_node_path13.basename)(v).toLowerCase().includes(recBase));
+    const byRecPartial = videoPaths.find((v) => (0, import_node_path16.basename)(v).toLowerCase().includes(recBase));
     if (byRecPartial) return byRecPartial;
   }
   return null;
 }
 function matchScreenshotsToFlow(flowFile, screenshotPaths) {
   if (screenshotPaths.length === 0) return [];
-  const flowBase = (0, import_node_path13.basename)(flowFile, (0, import_node_path13.extname)(flowFile)).toLowerCase();
+  const flowBase = (0, import_node_path16.basename)(flowFile, (0, import_node_path16.extname)(flowFile)).toLowerCase();
   const matched = screenshotPaths.filter((s) => {
-    const name = (0, import_node_path13.basename)(s).toLowerCase();
-    const nameBase = (0, import_node_path13.basename)(s, (0, import_node_path13.extname)(s)).toLowerCase();
+    const name = (0, import_node_path16.basename)(s).toLowerCase();
+    const nameBase = (0, import_node_path16.basename)(s, (0, import_node_path16.extname)(s)).toLowerCase();
     if (name.startsWith(flowBase) || name.includes(flowBase)) return true;
     return nameBase.length >= 3 && (flowBase.startsWith(nameBase) || flowBase.includes(nameBase));
   });
@@ -3663,18 +4566,18 @@ function extractRecordingPath(commands) {
 function buildFlowRecordingMap(commandSteps) {
   const map = /* @__PURE__ */ new Map();
   for (const [filePath, commands] of commandSteps) {
-    const name = (0, import_node_path13.basename)(filePath).replace(/^commands[-_]?/i, "").replace(/\.json$/i, "").toLowerCase();
+    const name = (0, import_node_path16.basename)(filePath).replace(/^commands[-_]?/i, "").replace(/\.json$/i, "").toLowerCase();
     const recPath = extractRecordingPath(commands);
     if (recPath && name) map.set(name, recPath);
   }
   return map;
 }
 function commandsForFlow(commandSteps, flowFile) {
-  const flowBase = (0, import_node_path13.basename)(flowFile, (0, import_node_path13.extname)(flowFile)).toLowerCase();
+  const flowBase = (0, import_node_path16.basename)(flowFile, (0, import_node_path16.extname)(flowFile)).toLowerCase();
   if (!flowBase || commandSteps.size === 0) {
     return { commands: [], matchedAnyFile: false };
   }
-  const stripCmdPrefix = (p) => (0, import_node_path13.basename)(p, (0, import_node_path13.extname)(p)).replace(/^commands[-_]?/i, "").toLowerCase();
+  const stripCmdPrefix = (p) => (0, import_node_path16.basename)(p, (0, import_node_path16.extname)(p)).replace(/^commands[-_]?/i, "").toLowerCase();
   for (const [cmdFile, cmds] of commandSteps) {
     if (stripCmdPrefix(cmdFile) === flowBase) {
       return { commands: cmds, matchedAnyFile: true };
@@ -3706,7 +4609,7 @@ function platformToOs(platform) {
       return void 0;
   }
 }
-function flowToTestResult(flow) {
+function flowToTestResult(flow, apiCalls) {
   const consoleLogs = flow.logEntries.length > 0 ? flow.logEntries.map((entry) => ({
     level: entry.level.toLowerCase(),
     message: entry.message,
@@ -3733,7 +4636,8 @@ function flowToTestResult(flow) {
     platform: flow.platform !== "unknown" ? flow.platform : void 0,
     os: platformToOs(flow.platform),
     deviceName: flow.deviceId,
-    ...consoleLogs ? { consoleLogs } : {}
+    ...consoleLogs ? { consoleLogs } : {},
+    ...apiCalls && apiCalls.length > 0 ? { apiCalls } : {}
   };
 }
 function logEntriesForFlow(allEntries, flowStartedAt, flowCompletedAt) {
@@ -3752,7 +4656,7 @@ function logEntriesForFlow(allEntries, flowStartedAt, flowCompletedAt) {
 async function orchestrateReport(input) {
   const { config } = input;
   const startedAt = (/* @__PURE__ */ new Date()).toISOString();
-  const testRunId = config.testRunId ?? (0, import_node_crypto3.randomUUID)();
+  const testRunId = config.testRunId ?? (0, import_node_crypto4.randomUUID)();
   const artifacts = collectArtifacts(input.testOutputDir, input.debugOutputDir);
   const junitPath = input.junitPath ?? artifacts.junitReportPath;
   const logFiles = input.debugOutputDir ? discoverLogFiles(input.debugOutputDir) : artifacts.logPaths;
@@ -3767,7 +4671,7 @@ async function orchestrateReport(input) {
     if (detected !== "unknown") platform = detected;
   }
   const flowMetadataMap = /* @__PURE__ */ new Map();
-  if (input.flowsDir && (0, import_node_fs15.existsSync)(input.flowsDir)) {
+  if (input.flowsDir && (0, import_node_fs18.existsSync)(input.flowsDir)) {
     const flowFiles = discoverFlowFiles(input.flowsDir);
     for (const flowFile of flowFiles) {
       const meta = parseFlowFile(flowFile);
@@ -3788,7 +4692,7 @@ async function orchestrateReport(input) {
   }
   const flowRecordingMap = buildFlowRecordingMap(commandSteps);
   const flowResults = [];
-  if (junitPath && (0, import_node_fs15.existsSync)(junitPath)) {
+  if (junitPath && (0, import_node_fs18.existsSync)(junitPath)) {
     const junit = parseJUnitFile(junitPath);
     const allCommands = Array.from(commandSteps.values()).flat();
     const allAssertions = allCommands.filter((c) => c.category === "assertion");
@@ -3802,7 +4706,7 @@ async function orchestrateReport(input) {
         const flowStartedAt = startedAt;
         const flowCompletedAt = new Date(new Date(flowStartedAt).getTime() + durationMs).toISOString();
         const flowFile = testCase.classname || name;
-        const flowBase = (0, import_node_path13.basename)(flowFile, (0, import_node_path13.extname)(flowFile)).toLowerCase();
+        const flowBase = (0, import_node_path16.basename)(flowFile, (0, import_node_path16.extname)(flowFile)).toLowerCase();
         const recordingPath = flowRecordingMap.get(flowBase) ?? null;
         const { commands: flowCmds, matchedAnyFile } = commandsForFlow(commandSteps, flowFile);
         const perFlowCommands = matchedAnyFile ? flowCmds.filter((c) => c.category !== "assertion") : allNonAssertions;
@@ -3863,7 +4767,20 @@ async function orchestrateReport(input) {
       });
     }
   }
-  const timeline = buildTimeline(flowResults);
+  const apiCallsByFlow = (() => {
+    if (!config.network?.enabled && !config.network?.harPath) return void 0;
+    const windows = flowResults.map((f) => ({
+      testId: `${f.flowFile}::${f.flowName}`,
+      startedAt: f.startedAt,
+      completedAt: f.completedAt
+    }));
+    const bound = collectNetworkByFlow(input.networkJsonlDir ?? null, config.network, windows);
+    if (bound.size === 0) return void 0;
+    const remapped = /* @__PURE__ */ new Map();
+    for (const [k, v] of bound) remapped.set(k, reindexFlowCalls(v));
+    return remapped;
+  })();
+  const timeline = buildTimeline(flowResults, apiCallsByFlow);
   const summary = buildSummary(timeline);
   const completedAt = (/* @__PURE__ */ new Date()).toISOString();
   const totalDuration = Date.now() - new Date(startedAt).getTime();
@@ -3879,12 +4796,12 @@ async function orchestrateReport(input) {
     timeline,
     shardRunIds: null
   };
-  (0, import_node_fs15.mkdirSync)((0, import_node_path13.dirname)((0, import_node_path13.resolve)(config.outputPath)), { recursive: true });
-  (0, import_node_fs15.writeFileSync)((0, import_node_path13.resolve)(config.outputPath), JSON.stringify(report, null, 2), "utf-8");
-  generateHtmlReport(report, allAiDefects, artifacts.screenshotPaths, (0, import_node_path13.resolve)(config.htmlReportPath));
+  (0, import_node_fs18.mkdirSync)((0, import_node_path16.dirname)((0, import_node_path16.resolve)(config.outputPath)), { recursive: true });
+  (0, import_node_fs18.writeFileSync)((0, import_node_path16.resolve)(config.outputPath), JSON.stringify(report, null, 2), "utf-8");
+  generateHtmlReport(report, allAiDefects, artifacts.screenshotPaths, (0, import_node_path16.resolve)(config.htmlReportPath));
   printConsoleSummary(summary, config.outputPath, config.htmlReportPath, config.quiet, allAiDefects);
   if (config.openReport) {
-    openInBrowser((0, import_node_path13.resolve)(config.htmlReportPath));
+    openInBrowser((0, import_node_path16.resolve)(config.htmlReportPath));
   }
   if (config.cloud) {
     const cloudClient = new CloudClient(config.cloud);
@@ -3893,7 +4810,7 @@ async function orchestrateReport(input) {
     const videoArtifacts = [];
     if (videoPathsToUpload.length > 0) {
       for (const flow of flowResults) {
-        const flowBase = (0, import_node_path13.basename)(flow.flowFile, (0, import_node_path13.extname)(flow.flowFile)).toLowerCase();
+        const flowBase = (0, import_node_path16.basename)(flow.flowFile, (0, import_node_path16.extname)(flow.flowFile)).toLowerCase();
         const recordingPath = flowRecordingMap.get(flowBase) ?? null;
         const matched = matchVideoToFlow(flow.flowFile, videoPathsToUpload, recordingPath);
         if (matched) {
@@ -3915,7 +4832,10 @@ async function orchestrateReport(input) {
     }
     const matchedPaths = new Set(videoArtifacts.map((va) => va.path));
     const unmatchedVideos = videoPathsToUpload.filter((v) => !matchedPaths.has(v));
-    const testsForUpload = flowResults.map(flowToTestResult);
+    const testsForUpload = flowResults.map((f) => {
+      const testId = `${f.flowFile}::${f.flowName}`;
+      return flowToTestResult(f, apiCallsByFlow?.get(testId));
+    });
     await finalizeAndUpload(
       cloudClient,
       config.cloud,
@@ -3962,6 +4882,16 @@ Test Options:
   -e, --env <KEY=VALUE>   Environment variable
   --quiet                 Suppress output
 
+Network Capture Options (mobile API logs):
+  --capture-network       Spawn mitmproxy to capture HTTP traffic from the app
+                          (requires mitmdump on PATH; --har-path is an alternative)
+  --proxy-port <n>        Proxy listen port (default: 8080)
+  --proxy-host <host>     Proxy listen host (default: 127.0.0.1)
+  --har-path <file>       Import a pre-recorded HAR file instead of running a proxy
+  --skip-cert-install     Skip auto-installing the mitmproxy CA on the device
+  --proxy-include <pat>   Only capture URLs matching this substring or regex (repeatable)
+  --proxy-exclude <pat>   Drop URLs matching this substring or regex (repeatable)
+
 Report Options:
   --junit <path>          Path to JUnit XML report
   --artifacts <dir>       Path to Maestro test output directory
@@ -4001,6 +4931,15 @@ function parseArgs(args) {
           } else {
             options["env"] = args[i];
           }
+        } else if (key === "proxy-include" || key === "proxy-exclude") {
+          const existing = options[key];
+          if (Array.isArray(existing)) {
+            existing.push(args[i]);
+          } else if (typeof existing === "string") {
+            options[key] = [existing, args[i]];
+          } else {
+            options[key] = args[i];
+          }
         } else {
           options[key] = args[i];
         }
@@ -4036,11 +4975,30 @@ function parseEnvVars(raw) {
   }
   return env;
 }
+function asStringArray(v) {
+  if (!v) return [];
+  return Array.isArray(v) ? v : [v];
+}
+function buildNetworkOptions(options) {
+  const enabled = options["capture-network"] === "true";
+  const harPath = typeof options["har-path"] === "string" ? options["har-path"] : void 0;
+  if (!enabled && !harPath) return void 0;
+  return {
+    enabled,
+    proxyPort: typeof options["proxy-port"] === "string" ? Number.parseInt(options["proxy-port"], 10) : void 0,
+    proxyHost: typeof options["proxy-host"] === "string" ? options["proxy-host"] : void 0,
+    harPath,
+    skipCertInstall: options["skip-cert-install"] === "true",
+    includeUrls: asStringArray(options["proxy-include"]),
+    excludeUrls: asStringArray(options["proxy-exclude"])
+  };
+}
 async function handleTest(options, positional) {
   if (positional.length === 0) {
     process.stderr.write("Error: No flow paths specified. Usage: testrelic-maestro test <flow-paths...>\n");
     process.exit(1);
   }
+  const network = buildNetworkOptions(options);
   const testOptions = {
     flowPaths: positional,
     apiKey: typeof options["api-key"] === "string" ? options["api-key"] : void 0,
@@ -4054,12 +5012,10 @@ async function handleTest(options, positional) {
     shards: typeof options["shards"] === "string" ? parseInt(options["shards"], 10) : void 0,
     config: typeof options["config"] === "string" ? options["config"] : void 0,
     env: parseEnvVars(options["env"]),
-    quiet: options["quiet"] === "true"
+    quiet: options["quiet"] === "true",
+    network
   };
   process.stderr.write("\u2139 TestRelic: Running Maestro tests...\n");
-  const runResult = await runMaestro(testOptions);
-  process.stderr.write(`\u2139 TestRelic: Maestro exited with code ${runResult.exitCode}. Parsing results...
-`);
   const config = resolveConfig({
     outputPath: typeof options["output-dir"] === "string" ? `${options["output-dir"]}/testrelic-maestro.json` : void 0,
     htmlReportPath: typeof options["html-report"] === "string" ? options["html-report"] : void 0,
@@ -4069,18 +5025,26 @@ async function handleTest(options, positional) {
       endpoint: typeof options["endpoint"] === "string" ? options["endpoint"] : void 0
     },
     quiet: options["quiet"] === "true",
-    flowsDir: positional[0]
+    flowsDir: positional[0],
+    network
   });
+  const runResult = await runMaestro(testOptions, { network: config.network });
+  process.stderr.write(`\u2139 TestRelic: Maestro exited with code ${runResult.exitCode}. Parsing results...
+`);
   await orchestrateReport({
     junitPath: runResult.junitPath,
     testOutputDir: runResult.testOutputDir,
     debugOutputDir: runResult.debugOutputDir,
     flowsDir: positional[0],
-    config
+    config,
+    platform: testOptions.platform ?? "unknown",
+    device: testOptions.device,
+    networkJsonlDir: runResult.networkJsonlDir
   });
   process.exit(runResult.exitCode);
 }
 async function handleReport(options) {
+  const network = buildNetworkOptions(options);
   const config = resolveConfig({
     outputPath: typeof options["output-dir"] === "string" ? `${options["output-dir"]}/testrelic-maestro.json` : void 0,
     htmlReportPath: typeof options["html-report"] === "string" ? options["html-report"] : void 0,
@@ -4090,14 +5054,16 @@ async function handleReport(options) {
       endpoint: typeof options["endpoint"] === "string" ? options["endpoint"] : void 0
     },
     quiet: options["quiet"] === "true",
-    flowsDir: typeof options["flows-dir"] === "string" ? options["flows-dir"] : void 0
+    flowsDir: typeof options["flows-dir"] === "string" ? options["flows-dir"] : void 0,
+    network
   });
   process.stderr.write("\u2139 TestRelic: Parsing Maestro artifacts...\n");
   await orchestrateReport({
     junitPath: typeof options["junit"] === "string" ? options["junit"] : void 0,
     testOutputDir: typeof options["artifacts"] === "string" ? options["artifacts"] : void 0,
     flowsDir: typeof options["flows-dir"] === "string" ? options["flows-dir"] : void 0,
-    config
+    config,
+    networkJsonlDir: typeof options["network-dir"] === "string" ? options["network-dir"] : null
   });
 }
 async function main() {