npm - dev3000 - Versions diffs - 0.0.173 → 0.0.175 - Mend

dev3000 0.0.173 → 0.0.175

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (83) hide show

package/README.md +0 -4
package/dist/cdp-monitor.d.ts +21 -2
package/dist/cdp-monitor.d.ts.map +1 -1
package/dist/cdp-monitor.js +449 -107
package/dist/cdp-monitor.js.map +1 -1
package/dist/cli.js +193 -216
package/dist/cli.js.map +1 -1
package/dist/commands/crawl.d.ts.map +1 -1
package/dist/commands/crawl.js +4 -43
package/dist/commands/crawl.js.map +1 -1
package/dist/commands/errors.d.ts.map +1 -1
package/dist/commands/errors.js +4 -53
package/dist/commands/errors.js.map +1 -1
package/dist/commands/fix.d.ts.map +1 -1
package/dist/commands/fix.js +5 -74
package/dist/commands/fix.js.map +1 -1
package/dist/commands/logs.d.ts.map +1 -1
package/dist/commands/logs.js +4 -53
package/dist/commands/logs.js.map +1 -1
package/dist/commands/resume.d.ts +11 -0
package/dist/commands/resume.d.ts.map +1 -0
package/dist/commands/resume.js +75 -0
package/dist/commands/resume.js.map +1 -0
package/dist/commands/skill-runner.d.ts +14 -0
package/dist/commands/skill-runner.d.ts.map +1 -0
package/dist/commands/skill-runner.js +494 -0
package/dist/commands/skill-runner.js.map +1 -0
package/dist/dev-environment.d.ts +26 -3
package/dist/dev-environment.d.ts.map +1 -1
package/dist/dev-environment.js +285 -118
package/dist/dev-environment.js.map +1 -1
package/dist/skills/d3k/internal-skill.md +145 -0
package/dist/skills/index.test.ts +28 -1
package/dist/skills/index.ts +58 -7
package/dist/tui-interface-opentui.d.ts +2 -0
package/dist/tui-interface-opentui.d.ts.map +1 -1
package/dist/tui-interface-opentui.js +17 -3
package/dist/tui-interface-opentui.js.map +1 -1
package/dist/utils/agent-browser.d.ts.map +1 -1
package/dist/utils/agent-browser.js +6 -3
package/dist/utils/agent-browser.js.map +1 -1
package/dist/utils/agent-detection.d.ts +1 -0
package/dist/utils/agent-detection.d.ts.map +1 -1
package/dist/utils/agent-detection.js +11 -0
package/dist/utils/agent-detection.js.map +1 -1
package/dist/utils/agent-selection.js +4 -4
package/dist/utils/agent-selection.js.map +1 -1
package/dist/utils/browser-command-argv.d.ts +1 -1
package/dist/utils/browser-command-argv.d.ts.map +1 -1
package/dist/utils/browser-command-argv.js +1 -1
package/dist/utils/browser-command-argv.js.map +1 -1
package/dist/utils/project-metadata.d.ts +4 -0
package/dist/utils/project-metadata.d.ts.map +1 -0
package/dist/utils/project-metadata.js +48 -0
package/dist/utils/project-metadata.js.map +1 -0
package/dist/utils/project-name.d.ts +2 -0
package/dist/utils/project-name.d.ts.map +1 -1
package/dist/utils/project-name.js +6 -0
package/dist/utils/project-name.js.map +1 -1
package/dist/utils/session.d.ts +14 -0
package/dist/utils/session.d.ts.map +1 -0
package/dist/utils/session.js +65 -0
package/dist/utils/session.js.map +1 -0
package/dist/utils/version-check.js +2 -2
package/dist/utils/version-check.js.map +1 -1
package/package.json +9 -21
package/dist/commands/cloud-check-pr.d.ts +0 -9
package/dist/commands/cloud-check-pr.d.ts.map +0 -1
package/dist/commands/cloud-check-pr.js +0 -243
package/dist/commands/cloud-check-pr.js.map +0 -1
package/dist/commands/cloud-fix.d.ts +0 -13
package/dist/commands/cloud-fix.d.ts.map +0 -1
package/dist/commands/cloud-fix.js +0 -79
package/dist/commands/cloud-fix.js.map +0 -1
package/dist/commands/find-component.d.ts +0 -8
package/dist/commands/find-component.d.ts.map +0 -1
package/dist/commands/find-component.js +0 -182
package/dist/commands/find-component.js.map +0 -1
package/dist/skills/d3k/SKILL.md +0 -126
package/dist/skills/index.d.ts +0 -46
package/dist/skills/index.d.ts.map +0 -1
package/dist/skills/index.js +0 -174
package/dist/skills/index.js.map +0 -1

