browser-debugger-cli 0.3.0 → 0.5.1

package/dist/daemon/worker.js

@@ -15,445 +15,77 @@
  * - Worker handles SIGTERM for graceful shutdown
  */
 import { CDPConnection } from '../connection/cdp.js';
-import { queryBySelector, getNodeInfo, createNodePreview } from '../connection/domOperations.js';
 import { launchChrome } from '../connection/launcher.js';
+import { waitForPageReady } from '../connection/pageReadiness.js';
 import { DEFAULT_PAGE_READINESS_TIMEOUT_MS } from '../constants.js';
+import { TelemetryStore } from '../daemon/worker/TelemetryStore.js';
+import { startTelemetryCollectors } from '../daemon/worker/collectors.js';
+import { createCommandRegistry } from '../daemon/worker/commandRegistry.js';
+import { writeChromePid } from '../session/chrome.js';
 import { writeSessionMetadata } from '../session/metadata.js';
 import { writeSessionOutput } from '../session/output.js';
 import { writePid } from '../session/pid.js';
-import { writeQueryCache, getNodeIdByIndex } from '../session/queryCache.js';
-import { startConsoleCollection } from '../telemetry/console.js';
-import { prepareDOMCollection, collectDOM } from '../telemetry/dom.js';
-import { startNetworkCollection } from '../telemetry/network.js';
-import { workerActivatingCollector, workerCollectorsActivated, workerUnknownCommand, workerHandlingCommand, workerCommandResponse, workerIPCParseError, workerStdinClosed, workerStdinListenerSetup, workerReadySignalSent, workerShutdownStarted, workerCollectingDOM, workerDOMCollected, workerDOMCollectionFailed, workerWritingOutput, workerRunningCleanup, workerClosingCDP, workerShutdownComplete, workerExitingConnectionLoss, workerReceivedSIGTERM, workerReceivedSIGINT, workerTimeoutReached, workerSessionActive, } from '../ui/messages/debug.js';
-import { getErrorMessage } from '../utils/errors.js';
+import { isProcessAlive, killChromeProcess } from '../session/process.js';
+import { collectDOM } from '../telemetry/dom.js';
+import { getErrorMessage } from '../ui/errors/index.js';
+import { createLogger } from '../ui/logging/index.js';
+import { chromeExternalConnectionMessage, chromeExternalWebSocketMessage, chromeExternalNoPidMessage, chromeExternalSkipTerminationMessage, noPageTargetFoundError, } from '../ui/messages/chrome.js';
+import { workerUnknownCommand, workerHandlingCommand, workerCommandResponse, workerIPCParseError, workerStdinClosed, workerStdinListenerSetup, workerReadySignalSent, workerCollectingDOM, workerDOMCollected, workerDOMCollectionFailed, workerWritingOutput, workerRunningCleanup, workerClosingCDP, workerShutdownComplete, workerExitingConnectionLoss, workerReceivedSIGTERM, workerReceivedSIGINT, workerTimeoutReached, workerSessionActive, } from '../ui/messages/debug.js';
 import { fetchCDPTargets } from '../utils/http.js';
-import { createLogger } from '../utils/logger.js';
-import { waitForPageReady } from '../utils/pageReadiness.js';
+import { filterDefined } from '../utils/objects.js';
 import { normalizeUrl } from '../utils/url.js';
-import { VERSION } from '../utils/version.js';
 const log = createLogger('worker');
-/**
- * Color presets for highlight overlay
- */
-const HIGHLIGHT_COLORS = {
-    red: { r: 255, g: 0, b: 0, a: 0.5 },
-    blue: { r: 0, g: 0, b: 255, a: 0.5 },
-    green: { r: 0, g: 255, b: 0, a: 0.5 },
-    yellow: { r: 255, g: 255, b: 0, a: 0.5 },
-    orange: { r: 255, g: 165, b: 0, a: 0.5 },
-    purple: { r: 128, g: 0, b: 128, a: 0.5 },
-};
-// Global state for cleanup
+const telemetryStore = new TelemetryStore();
+const commandRegistry = createCommandRegistry(telemetryStore);
 let chrome = null;
 let cdp = null;
 let cleanupFunctions = [];
