@wdio/nightwatch-devtools 1.8.2 → 2.0.0

package/dist/index.js

@@ -1,6 +1,8 @@
 import {
   CAPTURE_PERFORMANCE_SCRIPT,
   COLLECTOR_READY_EXPRESSION,
+  NETWORK_CAPTURE_SOURCE,
+  NativeNetworkCapture,
   REUSE_ENV,
   RetryTracker,
   SCREENCAST_DEFAULTS,
@@ -47,9 +49,11 @@ import {
   recordSpecBoundary,
   registerCollectorPreload,
   rememberReadValue,
+  requestsInterceptedNetwork,
   resolveAdapterOutputDir,
   resolveAssertTargetFromArgs,
   resolveViewport,
+  restoreBrowserFocus,
   safeSerializeAssertArg,
   serializeError,
   stampSuiteEnd,
@@ -58,9 +62,10 @@ import {
   toError,
   tracePolicyModeWarning,
   upsertRichestSnapshot,
+  webdriverExecute,
   webdriverGet,
   webdriverPost
-} from "./chunk-DM4FCAIJ.js";
+} from "./chunk-TUK7ZLQI.js";
 
 // src/index.ts
 import { fileURLToPath } from "url";
@@ -654,7 +659,7 @@ var firstDefined = (obj, ...keys) => {
   }
   return void 0;
 };
