cdp-tunnel 1.0.10 → 1.0.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cdp-tunnel",
-  "version": "1.0.10",
+  "version": "1.0.12",
   "description": "Chrome Extension CDP Proxy - 通过 Chrome 扩展将 chrome.debugger API 暴露为 WebSocket 端点",
   "main": "server/proxy-server.js",
   "bin": "./cli/index.js",

package/server/modules/config.js

@@ -1,5 +1,5 @@
 const CONFIG = {
-  PORT: 9221,
+  PORT: process.env.PORT ? parseInt(process.env.PORT) : 9221,
   HEARTBEAT_INTERVAL: 30000,
   STATUS_PRINT_INTERVAL: 60000,
   TARGETS_CACHE_TTL: 2000,

package/server/modules/logger.js

@@ -11,6 +11,7 @@ const statusLogFile = path.join(logDir, 'server-status.log');
 
 const MAX_LOG_SIZE = 10 * 1024 * 1024;
 const MAX_LOG_FILES = 5;
+const MAX_TOTAL_LOG_SIZE = 30 * 1024 * 1024;
 
 let logWriteQueue = [];
 let isWritingLog = false;
@@ -84,6 +85,25 @@ function flushStatusQueue() {
 function checkLogRotation() {
   checkAndRotateLog(logFile);
   checkAndRotateLog(statusLogFile);
+  cleanupOldLogs();
+}
+
+function cleanupOldLogs() {
+  try {
+    const files = fs.readdirSync(logDir).filter(f => f.endsWith('.log')).map(f => {
+      const fp = path.join(logDir, f);
+      try {
+        return { path: fp, stat: fs.statSync(fp) };
+      } catch { return null; }
+    }).filter(Boolean).sort((a, b) => a.stat.mtimeMs - b.stat.mtimeMs);
+
+    let totalSize = files.reduce((sum, f) => sum + f.stat.size, 0);
+    while (totalSize > MAX_TOTAL_LOG_SIZE && files.length > 1) {
+      const oldest = files.shift();
+      fs.unlinkSync(oldest.path);
+      totalSize -= oldest.stat.size;
+    }
+  } catch {}
 }
 
 setInterval(checkLogRotation, 60000);
@@ -105,7 +125,43 @@ const NOISY_METHODS = [
   'Network.responseReceivedExtraInfo',
   'Network.dataReceived',
   'Network.loadingFinished',
+  'Network.resourceChangedPriority',
+  'Network.requestServedFromCache',
+  'Network.webSocketFrameSent',
+  'Network.webSocketFrameReceived',
+  'Network.eventSourceMessageReceived',
   'Input.dispatchMouseEvent',
+  'Input.mouseMoved',
+  'Input.keyDown',
+  'Input.keyUp',
+  'Input.char',
+  'Input.dispatchKeyEvent',
+  'Page.lifecycleEvent',
+  'Page.frameStartedLoading',
+  'Page.frameStoppedLoading',
+  'Page.frameNavigated',
+  'Page.frameRequestedNavigation',
+  'Page.frameScheduledNavigation',
+  'Page.frameStartedNavigating',
+  'Page.frameAttached',
+  'Page.frameClearedScheduledNavigation',
+  'Page.navigatedWithinDocument',
+  'Page.domContentEventFired',
+  'Page.loadEventFired',
+  'Page.screencastFrame',
+  'Page.screencastFrameAck',
+  'Runtime.executionContextCreated',
+  'Runtime.executionContextDestroyed',
+  'Runtime.executionContextsCleared',
+  'Runtime.bindingCalled',
+  'CSS.styleChanged',
+  'CSS.fontsUpdated',
+  'DOM.childNodeInserted',
+  'DOM.childNodeRemoved',
+  'DOM.attributeModified',
+  'DOM.attributeRemoved',
+  'DOM.childNodeCountUpdated',
+  'Log.entryAdded',
 ];
 
 function truncateMessage(message) {

package/tests/e2e-auto-test.js

@@ -0,0 +1,304 @@
+const { chromium } = require('playwright');
+const { spawn } = require('child_process');
+const http = require('http');
+const path = require('path');
+const fs = require('fs');
+
+const CHROMIUM = '/Applications/Chromium.app/Contents/MacOS/Chromium';
+const CHROME = '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome';
+const EXTENSION_PATH = path.join(__dirname, '..', 'extension-new');
+const SERVER_SCRIPT = path.join(__dirname, '..', 'server', 'proxy-server.js');
+const USER_DATA_DIR = '/tmp/cdp-tunnel-e2e-test';
+const PROXY_PORT = 19221;
+const CDP_URL = `http://localhost:${PROXY_PORT}`;
+const TEST_EXT_DIR = '/tmp/cdp-tunnel-e2e-extension';
+
+const CHROME_PATH = fs.existsSync(CHROMIUM) ? CHROMIUM : fs.existsSync(CHROME) ? CHROME : null;
+
+if (!CHROME_PATH) {
+  console.error('Chrome/Chromium not found');
+  process.exit(1);
+}
+
+async function sleep(ms) {
+  return new Promise(r => setTimeout(r, ms));
+}
+
+function httpGet(url) {
+  return new Promise((resolve, reject) => {
+    http.get(url, (res) => {
+      let data = '';
+      res.on('data', (chunk) => data += chunk);
+      res.on('end', () => resolve(data));
+    }).on('error', reject);
+  });
+}
+
+async function waitForServer(port, maxWait = 10000) {
+  const start = Date.now();
+  while (Date.now() - start < maxWait) {
+    try {
+      await httpGet(`http://localhost:${port}/json/version`);
+      return true;
+    } catch {
+      await sleep(500);
+    }
+  }
+  return false;
+}
+
+async function waitForExtension(maxWait = 15000) {
+  const start = Date.now();
+  while (Date.now() - start < maxWait) {
+    try {
+      const data = await httpGet(`http://localhost:${PROXY_PORT}/json/version`);
+      const info = JSON.parse(data);
+      return true;
+    } catch {}
+    await sleep(500);
+  }
+  return false;
+}
+
+async function runTest() {
+  let serverProc = null;
+  let chromeProc = null;
+  let browser = null;
+  let passed = 0;
+  let failed = 0;
+
+  console.log('='.repeat(60));
+  console.log('  CDP Tunnel E2E Automated Test');
+  console.log('='.repeat(60));
+  console.log(`  Chrome: ${CHROME_PATH}`);
+  console.log(`  Extension: ${EXTENSION_PATH}`);
+  console.log(`  Proxy: ${CDP_URL}`);
+  console.log('='.repeat(60));
+
+  try {
+    // 1. Cleanup
+    console.log('\n[Setup] Cleaning up...');
+    if (fs.existsSync(USER_DATA_DIR)) {
+      fs.rmSync(USER_DATA_DIR, { recursive: true });
+    }
+    if (fs.existsSync(TEST_EXT_DIR)) {
+      fs.rmSync(TEST_EXT_DIR, { recursive: true });
+    }
+
+    // Kill any existing process on port
+    const { execSync } = require('child_process');
+    try { execSync(`lsof -ti :${PROXY_PORT} | xargs kill -9 2>/dev/null`, { stdio: 'ignore' }); } catch {}
+    await sleep(500);
+
+    // 2. Copy extension and patch WS port
+    console.log('[Setup] Preparing test extension (port ' + PROXY_PORT + ')...');
+    execSync(`cp -r "${EXTENSION_PATH}" "${TEST_EXT_DIR}"`, { stdio: 'ignore' });
+    const configPath = path.join(TEST_EXT_DIR, 'utils', 'config.js');
+    let configContent = fs.readFileSync(configPath, 'utf8');
+    configContent = configContent.replace(
+      /WS_URL:\s*'ws:\/\/localhost:\d+\/plugin'/,
+      `WS_URL: 'ws://localhost:${PROXY_PORT}/plugin'`
+    );
+    fs.writeFileSync(configPath, configContent);
+
+    // 2. Start proxy server
+    console.log('[Setup] Starting proxy server...');
+    serverProc = spawn('node', [SERVER_SCRIPT], {
+      detached: false,
+      stdio: ['ignore', 'pipe', 'pipe'],
+      env: { ...process.env, PORT: String(PROXY_PORT) }
+    });
+    serverProc.stdout.on('data', (d) => {
+      const msg = d.toString().trim();
+      if (msg.includes('PLUGIN') || msg.includes('CLIENT') || msg.includes('IFRAME')) {
+        console.log(`  [Server] ${msg.substring(0, 120)}`);
+      }
+    });
+    serverProc.stderr.on('data', () => {});
+
+    if (!(await waitForServer(PROXY_PORT))) {
+      throw new Error('Proxy server failed to start');
+    }
+    console.log('[Setup] Proxy server started');
+
+    // 3. Launch Chrome with extension
+    console.log('[Setup] Launching Chrome with extension...');
+    chromeProc = spawn(CHROME_PATH, [
+      `--user-data-dir=${USER_DATA_DIR}`,
+      '--no-first-run',
+      '--no-default-browser-check',
+      '--disable-background-timer-throttling',
+      '--disable-backgrounding-occluded-windows',
+      '--disable-renderer-backgrounding',
+      `--load-extension=${TEST_EXT_DIR}`,
+      '--enable-features=AutomationControlled',
+      'about:blank'
+    ], {
+      detached: false,
+      stdio: 'ignore'
+    });
+
+    console.log('[Setup] Waiting for extension to connect...');
+    await sleep(5000);
+
+    // 4. Connect Playwright
+    console.log('[Setup] Connecting Playwright...');
+    browser = await chromium.connectOverCDP(CDP_URL, { timeout: 15000 });
+    console.log('[Setup] Connected!\n');
+
+    const context = browser.contexts()[0];
+    const pages = context.pages();
+    let page = pages.find(p => p.url() === 'about:blank') || pages[0];
+    if (!page) page = await context.newPage();
+
+    // === TESTS ===
+
+    // Test 1: Basic page navigation
+    console.log('[Test 1] Basic page navigation...');
+    try {
+      await page.goto('https://example.com', { waitUntil: 'domcontentloaded', timeout: 10000 });
+      const title = await page.title();
+      console.log(`[Test 1] PASS - title: "${title}"`);
+      passed++;
+    } catch (e) {
+      console.error(`[Test 1] FAIL - ${e.message}`);
+      failed++;
+    }
+
+    // Test 2: Fill input on main page
+    console.log('\n[Test 2] Fill input on main page...');
+    try {
+      await page.goto(`file://${path.join(__dirname, 'iframe-test-page.html')}`, { waitUntil: 'domcontentloaded', timeout: 10000 });
+      await page.fill('#main-input-1', 'E2E test');
+      const val = await page.inputValue('#main-input-1');
+      if (val === 'E2E test') {
+        console.log(`[Test 2] PASS - value: "${val}"`);
+        passed++;
+      } else {
+        console.error(`[Test 2] FAIL - expected "E2E test", got "${val}"`);
+        failed++;
+      }
+    } catch (e) {
+      console.error(`[Test 2] FAIL - ${e.message}`);
+      failed++;
+    }
+
+    // Test 3: Same-origin iframe fill
+    console.log('\n[Test 3] Same-origin iframe fill...');
+    try {
+      const frame = page.frameLocator('#same-origin-iframe');
+      await frame.locator('#iframe-input-1').fill('iframe works', { timeout: 10000 });
+      const val = await frame.locator('#iframe-input-1').inputValue({ timeout: 5000 });
+      if (val === 'iframe works') {
+        console.log(`[Test 3] PASS - value: "${val}"`);
+        passed++;
+      } else {
+        console.error(`[Test 3] FAIL - expected "iframe works", got "${val}"`);
+        failed++;
+      }
+    } catch (e) {
+      console.error(`[Test 3] FAIL - ${e.message.substring(0, 100)}`);
+      failed++;
+    }
+
+    // Test 4: Create new page
+    console.log('\n[Test 4] Create new page...');
+    try {
+      const newPage = await context.newPage();
+      await newPage.goto('https://example.com', { waitUntil: 'domcontentloaded', timeout: 10000 });
+      const title = await newPage.title();
+      await newPage.close();
+      console.log(`[Test 4] PASS - new page title: "${title}"`);
+      passed++;
+    } catch (e) {
+      console.error(`[Test 4] FAIL - ${e.message}`);
+      failed++;
+    }
+
+    // Test 5: Page.getFrameTree
+    console.log('\n[Test 5] CDP Page.getFrameTree...');
+    try {
+      const cdpSession = await page.context().newCDPSession(page);
+      const frameTree = await cdpSession.send('Page.getFrameTree');
+      const mainFrame = frameTree.frameTree.frame;
+      const childCount = frameTree.frameTree.childFrames?.length || 0;
+      await cdpSession.detach();
+      console.log(`[Test 5] PASS - main frame: ${mainFrame.id} children: ${childCount}`);
+      passed++;
+    } catch (e) {
+      console.error(`[Test 5] FAIL - ${e.message}`);
+      failed++;
+    }
+
+    // Test 6: Target.setAutoAttach event count
+    console.log('\n[Test 6] Target.setAutoAttach events...');
+    try {
+      const cdpSession = await page.context().newCDPSession(page);
+      let eventCount = 0;
+      cdpSession.on('Target.attachedToTarget', () => eventCount++);
+      await cdpSession.send('Target.setAutoAttach', {
+        autoAttach: true,
+        waitForDebuggerOnStart: false,
+        flatten: true
+      });
+      await sleep(3000);
+      await cdpSession.detach();
+      console.log(`[Test 6] PASS - attachedToTarget events: ${eventCount}`);
+      passed++;
+    } catch (e) {
+      console.error(`[Test 6] FAIL - ${e.message}`);
+      failed++;
+    }
+
+    // Test 7: Douyin page (custom protocol blocking) - no disconnect
+    console.log('\n[Test 7] Douyin custom protocol (no disconnect)...');
+    try {
+      await page.goto('https://www.douyin.com', { waitUntil: 'domcontentloaded', timeout: 20000 });
+      await sleep(3000);
+      // If we get here without disconnect, the test passes
+      const url = page.url();
+      if (url.includes('douyin')) {
+        console.log(`[Test 7] PASS - page alive at ${url.substring(0, 50)}`);
+        passed++;
+      } else {
+        console.error(`[Test 7] FAIL - unexpected URL: ${url}`);
+        failed++;
+      }
+    } catch (e) {
+      console.error(`[Test 7] FAIL (possible disconnect) - ${e.message.substring(0, 120)}`);
+      failed++;
+    }
+
+  } catch (e) {
+    console.error(`\n!!! FATAL: ${e.message}`);
+    failed++;
+  } finally {
+    // Cleanup
+    console.log('\n[Cleanup] Tearing down...');
+    if (browser) {
+      try { await browser.close(); } catch {}
+    }
+    if (chromeProc) {
+      try { chromeProc.kill('SIGKILL'); } catch {}
+    }
+    if (serverProc) {
+      try { serverProc.kill('SIGKILL'); } catch {}
+    }
+    // Kill any leftover processes on our port
+    const { execSync } = require('child_process');
+    try { execSync(`lsof -ti :${PROXY_PORT} | xargs kill -9 2>/dev/null`, { stdio: 'ignore' }); } catch {}
+    try {
+      if (fs.existsSync(USER_DATA_DIR)) {
+        fs.rmSync(USER_DATA_DIR, { recursive: true });
+      }
+    } catch {}
+
+    console.log('\n' + '='.repeat(60));
+    console.log(`  Results: ${passed} passed, ${failed} failed`);
+    console.log('='.repeat(60));
+
+    process.exit(failed > 0 ? 1 : 0);
+  }
+}
+
+runTest();

package/tests/iframe-test-page.html

@@ -0,0 +1,89 @@
+<!DOCTYPE html>
+<html lang="zh-CN">
+<head>
+  <meta charset="UTF-8">
+  <title>IFrame Test Page</title>
+  <style>
+    body { font-family: sans-serif; padding: 20px; }
+    .section { margin: 20px 0; padding: 15px; border: 1px solid #ccc; border-radius: 8px; }
+    h2 { margin-top: 0; color: #333; }
+    iframe { width: 100%; height: 200px; border: 2px solid #666; margin: 10px 0; }
+    input { padding: 8px; font-size: 14px; margin: 5px; }
+    button { padding: 8px 16px; font-size: 14px; cursor: pointer; }
+    #status { margin-top: 10px; padding: 10px; background: #f0f0f0; border-radius: 4px; }
+  </style>
+</head>
+<body>
+  <h1>CDP Tunnel - IFrame Test Page</h1>
+
+  <div class="section">
+    <h2>Main Page Inputs</h2>
+    <input id="main-input-1" type="text" placeholder="Main input 1" />
+    <input id="main-input-2" type="text" placeholder="Main input 2" />
+    <button id="main-btn" onclick="document.getElementById('status').textContent='Main button clicked at ' + new Date().toISOString()">Main Button</button>
+    <div id="status"></div>
+  </div>
+
+  <div class="section">
+    <h2>Same-Origin IFrame</h2>
+    <iframe id="same-origin-iframe" srcdoc="
+      <html>
+        <body style='padding:10px; font-family:sans-serif;'>
+          <h3>Same-Origin IFrame Content</h3>
+          <input id='iframe-input-1' type='text' placeholder='Same-origin input 1' />
+          <input id='iframe-input-2' type='text' placeholder='Same-origin input 2' />
+          <button id='iframe-btn' onclick=\"document.getElementById('iframe-result').textContent='Iframe button clicked!'\">
+            Iframe Button
+          </button>
+          <div id='iframe-result'></div>
+        </body>
+      </html>
+    "></iframe>
+  </div>
+
+  <div class="section">
+    <h2>Cross-Origin IFrame (Wikipedia)</h2>
+    <iframe id="cross-origin-iframe" src="https://en.wikipedia.org/wiki/Main_Page" sandbox="allow-scripts allow-same-origin allow-forms"></iframe>
+  </div>
+
+  <div class="section">
+    <h2>Nested IFrame (same-origin, 2 levels)</h2>
+    <iframe id="nested-iframe" srcdoc="
+      <html>
+        <body style='padding:10px; font-family:sans-serif;'>
+          <h3>Level 1 IFrame</h3>
+          <input id='l1-input' type='text' placeholder='Level 1 input' />
+          <iframe id='nested-inner' srcdoc=\"
+            <html>
+              <body style='padding:10px; font-family:sans-serif;'>
+                <h4>Level 2 Nested IFrame</h4>
+                <input id='l2-input' type='text' placeholder='Level 2 input' />
+              </body>
+            </html>
+          \" width='100%' height='120' style='border:1px solid #999;'></iframe>
+        </body>
+      </html>
+    "></iframe>
+  </div>
+
+  <div class="section">
+    <h2>Dynamic IFrame (created by JS)</h2>
+    <button id="create-iframe-btn" onclick="createDynamicIframe()">Create Dynamic IFrame</button>
+    <div id="dynamic-iframe-container"></div>
+    <script>
+      function createDynamicIframe() {
+        const container = document.getElementById('dynamic-iframe-container');
+        const iframe = document.createElement('iframe');
+        iframe.id = 'dynamic-iframe';
+        iframe.width = '100%';
+        iframe.height = '150';
+        iframe.style.border = '2px solid red';
+        iframe.style.marginTop = '10px';
+        iframe.srcdoc = '<html><body style="padding:10px; font-family:sans-serif;"><h3>Dynamic IFrame</h3><input id="dyn-input" type="text" placeholder="Dynamic iframe input" /></body></html>';
+        container.appendChild(iframe);
+        document.getElementById('status').textContent = 'Dynamic iframe created';
+      }
+    </script>
+  </div>
+</body>
+</html>

package/tests/test-douyin-iframe.js

@@ -0,0 +1,171 @@
+const { chromium } = require('playwright');
+
+const SERVER_URL = process.env.CDP_SERVER || 'http://localhost:9221';
+const DOUYIN_URL = 'https://www.douyin.com/user/MS4wLjABAAAAnKeRN8QUgooS1pPRqOf_N_jnuztzUyocl0_vUndQFJs?modal_id=7635666432337351530';
+
+async function sleep(ms) {
+  return new Promise(r => setTimeout(r, ms));
+}
+
+async function main() {
+  console.log('=== Douyin IFrame Disconnect Test ===');
+  console.log(`Server: ${SERVER_URL}\n`);
+
+  let browser;
+  try {
+    console.log('[1] Connecting to CDP tunnel...');
+    browser = await chromium.connectOverCDP(SERVER_URL, { timeout: 15000 });
+    console.log('[1] Connected!\n');
+
+    const context = browser.contexts()[0];
+    const page = context.pages()[0] || await context.newPage();
+
+    console.log('[2] Navigating to Douyin page...');
+    await page.goto(DOUYIN_URL, { waitUntil: 'domcontentloaded', timeout: 30000 });
+    console.log(`[2] Page loaded: ${page.url()}\n`);
+
+    await sleep(3000);
+    console.log('[3] Waiting for page to fully render...');
+    await sleep(2000);
+
+    // Check frame tree first
+    console.log('[4] Checking frame tree...');
+    try {
+      const cdpSession = await page.context().newCDPSession(page);
+      const frameTree = await cdpSession.send('Page.getFrameTree');
+
+      function printFrame(tree, indent) {
+        if (!tree || !tree.frame) return;
+        const pad = '  '.repeat(indent);
+        console.log(`${pad}Frame: id=${tree.frame.id} url=${(tree.frame.url || '').substring(0, 80)}`);
+        if (tree.childFrames) {
+          for (const child of tree.childFrames) printFrame(child, indent + 1);
+        }
+      }
+      printFrame(frameTree.frameTree, 0);
+      await cdpSession.detach();
+    } catch (e) {
+      console.error('[4] Frame tree error:', e.message);
+    }
+    console.log('');
+
+    // Try to find and click the entry button
+    // The button has data-popupid attribute and contains an SVG
+    console.log('[5] Looking for the entry button...');
+    const selectors = [
+      '[data-popupid]',
+      'svg.wNbQukcA',
+      '.r68hW_1W',
+    ];
+
+    let clicked = false;
+    for (const sel of selectors) {
+      try {
+        const el = page.locator(sel).first();
+        const count = await el.count();
+        if (count > 0) {
+          console.log(`[5] Found element with selector: ${sel}`);
+          await el.click({ timeout: 5000 });
+          console.log(`[5] Clicked!`);
+          clicked = true;
+          break;
+        }
+      } catch (e) {
+        console.log(`[5] Selector ${sel}: ${e.message.substring(0, 80)}`);
+      }
+    }
+
+    if (!clicked) {
+      console.log('[5] Could not find entry button with known selectors, trying to list clickable elements...');
+      const buttons = await page.$$eval('[data-popupid]', els => els.map(e => ({
+        tag: e.tagName,
+        popupid: e.getAttribute('data-popupid'),
+        html: e.innerHTML.substring(0, 100)
+      })));
+      console.log('[5] Elements with data-popupid:', JSON.stringify(buttons, null, 2));
+    }
+
+    await sleep(3000);
+
+    // Check frame tree again after click
+    console.log('\n[6] Checking frame tree AFTER click...');
+    try {
+      const cdpSession = await page.context().newCDPSession(page);
+      const frameTree = await cdpSession.send('Page.getFrameTree');
+      printFrameTree(frameTree.frameTree, 0);
+      await cdpSession.detach();
+    } catch (e) {
+      console.error('[6] Frame tree error:', e.message);
+    }
+
+    // List all iframes on the page
+    console.log('\n[7] Listing all iframes...');
+    const iframes = await page.$$eval('iframe', els => els.map(e => ({
+      id: e.id,
+      src: e.src || e.getAttribute('srcdoc')?.substring(0, 50) || '(empty)',
+      className: e.className,
+      visible: e.offsetParent !== null
+    })));
+    console.log('[7] Iframes found:', JSON.stringify(iframes, null, 2));
+
+    // Try to find and interact with iframe input
+    console.log('\n[8] Trying to find input in iframes...');
+    const frames = page.frames();
+    console.log(`[8] Total frames: ${frames.length}`);
+    for (let i = 0; i < frames.length; i++) {
+      const frame = frames[i];
+      console.log(`[8] Frame ${i}: url=${frame.url().substring(0, 80)} name=${frame.name()}`);
+
+      if (frame === page.mainFrame()) continue;
+
+      try {
+        const inputs = await frame.locator('input, textarea').count();
+        console.log(`[8]   Found ${inputs} input/textarea elements`);
+
+        if (inputs > 0) {
+          console.log(`[8]   Attempting to click first input in frame ${i}...`);
+          const input = frame.locator('input, textarea').first();
+          await input.click({ timeout: 5000 });
+          console.log(`[8]   CLICK SUCCEEDED - no disconnect!`);
+
+          await sleep(1000);
+          await input.fill('test input');
+          console.log(`[8]   FILL SUCCEEDED`);
+        }
+      } catch (e) {
+        console.error(`[8]   Frame ${i} error: ${e.message.substring(0, 120)}`);
+      }
+    }
+
+    console.log('\n=== Test completed - Playwright did NOT disconnect ===');
+
+  } catch (e) {
+    console.error('\n!!! FATAL ERROR - Possible disconnect !!!');
+    console.error('Error:', e.message);
+    console.error('This might indicate Playwright disconnected');
+  } finally {
+    if (browser) {
+      try {
+        await browser.close();
+        console.log('\nBrowser closed normally');
+      } catch (e) {
+        console.error('\nBrowser close FAILED:', e.message);
+        console.error('This confirms Playwright disconnected');
+      }
+    }
+  }
+}
+
+function printFrameTree(tree, indent) {
+  if (!tree || !tree.frame) return;
+  const pad = '  '.repeat(indent);
+  console.log(`${pad}Frame: id=${tree.frame.id} url=${(tree.frame.url || '').substring(0, 80)}`);
+  if (tree.childFrames) {
+    for (const child of tree.childFrames) printFrameTree(child, indent + 1);
+  }
+}
+
+main().catch(e => {
+  console.error('UNHANDLED:', e);
+  process.exit(1);
+});

package/tests/test-iframe-debug.js

@@ -0,0 +1,204 @@
+const { chromium } = require('playwright');
+
+const SERVER_URL = process.env.CDP_SERVER || 'http://localhost:9221';
+const TEST_PAGE = `file://${__dirname}/iframe-test-page.html`;
+
+async function sleep(ms) {
+  return new Promise(r => setTimeout(r, ms));
+}
+
+async function main() {
+  console.log('=== IFrame Debug Test ===');
+  console.log(`Server: ${SERVER_URL}`);
+  console.log(`Test page: ${TEST_PAGE}\n`);
+
+  let browser;
+  try {
+    console.log('[1] Connecting to CDP tunnel...');
+    browser = await chromium.connectOverCDP(SERVER_URL, {
+      timeout: 10000
+    });
+    console.log('[1] Connected!\n');
+
+    const context = browser.contexts()[0];
+    if (!context) {
+      throw new Error('No default context found');
+    }
+
+    const pages = context.pages();
+    let page;
+    if (pages.length > 0) {
+      page = pages[0];
+      console.log(`[2] Using existing page: ${page.url()}`);
+    } else {
+      page = await context.newPage();
+      console.log('[2] Created new page');
+    }
+
+    console.log(`[2] Navigating to test page...`);
+    await page.goto(TEST_PAGE, { waitUntil: 'domcontentloaded', timeout: 15000 });
+    console.log(`[2] Page loaded: ${page.url()}\n`);
+
+    // --- Test 1: Main page input ---
+    console.log('[Test 1] Main page input...');
+    try {
+      await page.fill('#main-input-1', 'Hello from main');
+      const val1 = await page.inputValue('#main-input-1');
+      console.log(`[Test 1] OK - value: "${val1}"\n`);
+    } catch (e) {
+      console.error(`[Test 1] FAIL: ${e.message}\n`);
+    }
+
+    // --- Test 2: Main page button ---
+    console.log('[Test 2] Main page button click...');
+    try {
+      await page.click('#main-btn');
+      await sleep(500);
+      const status = await page.textContent('#status');
+      console.log(`[Test 2] OK - status: "${status}"\n`);
+    } catch (e) {
+      console.error(`[Test 2] FAIL: ${e.message}\n`);
+    }
+
+    // --- Test 3: Same-origin iframe ---
+    console.log('[Test 3] Same-origin iframe input...');
+    try {
+      const frame = page.frameLocator('#same-origin-iframe');
+      const input = frame.locator('#iframe-input-1');
+      await input.fill('Hello from iframe');
+      const val = await input.inputValue();
+      console.log(`[Test 3] OK - value: "${val}"\n`);
+    } catch (e) {
+      console.error(`[Test 3] FAIL: ${e.message}\n`);
+    }
+
+    // --- Test 4: Same-origin iframe button ---
+    console.log('[Test 4] Same-origin iframe button click...');
+    try {
+      const frame = page.frameLocator('#same-origin-iframe');
+      await frame.locator('#iframe-btn').click();
+      await sleep(500);
+      const result = await frame.locator('#iframe-result').textContent();
+      console.log(`[Test 4] OK - result: "${result}"\n`);
+    } catch (e) {
+      console.error(`[Test 4] FAIL: ${e.message}\n`);
+    }
+
+    // --- Test 5: Cross-origin iframe (Wikipedia) ---
+    console.log('[Test 5] Cross-origin iframe (Wikipedia)...');
+    try {
+      const frame = page.frameLocator('#cross-origin-iframe');
+      // Just try to access the frame - this will likely fail
+      const title = await frame.locator('h1').first().textContent({ timeout: 5000 });
+      console.log(`[Test 5] OK - title: "${title}"\n`);
+    } catch (e) {
+      console.error(`[Test 5] FAIL (expected): ${e.message}\n`);
+    }
+
+    // --- Test 6: Nested iframe ---
+    console.log('[Test 6] Nested iframe (level 1 input)...');
+    try {
+      const frame = page.frameLocator('#nested-iframe');
+      await frame.locator('#l1-input').fill('Level 1');
+      const val = await frame.locator('#l1-input').inputValue();
+      console.log(`[Test 6] OK - value: "${val}"\n`);
+    } catch (e) {
+      console.error(`[Test 6] FAIL: ${e.message}\n`);
+    }
+
+    // --- Test 7: Nested iframe level 2 ---
+    console.log('[Test 7] Nested iframe (level 2 input)...');
+    try {
+      const frame = page.frameLocator('#nested-iframe').frameLocator('#nested-inner');
+      await frame.locator('#l2-input').fill('Level 2');
+      const val = await frame.locator('#l2-input').inputValue();
+      console.log(`[Test 7] OK - value: "${val}"\n`);
+    } catch (e) {
+      console.error(`[Test 7] FAIL: ${e.message}\n`);
+    }
+
+    // --- Test 8: Dynamic iframe ---
+    console.log('[Test 8] Dynamic iframe...');
+    try {
+      await page.click('#create-iframe-btn');
+      await sleep(1000);
+      const frame = page.frameLocator('#dynamic-iframe');
+      await frame.locator('#dyn-input').fill('Dynamic!');
+      const val = await frame.locator('#dyn-input').inputValue();
+      console.log(`[Test 8] OK - value: "${val}"\n`);
+    } catch (e) {
+      console.error(`[Test 8] FAIL: ${e.message}\n`);
+    }
+
+    // --- Test 9: Page.getFrameTree via CDP directly ---
+    console.log('[Test 9] CDP Page.getFrameTree...');
+    try {
+      const cdpSession = await page.context().newCDPSession(page);
+      const frameTree = await cdpSession.send('Page.getFrameTree');
+      console.log(`[Test 9] Frame tree:`);
+      printFrameTree(frameTree.frameTree, 0);
+      await cdpSession.detach();
+      console.log('');
+    } catch (e) {
+      console.error(`[Test 9] FAIL: ${e.message}\n`);
+    }
+
+    // --- Test 10: Target.setAutoAttach + Target.attachedToTarget ---
+    console.log('[Test 10] CDP Target.setAutoAttach + iframe sessions...');
+    try {
+      const cdpSession = await page.context().newCDPSession(page);
+
+      let attachedEventCount = 0;
+      cdpSession.on('Target.attachedToTarget', (event) => {
+        attachedEventCount++;
+        console.log(`[Test 10] Target.attachedToTarget event #${attachedEventCount}:`);
+        console.log(`  sessionId: ${event.sessionId}`);
+        console.log(`  targetInfo.type: ${event.targetInfo?.type}`);
+        console.log(`  targetInfo.targetId: ${event.targetInfo?.targetId}`);
+        console.log(`  targetInfo.url: ${event.targetInfo?.url}`);
+        console.log(`  waitingForDebugger: ${event.waitingForDebugger}`);
+      });
+
+      cdpSession.on('Target.targetCreated', (event) => {
+        console.log(`[Test 10] Target.targetCreated: type=${event.targetInfo?.type} targetId=${event.targetInfo?.targetId}`);
+      });
+
+      await cdpSession.send('Target.setAutoAttach', {
+        autoAttach: true,
+        waitForDebuggerOnStart: false,
+        flatten: true
+      });
+
+      await sleep(3000);
+
+      console.log(`[Test 10] Total attachedToTarget events: ${attachedEventCount}`);
+      await cdpSession.detach();
+      console.log('');
+    } catch (e) {
+      console.error(`[Test 10] FAIL: ${e.message}\n`);
+    }
+
+    console.log('=== All tests completed ===');
+
+  } catch (e) {
+    console.error('Fatal error:', e);
+  } finally {
+    if (browser) {
+      await browser.close().catch(() => {});
+    }
+  }
+}
+
+function printFrameTree(tree, indent) {
+  if (!tree || !tree.frame) return;
+  const pad = '  '.repeat(indent);
+  const frame = tree.frame;
+  console.log(`${pad}Frame: id=${frame.id} url=${frame.url?.substring(0, 60)}`);
+  if (tree.childFrames) {
+    for (const child of tree.childFrames) {
+      printFrameTree(child, indent + 1);
+    }
+  }
+}
+
+main().catch(console.error);