/tests/e2e/telemetry.test.ts

/**
 * @license
 * Copyright 2026 Google LLC
 * SPDX-License-Identifier: Apache-2.0
 */

import assert from 'node:assert';
import {spawn, type ChildProcess, type SpawnOptions} from 'node:child_process';
import http from 'node:http';
import type {AddressInfo} from 'node:net';
import path from 'node:path';
import {describe, it} from 'node:test';

import type {ChromeDevToolsMcpExtension} from '../../src/telemetry/types';

const SERVER_PATH = path.resolve('build/src/main.js');

interface MockServerContext {
  server: http.Server;
  port: number;
  events: ChromeDevToolsMcpExtension[];
  watchdogPid?: number;
  waitForEvent: (
    predicate: (event: ChromeDevToolsMcpExtension) => boolean,
  ) => Promise<ChromeDevToolsMcpExtension>;
}

async function startMockServer(): Promise<MockServerContext> {
  const events: ChromeDevToolsMcpExtension[] = [];
  let waitingResolvers: Array<{
    predicate: (event: ChromeDevToolsMcpExtension) => boolean;
    resolve: (event: ChromeDevToolsMcpExtension) => void;
  }> = [];
  let watchdogPid: number | undefined;

  const server = http.createServer((req, res) => {
    if (req.method === 'POST') {
      const pidHeader = req.headers['x-watchdog-pid'];
      if (pidHeader && !Array.isArray(pidHeader)) {
        watchdogPid = parseInt(pidHeader, 10);
      }

      let body = '';
      req.on('data', chunk => {
        body += chunk.toString();
      });
      req.on('end', () => {
        try {
          const parsed = JSON.parse(body);
          // Extract internal log events
          if (parsed.log_event) {
            for (const logEvent of parsed.log_event) {
              if (logEvent.source_extension_json) {
                const ext = JSON.parse(
                  logEvent.source_extension_json,
                ) as ChromeDevToolsMcpExtension;
                events.push(ext);

                // Check if any waiters are satisfied
                waitingResolvers = waitingResolvers.filter(
                  ({predicate, resolve}) => {
                    if (predicate(ext)) {
                      resolve(ext);
                      return false;
                    }
                    return true;
                  },
                );
              }
            }
          }
        } catch (err) {
          console.error('Failed to parse mock server request', err);
        }
        res.writeHead(200, {'Content-Type': 'application/json'});
        res.end(JSON.stringify({next_request_wait_millis: 100}));
      });
    } else {
      res.writeHead(404);
      res.end();
    }
  });

  await new Promise<void>(resolve => {
    server.listen(0, '127.0.0.1', () => resolve());
  });

  const address = server.address() as AddressInfo;
  return {
    server,
    port: address.port,
    events,
    get watchdogPid() {
      return watchdogPid;
    },
    waitForEvent: predicate => {
      const existing = events.find(predicate);
      if (existing) {
        return Promise.resolve(existing);
      }

      return new Promise(resolve => {
        waitingResolvers.push({predicate, resolve});
      });
    },
  };
}

interface TestContext {
  process?: ChildProcess;
  mockServer?: MockServerContext;
}

function isProcessAlive(pid: number): boolean {
  try {
    process.kill(pid, 0);
    return true;
  } catch {
    return false;
  }
}

async function waitForProcessExit(
  pid: number,
  timeoutMs = 5000,
): Promise<void> {
  const startTime = Date.now();
  while (Date.now() - startTime < timeoutMs) {
    if (!isProcessAlive(pid)) {
      return;
    }
    await new Promise(resolve => setTimeout(resolve, 50));
  }
  throw new Error(`Timeout waiting for process ${pid} to exit`);
}

function cleanupTest(ctx: TestContext): void {
  // Kill Main Process
  if (ctx.process && ctx.process.exitCode === null) {
    try {
      ctx.process.kill('SIGKILL');
    } catch {
      // ignore
    }
  }
  // Kill Watchdog Process
  if (ctx.mockServer?.watchdogPid) {
    try {
      process.kill(ctx.mockServer.watchdogPid, 'SIGKILL');
    } catch {
      // ignore
    }
  }
  // Stop Mock Server
  if (ctx.mockServer) {
    ctx.mockServer.server.close();
  }
}

describe('Telemetry E2E', () => {
  async function runTelemetryTest(
    killFn: (ctx: TestContext) => void,
    spawnOptions?: SpawnOptions,
  ): Promise<void> {
    const mockContext = await startMockServer();
    const ctx: TestContext = {
      mockServer: mockContext,
    };

    try {
      ctx.process = spawn(
        process.execPath,
        [
          SERVER_PATH,
          '--usage-statistics',
          '--headless',
          `--clearcutEndpoint=http://127.0.0.1:${mockContext.port}`,
          '--clearcutForceFlushIntervalMs=10',
          '--clearcutIncludePidHeader',
        ],
        {
          stdio: ['pipe', 'pipe', 'pipe'],
          env: {
            ...process.env,
          },
          ...spawnOptions,
        },
      );

      const startEvent = await Promise.race([
        mockContext.waitForEvent(e => e.server_start !== undefined),
        new Promise((_, reject) =>
          setTimeout(
            () => reject(new Error('Timeout waiting for server_start')),
            10000,
          ),
        ),
      ]);
      assert.ok(startEvent, 'server_start event not received');

      // Now that we received an event, we should have the Watchdog PID
      const watchdogPid = mockContext.watchdogPid;
      assert.ok(watchdogPid, 'Watchdog PID not captured from headers');

      // Assert Watchdog is actually running
      assert.strictEqual(
        isProcessAlive(watchdogPid),
        true,
        'Watchdog process should be running',
      );

      // Trigger shutdown
      killFn(ctx);

      // Verify shutdown event
      const shutdownEvent = await Promise.race([
        mockContext.waitForEvent(e => e.server_shutdown !== undefined),
        new Promise((_, reject) =>
          setTimeout(
            () => reject(new Error('Timeout waiting for server_shutdown')),
            10000,
          ),
        ),
      ]);
      assert.ok(shutdownEvent, 'server_shutdown event not received');

      // Wait for Watchdog to exit naturally
      await waitForProcessExit(watchdogPid);
    } finally {
      cleanupTest(ctx);
    }
  }

  it('handles SIGKILL', () =>
    runTelemetryTest(ctx => {
      ctx.process!.kill('SIGKILL');
    }));

  it('handles SIGTERM', () =>
    runTelemetryTest(ctx => {
      ctx.process!.kill('SIGTERM');
    }));

  it(
    'handles POSIX process group SIGTERM',
    {skip: process.platform === 'win32'},
    () =>
      runTelemetryTest(
        ctx => {
          process.kill(-ctx.process!.pid!, 'SIGTERM');
        },
        {detached: true},
      ),
  );
});