cdp-tunnel 1.0.0

package/extension-new/background.js

@@ -0,0 +1,294 @@
+importScripts('utils/config.js');
+importScripts('utils/logger.js');
+importScripts('utils/helpers.js');
+importScripts('utils/diagnostics.js');
+importScripts('core/state.js');
+importScripts('core/websocket.js');
+importScripts('core/debugger.js');
+importScripts('cdp/response.js');
+importScripts('cdp/handler/local.js');
+importScripts('cdp/handler/special.js');
+importScripts('cdp/handler/forward.js');
+importScripts('cdp/index.js');
+importScripts('features/screencast.js');
+importScripts('features/automation-badge.js');
+
+(function() {
+  'use strict';
+
+  var keepAliveInterval = null;
+
+  function startKeepAlive() {
+    if (keepAliveInterval) {
+      clearInterval(keepAliveInterval);
+    }
+    
+    keepAliveInterval = setInterval(function() {
+      var ws = State.getWs();
+      if (ws && ws.readyState === WebSocket.OPEN) {
+        Logger.info('[KeepAlive] Sending heartbeat');
+        WebSocketManager.send({ type: 'keepalive', timestamp: Date.now() });
+      }
+    }, 20000);
+    
+    Logger.info('[KeepAlive] Started keepalive interval');
+  }
+
+  function stopKeepAlive() {
+    if (keepAliveInterval) {
+      clearInterval(keepAliveInterval);
+      keepAliveInterval = null;
+      Logger.info('[KeepAlive] Stopped keepalive interval');
+    }
+  }
+
+  function init() {
+    Logger.info('[Init] CDP Bridge starting...');
+
+    // 点击扩展图标时打开配置页面
+    chrome.action.onClicked.addListener(function(tab) {
+      Logger.info('[Action] Extension icon clicked, opening config page');
+      chrome.tabs.create({
+        url: chrome.runtime.getURL('config-page-preview.html')
+      });
+    });
+
+    State.loadPersisted().then(function(result) {
+      Logger.info('[Init] Loaded persisted state:', result);
+
+      if (result.currentTabId != null) {
+        validatePersistedState(result.currentTabId, result.isAttached);
+      }
+
+      WebSocketManager.connect();
+      startKeepAlive();
+      
+      setTimeout(function() {
+        Diagnostics.start();
+      }, 2000);
+    });
+  }
+
+  function validatePersistedState(tabId, expectedAttached) {
+    chrome.tabs.get(tabId, function(tab) {
+      if (chrome.runtime.lastError) {
+        Logger.info('[Init] Failed to validate persisted state, resetting');
+        State.persist(null, false);
+        return;
+      }
+      if (!tab || !tab.id) {
+        Logger.info('[Init] Persisted tab no longer exists, resetting state');
+        State.persist(null, false);
+        return;
+      }
+
+      DebuggerManager.getActualAttachState(tabId).then(function(isActuallyAttached) {
+        if (expectedAttached && !isActuallyAttached) {
+          Logger.info('[Init] Persisted state mismatch, resetting');
+          State.persist(null, false);
+        }
+      }).catch(function() {
+        Logger.info('[Init] Failed to get attach state, resetting');
+        State.persist(null, false);
+      });
+    });
+  }
+
+  chrome.debugger.onEvent.addListener(function(source, method, params) {
+    if (method === 'Runtime.bindingCalled' && params && params.name === '__notifyChange') {
+      Screencast.onNotify(source.tabId);
+      return;
+    }
+
+    DebuggerManager.handleDebuggerEvent(source, method, params);
+  });
+
+  chrome.debugger.onDetach.addListener(function(source, reason) {
+    DebuggerManager.handleDetach(source, reason);
+  });
+
+  chrome.tabs.onRemoved.addListener(function(tabId) {
+    Logger.info('[Tabs] Tab removed:', tabId);
+
+    State.removeAttachedTab(tabId);
+    Screencast.stopPolling(tabId);
+    AutomationBadge.remove(tabId);
+
+    var sessionId = State.findSessionByTabId(tabId);
+    if (sessionId) {
+      var targetId = State.getTargetIdBySession(sessionId);
+      EventBuilder.send('Target.targetDestroyed', { targetId: targetId });
+      EventBuilder.send('Target.detachedFromTarget', {
+        sessionId: sessionId,
+        targetId: targetId
+      });
+      State.unmapSession(sessionId);
+    }
+
+    if (State.getCurrentTabId() === tabId) {
+      State.persist(null, false);
+    }
+  });
+
+  chrome.tabs.onUpdated.addListener(function(tabId, changeInfo, tab) {
+    if (changeInfo.status === 'complete' && State.isTabAttached(tabId)) {
+      AutomationBadge.inject(tabId);
+    }
+  });
+
+  chrome.tabs.onCreated.addListener(function(tab) {
+    Logger.info('[Tabs] Tab created:', tab.id, tab.url, 'openerTabId:', tab.openerTabId);
+    
+    if (!State.hasConnectedClient()) {
+      Logger.info('[Tabs] No connected client, skipping');
+      return;
+    }
+    
+    var tabId = tab.id;
+    
+    var tabUrl = tab.url || tab.pendingUrl || 'about:blank';
+    if (State.hasPendingCreatedTabUrl(tabUrl)) {
+      Logger.info('[Tabs] Tab created by Target.createTarget, will be handled by createTarget:', tabUrl);
+      State.removePendingCreatedTabUrl(tabUrl);
+      return;
+    }
+    
+    var openerTabId = tab.openerTabId;
+    var isOpenerControlled = openerTabId && State.isTabAttached(openerTabId);
+    
+    if (!isOpenerControlled) {
+      Logger.info('[Tabs] Tab not controlled (no controlled opener), skipping. openerTabId:', openerTabId);
+      return;
+    }
+    
+    Logger.info('[Tabs] Tab has controlled opener:', openerTabId, ', will attach');
+    
+    LocalHandler.getTargetInfoById(String(tabId)).then(function(targetInfo) {
+      if (!targetInfo) return;
+      
+      var targetId = targetInfo.targetId;
+      
+      if (State.hasEmittedTarget(targetId)) {
+        Logger.info('[Tabs] Target already emitted, skipping:', targetId);
+        return;
+      }
+      
+      State.addEmittedTarget(targetId);
+      
+      EventBuilder.send('Target.targetCreated', { targetInfo: targetInfo });
+      
+      return DebuggerManager.attach(tabId).then(function(attached) {
+        if (!attached) return;
+        
+        var sessionId = CDPUtils.generateSessionId();
+        State.mapSession(sessionId, tabId, targetId);
+        
+        AutomationBadge.inject(tabId);
+        
+        EventBuilder.send('Target.attachedToTarget', {
+          sessionId: sessionId,
+          targetInfo: targetInfo,
+          waitingForDebugger: false
+        });
+      });
+    });
+  });
+
+  chrome.runtime.onInstalled.addListener(function(details) {
+    Logger.info('[Runtime] Extension installed/updated:', details.reason);
+    State.persist(null, false);
+    WebSocketManager.setBadgeStatus('ON');
+    init();
+  });
+
+  chrome.runtime.onStartup.addListener(function() {
+    Logger.info('[Runtime] Browser started');
+    init();
+  });
+
+  chrome.runtime.onMessage.addListener(function(message, sender, sendResponse) {
+    if (message.type === 'reconnect') {
+      Logger.info('[Runtime] Received reconnect request from popup');
+      var ws = State.getWs();
+      if (ws) {
+        ws.close();
+      }
+      WebSocketManager.connect();
+      sendResponse({ success: true });
+    } else if (message.type === 'getState') {
+      var ws = State.getWs();
+      var isConnected = ws && ws.readyState === WebSocket.OPEN;
+      
+      chrome.storage.local.get(['wsAddress'], function(result) {
+        var attachedTabs = State.getAttachedTabIds();
+        var cdpClients = State.getCDPClients() || [];
+        
+        if (attachedTabs.length === 0) {
+          sendResponse({
+            connected: isConnected,
+            serverAddress: result.wsAddress || Config.WS_URL,
+            cdpClients: cdpClients,
+            attachedPages: []
+          });
+          return;
+        }
+        
+        var attachedPages = [];
+        var pendingTabs = attachedTabs.length;
+        
+        attachedTabs.forEach(function(tabId) {
+          chrome.tabs.get(tabId, function(tab) {
+            pendingTabs--;
+            
+            if (chrome.runtime.lastError) {
+              Logger.info('[Runtime] Tab not found:', tabId);
+            } else if (tab) {
+              attachedPages.push({
+                tabId: tabId,
+                title: tab.title || 'Untitled',
+                url: tab.url || ''
+              });
+            }
+            
+            if (pendingTabs === 0) {
+              sendResponse({
+                connected: isConnected,
+                serverAddress: result.wsAddress || Config.WS_URL,
+                cdpClients: cdpClients,
+                attachedPages: attachedPages
+              });
+            }
+          });
+        });
+      });
+      
+      return true;
+    } else if (message.type === 'connect') {
+      var address = message.serverAddress;
+      if (address) {
+        Logger.info('[Runtime] Saving and connecting to:', address);
+        chrome.storage.local.set({ wsAddress: address }, function() {
+          var ws = State.getWs();
+          if (ws) {
+            ws.close();
+          }
+          WebSocketManager.connect();
+          sendResponse({ success: true });
+        });
+      } else {
+        sendResponse({ success: false, error: 'No address provided' });
+      }
+      return true;
+    } else if (message.type === 'disconnect') {
+      Logger.info('[Runtime] Disconnecting...');
+      var ws = State.getWs();
+      if (ws) {
+        ws.close();
+      }
+      sendResponse({ success: true });
+    }
+    return true;
+  });
+
+  init();
+})();

