@analitikisler/ai-tag-debugger 0.7.5 → 0.7.7

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## 0.7.7 (2026-10-14)
+
+- A replay answers a request from the recording when the address only differs by a timestamp (`_=1791977697130`, `ts`, `timestamp`, `cb`, `nocache`). Magento sites reload the basket this way after "add to basket", so the replay never got the answer that makes the page send `add_to_cart`. Exact matches still come from the recording as before.
+- A click found without a saved path no longer keeps its text when it looks like an email address or phone number.
+
+## 0.7.6 (2026-10-14)
+
+- `replay` says when a saved click was found by its text rather than its saved place (`~` lines), since that may not be the element that was saved.
+- Only clicks fall back to their text. Typing into a field or choosing an option uses its saved place only.
+- A click's text is not saved when it looks like an email address or phone number.
+
 ## 0.7.5 (2026-10-14)
 
 - A saved click keeps the element's text as well as its path through the page. When a replay finds nothing visible at that path (a banner or overlay shifted the layout), it clicks the element with that text instead. Sites saved before 0.7.5 have no text to fall back on; save them again to use it.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@analitikisler/ai-tag-debugger",
-  "version": "0.7.5",
+  "version": "0.7.7",
   "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

@@ -201,8 +201,48 @@ function trackingBody(request) {
  * How a scripted run can find the element an action used again: the selector it was given,
  * else a CSS path to the element, else its visible text. Refs only mean something in one run.
  */
+// Text that looks like an email address or phone number is not saved with a click.
+/** Query parameters that only carry the time or a cache-buster, so they differ between a recording and its replay. */
+const STAMP_PARAMS = /^(_|_t|ts|timestamp|cb|cachebust|nocache)$/i;
+/** The address without its timestamp parameters. */
+function unstamped(href) {
+  const url = new URL(href);
+  for (const name of [...url.searchParams.keys()]) if (STAMP_PARAMS.test(name)) url.searchParams.delete(name);
+  return url.href;
+}
+/**
+ * The GET answers in a recording whose address carries a timestamp, by address without it.
+ * Entries the recording has no body for (still loading when the page was left) are not included.
+ */
+async function restampedAnswers(file) {
+  const answers = new Map();
+  answers.exact = new Set();
+  const har = JSON.parse(await readFile(file, "utf8"));
+  for (const e of har.log.entries) {
+    const { request, response } = e;
+    answers.exact.add(request.url);
+    if (request.method !== "GET" || response.status < 200 || response.status >= 300 || typeof response.content?.text !== "string") continue;
+    const key = unstamped(request.url);
+    if (key === request.url) continue;
+    const headers = {};
+    for (const h of response.headers ?? []) {
+      const name = h.name.toLowerCase();
+      if (["content-encoding", "content-length", "transfer-encoding"].includes(name)) continue;
+      headers[name] = name === "set-cookie" && headers[name] ? `${headers[name]}\n${h.value}` : h.value;
+    }
+    const body = response.content.encoding === "base64" ? Buffer.from(response.content.text, "base64") : response.content.text;
+    const entry = answers.get(key) ?? { queue: [] };
+    entry.queue.push({ status: response.status, headers, body });
+    answers.set(key, entry);
+  }
+  return answers;
+}
+const savableText = (text) => (typeof text === "string" && text && !/@|\d[\d\s().+-]{6,}\d/.test(text) ? text : undefined);
+
 async function replayTarget(a, locator) {
-  if (a.selector) return { selector: a.selector, ...(a.text ? { text: a.text } : {}) };
+  // Only a click keeps its text: a field's text is what was typed in it, not what identifies it.
+  const keepText = a.action === "click";
+  if (a.selector) return { selector: a.selector, ...(keepText && savableText(a.text) ? { text: a.text } : {}) };
   const found = await locator
     .evaluate((el) => {
       const text = (el.innerText || el.value || el.getAttribute("aria-label") || "").replace(/\s+/g, " ").trim().slice(0, 80);
@@ -222,8 +262,8 @@ async function replayTarget(a, locator) {
     .catch(() => null);
   const text = found?.text || a.text;
   // The text too, since a path through the page's layout breaks when a banner or overlay shifts it.
-  if (found?.selector) return { selector: found.selector, ...(text ? { text } : {}) };
-  return text ? { text } : {};
+  if (found?.selector) return { selector: found.selector, ...(keepText && savableText(text) ? { text } : {}) };
+  return keepText && savableText(text) ? { text } : {};
 }
 
 // Images, fonts and video don't change what tracking sends, and are most of a recording's size.
@@ -416,6 +456,21 @@ export class AuditSession {
       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.
+      // A page asks again for what it asked when saved, with a new timestamp on the address. Registered
+      // after the recording, so it runs first and leaves every exact match to the recording.
+      const restamped = await restampedAnswers(this.opts.replayHar);
+      if (restamped.size) {
+        await this.context.route(
+          (url) => restamped.has(unstamped(url.href)),
+          (route) => {
+            const request = route.request();
+            const answers = restamped.get(unstamped(request.url()));
+            if (request.method() !== "GET" || restamped.exact.has(request.url())) return route.fallback().catch(() => {});
+            const answer = answers.queue.length > 1 ? answers.queue.shift() : answers.queue[0];
+            return route.fulfill(answer).catch(() => {});
+          },
+        );
+      }
       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(() => {}));
@@ -741,13 +796,16 @@ export class AuditSession {
         case "fill":
         case "select": {
           let target;
-          if (a.selector && typeof a.text === "string" && a.text.trim()) {
-            // A saved step: its path first, then its text if the path finds nothing to click.
+          if (a.action === "click" && a.selector && typeof a.text === "string" && a.text.trim()) {
+            // A saved click: its path first, then its text if the path finds nothing to click.
             target = this.locatorFor(a);
             const shown = await target.waitFor({ state: "visible", timeout: 5000 }).then(() => true, () => false);
             if (!shown) {
               const found = await this.locateByText(a.text.trim());
-              if (!found.error) target = found.locator;
+              if (!found.error) {
+                target = found.locator;
+                step.foundBy = "text"; // the replay summary says so, in case it is not the element saved
+              }
             }
           } else if (a.selector || Number.isInteger(a.ref)) target = this.locatorFor(a);
           else if (typeof a.text === "string" && a.text.trim()) {

package/src/cli.js

@@ -125,6 +125,7 @@ async function main() {
       for (const k of r.extra) console.log(`    + ${k}`);
       for (const k of r.missing) console.log(`    - ${k}`);
       for (const note of r.incomplete) console.log(`    ! ${note}`);
+      for (const note of r.foundByText) console.log(`    ~ ${note}`);
     }
     if (changed && !values.update) process.exitCode = 1;
     return;

package/src/replay.js

@@ -65,7 +65,7 @@ export async function writeSavedSite(dir, { config, plan, runs, findings }) {
 /**
  * Audits a saved site again, offline and without AI, and compares the findings with the expected ones.
  * update: make this replay's findings the expected ones.
- * @returns {Promise<{ site: string, missing: string[], extra: string[], reportPaths: string[], incomplete: string[] }>}
+ * @returns {Promise<{ site: string, missing: string[], extra: string[], reportPaths: string[], incomplete: string[], foundByText: string[] }>}
  */
 export async function replaySavedSite(dir, { update = false, outDir, log = () => {} } = {}) {
   const file = path.join(dir, SAVED_SITE_FILE);
@@ -79,6 +79,7 @@ export async function replaySavedSite(dir, { update = false, outDir, log = () =>
   const findings = [];
   const reportPaths = [];
   const incomplete = [];
+  const foundByText = [];
   for (const viewport of viewports) {
     const journeys = saved.journeys.filter((j) => j.viewport === viewport).map(({ viewport: _v, ...j }) => j);
     const out = path.resolve(outDir ?? path.join(dir, "last-replay"), viewports.length > 1 ? viewport : "");
@@ -98,11 +99,14 @@ export async function replaySavedSite(dir, { update = false, outDir, log = () =>
     // Journeys that were already unfinished when saved are compared through their findings only.
     const wasIncomplete = (r) => journeys.find((j) => j.id === r.journeyId)?.incomplete === r.note;
     incomplete.push(...result.runs.filter((r) => !r.completed && !wasIncomplete(r)).map((r) => `${r.journeyId} (${r.viewport}): ${r.note}`));
+    for (const r of result.runs) {
+      for (const s of r.steps.filter((s) => s.foundBy === "text")) foundByText.push(`${r.journeyId} (${r.viewport}): "${s.label}" was clicked by its text, since nothing was at its saved place.`);
+    }
   }
   const actual = findingKeys(findings);
   const { missing, extra } = compareKeys(saved.expected ?? [], actual);
   if (update && (missing.length || extra.length)) {
     await writeFile(file, JSON.stringify({ ...saved, expected: actual }, null, 2));
   }
-  return { site: saved.config.site, missing, extra, reportPaths, incomplete };
+  return { site: saved.config.site, missing, extra, reportPaths, incomplete, foundByText };
 }