@yezack/chrome-devtools-mcp-108 0.0.0-stage → 1.10.2

package/build/src/telemetry/persistence.js

@@ -0,0 +1,82 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import process from 'node:process';
+import { logger } from '../utils/logger.js';
+import { ClearcutLogger } from './ClearcutLogger.js';
+import { ErrorCode } from './errors.js';
+function isValidTime(time) {
+    if (time === undefined) {
+        return true;
+    }
+    if (typeof time !== 'string' || time === '') {
+        return false;
+    }
+    return !Number.isNaN(new Date(time).getTime());
+}
+function isContextValid(state) {
+    return isValidTime(state.lastActive) && isValidTime(state.lastToolCall);
+}
+const STATE_FILE_NAME = 'telemetry_state.json';
+function getDataFolder() {
+    const homedir = os.homedir();
+    const { env } = process;
+    const name = 'chrome-devtools-mcp';
+    if (process.platform === 'darwin') {
+        return path.join(homedir, 'Library', 'Application Support', name);
+    }
+    if (process.platform === 'win32') {
+        const localAppData = env.LOCALAPPDATA || path.join(homedir, 'AppData', 'Local');
+        return path.join(localAppData, name, 'Data');
+    }
+    return path.join(env.XDG_DATA_HOME || path.join(homedir, '.local', 'share'), name);
+}
+export class FilePersistence {
+    #dataFolder;
+    constructor(dataFolderOverride) {
+        this.#dataFolder = dataFolderOverride ?? getDataFolder();
+    }
+    async loadState() {
+        const filePath = path.join(this.#dataFolder, STATE_FILE_NAME);
+        try {
+            await fs.access(filePath);
+        }
+        catch {
+            // File doesn't exist. Not an error because new users do not have the state file.
+            return {};
+        }
+        let state;
+        try {
+            const content = await fs.readFile(filePath, 'utf-8');
+            state = JSON.parse(content);
+        }
+        catch (error) {
+            logger?.(`Failed to read telemetry state from ${filePath}:`, error);
+            void ClearcutLogger.get()?.logServerError({
+                errorCode: ErrorCode.ERROR_CODE_PERSISTENCE_FILE_READ_FAILED,
+            });
+            return {};
+        }
+        return isContextValid(state) ? state : {};
+    }
+    async saveState(state) {
+        const filePath = path.join(this.#dataFolder, STATE_FILE_NAME);
+        try {
+            await fs.mkdir(this.#dataFolder, { recursive: true });
+            await fs.writeFile(filePath, JSON.stringify(state, null, 2), 'utf-8');
+        }
+        catch (error) {
+            // Ignore errors during state saving to avoid crashing the server
+            logger?.(`Failed to save telemetry state to ${filePath}:`, error);
+            void ClearcutLogger.get()?.logServerError({
+                errorCode: ErrorCode.ERROR_CODE_PERSISTENCE_FILE_SAVE_FAILED,
+            });
+        }
+    }
+}
+//# sourceMappingURL=persistence.js.map

package/build/src/telemetry/transformation.js

@@ -0,0 +1,233 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { isLocalhost } from '../utils/url.js';
+const LATENCY_BUCKETS = [50, 100, 250, 500, 1000, 2500, 5000, 10000];
+export function bucketizeLatency(latencyMs) {
+    for (const bucket of LATENCY_BUCKETS) {
+        if (latencyMs <= bucket) {
+            return bucket;
+        }
+    }
+    return LATENCY_BUCKETS[LATENCY_BUCKETS.length - 1];
+}
+export const MAX_ACTIVE_DAYS = 31;
+export function bucketizeDaysSince(days) {
+    return Math.min(days, MAX_ACTIVE_DAYS);
+}
+export const REDACTED_CLIENT_NAME = '<redacted>';
+const VALID_CLIENT_NAME_REGEX = /^[a-zA-Z0-9_-]+$/;
+const MAX_CLIENT_NAME_LENGTH = 32;
+export function sanitizeClientName(clientName) {
+    if (clientName.length > 0 &&
+        clientName.length < MAX_CLIENT_NAME_LENGTH &&
+        VALID_CLIENT_NAME_REGEX.test(clientName)) {
+        return clientName;
+    }
+    return REDACTED_CLIENT_NAME;
+}
+export const PARAM_BLOCKLIST = new Set(['uid', 'reqid', 'msgid']);
+const SUPPORTED_ZOD_TYPES = [
+    'ZodString',
+    'ZodNumber',
+    'ZodBoolean',
+    'ZodArray',
+    'ZodEnum',
+];
+function isObjectWithDef(val) {
+    return typeof val === 'object' && val !== null && '_def' in val;
+}
+function isZodType(type) {
+    return SUPPORTED_ZOD_TYPES.includes(type);
+}
+export function getZodType(zodType) {
+    if (!isObjectWithDef(zodType)) {
+        throw new Error('Invalid zod schema');
+    }
+    const def = zodType._def;
+    let typeName = def.typeName;
+    if (!typeName && def.type) {
+        typeName = 'Zod' + def.type.charAt(0).toUpperCase() + def.type.slice(1);
+    }
+    if (typeName === 'ZodOptional' ||
+        typeName === 'ZodDefault' ||
+        typeName === 'ZodNullable') {
+        return getZodType(def.innerType);
+    }
+    if (typeName === 'ZodEffects') {
+        return getZodType(def.schema);
+    }
+    if (typeName === 'ZodPipeline' || typeName === 'ZodPipe') {
+        return getZodType(isObjectWithDef(def.in) &&
+            (def.in._def.type === 'transform' ||
+                def.in._def.typeName === 'ZodTransform')
+            ? def.out
+            : def.in);
+    }
+    if (typeName && isZodType(typeName)) {
+        return typeName;
+    }
+    throw new Error(`Unsupported zod type for tool parameter: ${typeName}`);
+}
+/**
+ * Resolves the values of an enum parameter, unwrapping any optional/default/
+ * nullable/effects wrappers (in any order), mirroring {@link getZodType}.
+ */
+export function getEnumValues(zodType) {
+    if (!isObjectWithDef(zodType)) {
+        throw new Error('Invalid zod schema');
+    }
+    const def = zodType._def;
+    let typeName = def.typeName;
+    if (!typeName && def.type) {
+        typeName = 'Zod' + def.type.charAt(0).toUpperCase() + def.type.slice(1);
+    }
+    if (typeName === 'ZodOptional' ||
+        typeName === 'ZodDefault' ||
+        typeName === 'ZodNullable') {
+        return getEnumValues(def.innerType);
+    }
+    if (typeName === 'ZodEffects') {
+        return getEnumValues(def.schema);
+    }
+    if (typeName === 'ZodPipeline' || typeName === 'ZodPipe') {
+        return getEnumValues(isObjectWithDef(def.in) &&
+            (def.in._def.type === 'transform' ||
+                def.in._def.typeName === 'ZodTransform')
+            ? def.out
+            : def.in);
+    }
+    if (typeName === 'ZodEnum') {
+        if (def.values) {
+            return def.values;
+        }
+        if (def.entries) {
+            return Object.values(def.entries);
+        }
+    }
+    throw new Error(`Cannot resolve enum values for zod type: ${typeName}`);
+}
+export function stripUnderscoreBeforeNumber(name) {
+    return name.replace(/_([0-9])/g, '$1');
+}
+export function transformArgName(zodType, name) {
+    const snakeCaseName = name.replace(/[A-Z]/g, letter => `_${letter.toLowerCase()}`);
+    let transformed;
+    if (zodType === 'ZodString') {
+        transformed = `${snakeCaseName}_length`;
+    }
+    else if (zodType === 'ZodArray') {
+        transformed = `${snakeCaseName}_count`;
+    }
+    else {
+        transformed = snakeCaseName;
+    }
+    return stripUnderscoreBeforeNumber(transformed);
+}
+export function transformArgType(zodType) {
+    if (zodType === 'ZodString' || zodType === 'ZodArray') {
+        return 'number';
+    }
+    switch (zodType) {
+        case 'ZodNumber':
+            return 'number';
+        case 'ZodBoolean':
+            return 'boolean';
+        case 'ZodEnum':
+            return 'enum';
+        default:
+            throw new Error(`Unsupported zod type for tool parameter: ${zodType}`);
+    }
+}
+const BUCKETS = [
+    0, 1, 2, 5, 10, 20, 50, 100, 200, 500, 1000, 2000, 5000, 10000,
+];
+function bucketize(value) {
+    for (const bucket of BUCKETS) {
+        if (bucket >= value) {
+            return bucket;
+        }
+    }
+    return BUCKETS[BUCKETS.length - 1];
+}
+function transformValue(zodType, value) {
+    if (zodType === 'ZodString') {
+        return bucketize(value.length);
+    }
+    else if (zodType === 'ZodArray') {
+        return value.length;
+    }
+    else {
+        return value;
+    }
+}
+function hasEquivalentType(zodType, value) {
+    if (zodType === 'ZodString') {
+        return typeof value === 'string';
+    }
+    else if (zodType === 'ZodArray') {
+        return Array.isArray(value);
+    }
+    else if (zodType === 'ZodNumber') {
+        return typeof value === 'number';
+    }
+    else if (zodType === 'ZodBoolean') {
+        return typeof value === 'boolean';
+    }
+    else if (zodType === 'ZodEnum') {
+        return (typeof value === 'string' ||
+            typeof value === 'number' ||
+            typeof value === 'boolean');
+    }
+    else {
+        return false;
+    }
+}
+export function sanitizeParams(params, schema) {
+    const transformed = {};
+    for (const [name, value] of Object.entries(params)) {
+        if (PARAM_BLOCKLIST.has(name)) {
+            continue;
+        }
+        const zodType = getZodType(schema[name]);
+        if (!hasEquivalentType(zodType, value)) {
+            throw new Error(`parameter ${name} has type ${zodType} but value ${value} is not of equivalent type`);
+        }
+        const transformedName = transformArgName(zodType, name);
+        const transformedValue = transformValue(zodType, value);
+        transformed[transformedName] = transformedValue;
+    }
+    return transformed;
+}
+function transformDevToolsData(devToolsData) {
+    const logged = {};
+    if (devToolsData.cdpBackendNodeId !== undefined) {
+        logged.is_dom_element_selected = true;
+    }
+    if (devToolsData.cdpRequestId !== undefined) {
+        logged.is_network_request_selected = true;
+    }
+    return logged;
+}
+export function buildContext(devToolsData, pageUrl) {
+    let context;
+    if (devToolsData === undefined) {
+        context = { is_devtools_open: false };
+    }
+    else {
+        context = {
+            is_devtools_open: Object.keys(devToolsData).length > 0,
+        };
+        const loggedDevtoolsData = transformDevToolsData(devToolsData);
+        if (Object.keys(loggedDevtoolsData).length > 0) {
+            context.devtools_data = loggedDevtoolsData;
+        }
+    }
+    if (pageUrl !== undefined) {
+        context.is_localhost = isLocalhost(pageUrl);
+    }
+    return context;
+}
+//# sourceMappingURL=transformation.js.map

package/build/src/telemetry/types.js

@@ -0,0 +1,36 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+// Enums
+export var OsType;
+(function (OsType) {
+    OsType[OsType["OS_TYPE_UNSPECIFIED"] = 0] = "OS_TYPE_UNSPECIFIED";
+    OsType[OsType["OS_TYPE_WINDOWS"] = 1] = "OS_TYPE_WINDOWS";
+    OsType[OsType["OS_TYPE_MACOS"] = 2] = "OS_TYPE_MACOS";
+    OsType[OsType["OS_TYPE_LINUX"] = 3] = "OS_TYPE_LINUX";
+})(OsType || (OsType = {}));
+export var McpClient;
+(function (McpClient) {
+    McpClient[McpClient["MCP_CLIENT_UNSPECIFIED"] = 0] = "MCP_CLIENT_UNSPECIFIED";
+    McpClient[McpClient["MCP_CLIENT_CLAUDE_CODE"] = 1] = "MCP_CLIENT_CLAUDE_CODE";
+    McpClient[McpClient["MCP_CLIENT_GEMINI_CLI"] = 2] = "MCP_CLIENT_GEMINI_CLI";
+    McpClient[McpClient["MCP_CLIENT_DT_MCP_CLI"] = 4] = "MCP_CLIENT_DT_MCP_CLI";
+    McpClient[McpClient["MCP_CLIENT_OPENCLAW"] = 5] = "MCP_CLIENT_OPENCLAW";
+    McpClient[McpClient["MCP_CLIENT_CODEX"] = 6] = "MCP_CLIENT_CODEX";
+    McpClient[McpClient["MCP_CLIENT_ANTIGRAVITY"] = 7] = "MCP_CLIENT_ANTIGRAVITY";
+    McpClient[McpClient["MCP_CLIENT_GROK"] = 8] = "MCP_CLIENT_GROK";
+    McpClient[McpClient["MCP_CLIENT_OPENCODE"] = 9] = "MCP_CLIENT_OPENCODE";
+    McpClient[McpClient["MCP_CLIENT_CLAUDE_DESKTOP"] = 10] = "MCP_CLIENT_CLAUDE_DESKTOP";
+    McpClient[McpClient["MCP_CLIENT_GITHUB_COPILOT"] = 11] = "MCP_CLIENT_GITHUB_COPILOT";
+    McpClient[McpClient["MCP_CLIENT_HERMES"] = 12] = "MCP_CLIENT_HERMES";
+    McpClient[McpClient["MCP_CLIENT_OTHER"] = 3] = "MCP_CLIENT_OTHER";
+})(McpClient || (McpClient = {}));
+// IPC types for messages between the main process and the
+// telemetry watchdog process.
+export var WatchdogMessageType;
+(function (WatchdogMessageType) {
+    WatchdogMessageType["LOG_EVENT"] = "log-event";
+})(WatchdogMessageType || (WatchdogMessageType = {}));
+//# sourceMappingURL=types.js.map

package/build/src/telemetry/watchdog/ClearcutSender.js

@@ -0,0 +1,205 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import crypto from 'node:crypto';
+import { logger } from '../../utils/logger.js';
+const MAX_BUFFER_SIZE = 1000;
+const DEFAULT_CLEARCUT_ENDPOINT = 'https://play.googleapis.com/log?format=json_proto';
+const DEFAULT_FLUSH_INTERVAL_MS = 15 * 60 * 1000;
+const LOG_SOURCE = 2839;
+const CLIENT_TYPE = 47;
+const MIN_RATE_LIMIT_WAIT_MS = 30_000;
+const REQUEST_TIMEOUT_MS = 30_000;
+const SHUTDOWN_TIMEOUT_MS = 5_000;
+const SESSION_ROTATION_INTERVAL_MS = 24 * 60 * 60 * 1000;
+export class ClearcutSender {
+    #appVersion;
+    #osType;
+    #clearcutEndpoint;
+    #flushIntervalMs;
+    #includePidHeader;
+    #sessionId;
+    #sessionCreated;
+    #buffer = [];
+    #flushTimer = null;
+    #isFlushing = false;
+    #timerStarted = false;
+    constructor(config) {
+        this.#appVersion = config.appVersion;
+        this.#osType = config.osType;
+        this.#clearcutEndpoint =
+            config.clearcutEndpoint ?? DEFAULT_CLEARCUT_ENDPOINT;
+        this.#flushIntervalMs =
+            config.forceFlushIntervalMs ?? DEFAULT_FLUSH_INTERVAL_MS;
+        this.#includePidHeader = config.includePidHeader ?? false;
+        this.#sessionId = crypto.randomUUID();
+        this.#sessionCreated = Date.now();
+    }
+    enqueueEvent(event) {
+        if (Date.now() - this.#sessionCreated > SESSION_ROTATION_INTERVAL_MS) {
+            this.#sessionId = crypto.randomUUID();
+            this.#sessionCreated = Date.now();
+        }
+        const eventToSend = {
+            ...event,
+            session_id: this.#sessionId,
+            app_version: this.#appVersion,
+            os_type: this.#osType,
+        };
+        logger?.('Enqueing telemetry event', JSON.stringify(eventToSend, null, 2));
+        this.#addToBuffer(eventToSend);
+        if (!this.#timerStarted) {
+            this.#timerStarted = true;
+            this.#scheduleFlush(this.#flushIntervalMs);
+        }
+    }
+    async sendShutdownEvent() {
+        if (this.#flushTimer) {
+            clearTimeout(this.#flushTimer);
+            this.#flushTimer = null;
+        }
+        const shutdownEvent = {
+            server_shutdown: {},
+        };
+        this.enqueueEvent(shutdownEvent);
+        try {
+            await Promise.race([
+                this.#finalFlush(),
+                new Promise(resolve => setTimeout(resolve, SHUTDOWN_TIMEOUT_MS)),
+            ]);
+            logger?.('Final flush completed');
+        }
+        catch (error) {
+            logger?.('Final flush failed:', error);
+        }
+    }
+    async #flush() {
+        if (this.#isFlushing) {
+            return;
+        }
+        if (this.#buffer.length === 0) {
+            this.#scheduleFlush(this.#flushIntervalMs);
+            return;
+        }
+        this.#isFlushing = true;
+        let nextDelayMs = this.#flushIntervalMs;
+        // Optimistically remove events from buffer before sending.
+        // This prevents race conditions where a simultaneous #finalFlush would include these same events.
+        const eventsToSend = [...this.#buffer];
+        this.#buffer = [];
+        try {
+            const result = await this.#sendBatch(eventsToSend);
+            if (result.success) {
+                if (result.nextRequestWaitMs !== undefined) {
+                    nextDelayMs = Math.max(result.nextRequestWaitMs, MIN_RATE_LIMIT_WAIT_MS);
+                }
+            }
+            else if (result.isPermanentError) {
+                logger?.('Permanent error, dropped batch of', eventsToSend.length, 'events');
+            }
+            else {
+                // Transient error: Requeue events at the front of the buffer
+                // to maintain order and retry them later.
+                this.#buffer = [...eventsToSend, ...this.#buffer];
+            }
+        }
+        catch (error) {
+            // Safety catch for unexpected errors, requeue events
+            this.#buffer = [...eventsToSend, ...this.#buffer];
+            logger?.('Flush failed unexpectedly:', error);
+        }
+        finally {
+            this.#isFlushing = false;
+            this.#scheduleFlush(nextDelayMs);
+        }
+    }
+    #addToBuffer(event) {
+        if (this.#buffer.length >= MAX_BUFFER_SIZE) {
+            this.#buffer.shift();
+            logger?.('Telemetry buffer overflow: dropped oldest event');
+        }
+        this.#buffer.push({
+            event,
+            timestamp: Date.now(),
+        });
+    }
+    #scheduleFlush(delayMs) {
+        logger?.(`Scheduling flush in ${delayMs}`);
+        if (this.#flushTimer) {
+            clearTimeout(this.#flushTimer);
+        }
+        this.#flushTimer = setTimeout(() => {
+            this.#flush().catch(err => {
+                logger?.('Flush error:', err);
+            });
+        }, delayMs);
+    }
+    async #sendBatch(events) {
+        logger?.(`Sending batch of ${events.length}`);
+        const requestBody = {
+            log_source: LOG_SOURCE,
+            request_time_ms: Date.now().toString(),
+            client_info: {
+                client_type: CLIENT_TYPE,
+            },
+            log_event: events.map(({ event, timestamp }) => ({
+                event_time_ms: timestamp.toString(),
+                source_extension_json: JSON.stringify(event),
+            })),
+        };
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+        try {
+            const response = await fetch(this.#clearcutEndpoint, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    // Used in E2E tests to confirm that the watchdog process is killed
+                    ...(this.#includePidHeader
+                        ? { 'X-Watchdog-Pid': process.pid.toString() }
+                        : {}),
+                },
+                body: JSON.stringify(requestBody),
+                signal: controller.signal,
+            });
+            clearTimeout(timeoutId);
+            if (response.ok) {
+                const data = (await response.json());
+                return {
+                    success: true,
+                    nextRequestWaitMs: data.next_request_wait_millis,
+                };
+            }
+            const status = response.status;
+            if (status >= 500 || status === 429) {
+                return { success: false };
+            }
+            logger?.('Telemetry permanent error:', status);
+            return { success: false, isPermanentError: true };
+        }
+        catch {
+            clearTimeout(timeoutId);
+            return { success: false };
+        }
+    }
+    async #finalFlush() {
+        if (this.#buffer.length === 0) {
+            return;
+        }
+        const eventsToSend = [...this.#buffer];
+        await this.#sendBatch(eventsToSend);
+    }
+    stopForTesting() {
+        if (this.#flushTimer) {
+            clearTimeout(this.#flushTimer);
+            this.#flushTimer = null;
+        }
+        this.#timerStarted = false;
+    }
+    get bufferSizeForTesting() {
+        return this.#buffer.length;
+    }
+}
+//# sourceMappingURL=ClearcutSender.js.map