package/extension-new/cdp/handler/forward.js

@@ -0,0 +1,44 @@
+var ForwardHandler = (function() {
+  function execute(context) {
+    var id = context.id;
+    var method = context.method;
+    var params = context.params;
+    var sessionId = context.sessionId;
+
+    var tabId = resolveTabId(sessionId);
+
+    if (!tabId) {
+      Logger.warn('[Forward] No tabId for command:', method);
+      return Promise.resolve({});
+    }
+
+    if (!State.isTabAttached(tabId)) {
+      Logger.warn('[Forward] Tab not attached, skipping command:', method, 'tabId:', tabId);
+      return Promise.resolve({});
+    }
+
+    Logger.debug('[Forward]', method, '-> tabId:', tabId);
+    return chrome.debugger.sendCommand({ tabId: tabId }, method, params).then(function(result) {
+      return result || {};
+    });
+  }
+
+  function resolveTabId(sessionId) {
+    if (sessionId) {
+      return State.getTabIdBySession(sessionId);
+    }
+    var currentTabId = State.getCurrentTabId();
+    if (currentTabId != null && State.isTabAttached(currentTabId)) {
+      return currentTabId;
+    }
+    var attachedTabs = State.getAttachedTabIds();
+    if (attachedTabs.length > 0) {
+      return attachedTabs[0];
+    }
+    return null;
+  }
+
+  return {
+    execute: execute
+  };
+})();

