[MCP]: Extension recovery timeout leaks debugger when pending attach completes after close #43005

const assert = require('node:assert/strict');
const fs = require('node:fs');
const path = require('node:path');
const vm = require('node:vm');
const ts = require('node:module').createRequire(path.resolve('package.json'))('typescript');

(async () => {
  const ref = process.argv[2] || 'v1.63.0';
  const response = await fetch(
    'https://raw.githubusercontent.com/microsoft/playwright/' + ref +
    '/packages/extension/src/relayConnection.ts'
  );
  assert.equal(response.status, 200);
  const source = await response.text();
  const js = ts.transpileModule(source, {
    compilerOptions: { target: ts.ScriptTarget.ES2022, module: ts.ModuleKind.CommonJS }
  }).outputText;
  const event = () => ({
    listeners: new Set(),
    addListener(fn) { this.listeners.add(fn); },
    removeListener(fn) { this.listeners.delete(fn); },
    emit(...args) { for (const fn of [...this.listeners]) fn(...args); }
  });
  const timers = [];
  const liveDebuggers = new Set();
  let completeAttach;
  let detachCalls = 0;
  const chrome = {
    debugger: {
      onEvent: event(), onDetach: event(),
      attach: async ({ tabId }) => { liveDebuggers.add(tabId); },
      detach: async ({ tabId }) => { detachCalls++; liveDebuggers.delete(tabId); }
    },
    tabs: {
      onCreated: event(), onRemoved: event(),
      get: async id => ({ id, windowId: 1, url: 'https://example.com/' })
    }
  };
  class Socket {
    static OPEN = 1;
    readyState = 1;
    send() {}
    close() { this.readyState = 3; }
  }
  const context = {
    exports: {}, chrome, WebSocket: Socket, console,
    setTimeout: (callback, delay) => { timers.push({ callback, delay }); },
    clearTimeout() {}
  };
  vm.runInNewContext(js, context);
  const connection = new context.exports.RelayConnection(new Socket());
  const attach = () => connection._onMessageAsync({
    data: JSON.stringify({
      id: 1, method: 'chrome.debugger.attach', params: [{ tabId: 23 }, '1.3']
    })
  });
  const runTimer = async delay => {
    const index = timers.findIndex(timer => timer.delay === delay);
    assert.ok(index >= 0, 'Expected timer: ' + delay);
    await timers.splice(index, 1)[0].callback();
    await Promise.resolve();
    await Promise.resolve();
  };
  await attach();
  liveDebuggers.delete(23);
  chrome.debugger.onDetach.emit({ tabId: 23 }, 'target_closed');
  await runTimer(150);

  // The relay processes the extension's re-announced tab and requests attach.
  // Hold Chrome's completion until after the extension's recovery timeout.
  chrome.debugger.attach = ({ tabId }) => new Promise(resolve => {
    completeAttach = () => { liveDebuggers.add(tabId); resolve(); };
  });
  const pendingAttach = attach();
  await runTimer(2500);
  assert.equal(connection._closed, true);
  completeAttach();
  await pendingAttach;

  console.log(JSON.stringify({
    ref, closed: connection._closed,
    liveDebuggers: [...liveDebuggers],
    trackedTabs: [...connection.attachedTabs], detachCalls
  }));
  assert.equal(liveDebuggers.size, 0, 'Debugger must be released after a late attach');
})().catch(error => { console.error(error); process.exitCode = 1; });