package/dist/cdp-monitor.js CHANGED Viewed

@@ -1,5 +1,5 @@
 import { spawn } from "child_process";
-import { existsSync, mkdtempSync, readFileSync, writeFileSync } from "fs";
+import { existsSync, mkdtempSync, readdirSync, readFileSync, writeFileSync } from "fs";
 import { tmpdir } from "os";
 import { dirname, join } from "path";
 import { fileURLToPath } from "url";
@@ -43,6 +43,190 @@ const EMBEDDED_LOADING_HTML = `<!DOCTYPE html>
   </div>
 </body>
 </html>`;
+const DEFAULT_CDP_COMMAND_TIMEOUT_MS = 10000;
+const DEFAULT_NAVIGATION_TIMEOUT_MS = 60000;
+export const CHROME_CRASH_RESTORE_SUPPRESSION_FLAGS = [
+    "--disable-session-crashed-bubble",
+    "--disable-restore-session-state",
+    "--hide-crash-restore-bubble"
+];
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function patchChromePreferences(data) {
+    let changed = false;
+    const profile = isRecord(data.profile) ? data.profile : {};
+    if (data.profile !== profile) {
+        data.profile = profile;
+        changed = true;
+    }
+    if (profile.exit_type !== "Normal") {
+        profile.exit_type = "Normal";
+        changed = true;
+    }
+    if (profile.exited_cleanly !== true) {
+        profile.exited_cleanly = true;
+        changed = true;
+    }
+    return changed;
+}
+function patchChromeLocalState(data) {
+    let changed = false;
+    if (data.exit_type === "Crashed") {
+        data.exit_type = "Normal";
+        changed = true;
+    }
+    if (data.exited_cleanly === false) {
+        data.exited_cleanly = true;
+        changed = true;
+    }
+    if (isRecord(data.profile)) {
+        if (data.profile.exit_type === "Crashed") {
+            data.profile.exit_type = "Normal";
+            changed = true;
+        }
+        if (data.profile.exited_cleanly === false) {
+            data.profile.exited_cleanly = true;
+            changed = true;
+        }
+    }
+    return changed;
+}
+function patchJsonFile(filePath, patch) {
+    if (!existsSync(filePath)) {
+        return false;
+    }
+    try {
+        const data = JSON.parse(readFileSync(filePath, "utf-8"));
+        if (!isRecord(data) || !patch(data)) {
+            return false;
+        }
+        writeFileSync(filePath, JSON.stringify(data));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function getChromePreferencesFiles(profileDir) {
+    const files = new Set([join(profileDir, "Default", "Preferences")]);
+    if (!existsSync(profileDir)) {
+        return Array.from(files);
+    }
+    try {
+        for (const entry of readdirSync(profileDir, { withFileTypes: true })) {
+            if (entry.isDirectory() && (entry.name === "Default" || entry.name.startsWith("Profile "))) {
+                files.add(join(profileDir, entry.name, "Preferences"));
+            }
+        }
+    }
+    catch {
+        // Ignore unreadable profile directories.
+    }
+    return Array.from(files);
+}
+export function resetChromeCrashRestoreState(profileDir) {
+    let changedFiles = 0;
+    for (const preferencesFile of getChromePreferencesFiles(profileDir)) {
+        if (patchJsonFile(preferencesFile, patchChromePreferences)) {
+            changedFiles++;
+        }
+    }
+    if (patchJsonFile(join(profileDir, "Local State"), patchChromeLocalState)) {
+        changedFiles++;
+    }
+    return changedFiles;
+}
+export function getLoadingHtmlCandidates(currentDir, execPath = process.execPath) {
+    const candidates = [join(currentDir, "src/loading.html"), join(currentDir, "loading.html")];
+    const packageRoot = dirname(dirname(execPath));
+    candidates.push(join(packageRoot, "src/loading.html"));
+    candidates.push(join(packageRoot, "loading.html"));
+    candidates.push(join(process.cwd(), "src/loading.html"));
+    return candidates;
+}
+function isD3kLoadingPageUrl(url) {
+    if (!url?.startsWith("file://")) {
+        return false;
+    }
+    try {
+        const pathname = decodeURIComponent(new URL(url).pathname);
+        return pathname.includes("/dev3000-loading-") && pathname.endsWith("/loading.html");
+    }
+    catch {
+        return false;
+    }
+}
+function matchesAppServerPort(url, appServerPort) {
+    if (!url || !appServerPort) {
+        return false;
+    }
+    try {
+        const parsed = new URL(url);
+        const hostname = parsed.hostname;
+        const port = parsed.port || (parsed.protocol === "https:" ? "443" : "80");
+        return (hostname === "localhost" || hostname === "127.0.0.1" || hostname === "0.0.0.0") && port === appServerPort;
+    }
+    catch {
+        return false;
+    }
+}
+function matchesInitialAppUrl(url, initialAppUrl) {
+    if (!url || !initialAppUrl) {
+        return false;
+    }
+    try {
+        const actual = new URL(url);
+        const expected = new URL(initialAppUrl);
+        const actualPort = actual.port || (actual.protocol === "https:" ? "443" : "80");
+        const expectedPort = expected.port || (expected.protocol === "https:" ? "443" : "80");
+        return (actual.protocol === expected.protocol &&
+            actual.hostname === expected.hostname &&
+            actualPort === expectedPort &&
+            actual.pathname === expected.pathname);
+    }
+    catch {
+        return false;
+    }
+}
+function formatTargetForLog(target) {
+    return `${target.type || "unknown"}:${target.url || "<no-url>"}`;
+}
+export function selectCDPTarget(targets, options = {}) {
+    const debuggableTargets = targets.filter((target) => target.webSocketDebuggerUrl);
+    if (debuggableTargets.length === 0) {
+        throw new Error(`No debuggable target found in Chrome (found ${targets.length} targets)`);
+    }
+    const contextualMatches = debuggableTargets
+        .map((target) => ({
+        target,
+        score: (matchesInitialAppUrl(target.url, options.initialAppUrl) ? 100 : 0) +
+            (matchesAppServerPort(target.url, options.appServerPort) ? 70 : 0) +
+            (isD3kLoadingPageUrl(target.url) ? 90 : 0) +
+            (target.type === "page" ? 10 : 0)
+    }))
+        .sort((left, right) => right.score - left.score);
+    const bestContextualScore = contextualMatches[0]?.score || 0;
+    const minimumContextualScore = 70;
+    if (bestContextualScore >= minimumContextualScore) {
+        return contextualMatches[0].target;
+    }
+    const pageTarget = debuggableTargets.find((target) => target.type === "page");
+    if (!options.appServerPort && !options.initialAppUrl) {
+        return pageTarget || debuggableTargets[0];
+    }
+    if (debuggableTargets.length === 1 && debuggableTargets[0]?.url === "about:blank") {
+        return debuggableTargets[0];
+    }
+    const expectedDetails = [
+        options.initialAppUrl ? `url ${options.initialAppUrl}` : null,
+        options.appServerPort ? `port ${options.appServerPort}` : null,
+        "d3k loading page"
+    ]
+        .filter(Boolean)
+        .join(", ");
+    throw new Error(`CDP target mismatch on port ${options.appServerPort || "unknown"}; expected ${expectedDetails}, found ${debuggableTargets.map(formatTargetForLog).join(", ")}`);
+}
 export class CDPMonitor {
     browser = null;
     connection = null;
@@ -69,7 +253,9 @@ export class CDPMonitor {
     framework; // Framework hint from project detection
     reactTrackingEnabled = false;
     lastReactSnapshotLogTime = 0;
-    constructor(profileDir, screenshotDir, logger, debug = false, browserPath, pluginReactScan = false, appServerPort, initialAppUrl, debugPort, headless = false, framework) {
+    pendingCommands = new Map();
+    navigationTimeoutMs = DEFAULT_NAVIGATION_TIMEOUT_MS;
+    constructor(profileDir, screenshotDir, logger, debug = false, browserPath, pluginReactScan = false, appServerPort, initialAppUrl, navigationTimeoutMs = DEFAULT_NAVIGATION_TIMEOUT_MS, debugPort, headless = false, framework) {
         this.profileDir = profileDir;
         this.screenshotDir = screenshotDir;
         this.appServerPort = appServerPort;
@@ -78,6 +264,7 @@ export class CDPMonitor {
         this.browserPath = browserPath;
         this.pluginReactScan = pluginReactScan;
         this.initialAppUrl = initialAppUrl;
+        this.navigationTimeoutMs = navigationTimeoutMs;
         this.headless = headless;
         this.framework = framework;
         this.reactTrackingEnabled = framework === "nextjs";
@@ -269,11 +456,7 @@ export class CDPMonitor {
         const currentDir = dirname(currentFile);
         let loadingHtml;
         try {
-            const loadingHtmlCandidates = [
-                join(currentDir, "src/loading.html"),
-                join(currentDir, "loading.html"),
-                join(process.cwd(), "src/loading.html")
-            ];
+            const loadingHtmlCandidates = getLoadingHtmlCandidates(currentDir);
             const loadingHtmlPath = loadingHtmlCandidates.find((path) => existsSync(path));
             if (!loadingHtmlPath) {
                 throw new Error("No loading.html found in expected locations");
@@ -347,10 +530,21 @@ export class CDPMonitor {
      */
     async killExistingChromeWithProfile() {
         try {
-            // Find Chrome processes using this profile directory
+            // Build a set of PIDs that must never be killed: this Node process and
+            // its parent. d3k's own argv contains the profile path (via --profile-dir),
+            // which previously caused a substring match here and made d3k SIGTERM itself.
+            const selfPids = new Set();
+            if (typeof process.pid === "number")
+                selfPids.add(process.pid);
+            if (typeof process.ppid === "number")
+                selfPids.add(process.ppid);
+            // Find Chrome processes using this profile directory. We only match the
+            // canonical `--user-data-dir=<profile>` form Chrome consumes; matching the
+            // bare path was too loose and caught unrelated processes (including d3k itself).
             const processes = await this.listProcesses();
             const pids = processes
-                .filter((proc) => proc.command.includes(`--user-data-dir=${this.profileDir}`) || proc.command.includes(this.profileDir))
+                .filter((proc) => !selfPids.has(proc.pid))
+                .filter((proc) => proc.command.includes(`--user-data-dir=${this.profileDir}`))
                 .map((proc) => proc.pid)
                 .filter((pid) => pid !== this.browser?.pid);
             for (const pid of pids) {
@@ -374,6 +568,10 @@ export class CDPMonitor {
     async launchChrome() {
         // Kill any existing Chrome using this profile to prevent CDP conflicts
         await this.killExistingChromeWithProfile();
+        const resetProfileFiles = resetChromeCrashRestoreState(this.profileDir);
+        if (resetProfileFiles > 0) {
+            this.debugLog(`Reset Chrome crash restore state in ${resetProfileFiles} profile file(s)`);
+        }
         return new Promise((resolve, reject) => {
             // Use custom browser path if provided, otherwise try different Chrome executables based on platform
             const chromeCommands = this.browserPath
@@ -383,6 +581,8 @@ export class CDPMonitor {
                     "google-chrome",
                     "chrome",
                     "chromium",
+                    "brave",
+                    "brave-browser",
                     "/Applications/Arc.app/Contents/MacOS/Arc",
                     "/Applications/Comet.app/Contents/MacOS/Comet",
                     "/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge"
@@ -422,8 +622,7 @@ export class CDPMonitor {
                     "--disable-sync",
                     "--metrics-recording-only",
                     "--disable-default-apps",
-                    "--disable-session-crashed-bubble",
-                    "--disable-restore-session-state"
+                    ...CHROME_CRASH_RESTORE_SUPPRESSION_FLAGS
                 ];
                 if (shouldEnableReactDevTools && reactDevToolsExtensionPath) {
                     chromeArgs.push(`--disable-extensions-except=${reactDevToolsExtensionPath}`);
@@ -442,6 +641,10 @@ export class CDPMonitor {
                     chromeArgs.push("--disable-setuid-sandbox");
                     chromeArgs.push("--disable-gpu");
                     chromeArgs.push("--disable-dev-shm-usage");
+                    chromeArgs.push("--disable-background-timer-throttling");
+                    chromeArgs.push("--disable-backgrounding-occluded-windows");
+                    chromeArgs.push("--disable-renderer-backgrounding");
+                    chromeArgs.push("--window-size=1920,1080");
                     this.debugLog("Launching Chrome in headless mode");
                 }
                 else {
@@ -538,15 +741,15 @@ export class CDPMonitor {
             try {
                 // Get the WebSocket URL from Chrome's debug endpoint
                 const targetsResponse = await fetch(`http://localhost:${this.debugPort}/json`);
-                let targets = await targetsResponse.json();
-                this.debugLog(`Found ${targets.length} targets: ${JSON.stringify(targets.map((t) => ({ type: t.type, url: t.url })))}`);
+                let targets = (await targetsResponse.json());
+                this.debugLog(`Found ${targets.length} targets: ${JSON.stringify(targets.map((target) => ({ type: target.type ?? "unknown", url: target.url ?? "" })))}`);
                 if (targets.length === 0) {
                     this.debugLog("No debuggable targets found; creating a blank page target");
                     const newTargetResponse = await fetch(`http://localhost:${this.debugPort}/json/new?about:blank`, {
                         method: "PUT"
                     });
                     if (newTargetResponse.ok) {
-                        const createdTarget = await newTargetResponse.json();
+                        const createdTarget = (await newTargetResponse.json());
                         targets = [createdTarget];
                         this.debugLog(`Created page target: ${createdTarget.id || "unknown"} - ${createdTarget.url || ""}`);
                     }
@@ -554,19 +757,14 @@ export class CDPMonitor {
                         this.debugLog(`Failed to create page target: HTTP ${newTargetResponse.status}`);
                     }
                 }
-                // Find the first page target (tab) - prefer 'page' type but accept any target with a webSocketDebuggerUrl
-                let pageTarget = targets.find((target) => target.type === "page");
-                // Fallback: if no 'page' type found, try to use any target with a debugger URL
-                if (!pageTarget && targets.length > 0) {
-                    pageTarget = targets.find((target) => target.webSocketDebuggerUrl);
-                    if (pageTarget) {
-                        this.debugLog(`No 'page' type target found, using target of type '${pageTarget.type}' instead`);
-                    }
-                }
-                if (!pageTarget) {
-                    throw new Error(`No debuggable target found in Chrome (found ${targets.length} targets)`);
-                }
+                const pageTarget = selectCDPTarget(targets, {
+                    appServerPort: this.appServerPort,
+                    initialAppUrl: this.initialAppUrl
+                });
                 const wsUrl = pageTarget.webSocketDebuggerUrl;
+                if (!wsUrl) {
+                    throw new Error(`Selected CDP target does not have a websocket URL: ${formatTargetForLog(pageTarget)}`);
+                }
                 this.cdpUrl = wsUrl; // Store the CDP URL
                 this.debugLog(`Found page target: ${pageTarget.title || "Unknown"} - ${pageTarget.url}`);
                 this.debugLog(`Got CDP WebSocket URL: ${wsUrl}`);
@@ -599,6 +797,7 @@ export class CDPMonitor {
                     });
                     ws.on("close", (code, reason) => {
                         this.debugLog(`WebSocket closed with code ${code}, reason: ${reason}`);
+                        this.rejectPendingCDPCommands(new Error(`CDP connection closed before response (code=${code})`));
                         if (!this.isShuttingDown) {
                             this.logger("browser", `[CDP] Connection lost unexpectedly (code: ${code}, reason: ${reason})`);
                             this.logger("browser", "[CDP] CDP connection lost - check for Chrome crash or server issues");
@@ -682,7 +881,7 @@ export class CDPMonitor {
             throw err;
         }
     }
-    async sendCDPCommand(method, params = {}) {
+    async sendCDPCommand(method, params = {}, timeoutMs = DEFAULT_CDP_COMMAND_TIMEOUT_MS) {
         if (!this.connection) {
             throw new Error("No CDP connection available");
         }
@@ -693,42 +892,32 @@ export class CDPMonitor {
                 method,
                 params
             };
-            const messageHandler = (data) => {
-                try {
-                    const message = JSON.parse(data.toString());
-                    if (message.id === id) {
-                        this.connection?.ws.removeListener("message", messageHandler);
-                        if (message.error) {
-                            reject(new Error(message.error.message));
-                        }
-                        else {
-                            resolve(message.result);
-                        }
-                    }
-                }
-                catch (error) {
-                    this.connection?.ws.removeListener("message", messageHandler);
-                    reject(error);
-                }
-            };
-            this.connection?.ws.on("message", messageHandler);
-            // Command timeout
             const timeout = setTimeout(() => {
-                this.connection?.ws.removeListener("message", messageHandler);
+                this.pendingCommands.delete(id);
+                this.debugLog(`CDP command #${id} timed out after ${timeoutMs}ms: ${method}`);
                 reject(new Error(`CDP command timeout: ${method}`));
-            }, 10000);
-            // Clear timeout if command succeeds/fails
-            const originalResolve = resolve;
-            const originalReject = reject;
-            resolve = (value) => {
-                clearTimeout(timeout);
-                originalResolve(value);
-            };
-            reject = (reason) => {
-                clearTimeout(timeout);
-                originalReject(reason);
-            };
-            this.connection?.ws.send(JSON.stringify(command));
+            }, timeoutMs);
+            this.pendingCommands.set(id, {
+                method,
+                startedAt: Date.now(),
+                timeout,
+                resolve,
+                reject: (error) => reject(error)
+            });
+            this.debugLog(`Sending CDP command #${id}: ${method} ${JSON.stringify(params)}`);
+            this.connection?.ws.send(JSON.stringify(command), (error) => {
+                if (!error) {
+                    return;
+                }
+                const pending = this.pendingCommands.get(id);
+                if (!pending) {
+                    return;
+                }
+                clearTimeout(pending.timeout);
+                this.pendingCommands.delete(id);
+                this.debugLog(`Failed to send CDP command #${id}: ${method}: ${String(error)}`);
+                reject(error instanceof Error ? error : new Error(String(error)));
+            });
         });
     }
     getBundleTypeLabel(bundleType) {
@@ -808,39 +997,39 @@ export class CDPMonitor {
     }
     async enableCDPDomains() {
         const domains = [
-            "Runtime", // Console logs, exceptions
-            "Network", // Network requests/responses
-            "Page", // Page events, navigation
-            "DOM", // DOM mutations
-            "Performance", // Performance metrics
-            "Security", // Security events
-            "Log", // Browser console logs
-            "Target" // Target events (window/tab creation/destruction)
+            { name: "Runtime", required: true },
+            { name: "Network", required: true },
+            { name: "Page", required: true },
+            { name: "DOM", required: true },
+            { name: "Performance", required: false },
+            { name: "Security", required: false },
+            { name: "Log", required: true },
+            { name: "Target", required: false }
             // Note: Input domain is for dispatching events, not monitoring them - we use JS injection instead
         ];
         for (const domain of domains) {
             try {
-                this.debugLog(`Enabling CDP domain: ${domain}`);
-                await this.sendCDPCommand(`${domain}.enable`);
-                this.debugLog(`Successfully enabled CDP domain: ${domain}`);
+                this.debugLog(`Enabling CDP domain: ${domain.name}`);
+                await this.sendCDPCommand(`${domain.name}.enable`, {}, 3000);
+                this.debugLog(`Successfully enabled CDP domain: ${domain.name}`);
                 if (this.debug) {
-                    this.logger("browser", `[CDP] Enabled ${domain} domain`);
+                    this.logger("browser", `[CDP] Enabled ${domain.name} domain`);
                 }
             }
             catch (error) {
-                this.debugLog(`Failed to enable CDP domain ${domain}: ${error}`);
-                // Only log CDP errors when debug mode is enabled
+                this.debugLog(`Failed to enable CDP domain ${domain.name}: ${error}`);
+                if (domain.required) {
+                    throw new Error(`Failed to enable required CDP domain ${domain.name}: ${String(error)}`);
+                }
                 if (this.debug) {
-                    this.logger("browser", `[CDP] Failed to enable ${domain}: ${error}`);
+                    this.logger("browser", `[CDP] Failed to enable optional ${domain.name}: ${error}`);
                 }
-                // Continue with other domains instead of throwing
             }
         }
-        this.debugLog("Enabling runtime for console and exception capture");
-        await this.sendCDPCommand("Runtime.enable");
+        this.debugLog("Setting async call stack depth for console and exception capture");
         await this.sendCDPCommand("Runtime.setAsyncCallStackDepth", {
             maxDepth: 32
-        });
+        }, 3000);
         this.debugLog("CDP domains enabled successfully");
         // Set viewport for headless mode to ensure consistent CLS measurements
         // Without this, headless Chrome defaults to 800x600 which can cause
@@ -859,6 +1048,18 @@ export class CDPMonitor {
             catch (error) {
                 this.debugLog(`Failed to set viewport: ${error}`);
             }
+            try {
+                await this.sendCDPCommand("Page.bringToFront", {});
+            }
+            catch (error) {
+                this.debugLog(`Failed to bring headless page to front: ${error}`);
+            }
+            try {
+                await this.sendCDPCommand("Emulation.setFocusEmulationEnabled", { enabled: true });
+            }
+            catch (error) {
+                this.debugLog(`Failed to enable focus emulation: ${error}`);
+            }
         }
     }
     setupEventHandlers() {
@@ -1089,8 +1290,34 @@ export class CDPMonitor {
     onCDPEvent(method, handler) {
         this.eventHandlers.set(method, handler);
     }
+    rejectPendingCDPCommands(error) {
+        for (const [id, pending] of this.pendingCommands) {
+            clearTimeout(pending.timeout);
+            this.pendingCommands.delete(id);
+            pending.reject(error);
+        }
+    }
     handleCDPMessage(message) {
+        if (typeof message.id === "number") {
+            const pending = this.pendingCommands.get(message.id);
+            if (!pending) {
+                this.debugLog(`Received CDP response for unknown command #${message.id}`);
+                return;
+            }
+            clearTimeout(pending.timeout);
+            this.pendingCommands.delete(message.id);
+            const duration = Date.now() - pending.startedAt;
+            if (message.error) {
+                this.debugLog(`Received CDP error for #${message.id} (${pending.method}) after ${duration}ms: ${message.error.message}`);
+                pending.reject(new Error(message.error.message || `CDP command failed: ${pending.method}`));
+                return;
+            }
+            this.debugLog(`Received CDP response for #${message.id} (${pending.method}) after ${duration}ms`);
+            pending.resolve(message.result || {});
+            return;
+        }
         if (message.method) {
+            this.debugLog(`Received CDP event: ${message.method}`);
             const handler = this.eventHandlers.get(message.method);
             if (handler) {
                 const event = {
@@ -1103,7 +1330,7 @@ export class CDPMonitor {
             }
         }
     }
-    async navigateToUrl(url) {
+    async navigateToUrl(url, timeoutMs = this.navigationTimeoutMs) {
         if (!this.connection) {
             throw new Error("No CDP connection available");
         }
@@ -1113,7 +1340,7 @@ export class CDPMonitor {
         try {
             const result = await this.sendCDPCommand("Page.navigate", {
                 url
-            });
+            }, timeoutMs);
             const navigationTime = Date.now() - navigationStartTime;
             this.debugLog(`Navigation command sent successfully (${navigationTime}ms)`);
             this.debugLog(`Navigation result: ${JSON.stringify(result)}`);
@@ -1635,37 +1862,148 @@ export class CDPMonitor {
         this.isShuttingDown = true;
         this.debugLog("Shutdown signaled - reconnection attempts will be blocked");
     }
+    async waitForBrowserExit(timeoutMs) {
+        const browser = this.browser;
+        if (!browser) {
+            return true;
+        }
+        if (browser.exitCode !== null || browser.killed) {
+            return true;
+        }
+        return await new Promise((resolve) => {
+            const onExit = () => {
+                clearTimeout(timer);
+                resolve(true);
+            };
+            const timer = setTimeout(() => {
+                browser.removeListener("exit", onExit);
+                resolve(false);
+            }, timeoutMs);
+            browser.once("exit", onExit);
+        });
+    }
+    async sendBrowserCloseCommand() {
+        try {
+            await this.sendCDPCommand("Browser.close", {}, 3000);
+            this.debugLog("Sent Browser.close command");
+            return;
+        }
+        catch (error) {
+            this.debugLog(`Browser.close on page target failed: ${error}`);
+        }
+        const versionResponse = await fetch(`http://localhost:${this.debugPort}/json/version`, {
+            signal: AbortSignal.timeout(1000)
+        });
+        if (!versionResponse.ok) {
+            throw new Error(`Failed to get browser CDP endpoint: HTTP ${versionResponse.status}`);
+        }
+        const version = (await versionResponse.json());
+        if (!version.webSocketDebuggerUrl) {
+            throw new Error("Browser CDP endpoint did not include webSocketDebuggerUrl");
+        }
+        await new Promise((resolve, reject) => {
+            const ws = new WebSocket(version.webSocketDebuggerUrl);
+            let commandSent = false;
+            let settled = false;
+            const settle = (callback) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timeout);
+                try {
+                    ws.close();
+                }
+                catch {
+                    // Ignore close errors.
+                }
+                callback();
+            };
+            const timeout = setTimeout(() => {
+                settle(() => reject(new Error("Browser.close command timed out")));
+            }, 3000);
+            ws.on("open", () => {
+                commandSent = true;
+                ws.send(JSON.stringify({ id: 1, method: "Browser.close", params: {} }), (error) => {
+                    if (error) {
+                        settle(() => reject(error));
+                    }
+                });
+            });
+            ws.on("message", (data) => {
+                try {
+                    const message = JSON.parse(data.toString());
+                    if (message.id !== 1) {
+                        return;
+                    }
+                    const responseError = message.error;
+                    if (responseError) {
+                        settle(() => reject(new Error(responseError.message || "Browser.close failed")));
+                        return;
+                    }
+                    settle(resolve);
+                }
+                catch (error) {
+                    settle(() => reject(error instanceof Error ? error : new Error(String(error))));
+                }
+            });
+            ws.on("error", (error) => {
+                settle(() => reject(error));
+            });
+            ws.on("close", () => {
+                if (commandSent) {
+                    settle(resolve);
+                }
+                else {
+                    settle(() => reject(new Error("Browser CDP websocket closed before Browser.close was sent")));
+                }
+            });
+        });
+        this.debugLog("Sent Browser.close command via browser CDP endpoint");
+    }
     async shutdown() {
         this.isShuttingDown = true;
-        // Try to close the page first, then the tab
-        if (this.connection?.sessionId) {
+        let browserClosedCleanly = false;
+        // Ask the browser process to exit first so Chrome doesn't think it crashed.
+        if (this.connection) {
             try {
-                // Try to close the page
-                await this.sendCDPCommand("Page.close");
-                this.debugLog("Sent Page.close command");
-                await new Promise((resolve) => setTimeout(resolve, 100));
+                await this.sendBrowserCloseCommand();
+                browserClosedCleanly = await this.waitForBrowserExit(5000);
             }
             catch (_e) {
-                this.debugLog("Page.close failed, trying Target.closeTarget");
+                this.debugLog("Browser.close failed, trying page/tab close fallback");
             }
-            try {
-                // Get the list of targets to find our specific tab
-                const targets = (await this.sendCDPCommand("Target.getTargets"));
-                this.debugLog(`Found ${targets.targetInfos?.length || 0} targets`);
-                // Find our page target
-                const pageTarget = targets.targetInfos?.find((t) => t.type === "page");
-                if (pageTarget) {
-                    this.debugLog(`Closing page target: ${pageTarget.targetId}`);
-                    await this.sendCDPCommand("Target.closeTarget", {
-                        targetId: pageTarget.targetId
-                    });
-                    this.debugLog("Closed Chrome tab via CDP");
+            if (!browserClosedCleanly) {
+                try {
+                    // Try to close the page
+                    await this.sendCDPCommand("Page.close");
+                    this.debugLog("Sent Page.close command");
+                    await new Promise((resolve) => setTimeout(resolve, 100));
+                }
+                catch (_e) {
+                    this.debugLog("Page.close failed, trying Target.closeTarget");
+                }
+                try {
+                    // Get the list of targets to find our specific tab
+                    const targets = (await this.sendCDPCommand("Target.getTargets"));
+                    this.debugLog(`Found ${targets.targetInfos?.length || 0} targets`);
+                    // Find our page target
+                    const pageTarget = targets.targetInfos?.find((t) => t.type === "page");
+                    if (pageTarget) {
+                        this.debugLog(`Closing page target: ${pageTarget.targetId}`);
+                        await this.sendCDPCommand("Target.closeTarget", {
+                            targetId: pageTarget.targetId
+                        });
+                        this.debugLog("Closed Chrome tab via CDP");
+                    }
+                    // Give it more time for the tab to close
+                    await new Promise((resolve) => setTimeout(resolve, 1000));
+                }
+                catch (_e) {
+                    this.debugLog("Failed to close tab via CDP, will force close Chrome");
+                }
+                if (!browserClosedCleanly) {
+                    browserClosedCleanly = await this.waitForBrowserExit(1500);
                 }
-                // Give it more time for the tab to close
-                await new Promise((resolve) => setTimeout(resolve, 1000));
-            }
-            catch (_e) {
-                this.debugLog("Failed to close tab via CDP, will force close Chrome");
             }
         }
         // Close CDP connection
@@ -1678,7 +2016,11 @@ export class CDPMonitor {
             }
             this.connection = null;
         }
-        // Kill only the Chrome processes for THIS instance
+        if (browserClosedCleanly) {
+            this.chromePids.clear();
+            return;
+        }
+        // Kill only the Chrome processes for THIS instance as a fallback.
         await this.killInstanceChromeProcesses();
     }
     async killInstanceChromeProcesses() {