cbrowser 18.73.1 → 18.73.4

package/dist/browser.js

@@ -19,6 +19,7 @@ import { DEVICE_PRESETS, LOCATION_PRESETS, CBrowserErrorCode } from "./types.js"
 import { runCognitiveJourney, isApiKeyConfigured, } from "./cognitive/index.js";
 import { SessionManager } from "./browser/session-manager.js";
 import { SelectorCacheManager } from "./browser/selector-cache.js";
+import { extractExpected, extractSubject, UNPARSEABLE_MESSAGE } from "./browser/assertion-value.js";
 import { OverlayHandler } from "./browser/overlay-handler.js";
 import { getRemoteMode, MAX_RESPONSE_SIZE } from "./mcp-tools/screenshot-utils.js";
 import { clampRect } from "./recording/timing.js";
@@ -152,6 +153,26 @@ export async function launchBrowserWithFallback(browserType = chromium, options
         }
     }
 }
+/**
+ * Compress a Playwright error for a tool response.
+ *
+ * Playwright appends a "Call log:" listing every retry, which for a click that
+ * waits out its timeout runs to dozens of near-identical lines and roughly 4k
+ * tokens. The first lines say what failed and the last say how it ended; the
+ * middle is the same line repeated. Keep both ends, drop the middle, and say how
+ * much was dropped so nobody wonders what they are not seeing. (2026-07-29)
+ */
+function summarizePlaywrightError(message, headLines = 6, tailLines = 4) {
+    const lines = message.split("\n");
+    if (lines.length <= headLines + tailLines + 2)
+        return message;
+    const dropped = lines.length - headLines - tailLines;
+    return [
+        ...lines.slice(0, headLines),
+        `  … ${dropped} more lines of Playwright retry log elided (set verbose for the full log) …`,
+        ...lines.slice(-tailLines),
+    ].join("\n");
+}
 export class CBrowser {
     config;
     paths;
@@ -161,6 +182,14 @@ export class CBrowser {
     currentPersona = null;
     networkRequests = [];
     networkResponses = new Map();
+    /**
+     * In-flight requests awaiting a response, so the response handler can attach
+     * status and duration to the originating record. Keyed by url+method, capped
+     * so a page that fires requests which never resolve cannot grow it without
+     * bound. (2026-07-28)
+     */
+    pendingRequests = new Map();
+    static MAX_PENDING_REQUESTS = 2000;
     harEntries = [];
     isRecordingHar = false;
     skipSessionRestore;
@@ -1185,6 +1214,17 @@ For more help: https://playwright.dev/docs/browsers
                 timestamp: new Date().toISOString(),
             };
             this.networkRequests.push(networkRequest);
+            // Track it so the response handler can complete the record. Evict the
+            // oldest entry rather than growing forever when responses never arrive.
+            if (this.pendingRequests.size >= CBrowser.MAX_PENDING_REQUESTS) {
+                const oldest = this.pendingRequests.keys().next();
+                if (!oldest.done)
+                    this.pendingRequests.delete(oldest.value);
+            }
+            this.pendingRequests.set(request.url() + request.method(), {
+                req: networkRequest,
+                startedAt: Date.now(),
+            });
             if (this.isRecordingHar) {
                 // Start HAR entry
                 const harEntry = {
@@ -1204,12 +1244,17 @@ For more help: https://playwright.dev/docs/browsers
         });
         this.page.on("response", async (response) => {
             const key = response.url() + response.request().method();
-            const _networkResponse = {
-                url: response.url(),
-                status: response.status(),
-                statusText: response.statusText(),
-                headers: response.headers(),
-            };
+            // This status was already being computed here and then discarded into an
+            // unused local, which is why get_network_requests could never report the
+            // status codes and timing its description promised. Attach it to the
+            // originating request record instead. (2026-07-28)
+            const pending = this.pendingRequests.get(key);
+            if (pending) {
+                pending.req.status = response.status();
+                pending.req.statusText = response.statusText();
+                pending.req.durationMs = Date.now() - pending.startedAt;
+                this.pendingRequests.delete(key);
+            }
             if (this.isRecordingHar && this.networkResponses.has(key)) {
                 const partial = this.networkResponses.get(key);
                 const startTime = new Date(partial.startedDateTime).getTime();
@@ -1284,6 +1329,7 @@ For more help: https://playwright.dev/docs/browsers
     clearNetworkHistory() {
         this.networkRequests = [];
         this.harEntries = [];
+        this.pendingRequests.clear();
     }
     // =========================================================================
     // Performance Metrics
@@ -1293,7 +1339,7 @@ For more help: https://playwright.dev/docs/browsers
      */
     async getPerformanceMetrics() {
         const page = await this.getPage();
-        const metrics = await page.evaluate(() => {
+        const metrics = await page.evaluate(async () => {
             const result = {};
             // Navigation timing
             const navTiming = performance.getEntriesByType("navigation")[0];
@@ -1309,19 +1355,45 @@ For more help: https://playwright.dev/docs/browsers
                     result.fcp = entry.startTime;
                 }
             }
-            // LCP from PerformanceObserver (if available)
-            const lcpEntries = performance.getEntriesByType("largest-contentful-paint");
-            if (lcpEntries.length > 0) {
-                result.lcp = lcpEntries[lcpEntries.length - 1].startTime;
-            }
-            // CLS from layout-shift entries
-            const clsEntries = performance.getEntriesByType("layout-shift");
+            // LCP and CLS are delivered ONLY to a PerformanceObserver. Chromium never
+            // adds largest-contentful-paint or layout-shift entries to the performance
+            // timeline, so the previous getEntriesByType() calls returned [] on every
+            // page. LCP was therefore always undefined, and CLS was always exactly 0 —
+            // which looked like a real measurement of a perfectly stable page rather
+            // than no measurement at all. `buffered: true` replays the entries that
+            // already fired before this observer existed. (2026-07-29)
             let clsScore = 0;
-            for (const entry of clsEntries) {
-                if (!entry.hadRecentInput) {
-                    clsScore += entry.value || 0;
+            await new Promise((resolve) => {
+                let settled = false;
+                const finish = () => { if (!settled) {
+                    settled = true;
+                    resolve();
+                } };
+                try {
+                    const lcpObs = new PerformanceObserver((list) => {
+                        const entries = list.getEntries();
+                        if (entries.length > 0) {
+                            result.lcp = entries[entries.length - 1].startTime;
+                        }
+                    });
+                    lcpObs.observe({ type: "largest-contentful-paint", buffered: true });
+                    const clsObs = new PerformanceObserver((list) => {
+                        for (const entry of list.getEntries()) {
+                            if (!entry.hadRecentInput) {
+                                clsScore += entry.value || 0;
+                            }
+                        }
+                    });
+                    clsObs.observe({ type: "layout-shift", buffered: true });
                 }
-            }
+                catch {
+                    // Older engines without these entry types: leave lcp undefined rather
+                    // than reporting a fabricated value.
+                    finish();
+                }
+                // Buffered entries arrive on the next task; give late shifts a moment too.
+                setTimeout(finish, 300);
+            });
             result.cls = clsScore;
             // Resource counts
             const resources = performance.getEntriesByType("resource");
@@ -2090,7 +2162,10 @@ For more help: https://playwright.dev/docs/browsers
             const result = {
                 success: false,
                 screenshot: await this.screenshot(),
-                message: `Failed to click: ${errorMessage}`,
+                // Was the raw Playwright error, whose Call log ran to ~4k tokens of
+                // near-identical retry lines and crowded out everything else in the
+                // response. verbose still gets the whole thing. (2026-07-29)
+                message: `Failed to click: ${options.verbose ? errorMessage : summarizePlaywrightError(errorMessage)}`,
             };
             if (options.verbose) {
                 const available = await this.getAvailableClickables(page);
@@ -4036,8 +4111,9 @@ For more help: https://playwright.dev/docs/browsers
         // Page title assertions
         if (lowerAssertion.includes("title") && (lowerAssertion.includes("is") || lowerAssertion.includes("contains"))) {
             const title = await page.title();
-            const match = assertion.match(/["']([^"']+)["']/);
-            const expected = match?.[1] || "";
+            const expected = extractExpected(assertion);
+            if (expected === null)
+                return { passed: false, assertion, actual: title, message: UNPARSEABLE_MESSAGE };
             if (lowerAssertion.includes("contains")) {
                 const passed = title.toLowerCase().includes(expected.toLowerCase());
                 return { passed, assertion, actual: title, expected, message: passed ? "Title contains expected text" : `Title "${title}" does not contain "${expected}"` };
@@ -4050,8 +4126,9 @@ For more help: https://playwright.dev/docs/browsers
         // URL assertions
         if (lowerAssertion.includes("url") && (lowerAssertion.includes("is") || lowerAssertion.includes("contains"))) {
             const url = page.url();
-            const match = assertion.match(/["']([^"']+)["']/);
-            const expected = match?.[1] || "";
+            const expected = extractExpected(assertion);
+            if (expected === null)
+                return { passed: false, assertion, actual: url, message: UNPARSEABLE_MESSAGE };
             if (lowerAssertion.includes("contains")) {
                 const passed = url.includes(expected);
                 return { passed, assertion, actual: url, expected, message: passed ? "URL contains expected text" : `URL "${url}" does not contain "${expected}"` };
@@ -4064,8 +4141,9 @@ For more help: https://playwright.dev/docs/browsers
         // Text presence assertions
         // v14.3.0: Filter script/style content to avoid ad injection false negatives
         if (lowerAssertion.includes("page") && (lowerAssertion.includes("contains") || lowerAssertion.includes("has") || lowerAssertion.includes("shows"))) {
-            const match = assertion.match(/["']([^"']+)["']/);
-            const expected = match?.[1] || "";
+            const expected = extractExpected(assertion);
+            if (expected === null)
+                return { passed: false, assertion, message: UNPARSEABLE_MESSAGE };
             // v14.3.0: Use filtered text extraction (excludes script/style content)
             const content = await page.evaluate(() => {
                 const clone = document.body.cloneNode(true);
@@ -4079,8 +4157,9 @@ For more help: https://playwright.dev/docs/browsers
         }
         // Element existence assertions
         if (lowerAssertion.includes("exists") || lowerAssertion.includes("visible") || lowerAssertion.includes("present")) {
-            const match = assertion.match(/["']([^"']+)["']/);
-            const selector = match?.[1] || "";
+            const selector = extractSubject(assertion);
+            if (selector === null)
+                return { passed: false, assertion, message: UNPARSEABLE_MESSAGE };
             const element = await this.findElement(selector);
             const passed = element !== null;
             return { passed, assertion, expected: selector, message: passed ? `Element "${selector}" exists` : `Element "${selector}" not found` };