package/extension-new/cdp/handler/local.js

@@ -0,0 +1,233 @@
+var LocalHandler = (function() {
+  function browserGetVersion() {
+    var userAgent = navigator.userAgent || '';
+    var chromeVersion = CDPUtils.getChromeVersion(userAgent);
+    return {
+      protocolVersion: '1.3',
+      product: chromeVersion ? 'Chrome/' + chromeVersion : 'Chrome',
+      revision: '',
+      userAgent: userAgent,
+      jsVersion: ''
+    };
+  }
+
+  function browserClose() {
+    return State.cleanupAllTabs().then(function() {
+      return {};
+    });
+  }
+
+  function getWindowForTarget() {
+    return {
+      windowId: 1,
+      bounds: { left: 0, top: 0, width: 1920, height: 1080, windowState: 'normal' }
+    };
+  }
+
+  function getWindowBounds() {
+    return {
+      bounds: { left: 0, top: 0, width: 1920, height: 1080, windowState: 'normal' }
+    };
+  }
+
+  function targetSetDiscoverTargets(params) {
+    State.setDiscoverTargets(!!(params && params.discover));
+    
+    if (params && params.discover) {
+      return getTargetInfos().then(function(targets) {
+        targets.forEach(function(targetInfo) {
+          EventBuilder.send('Target.targetCreated', { targetInfo: targetInfo });
+        });
+        return {};
+      });
+    }
+    return Promise.resolve({});
+  }
+
+  function targetGetTargets() {
+    return getTargetInfos().then(function(targetInfos) {
+      return { targetInfos: targetInfos };
+    });
+  }
+
+  function targetGetTargetInfo(params) {
+    return getFallbackTargetId().then(function(fallbackId) {
+      var targetId = (params && params.targetId) || fallbackId;
+      if (!targetId) {
+        throw new Error('targetId is required');
+      }
+      return getTargetInfoById(targetId).then(function(targetInfo) {
+        if (!targetInfo) {
+          throw new Error('Target not found');
+        }
+        return { targetInfo: targetInfo };
+      });
+    });
+  }
+
+  function targetCreateBrowserContext() {
+    var browserContextId = 'context-' + Date.now() + '-' + Math.random().toString(36).slice(2, 9);
+    State.addBrowserContext(browserContextId);
+    return { browserContextId: browserContextId };
+  }
+
+  function targetGetBrowserContexts() {
+    return { browserContextIds: State.getBrowserContexts() };
+  }
+
+  function targetDisposeBrowserContext(params) {
+    if (params && params.browserContextId) {
+      State.removeBrowserContext(params.browserContextId);
+    }
+    return {};
+  }
+
+  function targetAttachToBrowserTarget() {
+    return { sessionId: 'browser-session' };
+  }
+
+  function systemInfoGetInfo() {
+    return {
+      gpu: { devices: [], drivers: [], auxAttributes: {}, featureStatus: {} },
+      modelName: 'CDP Bridge',
+      modelVersion: '1.0.0',
+      commandLine: ''
+    };
+  }
+
+  function systemInfoGetProcessInfo() {
+    return { processInfo: [] };
+  }
+
+  function tetheringBind() {
+    return { port: 0 };
+  }
+
+  function ioRead() {
+    return { data: '', eof: true };
+  }
+
+  function ioResolveBlob() {
+    return { uuid: 'mock-uuid' };
+  }
+
+  function schemaGetDomains() {
+    return {
+      domains: [
+        { name: 'Page', version: '1.0' },
+        { name: 'Runtime', version: '1.0' },
+        { name: 'Network', version: '1.0' },
+        { name: 'DOM', version: '1.0' },
+        { name: 'Target', version: '1.0' }
+      ]
+    };
+  }
+
+  function emptyResult() {
+    return {};
+  }
+
+  function emptyArray() {
+    return { items: [] };
+  }
+
+  function emptyObject() {
+    return {};
+  }
+
+  function getTargetInfos() {
+    return chrome.debugger.getTargets().then(function(targets) {
+      return targets.map(mapToTargetInfo).filter(Boolean);
+    });
+  }
+
+  function getTargetInfoById(targetId) {
+    return chrome.debugger.getTargets().then(function(targets) {
+      var match = targets.find(function(t) {
+        return t.id === targetId || String(t.tabId) === String(targetId);
+      });
+      return match ? mapToTargetInfo(match) : null;
+    });
+  }
+
+  function getFallbackTargetId() {
+    var currentTabId = State.getCurrentTabId();
+    if (currentTabId != null) {
+      return ensureTabExists(currentTabId).then(function(exists) {
+        if (exists) return String(currentTabId);
+        return getActiveTabId().then(function(activeId) {
+          if (activeId != null) return String(activeId);
+          return getTargetInfos().then(function(infos) {
+            var page = infos.find(function(t) { return t.type === 'page'; });
+            return page ? page.targetId : null;
+          });
+        });
+      });
+    }
+    return getActiveTabId().then(function(activeId) {
+      if (activeId != null) return String(activeId);
+      return getTargetInfos().then(function(infos) {
+        var page = infos.find(function(t) { return t.type === 'page'; });
+        return page ? page.targetId : null;
+      });
+    });
+  }
+
+  function getActiveTabId() {
+    return new Promise(function(resolve) {
+      chrome.tabs.query({ active: true, lastFocusedWindow: true }, function(tabs) {
+        resolve(tabs[0] ? tabs[0].id : null);
+      });
+    });
+  }
+
+  function ensureTabExists(tabId) {
+    if (tabId == null) return Promise.resolve(false);
+    return new Promise(function(resolve) {
+      chrome.tabs.get(tabId, function(tab) {
+        resolve(!!(tab && tab.id));
+      });
+    }).catch(function() {
+      return false;
+    });
+  }
+
+  function mapToTargetInfo(target) {
+    if (!target) return null;
+    return {
+      targetId: target.id || String(target.tabId),
+      type: target.type || 'page',
+      title: target.title || '',
+      url: target.url || '',
+      attached: !!target.attached,
+      canAccessOpener: false,
+      browserContextId: 'default'
+    };
+  }
+
+  return {
+    browserGetVersion: browserGetVersion,
+    browserClose: browserClose,
+    getWindowForTarget: getWindowForTarget,
+    getWindowBounds: getWindowBounds,
+    targetSetDiscoverTargets: targetSetDiscoverTargets,
+    targetGetTargets: targetGetTargets,
+    targetGetTargetInfo: targetGetTargetInfo,
+    targetCreateBrowserContext: targetCreateBrowserContext,
+    targetGetBrowserContexts: targetGetBrowserContexts,
+    targetDisposeBrowserContext: targetDisposeBrowserContext,
+    targetAttachToBrowserTarget: targetAttachToBrowserTarget,
+    systemInfoGetInfo: systemInfoGetInfo,
+    systemInfoGetProcessInfo: systemInfoGetProcessInfo,
+    tetheringBind: tetheringBind,
+    ioRead: ioRead,
+    ioResolveBlob: ioResolveBlob,
+    schemaGetDomains: schemaGetDomains,
+    emptyResult: emptyResult,
+    emptyArray: emptyArray,
+    emptyObject: emptyObject,
+    getTargetInfos: getTargetInfos,
+    getTargetInfoById: getTargetInfoById,
+    mapToTargetInfo: mapToTargetInfo
+  };
+})();