@analitikisler/ai-tag-debugger 0.7.2 → 0.7.4

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 0.7.4 (2026-10-14)
+
+- Saving a site no longer fails on pages that keep a request open after they are left (a GA4 hit to `www.google.com/g/collect`, for example). The recording waited for it until the 30-second limit and was then skipped, so the site was not saved. The browser's pages are now closed before the recording is written.
+- Fewer test hits from popups reach the real account while a recording is written.
+
+## 0.7.3 (2026-10-13)
+
+- `replay` no longer crashes with `NavigationAbortedError: net::ERR_BLOCKED_BY_CLIENT` when a saved page redirects to another site. The redirect is refused again, so the journey stays unfinished as it was saved, and the other sites are still replayed.
+- Tracking hits sent while the browser closes are answered locally again on normal runs. In 0.7.2 the routes were removed before closing, so a hit sent at that moment could reach the real account. They are now removed only on `replay`, which never goes online.
+
 ## 0.7.2 (2026-10-13)
 
 - **GA4 and Google Ads hits sent through Google tag gateway are captured.** Sites using the gateway send GA4 to a short path on their own domain (`/<prefix>/ag/g/c`, `/<prefix>/ga/g/c`) and Google Ads to `/<prefix>/as/p/c/<id>/`. These were neither recognized nor answered locally, so their events were reported as missing and the audit's visits reached the site's real accounts. A `/g/c` path counts as GA4 only with a GA4 measurement id (`tid=G-…`).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@analitikisler/ai-tag-debugger",
-  "version": "0.7.2",
+  "version": "0.7.4",
   "description": "Open-source AI agent that QA-tests your website's analytics, ad and consent tracking (GA4, GTM, Google Ads, Meta, TikTok). Bring your own model (Claude, OpenAI, Gemini) or use it from your chat app over MCP.",
   "type": "module",
   "bin": {

package/src/browser.js

@@ -322,6 +322,11 @@ export class AuditSession {
       launch.proxy = { server: this.egress.url, bypass: "<-loopback>" };
       launch.args = ["--force-webrtc-ip-handling-policy=disable_non_proxied_udp"];
     }
+    if (this.opts.replayHar) {
+      // A replay never goes online: requests the routes below don't answer, including any still in
+      // flight once they are removed at the end, go to a proxy that isn't there.
+      launch.proxy = { server: "http://127.0.0.1:9", bypass: "<-loopback>" };
+    }
     this.browser = await chromium.launch(launch);
     const record = this.opts.recordHar ? { recordHar: { path: this.opts.recordHar, mode: "minimal" } } : {};
     this.context = await this.browser.newContext({ ...device, locale: "en-US", ...record });
@@ -407,6 +412,12 @@ export class AuditSession {
         (isDroppedMedia(route.request()) ? route.fulfill({ status: 200, body: "" }) : route.abort()).catch(() => {}),
       );
       await this.context.routeFromHAR(this.opts.replayHar, { notFound: "fallback" });
+      // A saved redirect to a page the browser may not open fails here, as it did when saved. Left to the
+      // recording, the redirect would be followed outside any handler, and its failure would end the run.
+      const refusedRedirects = await this.refusedRedirects(this.opts.replayHar);
+      if (refusedRedirects.size) {
+        await this.context.route((url) => refusedRedirects.has(url.href), (route) => route.abort("blockedbyclient").catch(() => {}));
+      }
     }
     if (this.opts.blockHits) {
       await this.context.route((url) => isCollectionEndpoint(url.href), async (route) => {
@@ -495,6 +506,21 @@ export class AuditSession {
     return true;
   }
 
+  /** Addresses whose saved answer redirects somewhere the browser may not go. */
+  async refusedRedirects(file) {
+    const refused = new Set();
+    const har = JSON.parse(await readFile(file, "utf8"));
+    for (const e of har.log.entries) {
+      const status = e.response?.status;
+      if (status < 300 || status >= 400) continue;
+      const location = e.response.redirectURL || e.response.headers?.find((h) => /^location$/i.test(h.name))?.value;
+      if (!location) continue;
+      const target = new URL(location, e.request.url).href;
+      if (await this.checkUrl(target)) refused.add(e.request.url);
+    }
+    return refused;
+  }
+
   /** Error message when the browser may not be on this URL, or null. */
   checkUrl(url) {
     if (url.startsWith("chrome-error:")) return null; // Chromium's own error page, e.g. after a blocked navigation
@@ -765,15 +791,32 @@ export class AuditSession {
   async close() {
     // Leaving the page first cancels what it is still loading (the recording would otherwise wait for it),
     // while tracking requests sent on the way out are still answered locally.
-    if (this.opts.recordHar) await this.page?.goto("about:blank", { timeout: 5000 }).catch(() => {});
-    // Requests still in flight then get no route callback that would throw once the browser is gone.
-    // A page stuck in a script never answers, so this waits at most 5 seconds.
-    let unrouteTimer;
-    await Promise.race([
-      this.context?.unrouteAll({ behavior: "ignoreErrors" }).catch(() => {}),
-      new Promise((resolve) => (unrouteTimer = setTimeout(resolve, 5000))),
-    ]);
-    clearTimeout(unrouteTimer);
+    if (this.opts.recordHar && this.context) {
+      await this.page?.goto("about:blank", { timeout: 5000 }).catch(() => {});
+      // The recording also waits for requests the browser holds for an open page, such as a tracking hit
+      // sent as the page was left, which can stay open for good. Once their page is closed it stops waiting.
+      // A moment first lets hits already sent be answered locally: once their page is closed,
+      // the browser would send them on its own.
+      await new Promise((resolve) => setTimeout(resolve, 1000));
+      let pagesTimer;
+      await Promise.race([
+        Promise.all(this.context.pages().map((p) => p.close().catch(() => {}))),
+        new Promise((resolve) => (pagesTimer = setTimeout(resolve, 5000))),
+      ]);
+      clearTimeout(pagesTimer);
+    }
+    if (this.opts.replayHar) {
+      // The recording's own route callbacks would otherwise throw for requests still in flight once the
+      // browser is gone. Without routes, those go nowhere (see start). Elsewhere the routes stay, so a
+      // hit sent while the browser closes is still answered locally instead of reaching the real account.
+      // A page stuck in a script never answers, so this waits at most 5 seconds.
+      let unrouteTimer;
+      await Promise.race([
+        this.context?.unrouteAll({ behavior: "ignoreErrors" }).catch(() => {}),
+        new Promise((resolve) => (unrouteTimer = setTimeout(resolve, 5000))),
+      ]);
+      clearTimeout(unrouteTimer);
+    }
     if (this.opts.recordHar && this.context) {
       // Writes the recording. If the browser already went away, or writing it takes too long, there is
       // none to clean: closing the browser below then ends the run's wait.