-function resolveWebDriverAddress(browser) {
+function configuredWebDriver(browser) {
   const transportSettings = getPath(browser, "transport", "settings", "webdriver") || getPath(browser, "queue", "transport", "settings", "webdriver") || getPath(
     browser,
     "nightwatchInstance",
@@ -664,13 +669,24 @@ function resolveWebDriverAddress(browser) {
   ) || {};
   const opts = getProp(browser, "options") ?? {};
   const nightwatchSettings = getPath(browser, "nightwatchInstance", "settings") || getPath(browser, "globals", "nightwatchInstance", "settings") || {};
-  const driverHost = String(
-    firstDefined(transportSettings, "host", "server_address") || firstDefined(getProp(opts, "webdriver"), "host") || firstDefined(getProp(nightwatchSettings, "webdriver"), "host") || "localhost"
-  );
-  const driverPort = Number(
-    firstDefined(transportSettings, "port") || firstDefined(getProp(opts, "webdriver"), "port") || firstDefined(getProp(nightwatchSettings, "webdriver"), "port") || 9515
-  );
-  return { driverHost, driverPort };
+  const sources = [
+    transportSettings,
+    getProp(opts, "webdriver"),
+    getProp(nightwatchSettings, "webdriver")
+  ];
+  const pick = (...keys) => sources.map((source) => firstDefined(source, ...keys)).find(Boolean);
+  return {
+    host: pick("host", "server_address"),
+    port: pick("port"),
+    pathPrefix: pick("default_path_prefix")
+  };
+}
+function resolveWebDriverAddress(browser) {
+  const { host, port } = configuredWebDriver(browser);
+  return {
+    driverHost: String(host || "localhost"),
+    driverPort: Number(port || 9515)
+  };
 }
 function address(browser) {
   const { driverHost, driverPort } = resolveWebDriverAddress(browser);
@@ -691,7 +707,21 @@ function webdriverPost2(browser, path5, body) {
   const id = sessionId(browser);
   return id ? webdriverPost(address(browser), id, path5, body) : Promise.resolve(null);
 }
-function webdriverExecute(browser, body) {
+function sessionExecutor(browser) {
+  const id = sessionId(browser);
+  const { host, port, pathPrefix } = configuredWebDriver(browser);
+  if (!id || !port) {
+    return void 0;
+  }
+  const at = {
+    hostname: String(host || "localhost"),
+    port: Number(port),
+    path: typeof pathPrefix === "string" ? pathPrefix : void 0,
+    onWarn: (message) => log3.warn(message)
+  };
+  return (script, args) => webdriverExecute(at, id, script, args);
+}
+function webdriverExecute2(browser, body) {
   return webdriverPost2(browser, "execute/sync", { script: body, args: [] });
 }
 
@@ -706,7 +736,7 @@ function captureActionSnapshot2(browser, command, timestamp, runner, native = fa
     runner,
     takeScreenshot: () => webdriverGet2(browser, "screenshot"),
     ...native ? {} : {
-      runScript: (src) => webdriverExecute(browser, `return (${src})`),
+      runScript: (src) => webdriverExecute2(browser, `return (${src})`),
       getUrl: () => webdriverGet2(browser, "url"),
       getTitle: () => webdriverGet2(browser, "title")
     }
@@ -714,6 +744,7 @@ function captureActionSnapshot2(browser, command, timestamp, runner, native = fa
 }
 
 // src/helpers/perfLogs.ts
+var RESOURCE_TIMING_MATCH_MS = 2e3;
 function applyResponseReceived(p, response) {
   const responseHeaders = {};
   for (const [k, v] of Object.entries(response.headers || {})) {
@@ -739,7 +770,9 @@ function startPendingRequest(params, entry, pending) {
     url: req.url,
     method: req.method,
     requestHeaders: req.headers ?? {},
-    timestamp: startTime,
+    // Epoch, from the event's own wall clock: every consumer dates a row by
+    // `timestamp`, and the monotonic `startTime` only diffs within a session.
+    timestamp: typeof params.wallTime === "number" ? Math.round(params.wallTime * 1e3) : entry.timestamp,
     startTime
   });
 }
@@ -797,6 +830,95 @@ function parseNetworkFromPerfLogs(logs) {
   }
   return completed;
 }
+function resourceTimingRowsByUrl(rows) {
+  const byUrl = /* @__PURE__ */ new Map();
+  rows.forEach((row, index) => {
+    if (row.source !== NETWORK_CAPTURE_SOURCE.RESOURCE_TIMING) {
+      return;
+    }
+    const indexes = byUrl.get(row.url);
+    if (indexes) {
+      indexes.push(index);
+    } else {
+      byUrl.set(row.url, [index]);
+    }
+  });
+  return byUrl;
+}
+function takeNearestResourceTimingRow(indexes, rows, at) {
+  let best;
+  let bestDelta = RESOURCE_TIMING_MATCH_MS;
+  for (const index of indexes) {
+    const delta = Math.abs(rows[index].timestamp - at);
+    if (delta <= bestDelta) {
+      best = index;
+      bestDelta = delta;
+    }
+  }
+  if (best !== void 0) {
+    indexes.splice(indexes.indexOf(best), 1);
+  }
+  return best;
+}
+function overlay(row, entry) {
+  const merged = {
+    ...row,
+    method: entry.method,
+    requestHeaders: entry.requestHeaders,
+    type: entry.type ?? row.type,
+    ...entry.status !== void 0 ? { status: entry.status } : {},
+    ...entry.statusText !== void 0 ? { statusText: entry.statusText } : {},
+    ...entry.responseHeaders ? { responseHeaders: entry.responseHeaders } : {},
+    ...entry.size !== void 0 ? { size: entry.size } : {},
+    ...entry.error !== void 0 ? { error: entry.error } : {}
+  };
+  delete merged.source;
+  return merged;
+}
+function withoutLoadsTheLogListed(payload, listed) {
+  const requests = payload.networkRequests;
+  if (!Array.isArray(requests) || listed.length === 0) {
+    return payload;
+  }
+  const rows = requests;
+  const rowsByUrl = resourceTimingRowsByUrl(rows);
+  const taken = /* @__PURE__ */ new Set();
+  for (const load of listed) {
+    const index = takeNearestResourceTimingRow(
+      rowsByUrl.get(load.url) ?? [],
+      rows,
+      load.timestamp
+    );
+    if (index !== void 0) {
+      taken.add(index);
+    }
+  }
+  if (taken.size === 0) {
+    return payload;
+  }
+  return {
+    ...payload,
+    networkRequests: rows.filter((_, index) => !taken.has(index))
+  };
+}
+function upgradeResourceTimingRows(incoming, existing) {
+  const rowsByUrl = resourceTimingRowsByUrl(existing);
+  const upgrades = [];
+  const fresh = [];
+  for (const entry of incoming) {
+    const index = takeNearestResourceTimingRow(
+      rowsByUrl.get(entry.url) ?? [],
+      existing,
+      entry.timestamp
+    );
+    if (index === void 0) {
+      fresh.push(entry);
+      continue;
+    }
+    upgrades.push({ index, request: overlay(existing[index], entry) });
+  }
+  return { upgrades, fresh };
+}
 function dedupeNetworkRequests(incoming, existing) {
   const failedKey = (entry) => {
     try {
@@ -849,6 +971,9 @@ var SessionCapturer = class extends SessionCapturerBase {
   // True once BiDi inspectors are attached — the per-command perf-log network
   // capture path skips when set, so we don't double-emit network requests.
   bidiActive = false;
+  /** Whether BiDi has delivered at least one network event; a subscription
+   *  that delivers nothing is not a source. */
+  bidiNetworkObserved = false;
   /** Whether the session was created with `goog:loggingPrefs.performance`, set
    *  from the capabilities at session init. A perf log exists only because a
    *  session asked for one, so without it every fetch is a round trip that can
@@ -857,6 +982,10 @@ var SessionCapturer = class extends SessionCapturerBase {
    *  21 of them in a two-test run, where XCUITest lists `performance` among its
    *  supported types and then serves none of it. */
   perfLogsRequested = false;
+  /** Loads the performance log listed before the page's drain could, spent
+   *  at the next drain that reaches the driver, whatever it finds, and
+   *  emptied with the session that listed them. */
+  loadsListedByLog = [];
   /** True once the collector is registered to run at document-start. Every
    *  document then instruments and anchors itself, so the paths that exist to
    *  notice a navigation after the fact — re-injection and the settle poll — have
@@ -869,6 +998,11 @@ var SessionCapturer = class extends SessionCapturerBase {
   runner = nightwatchRunnerId(false);
   actionSnapshots = [];
   snapshotCaptures = [];
+  /** Native app network from appium-interceptor's proxy; started per session. */
+  nativeNetwork = new NativeNetworkCapture(
+    this,
+    (level, message) => log4[level](message)
+  );
   constructor(devtoolsOptions = {}, browser) {
     super(devtoolsOptions);
     this.#browser = browser;
@@ -1014,7 +1148,7 @@ var SessionCapturer = class extends SessionCapturerBase {
   /** The current document's own birth time, which is what a DOM anchor is
    *  stamped with. Undefined when the session cannot answer. */
   async documentOrigin(browser) {
-    return webdriverExecute(browser, "return performance.timeOrigin;").then((origin) => origin ?? void 0).catch(() => void 0);
+    return webdriverExecute2(browser, "return performance.timeOrigin;").then((origin) => origin ?? void 0).catch(() => void 0);
   }
   /**
    * Wait for a navigation to actually replace the document, then drain with a
@@ -1097,7 +1231,7 @@ var SessionCapturer = class extends SessionCapturerBase {
       return;
     }
     try {
-      const alreadyPresent = await webdriverExecute(
+      const alreadyPresent = await webdriverExecute2(
         browser,
         `return ${COLLECTOR_READY_EXPRESSION};`
       );
@@ -1109,14 +1243,15 @@ var SessionCapturer = class extends SessionCapturerBase {
         const script = document.createElement('script');
         script.textContent = ${JSON.stringify(scriptContent)};
         document.head.appendChild(script);
-        return true;
+        return ${COLLECTOR_READY_EXPRESSION};
       `;
-      await webdriverExecute(browser, injectionScript);
-      const hasCollector = await pollUntilReady(
-        async () => await webdriverExecute(
+      const injected = await webdriverExecute2(browser, injectionScript);
+      const hasCollector = injected === true || await pollUntilReady(
+        async () => await webdriverExecute2(
           browser,
           `return ${COLLECTOR_READY_EXPRESSION};`
-        ) === true
+        ) === true,
+        { checkFirst: true }
       );
       if (hasCollector) {
         log4.info("\u2713 Script injected and collector ready");
@@ -1160,20 +1295,8 @@ var SessionCapturer = class extends SessionCapturerBase {
         return;
       }
       const networkEntries = parseNetworkFromPerfLogs(logs);
-      if (networkEntries.length === 0) {
-        return;
-      }
-      const deduped = dedupeNetworkRequests(
-        networkEntries,
-        this.networkRequests
-      );
-      if (deduped.length > 0) {
-        const normalized = deduped.map((d) => ({
-          ...d,
-          type: d.type ?? "other"
-        }));
-        this.networkRequests.push(...normalized);
-        this.sendUpstream("networkRequests", normalized);
+      if (networkEntries.length > 0) {
+        this.#ingestPerfLogEntries(networkEntries);
       }
     } catch (err) {
       const msg = errorMessage(err) ?? "";
@@ -1182,6 +1305,30 @@ var SessionCapturer = class extends SessionCapturerBase {
       }
     }
   }
+  /** A log entry for a load the page already reported replaces that row in
+   *  place, under the row's own id; the rest are appended once. */
+  #ingestPerfLogEntries(entries) {
+    const { upgrades, fresh } = upgradeResourceTimingRows(
+      entries,
+      this.networkRequests
+    );
+    for (const { index, request } of upgrades) {
+      this.networkRequests[index] = request;
+    }
+    const deduped = dedupeNetworkRequests(
+      fresh,
+      this.networkRequests
+    );
+    const appended = deduped.map((d) => ({ ...d, type: d.type ?? "other" }));
+    this.networkRequests.push(...appended);
+    this.loadsListedByLog.push(
+      ...appended.map(({ url, timestamp }) => ({ url, timestamp }))
+    );
+    const sent = [...upgrades.map((upgrade) => upgrade.request), ...appended];
+    if (sent.length > 0) {
+      this.sendUpstream("networkRequests", sent);
+    }
+  }
   /** `forceAnchor` forces a full-DOM anchor of the current document before
    *  draining, so a freshly injected collector's async anchor isn't lost.
    *  `anchorTimestamp` is the command this drain's anchors were CAUSED by — pass
@@ -1189,28 +1336,45 @@ var SessionCapturer = class extends SessionCapturerBase {
    *  that command, since it overrides the inference at ingest. */
   async captureTrace(browser, forceAnchor = false, anchorTimestamp) {
     if (this.isNativeAppSession) {
+      await this.nativeNetwork.forward({ throttle: true });
       return;
     }
     await this.drainCollector(browser, forceAnchor, anchorTimestamp);
     await this.captureNetworkFromPerformanceLogs(browser);
   }
+  /** At a test or scenario end, before its slice is written: the proxy drain there is never throttled. */
+  async captureTraceAtTestEnd(browser) {
+    if (this.isNativeAppSession) {
+      await this.nativeNetwork.forward();
+      return;
+    }
+    await this.captureTrace(browser, true);
+  }
   async drainCollector(browser, forceAnchor, anchorTimestamp) {
     try {
       const traceData = await drainCollectorWithRecovery({
-        drain: () => webdriverExecute(
+        drain: () => webdriverExecute2(
           browser,
           collectorDrainExpression(forceAnchor)
         ),
         injectIntoCurrentDocument: () => this.injectScript(browser),
-        currentUrl: () => webdriverExecute(browser, "return location.href;").then(
+        currentUrl: () => webdriverExecute2(browser, "return location.href;").then(
           (u) => u ?? void 0
         ),
         log: (level, message) => log4[level](message)
       });
+      const listedByLog = this.loadsListedByLog;
+      this.loadsListedByLog = [];
       if (!traceData) {
         return;
       }
-      this.processTracePayload(traceData, { anchorTimestamp });
+      this.processTracePayload(
+        withoutLoadsTheLogListed(traceData, listedByLog),
+        {
+          anchorTimestamp,
+          skipResourceTimingRequests: this.bidiNetworkObserved
+        }
+      );
       const mutationCount = Array.isArray(
         traceData.mutations
       ) ? traceData.mutations.length : 0;
@@ -1624,17 +1788,23 @@ function callbackError(result, depth = 0) {
     return void 0;
   }
   const r = result;
-  if ("value" in r) {
-    return depth < 2 ? callbackError(r.value, depth + 1) : void 0;
-  }
-  if ("passed" in r || !r.error) {
+  if ("passed" in r) {
     return void 0;
   }
-  const err = new Error(String(r.message ?? r.error));
-  if (typeof r.stack === "string") {
-    err.stack = r.stack;
+  if (r.error instanceof Error) {
+    return r.error;
+  }
+  if (r.error) {
+    const err = new Error(String(r.message ?? r.error));
+    if (typeof r.stack === "string") {
+      err.stack = r.stack;
+    }
+    return err;
+  }
+  if ("value" in r) {
+    return depth < 2 ? callbackError(r.value, depth + 1) : void 0;
   }
-  return err;
+  return void 0;
 }
 
 // src/helpers/assertTarget.ts
@@ -2308,6 +2478,9 @@ var BrowserProxy = class {
       this.attachScreenshot(browser, lastCommand, methodName);
     }
     this.anchorDestination(browser, methodName);
+    if (!this.isDomMutating(methodName)) {
+      void this.sessionCapturer.nativeNetwork.forward({ throttle: true });
+    }
   }
   isDomMutating(methodName) {
     return NAVIGATION_COMMANDS.includes(methodName) || [
@@ -2636,7 +2809,7 @@ function initReporterChain(ctx) {
 }
 function readViewport(browser) {
   return resolveViewport(browser.capabilities || {}, {
-    runScript: (body) => webdriverExecute(browser, body),
+    runScript: (body) => webdriverExecute2(browser, body),
     getWindowSize: () => webdriverGet2(browser, "window/rect"),
     onWarn: (message) => log10.warn(message)
   });
@@ -2674,6 +2847,18 @@ async function broadcastSessionMetadata(ctx, browser) {
   log10.info(
     `\u2713 Browser: ${browserName}${browserVersion ? " " + browserVersion : ""} (session: ${sessionId2})`
   );
+  if (ctx.mode === "live" && restoreBrowserFocus({
+    browserName: String(browserName),
+    platformName: String(
+      capabilities.platformName || desiredCapabilities.platformName || ""
+    ),
+    host: resolveWebDriverAddress(browser).driverHost,
+    onError: (message) => log10.warn(message)
+  })) {
+    log10.info(
+      "\u2713 Safari brought back to the front (it delivers clicks only there)"
+    );
+  }
   const wantsPerfLog = wantsPerformanceLog(
     capabilities,
     desiredCapabilities
@@ -2681,7 +2866,7 @@ async function broadcastSessionMetadata(ctx, browser) {
   ctx.sessionCapturer.perfLogsRequested = wantsPerfLog;
   if (!wantsPerfLog && !ctx.bidiEnabled) {
     log10.warn(
-      "\u26A0  Network tab will be empty \u2014 add 'goog:loggingPrefs': { performance: 'ALL' } to your capabilities (or enable bidi:true)"
+      "\u26A0  Network tab will carry the page's own Resource Timing only (no headers, no bodies). Add 'goog:loggingPrefs': { performance: 'ALL' } to your capabilities (or enable bidi:true) for full requests"
     );
   }
 }
@@ -2694,7 +2879,7 @@ async function tryAttachBidi(ctx, browser) {
     log10.warn("bidi:true set but browser.driver unavailable \u2014 skipping");
     return;
   }
-  const { attachBidiHandlers, buildBidiSinks } = await import("./bidi-WNZOXX5X.js");
+  const { attachBidiHandlers, buildBidiSinks } = await import("./bidi-AZX3WRGJ.js");
   const ok = await attachBidiHandlers(
     driver,
     buildBidiSinks(ctx.sessionCapturer)
@@ -2718,6 +2903,12 @@ async function armCaptureForSession(ctx, browser) {
   ctx.armedSessionId = browser.sessionId ?? void 0;
   await tryRegisterPreload(ctx, browser);
   await tryAttachBidi(ctx, browser);
+  await ctx.sessionCapturer.nativeNetwork.start({
+    requested: requestsInterceptedNetwork(browser.desiredCapabilities),
+    capabilities: browser.capabilities,
+    execute: sessionExecutor(browser),
+    unavailableReason: "the session id or the configured WebDriver port is unknown"
+  });
 }
 function needsCaptureRearm(ctx, sessionId2) {
   return Boolean(ctx.sessionCapturer) && sessionId2 !== void 0 && ctx.armedSessionId !== void 0 && ctx.armedSessionId !== sessionId2;
@@ -2729,6 +2920,9 @@ async function armReplacedSession(ctx, browser) {
   }
   ctx.sessionCapturer.preloadRegistered = false;
   ctx.sessionCapturer.bidiActive = false;
+  ctx.sessionCapturer.bidiNetworkObserved = false;
+  ctx.sessionCapturer.loadsListedByLog = [];
+  ctx.sessionCapturer.nativeNetwork.stop();
   log10.info(`Session replaced \u2014 re-arming capture for ${sessionId2}`);
   await armCaptureForSession(ctx, browser);
 }
@@ -3215,7 +3409,7 @@ async function captureCucumberScenarioBeforeQuit(ctx, browser, result) {
         assertCalls
       );
     }
-    await ctx.sessionCapturer.captureTrace(browser, true);
+    await ctx.sessionCapturer.captureTraceAtTestEnd(browser);
     flushTestSlice(ctx);
     await ctx.emitTestArtifacts(
       scenario?.uid,
@@ -3936,7 +4130,7 @@ var NightwatchDevToolsPlugin = class {
             this.browserProxy.drainNativeAssertCalls()
           );
         }
-        await this.sessionCapturer.captureTrace(browser, true);
+        await this.sessionCapturer.captureTraceAtTestEnd(browser);
         flushTestSlice(this.#getInternals());
         const results = browser.currentTest?.results;
         const failed = !!results && ((results.errors ?? 0) > 0 || (results.failed ?? 0) > 0);
@@ -3982,6 +4176,7 @@ var NightwatchDevToolsPlugin = class {
     });
   }
   async after(browser) {
+    this.sessionCapturer?.nativeNetwork.stop();
     await this.#screencast.rotation;
     await this.#finalizeCurrentScreencast();
     try {