-// Telemetry data storage
-const networkRequests = [];
-const consoleMessages = [];
-let domData = null;
-// Session metadata
-let sessionStartTime = Date.now();
-let targetInfo = null;
-let activeTelemetry = [];
 /**
  * Parse worker configuration from environment variables or argv.
  */
 function parseWorkerConfig() {
-    // For MVP: parse from argv (future: could use env vars or stdin)
     const args = process.argv.slice(2);
     if (args.length === 0) {
         throw new Error('Worker requires configuration arguments');
     }
-    // Parse simple JSON config from first argument
     try {
         const configArg = args[0];
         if (!configArg) {
             throw new Error('Missing configuration argument');
         }
         const config = JSON.parse(configArg);
-        return {
+        const normalized = {
             url: config.url,
             port: config.port ?? 9222,
-            timeout: config.timeout ?? undefined,
             telemetry: config.telemetry ?? ['network', 'console', 'dom'],
             includeAll: config.includeAll ?? false,
-            userDataDir: config.userDataDir ?? undefined,
-            maxBodySize: config.maxBodySize ?? undefined,
+            headless: config.headless ?? false,
         };
+        if (config.timeout !== undefined) {
+            normalized.timeout = config.timeout;
+        }
+        if (config.userDataDir !== undefined) {
+            normalized.userDataDir = config.userDataDir;
+        }
+        if (config.maxBodySize !== undefined) {
+            normalized.maxBodySize = config.maxBodySize;
+        }
+        if (config.chromeWsUrl !== undefined) {
+            normalized.chromeWsUrl = config.chromeWsUrl;
+        }
+        return normalized;
     }
     catch (error) {
         throw new Error(`Failed to parse worker config: ${getErrorMessage(error)}`);
     }
 }
-/**
- * Activate telemetry modules based on configuration.
- */
-async function activateCollectors(config) {
-    if (!cdp) {
-        throw new Error('CDP connection not initialized');
-    }
-    activeTelemetry = config.telemetry ?? ['network', 'console', 'dom'];
-    for (const collector of activeTelemetry) {
-        log.debug(workerActivatingCollector(collector));
-        switch (collector) {
-            case 'network':
-                {
-                    const networkOptions = {
-                        includeAll: config.includeAll ?? false,
-                        ...(config.maxBodySize !== undefined && { maxBodySize: config.maxBodySize }),
-                    };
-                    const cleanup = await startNetworkCollection(cdp, networkRequests, networkOptions);
-                    cleanupFunctions.push(cleanup);
-                }
-                break;
-            case 'console':
-                {
-                    const cleanup = await startConsoleCollection(cdp, consoleMessages, config.includeAll ?? false);
-                    cleanupFunctions.push(cleanup);
-                }
-                break;
-            case 'dom':
-                {
-                    const cleanup = await prepareDOMCollection(cdp);
-                    cleanupFunctions.push(cleanup);
-                }
-                break;
-        }
-    }
-    log.debug(workerCollectorsActivated(activeTelemetry));
-}
-/**
- * Command handler registry - maps command names to their business logic.
- */
-const commandHandlers = {
-    /**
-     * DOM Query Handler - Find elements by CSS selector
-     */
-    dom_query: async (cdp, params) => {
-        // Ensure DOM is enabled
-        await cdp.send('DOM.enable');
-        // Query elements
-        const nodeIds = await queryBySelector(cdp, params.selector);
-        // Get information for each node
-        const nodes = [];
-        for (let i = 0; i < nodeIds.length; i++) {
-            const nodeId = nodeIds[i];
-            if (nodeId === undefined)
-                continue;
-            const nodeInfo = await getNodeInfo(cdp, nodeId);
-            nodes.push({
-                index: i + 1,
-                nodeId: nodeInfo.nodeId,
-                ...(nodeInfo.tag !== undefined && { tag: nodeInfo.tag }),
-                ...(nodeInfo.classes !== undefined && { classes: nodeInfo.classes }),
-                preview: createNodePreview(nodeInfo),
-            });
-        }
-        // Write cache for index-based lookups
-        writeQueryCache({
-            selector: params.selector,
-            timestamp: new Date().toISOString(),
-            nodes,
-        });
-        return {
-            selector: params.selector,
-            count: nodes.length,
-            nodes,
-        };
-    },
-    /**
-     * DOM Highlight Handler - Highlight elements in browser
-     */
-    dom_highlight: async (cdp, params) => {
-        // Ensure DOM and Overlay are enabled
-        await cdp.send('DOM.enable');
-        await cdp.send('Overlay.enable');
-        let nodeIds = [];
-        // Direct nodeId provided
-        if (params.nodeId !== undefined) {
-            nodeIds = [params.nodeId];
-        }
-        else if (params.index !== undefined) {
-            // Look up nodeId from cache
-            const nodeId = getNodeIdByIndex(params.index);
-            if (!nodeId) {
-                throw new Error(`No cached element at index ${params.index}. Run 'bdg dom query <selector>' first.`);
-            }
-            nodeIds = [nodeId];
-        }
-        else if (params.selector) {
-            // Query by selector
-            nodeIds = await queryBySelector(cdp, params.selector);
-            if (nodeIds.length === 0) {
-                throw new Error(`No elements found matching "${params.selector}"`);
-            }
-            // Apply selector filters
-            if (params.first) {
-                const firstNode = nodeIds[0];
-                if (firstNode === undefined) {
-                    throw new Error('No elements found');
-                }
-                nodeIds = [firstNode];
-            }
-            else if (params.nth !== undefined) {
-                if (params.nth < 1 || params.nth > nodeIds.length) {
-                    throw new Error(`--nth ${params.nth} out of range (found ${nodeIds.length} elements)`);
-                }
-                const nthNode = nodeIds[params.nth - 1];
-                if (nthNode === undefined) {
-                    throw new Error(`Element at index ${params.nth} not found`);
-                }
-                nodeIds = [nthNode];
-            }
-        }
-        else {
-            throw new Error('Either selector, index, or nodeId must be provided');
-        }
-        // Prepare highlight color
-        const colorName = (params.color ?? 'red');
-        const color = HIGHLIGHT_COLORS[colorName] ?? HIGHLIGHT_COLORS.red;
-        const opacity = params.opacity ?? color.a;
-        // Highlight each node
-        for (const nodeId of nodeIds) {
-            await cdp.send('Overlay.highlightNode', {
-                highlightConfig: {
-                    contentColor: { ...color, a: opacity },
-                },
-                nodeId,
-            });
-        }
-        return {
-            highlighted: nodeIds.length,
-            nodeIds,
-        };
-    },
-    /**
-     * DOM Get Handler - Get full HTML and attributes for elements
-     */
-    dom_get: async (cdp, params) => {
-        // Ensure DOM is enabled
-        await cdp.send('DOM.enable');
-        let nodeIds = [];
-        // Direct nodeId provided
-        if (params.nodeId !== undefined) {
-            nodeIds = [params.nodeId];
-        }
-        else if (params.index !== undefined) {
-            // Look up nodeId from cache
-            const nodeId = getNodeIdByIndex(params.index);
-            if (!nodeId) {
-                throw new Error(`No cached element at index ${params.index}. Run 'bdg dom query <selector>' first.`);
-            }
-            nodeIds = [nodeId];
-        }
-        else if (params.selector) {
-            // Query by selector
-            nodeIds = await queryBySelector(cdp, params.selector);
-            if (nodeIds.length === 0) {
-                throw new Error(`No elements found matching "${params.selector}"`);
-            }
-            // Apply selector filters
-            if (params.nth !== undefined) {
-                if (params.nth < 1 || params.nth > nodeIds.length) {
-                    throw new Error(`--nth ${params.nth} out of range (found ${nodeIds.length} elements)`);
-                }
-                const nthNode = nodeIds[params.nth - 1];
-                if (nthNode === undefined) {
-                    throw new Error(`Element at index ${params.nth} not found`);
-                }
-                nodeIds = [nthNode];
-            }
-            else if (!params.all) {
-                // Default: first match only
-                const firstNode = nodeIds[0];
-                if (firstNode === undefined) {
-                    throw new Error('No elements found');
-                }
-                nodeIds = [firstNode];
-            }
-        }
-        else {
-            throw new Error('Either selector, index, or nodeId must be provided');
-        }
-        // Get information for each node
-        const nodes = [];
-        for (const nodeId of nodeIds) {
-            const info = await getNodeInfo(cdp, nodeId);
-            nodes.push({
-                nodeId: info.nodeId,
-                ...(info.tag !== undefined && { tag: info.tag }),
-                ...(info.attributes !== undefined && { attributes: info.attributes }),
-                ...(info.classes !== undefined && { classes: info.classes }),
-                ...(info.outerHTML !== undefined && { outerHTML: info.outerHTML }),
-            });
-        }
-        return {
-            nodes,
-        };
-    },
-    /**
-     * DOM Screenshot Handler - Capture page screenshot
-     */
-    dom_screenshot: async (cdp, params) => {
-        const fs = await import('node:fs/promises');
-        const path = await import('node:path');
-        // Validate path
-        const absolutePath = path.resolve(params.path);
-        // Ensure parent directory exists
-        const parentDir = path.dirname(absolutePath);
-        try {
-            await fs.mkdir(parentDir, { recursive: true });
-        }
-        catch (error) {
-            if (error && typeof error === 'object' && 'code' in error && error.code !== 'EEXIST') {
-                throw new Error(`Cannot create directory ${parentDir}: ${getErrorMessage(error)}`);
-            }
-        }
-        // Set defaults
-        const format = params.format ?? 'png';
-        const quality = params.quality;
-        const fullPage = params.fullPage ?? true;
-        // Validate quality for JPEG
-        if (format === 'jpeg' && quality !== undefined && (quality < 0 || quality > 100)) {
-            throw new Error('JPEG quality must be between 0 and 100');
-        }
-        // Capture screenshot via CDP
-        const screenshotParams = {
-            format,
-            ...(format === 'jpeg' && quality !== undefined && { quality }),
-            ...(fullPage && { captureBeyondViewport: true }),
-        };
-        const response = (await cdp.send('Page.captureScreenshot', screenshotParams));
-        const imageData = Buffer.from(response.data, 'base64');
-        // Write file
-        await fs.writeFile(absolutePath, imageData);
-        // Get file stats
-        const stats = await fs.stat(absolutePath);
-        // Get viewport dimensions if not full page
-        let viewport;
-        if (!fullPage) {
-            const metrics = (await cdp.send('Page.getLayoutMetrics'));
-            viewport = {
-                width: metrics.layoutViewport.clientWidth,
-                height: metrics.layoutViewport.clientHeight,
-            };
-        }
-        const layoutMetrics = (await cdp.send('Page.getLayoutMetrics'));
-        return {
-            path: absolutePath,
-            format,
-            ...(format === 'jpeg' && quality !== undefined && { quality }),
-            width: layoutMetrics.contentSize.width,
-            height: layoutMetrics.contentSize.height,
-            size: stats.size,
-            ...(viewport && { viewport }),
-            fullPage,
-        };
-    },
-    /**
-     * Worker Peek Handler - Return lightweight preview of collected data
-     */
-    worker_peek: async (_cdp, params) => {
-        const lastN = Math.min(params.lastN ?? 10, 100); // Cap at 100
-        const duration = Date.now() - sessionStartTime;
-        // Get last N items (slice from end)
-        const recentNetwork = networkRequests.slice(-lastN).map((req) => ({
-            requestId: req.requestId,
-            timestamp: req.timestamp,
-            method: req.method,
-            url: req.url,
-            ...(req.status !== undefined && { status: req.status }),
-            ...(req.mimeType !== undefined && { mimeType: req.mimeType }),
-        }));
-        const recentConsole = consoleMessages.slice(-lastN).map((msg) => ({
-            timestamp: msg.timestamp,
-            type: msg.type,
-            text: msg.text,
-        }));
-        // Return as resolved Promise to satisfy async handler contract
-        return Promise.resolve({
-            version: VERSION,
-            startTime: sessionStartTime,
-            duration,
-            target: {
-                url: targetInfo?.url ?? '',
-                title: targetInfo?.title ?? '',
-            },
-            activeTelemetry,
-            network: recentNetwork,
-            console: recentConsole,
-        });
-    },
-    /**
-     * Worker Details Handler - Return full object for specific item
-     */
-    worker_details: async (_cdp, params) => {
-        if (params.itemType === 'network') {
-            const request = networkRequests.find((r) => r.requestId === params.id);
-            if (!request) {
-                return Promise.reject(new Error(`Network request not found: ${params.id}`));
-            }
-            return Promise.resolve({ item: request });
-        }
-        else if (params.itemType === 'console') {
-            const index = parseInt(params.id, 10);
-            if (isNaN(index) || index < 0 || index >= consoleMessages.length) {
-                return Promise.reject(new Error(`Console message not found at index: ${params.id} (available: 0-${consoleMessages.length - 1})`));
-            }
-            return Promise.resolve({ item: consoleMessages[index] });
-        }
-        // Unreachable due to type narrowing, but TypeScript doesn't see it
-        return Promise.reject(new Error(`Unknown itemType: ${String(params.itemType)}. Expected 'network' or 'console'.`));
-    },
-    /**
-     * Worker Status Handler - Return live activity metrics and session state
-     *
-     * Provides comprehensive status information including activity counts,
-     * last activity timestamps, current page state, and active telemetry modules.
-     * Used by the status command to show detailed session information.
-     */
-    worker_status: async (_cdp, _params) => {
-        const duration = Date.now() - sessionStartTime;
-        // Get last activity timestamps
-        const lastNetworkRequest = networkRequests[networkRequests.length - 1];
-        const lastConsoleMessage = consoleMessages[consoleMessages.length - 1];
-        const result = {
-            startTime: sessionStartTime,
-            duration,
-            target: {
-                url: targetInfo?.url ?? '',
-                title: targetInfo?.title ?? '',
-            },
-            activeTelemetry,
-            activity: {
-                networkRequestsCaptured: networkRequests.length,
-                consoleMessagesCaptured: consoleMessages.length,
-                ...(lastNetworkRequest?.timestamp !== undefined && {
-                    lastNetworkRequestAt: lastNetworkRequest.timestamp,
-                }),
-                ...(lastConsoleMessage?.timestamp !== undefined && {
-                    lastConsoleMessageAt: lastConsoleMessage.timestamp,
-                }),
-            },
-        };
-        return Promise.resolve(result);
-    },
-    /**
-     * CDP Call Handler - Execute arbitrary CDP method
-     */
-    cdp_call: async (cdp, params) => {
-        // Execute CDP method with provided parameters
-        const result = await cdp.send(params.method, params.params ?? {});
-        return { result };
-    },
-};
+// Command handlers are defined via createCommandRegistry for modularity.
 /**
  * Handle incoming IPC message from daemon via stdin.
  */
 async function handleWorkerIPC(message) {
     const commandName = message.type.replace('_request', '');
-    const handler = commandHandlers[commandName];
+    const handler = commandRegistry[commandName];
     if (!handler) {
         log.debug(workerUnknownCommand(commandName));
         return;
@@ -462,9 +94,7 @@ async function handleWorkerIPC(message) {
     try {
         if (!cdp)
             throw new Error('CDP connection not initialized');
-        // Extract params by removing IPC metadata fields
         const { type: _type, requestId: _requestId, ...params } = message;
-        // Call handler with properly typed params
         // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-argument
         const data = await handler(cdp, params);
         const response = {
@@ -494,7 +124,6 @@ function setupStdinListener() {
     let buffer = '';
     process.stdin.on('data', (chunk) => {
         buffer += chunk.toString('utf-8');
-        // Process complete JSONL frames (separated by newlines)
         const lines = buffer.split('\n');
         buffer = lines.pop() ?? ''; // Keep incomplete line in buffer
         for (const line of lines) {
@@ -518,74 +147,59 @@ function setupStdinListener() {
  * Send worker_ready signal to parent via stdout.
  */
 function sendReadySignal(config) {
-    if (!chrome || !targetInfo) {
-        throw new Error('Cannot send ready signal: Chrome or target not initialized');
+    const targetInfo = telemetryStore.targetInfo;
+    if (!targetInfo) {
+        throw new Error('Cannot send ready signal: Target not initialized');
     }
+    const chromePid = chrome?.pid ?? 0;
     const message = {
         type: 'worker_ready',
         requestId: 'ready', // Special requestId for ready signal
         workerPid: process.pid,
-        chromePid: chrome.pid,
+        chromePid,
         port: config.port,
         target: {
             url: targetInfo.url,
             title: targetInfo.title,
         },
     };
-    // Send JSON line to stdout for parent to parse
     console.log(JSON.stringify(message));
-    log.debug(workerReadySignalSent(process.pid, chrome.pid));
+    log.debug(workerReadySignalSent(process.pid, chromePid));
 }
 /**
- * Build BdgOutput structure from collected data.
+ * Graceful shutdown: collect final DOM, write session.json, cleanup.
  */
-function buildOutput(partial = false) {
-    const duration = Date.now() - sessionStartTime;
-    const data = {};
-    if (networkRequests.length > 0) {
-        data.network = networkRequests;
-    }
-    if (consoleMessages.length > 0) {
-        data.console = consoleMessages;
-    }
-    if (domData) {
-        data.dom = domData;
-    }
-    return {
-        version: VERSION,
-        success: true,
-        timestamp: new Date(sessionStartTime).toISOString(),
-        duration,
-        target: {
-            url: targetInfo?.url ?? '',
-            title: targetInfo?.title ?? '',
-        },
-        data,
-        ...(partial && { partial: true }),
-    };
-}
 /**
- * Graceful shutdown: collect final DOM, write session.json, cleanup.
+ * Unified cleanup handler for all exit scenarios.
+ *
+ * Handles cleanup for normal shutdown, crashes, and timeouts.
+ * Ensures Chrome is always killed and verified dead.
+ *
+ * @param reason - Why cleanup is happening
  */
-async function gracefulShutdown() {
-    log.debug(workerShutdownStarted());
+async function cleanupWorker(reason) {
+    log.debug(`[worker] Cleanup started (reason: ${reason})`);
     try {
-        // Collect final DOM snapshot if DOM telemetry is active
-        if (activeTelemetry.includes('dom') && cdp) {
+        const chromePid = chrome?.pid;
+        if (chromePid) {
+            try {
+                writeChromePid(chromePid);
+                log.debug(`[worker] Chrome PID ${chromePid} cached for cleanup`);
+            }
+            catch (error) {
+                console.error(`[worker] Failed to cache Chrome PID: ${getErrorMessage(error)}`);
+            }
+        }
+        if (reason === 'normal' && telemetryStore.activeTelemetry.includes('dom') && cdp) {
             log.debug(workerCollectingDOM());
             try {
-                domData = await collectDOM(cdp);
+                telemetryStore.setDomData(await collectDOM(cdp));
                 log.debug(workerDOMCollected());
             }
             catch (error) {
                 log.debug(workerDOMCollectionFailed(getErrorMessage(error)));
             }
         }
-        // Write final output
-        log.debug(workerWritingOutput());
-        const finalOutput = buildOutput(false);
-        writeSessionOutput(finalOutput);
-        // Run cleanup functions
         log.debug(workerRunningCleanup());
         for (const cleanup of cleanupFunctions) {
             try {
@@ -595,23 +209,79 @@ async function gracefulShutdown() {
                 console.error(`[worker] Cleanup function error: ${getErrorMessage(error)}`);
             }
         }
-        // Close CDP connection
         if (cdp) {
-            log.debug(workerClosingCDP());
-            cdp.close();
-            cdp = null;
+            try {
+                log.debug(workerClosingCDP());
+                cdp.close();
+                cdp = null;
+            }
+            catch (error) {
+                console.error(`[worker] Error closing CDP: ${getErrorMessage(error)}`);
+            }
         }
-        // Kill Chrome
-        if (chrome) {
-            console.error(`[worker] Terminating Chrome (PID ${chrome.pid})...`);
-            await chrome.kill();
-            chrome = null;
+        if (chrome && chromePid) {
+            try {
+                console.error(`[worker] Terminating Chrome (PID ${chromePid})...`);
+                await chrome.kill();
+                let attempts = 0;
+                const maxAttempts = 10;
+                while (attempts < maxAttempts) {
+                    if (!isProcessAlive(chromePid)) {
+                        log.debug(`[worker] Chrome process ${chromePid} confirmed dead`);
+                        break;
+                    }
+                    await new Promise((resolve) => setTimeout(resolve, 500));
+                    attempts++;
+                }
+                if (isProcessAlive(chromePid)) {
+                    console.error(`[worker] Chrome did not die gracefully, force killing...`);
+                    try {
+                        killChromeProcess(chromePid, 'SIGKILL');
+                        await new Promise((resolve) => setTimeout(resolve, 500));
+                        if (isProcessAlive(chromePid)) {
+                            console.error(`[worker] WARNING: Chrome process ${chromePid} survived SIGKILL`);
+                        }
+                        else {
+                            log.debug(`[worker] Chrome process ${chromePid} force killed successfully`);
+                        }
+                    }
+                    catch (error) {
+                        console.error(`[worker] Failed to force kill Chrome: ${getErrorMessage(error)}`);
+                    }
+                }
+                chrome = null;
+            }
+            catch (error) {
+                console.error(`[worker] Error killing Chrome: ${getErrorMessage(error)}`);
+            }
+        }
+        else if (!chrome) {
+            console.error(`[worker] ${chromeExternalSkipTerminationMessage()}`);
+        }
+        if (reason === 'normal') {
+            try {
+                log.debug(workerWritingOutput());
+                const finalOutput = telemetryStore.buildOutput(false);
+                writeSessionOutput(finalOutput);
+            }
+            catch (error) {
+                console.error(`[worker] Error writing final output: ${getErrorMessage(error)}`);
+            }
+        }
+        else {
+            try {
+                log.debug(`[worker] Writing partial output (reason: ${reason})`);
+                const partialOutput = telemetryStore.buildOutput(true); // partial=true
+                writeSessionOutput(partialOutput);
+            }
+            catch (error) {
+                console.error(`[worker] Error writing partial output: ${getErrorMessage(error)}`);
+            }
         }
         log.debug(workerShutdownComplete());
     }
     catch (error) {
-        console.error(`[worker] Error during shutdown: ${getErrorMessage(error)}`);
-        throw error;
+        console.error(`[worker] Error during cleanup: ${getErrorMessage(error)}`);
     }
 }
 /**
@@ -621,130 +291,137 @@ async function main() {
     console.error(`[worker] Starting (PID ${process.pid})`);
     let config;
     try {
-        // Parse configuration
         config = parseWorkerConfig();
         console.error(`[worker] Config: ${JSON.stringify(config)}`);
-        // Write worker PID immediately
+        telemetryStore.resetSessionStart();
+        telemetryStore.setDomData(null);
+        telemetryStore.networkRequests.length = 0;
+        telemetryStore.consoleMessages.length = 0;
+        telemetryStore.navigationEvents.length = 0;
+        telemetryStore.setTargetInfo(null);
         writePid(process.pid);
-        // Launch Chrome WITHOUT a URL - we'll navigate after collectors are ready
-        // WHY: Collectors must be enabled BEFORE navigation to capture initial requests
-        console.error(`[worker] Launching Chrome on port ${config.port}...`);
-        const launchOptions = {
-            port: config.port,
-            // DO NOT pass url here - navigation happens after collectors are active
-            ...(config.userDataDir !== undefined && { userDataDir: config.userDataDir }),
-        };
-        chrome = await launchChrome(launchOptions);
-        console.error(`[worker] Chrome launched (PID ${chrome.pid})`);
-        // Connect to Chrome via CDP
-        console.error(`[worker] Connecting to Chrome via CDP...`);
-        const targets = await fetchCDPTargets(config.port);
-        // Find the blank page target (Chrome auto-creates one on launch)
-        let target = targets.find((t) => t.type === 'page');
-        if (!target) {
-            // Enhanced error message with available targets and diagnostics
-            const availableTargets = targets
-                .map((t, i) => `  ${i + 1}. ${t.title || '(no title)'}\n     URL: ${t.url}\n     Type: ${t.type}`)
-                .join('\n');
-            throw new Error(`No page target found after Chrome launch\n\n` +
-                `Possible causes:\n` +
-                `  1. Port conflict (${config.port})\n` +
-                `     → Check: lsof -ti:${config.port}\n` +
-                `     → Kill: pkill -f "chrome.*${config.port}"\n` +
-                `  2. Chrome failed to create default target\n` +
-                `  3. Stale session\n` +
-                `     → Fix: bdg cleanup && bdg <url>\n\n` +
-                `Available Chrome targets:\n${availableTargets || '  (none)'}\n\n` +
-                `Try:\n` +
-                `  - Clean up and retry: bdg cleanup && bdg <url>\n` +
-                `  - Use different port: bdg <url> --port ${config.port + 1}`);
+        if (config.chromeWsUrl) {
+            console.error(`[worker] ${chromeExternalConnectionMessage()}`);
+            console.error(`[worker] ${chromeExternalWebSocketMessage(config.chromeWsUrl)}`);
+            chrome = null;
+            const targetId = config.chromeWsUrl.split('/').pop() ?? 'external';
+            telemetryStore.setTargetInfo({
+                id: targetId,
+                type: 'page',
+                title: 'External Chrome',
+                url: config.url,
+                webSocketDebuggerUrl: config.chromeWsUrl,
+            });
+            console.error(`[worker] ${chromeExternalNoPidMessage()}`);
+        }
+        else {
+            console.error(`[worker] Launching Chrome on port ${config.port}...`);
+            const launchOptions = {
+                port: config.port,
+                ...filterDefined({
+                    userDataDir: config.userDataDir,
+                    headless: config.headless,
+                }),
+            };
+            chrome = await launchChrome(launchOptions);
+            console.error(`[worker] Chrome launched (PID ${chrome.pid})`);
+            writeChromePid(chrome.pid);
+            console.error(`[worker] Chrome PID ${chrome.pid} cached for emergency cleanup`);
+            console.error(`[worker] Connecting to Chrome via CDP...`);
+            const targets = await fetchCDPTargets(config.port);
+            const foundTarget = targets.find((t) => t.type === 'page');
+            if (!foundTarget) {
+                const availableTargets = targets.length
+                    ? targets
+                        .map((t, i) => `  ${i + 1}. ${t.title || '(no title)'}\n     URL: ${t.url}\n     Type: ${t.type}`)
+                        .join('\n')
+                    : null;
+                throw new Error(noPageTargetFoundError(config.port, availableTargets));
+            }
+            telemetryStore.setTargetInfo(foundTarget);
+            console.error(`[worker] Found target: ${foundTarget.title} (${foundTarget.url})`);
+        }
+        if (!telemetryStore.targetInfo) {
+            throw new Error('Failed to obtain target information');
         }
-        targetInfo = target;
-        console.error(`[worker] Found target: ${target.title} (${target.url})`);
-        // Establish CDP connection
         cdp = new CDPConnection();
-        await cdp.connect(target.webSocketDebuggerUrl, {
+        await cdp.connect(telemetryStore.targetInfo.webSocketDebuggerUrl, {
             autoReconnect: false,
             maxRetries: 10,
-            // P1.1: Exit gracefully if Chrome dies unexpectedly
-            // WHY: Prevents zombie worker processes when Chrome crashes/closes
+            // P1.1: Run cleanup if Chrome dies unexpectedly
+            // WHY: Prevents zombie worker processes and ensures Chrome cleanup
             onDisconnect: (code, reason) => {
                 console.error(`[worker] Chrome connection lost (code: ${code}, reason: ${reason})`);
                 log.debug(workerExitingConnectionLoss());
-                process.exit(0);
+                void cleanupWorker('crash').then(() => process.exit(1));
             },
         });
         console.error(`[worker] CDP connection established`);
         // CRITICAL: Activate telemetry modules BEFORE navigating to target URL
         // WHY: Network/Console events are only captured for requests that start
-        // AFTER Network.enable/Runtime.enable are called. If we navigate first,
-        // we miss all initial page load requests and console messages.
         console.error(`[worker] Activating collectors before navigation...`);
-        await activateCollectors(config);
+        const telemetryCleanups = await startTelemetryCollectors(cdp, config, telemetryStore, log);
+        cleanupFunctions.push(...telemetryCleanups);
         console.error(`[worker] Collectors active and ready to capture telemetry`);
-        // NOW navigate to the target URL
         const normalizedUrl = normalizeUrl(config.url);
         console.error(`[worker] Navigating to ${normalizedUrl}...`);
         await cdp.send('Page.navigate', { url: normalizedUrl });
-        // Wait for page to be ready using smart detection
         await waitForPageReady(cdp, {
             maxWaitMs: DEFAULT_PAGE_READINESS_TIMEOUT_MS,
         });
         console.error(`[worker] Page ready`);
-        // Update targetInfo with actual loaded URL (may differ from normalized URL due to redirects)
-        const updatedTargets = await fetchCDPTargets(config.port);
-        const updatedTarget = updatedTargets.find((t) => t.id === target.id);
-        if (updatedTarget) {
-            targetInfo = updatedTarget;
-            console.error(`[worker] Target updated: ${updatedTarget.title} (${updatedTarget.url})`);
+        if (chrome && telemetryStore.targetInfo) {
+            const currentTargetId = telemetryStore.targetInfo.id;
+            const updatedTargets = await fetchCDPTargets(config.port);
+            const updatedTarget = updatedTargets.find((t) => t.id === currentTargetId);
+            if (updatedTarget) {
+                telemetryStore.setTargetInfo(updatedTarget);
+                console.error(`[worker] Target updated: ${updatedTarget.title} (${updatedTarget.url})`);
+            }
         }
-        // Write session metadata for status command
         writeSessionMetadata({
             bdgPid: process.pid,
-            chromePid: chrome.pid,
-            startTime: sessionStartTime,
+            chromePid: chrome?.pid ?? 0, // 0 indicates external Chrome (not managed by bdg)
+            startTime: telemetryStore.sessionStartTime,
             port: config.port,
-            targetId: target.id,
-            webSocketDebuggerUrl: target.webSocketDebuggerUrl,
-            activeTelemetry,
+            targetId: telemetryStore.targetInfo?.id,
+            webSocketDebuggerUrl: telemetryStore.targetInfo?.webSocketDebuggerUrl,
+            activeTelemetry: telemetryStore.activeTelemetry,
         });
         console.error(`[worker] Session metadata written`);
-        // Send ready signal to parent
         sendReadySignal(config);
-        // Set up stdin listener for IPC commands from daemon
         setupStdinListener();
-        // Set up shutdown handlers
         process.on('SIGTERM', () => {
             log.debug(workerReceivedSIGTERM());
-            void gracefulShutdown().then(() => process.exit(0));
+            void (async () => {
+                await cleanupWorker('normal');
+                process.exit(0);
+            })();
         });
         process.on('SIGINT', () => {
             log.debug(workerReceivedSIGINT());
-            void gracefulShutdown().then(() => process.exit(0));
+            void (async () => {
+                await cleanupWorker('normal');
+                process.exit(0);
+            })();
         });
-        // Handle timeout if specified
         if (config.timeout) {
             console.error(`[worker] Auto-stop after ${config.timeout}s`);
             setTimeout(() => {
                 log.debug(workerTimeoutReached());
-                void gracefulShutdown().then(() => process.exit(0));
+                void (async () => {
+                    await cleanupWorker('timeout');
+                    process.exit(0);
+                })();
             }, config.timeout * 1000);
         }
-        // Keep process alive
         log.debug(workerSessionActive());
     }
     catch (error) {
         console.error(`[worker] Fatal error: ${getErrorMessage(error)}`);
-        // Cleanup on error
-        if (cdp) {
-            cdp.close();
-        }
-        if (chrome) {
-            await chrome.kill();
-        }
+        await cleanupWorker('crash');
         process.exit(1);
     }
 }
-// Start worker
 void main();
 //# sourceMappingURL=worker.js.map