package/build/src/telemetry/watchdog/main.js

@@ -0,0 +1,128 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import process from 'node:process';
+import readline from 'node:readline';
+import { parseArgs } from 'node:util';
+import { logger, flushLogs, saveLogsToFile } from '../../utils/logger.js';
+import { WatchdogMessageType } from '../types.js';
+import { ClearcutSender } from './ClearcutSender.js';
+function parseWatchdogArgs() {
+    const { values } = parseArgs({
+        options: {
+            'parent-pid': { type: 'string' },
+            'app-version': { type: 'string' },
+            'os-type': { type: 'string' },
+            'log-file': { type: 'string' },
+            'clearcut-endpoint': { type: 'string' },
+            'clearcut-force-flush-interval-ms': { type: 'string' },
+            'clearcut-include-pid-header': { type: 'boolean' },
+        },
+        strict: true,
+    });
+    // Verify required arguments
+    const parentPid = parseInt(values['parent-pid'] ?? '', 10);
+    const appVersion = values['app-version'];
+    const osType = parseInt(values['os-type'] ?? '', 10);
+    if (isNaN(parentPid) || !appVersion || isNaN(osType)) {
+        console.error('Invalid arguments provided for watchdog process: ', JSON.stringify({ parentPid, appVersion, osType }));
+        process.exit(1);
+    }
+    // Parse Optional Arguments
+    const logFile = values['log-file'];
+    const clearcutEndpoint = values['clearcut-endpoint'];
+    const clearcutIncludePidHeader = values['clearcut-include-pid-header'];
+    let clearcutForceFlushIntervalMs;
+    if (values['clearcut-force-flush-interval-ms']) {
+        const parsed = parseInt(values['clearcut-force-flush-interval-ms'], 10);
+        if (!isNaN(parsed)) {
+            clearcutForceFlushIntervalMs = parsed;
+        }
+    }
+    return {
+        parentPid,
+        appVersion,
+        osType,
+        logFile,
+        clearcutEndpoint,
+        clearcutForceFlushIntervalMs,
+        clearcutIncludePidHeader,
+    };
+}
+function main() {
+    const { parentPid, appVersion, osType, logFile, clearcutEndpoint, clearcutForceFlushIntervalMs, clearcutIncludePidHeader, } = parseWatchdogArgs();
+    let logStream;
+    if (logFile) {
+        logStream = saveLogsToFile(logFile);
+    }
+    const exit = (code) => {
+        if (!logStream) {
+            process.exit(code);
+        }
+        void flushLogs(logStream).finally(() => {
+            process.exit(code);
+        });
+    };
+    logger?.('Watchdog started', JSON.stringify({
+        pid: process.pid,
+        parentPid,
+        version: appVersion,
+        osType,
+    }, null, 2));
+    const sender = new ClearcutSender({
+        appVersion,
+        osType: osType,
+        clearcutEndpoint,
+        forceFlushIntervalMs: clearcutForceFlushIntervalMs,
+        includePidHeader: clearcutIncludePidHeader,
+    });
+    let isShuttingDown = false;
+    function onParentDeath(reason) {
+        if (isShuttingDown) {
+            return;
+        }
+        isShuttingDown = true;
+        logger?.(`Parent death detected (${reason}). Sending shutdown event...`);
+        sender
+            .sendShutdownEvent()
+            .then(() => {
+            logger?.('Shutdown event sent. Exiting.');
+            exit(0);
+        })
+            .catch(err => {
+            logger?.('Failed to send shutdown event', err);
+            exit(1);
+        });
+    }
+    process.stdin.on('end', () => onParentDeath('stdin end'));
+    process.stdin.on('close', () => onParentDeath('stdin close'));
+    process.on('disconnect', () => onParentDeath('ipc disconnect'));
+    const rl = readline.createInterface({
+        input: process.stdin,
+        terminal: false,
+    });
+    rl.on('line', line => {
+        try {
+            if (!line.trim()) {
+                return;
+            }
+            const msg = JSON.parse(line);
+            if (msg.type === WatchdogMessageType.LOG_EVENT && msg.payload) {
+                sender.enqueueEvent(msg.payload);
+            }
+        }
+        catch (err) {
+            logger?.('Failed to parse IPC message', err);
+        }
+    });
+}
+try {
+    main();
+}
+catch (err) {
+    console.error('Watchdog fatal error:', err);
+    process.exit(1);
+}
+//# sourceMappingURL=main.js.map