cdp-tunnel 1.0.0

package/extension-new/core/state.js

@@ -0,0 +1,384 @@
+var State = (function() {
+  var _state = {
+    ws: null,
+    reconnectTimer: null,
+    hasConnectedClient: false,
+    cdpClients: [],
+    sessionIdToTabId: new Map(),
+    sessionIdToTargetId: new Map(),
+    attachedTabIds: new Set(),
+    emittedTargets: new Set(),
+    browserContextIds: new Set(['default']),
+    autoAttachConfig: { 
+      autoAttach: false, 
+      waitForDebuggerOnStart: false, 
+      flatten: true 
+    },
+    discoverTargetsEnabled: false,
+    pendingDebuggerTabs: new Set(),
+    screencastPollingSessions: new Map(),
+    automatedTabs: new Set(),
+    currentTabId: null,
+    isAttached: false,
+    pendingCreatedTabUrls: new Set(),
+    clientIdToTabId: new Map(),
+    clientIdToSessionId: new Map()
+  };
+
+  function mapSession(sessionId, tabId, targetId) {
+    _state.sessionIdToTabId.set(sessionId, tabId);
+    _state.sessionIdToTargetId.set(sessionId, targetId);
+    _state.attachedTabIds.add(tabId);
+  }
+
+  function unmapSession(sessionId) {
+    var tabId = _state.sessionIdToTabId.get(sessionId);
+    _state.sessionIdToTabId.delete(sessionId);
+    _state.sessionIdToTargetId.delete(sessionId);
+    return tabId;
+  }
+
+  function getTabIdBySession(sessionId) {
+    return _state.sessionIdToTabId.get(sessionId);
+  }
+
+  function getTargetIdBySession(sessionId) {
+    return _state.sessionIdToTargetId.get(sessionId);
+  }
+
+  function findSessionByTabId(tabId) {
+    var entries = _state.sessionIdToTabId.entries();
+    var entry = entries.next();
+    while (!entry.done) {
+      if (entry.value[1] === tabId) {
+        return entry.value[0];
+      }
+      entry = entries.next();
+    }
+    return null;
+  }
+
+  function findSessionByTargetId(targetId) {
+    var entries = _state.sessionIdToTargetId.entries();
+    var entry = entries.next();
+    while (!entry.done) {
+      if (entry.value[1] === targetId) {
+        return entry.value[0];
+      }
+      entry = entries.next();
+    }
+    return null;
+  }
+
+  function getTabIdByTargetId(targetId) {
+    var sessionId = findSessionByTargetId(targetId);
+    if (sessionId) {
+      return _state.sessionIdToTabId.get(sessionId);
+    }
+    return null;
+  }
+
+  function hasOtherSessionForTab(tabId) {
+    var count = 0;
+    _state.sessionIdToTabId.forEach(function(mappedTabId) {
+      if (mappedTabId === tabId) {
+        count++;
+      }
+    });
+    return count > 0;
+  }
+
+  function addAttachedTab(tabId) {
+    _state.attachedTabIds.add(tabId);
+  }
+
+  function removeAttachedTab(tabId) {
+    _state.attachedTabIds.delete(tabId);
+  }
+
+  function isTabAttached(tabId) {
+    return _state.attachedTabIds.has(tabId);
+  }
+
+  function getAttachedTabIds() {
+    return Array.from(_state.attachedTabIds);
+  }
+
+  function addEmittedTarget(targetId) {
+    _state.emittedTargets.add(targetId);
+  }
+
+  function hasEmittedTarget(targetId) {
+    return _state.emittedTargets.has(targetId);
+  }
+
+  function setAutoAttachConfig(config) {
+    Object.assign(_state.autoAttachConfig, config);
+  }
+
+  function getAutoAttachConfig() {
+    return Object.assign({}, _state.autoAttachConfig);
+  }
+
+  function setDiscoverTargets(enabled) {
+    _state.discoverTargetsEnabled = enabled;
+  }
+
+  function addPendingDebuggerTab(tabId) {
+    _state.pendingDebuggerTabs.add(tabId);
+  }
+
+  function removePendingDebuggerTab(tabId) {
+    _state.pendingDebuggerTabs.delete(tabId);
+  }
+
+  function isPendingDebuggerTab(tabId) {
+    return _state.pendingDebuggerTabs.has(tabId);
+  }
+
+  function addBrowserContext(id) {
+    _state.browserContextIds.add(id);
+  }
+
+  function removeBrowserContext(id) {
+    _state.browserContextIds.delete(id);
+  }
+
+  function getBrowserContexts() {
+    return Array.from(_state.browserContextIds);
+  }
+
+  function loadPersisted() {
+    return new Promise(function(resolve) {
+      chrome.storage.local.get(['currentTabId', 'isAttached'], function(result) {
+        _state.currentTabId = result.currentTabId || null;
+        _state.isAttached = result.isAttached || false;
+        resolve(result);
+      });
+    });
+  }
+
+  function persist(tabId, attached) {
+    _state.currentTabId = tabId;
+    _state.isAttached = attached;
+    return new Promise(function(resolve) {
+      chrome.storage.local.set({ currentTabId: tabId, isAttached: attached }, resolve);
+    });
+  }
+
+  function getCurrentTabId() {
+    return _state.currentTabId;
+  }
+
+  function setCurrentTabId(tabId) {
+    _state.currentTabId = tabId;
+  }
+
+  function getWs() {
+    return _state.ws;
+  }
+
+  function setWs(ws) {
+    _state.ws = ws;
+  }
+
+  function getReconnectTimer() {
+    return _state.reconnectTimer;
+  }
+
+  function setReconnectTimer(timer) {
+    _state.reconnectTimer = timer;
+  }
+
+  function clearReconnectTimer() {
+    if (_state.reconnectTimer) {
+      clearTimeout(_state.reconnectTimer);
+      _state.reconnectTimer = null;
+    }
+  }
+
+  function hasConnectedClient() {
+    return _state.hasConnectedClient;
+  }
+
+  function setHasConnectedClient(value) {
+    _state.hasConnectedClient = value;
+  }
+
+  function addPendingCreatedTabUrl(url) {
+    _state.pendingCreatedTabUrls.add(url);
+  }
+
+  function removePendingCreatedTabUrl(url) {
+    _state.pendingCreatedTabUrls.delete(url);
+  }
+
+  function hasPendingCreatedTabUrl(url) {
+    return _state.pendingCreatedTabUrls.has(url);
+  }
+
+  function getScreencastSession(tabId) {
+    return _state.screencastPollingSessions.get(tabId);
+  }
+
+  function setScreencastSession(tabId, session) {
+    _state.screencastPollingSessions.set(tabId, session);
+  }
+
+  function deleteScreencastSession(tabId) {
+    _state.screencastPollingSessions.delete(tabId);
+  }
+
+  function addAutomatedTab(tabId) {
+    _state.automatedTabs.add(tabId);
+  }
+
+  function removeAutomatedTab(tabId) {
+    _state.automatedTabs.delete(tabId);
+  }
+
+  function getAutomatedTabs() {
+    return Array.from(_state.automatedTabs);
+  }
+
+  function clearSessionState() {
+    _state.sessionIdToTabId.clear();
+    _state.sessionIdToTargetId.clear();
+    _state.pendingDebuggerTabs.clear();
+    _state.emittedTargets.clear();
+  }
+
+  function clearAllState() {
+    clearSessionState();
+    _state.attachedTabIds.clear();
+    _state.screencastPollingSessions.clear();
+    _state.browserContextIds = new Set(['default']);
+    _state.autoAttachConfig = { 
+      autoAttach: false, 
+      waitForDebuggerOnStart: false, 
+      flatten: true 
+    };
+    _state.discoverTargetsEnabled = false;
+    _state.hasConnectedClient = false;
+  }
+
+  function cleanupAllTabs() {
+    return new Promise(function(resolve) {
+      var tabIds = Array.from(_state.attachedTabIds);
+      var promises = tabIds.map(function(tabId) {
+        return chrome.debugger.detach({ tabId: tabId }).catch(function() {});
+      });
+      Promise.all(promises).then(function() {
+        clearAllState();
+        persist(null, false).then(resolve);
+      });
+    });
+  }
+
+  function mapClientIdToTab(clientId, tabId, sessionId) {
+    _state.clientIdToTabId.set(clientId, tabId);
+    if (sessionId) {
+      _state.clientIdToSessionId.set(clientId, sessionId);
+    }
+  }
+
+  function getTabIdByClientId(clientId) {
+    return _state.clientIdToTabId.get(clientId);
+  }
+
+  function getSessionIdByClientId(clientId) {
+    return _state.clientIdToSessionId.get(clientId);
+  }
+
+  function unmapClientId(clientId) {
+    _state.clientIdToTabId.delete(clientId);
+    _state.clientIdToSessionId.delete(clientId);
+  }
+  
+  function addCDPClient(clientId, info) {
+    var exists = false;
+    for (var i = 0; i < _state.cdpClients.length; i++) {
+      if (_state.cdpClients[i].id === clientId) {
+        exists = true;
+        break;
+      }
+    }
+    if (!exists) {
+      _state.cdpClients.push({
+        id: clientId,
+        connectedAt: Date.now()
+      });
+    }
+  }
+  
+  function removeCDPClient(clientId) {
+    var newClients = [];
+    for (var i = 0; i < _state.cdpClients.length; i++) {
+      if (_state.cdpClients[i].id !== clientId) {
+        newClients.push(_state.cdpClients[i]);
+      }
+    }
+    _state.cdpClients = newClients;
+  }
+  
+  function getCDPClients() {
+    return _state.cdpClients;
+  }
+  
+  function setCDPClients(clients) {
+    _state.cdpClients = clients || [];
+  }
+
+  return {
+    mapSession: mapSession,
+    unmapSession: unmapSession,
+    getTabIdBySession: getTabIdBySession,
+    getTargetIdBySession: getTargetIdBySession,
+    findSessionByTabId: findSessionByTabId,
+    findSessionByTargetId: findSessionByTargetId,
+    getTabIdByTargetId: getTabIdByTargetId,
+    hasOtherSessionForTab: hasOtherSessionForTab,
+    addAttachedTab: addAttachedTab,
+    removeAttachedTab: removeAttachedTab,
+    isTabAttached: isTabAttached,
+    getAttachedTabIds: getAttachedTabIds,
+    addEmittedTarget: addEmittedTarget,
+    hasEmittedTarget: hasEmittedTarget,
+    setAutoAttachConfig: setAutoAttachConfig,
+    getAutoAttachConfig: getAutoAttachConfig,
+    setDiscoverTargets: setDiscoverTargets,
+    addPendingDebuggerTab: addPendingDebuggerTab,
+    removePendingDebuggerTab: removePendingDebuggerTab,
+    isPendingDebuggerTab: isPendingDebuggerTab,
+    addBrowserContext: addBrowserContext,
+    removeBrowserContext: removeBrowserContext,
+    getBrowserContexts: getBrowserContexts,
+    loadPersisted: loadPersisted,
+    persist: persist,
+    getCurrentTabId: getCurrentTabId,
+    setCurrentTabId: setCurrentTabId,
+    getWs: getWs,
+    setWs: setWs,
+    getReconnectTimer: getReconnectTimer,
+    setReconnectTimer: setReconnectTimer,
+    clearReconnectTimer: clearReconnectTimer,
+    hasConnectedClient: hasConnectedClient,
+    setHasConnectedClient: setHasConnectedClient,
+    addCDPClient: addCDPClient,
+    removeCDPClient: removeCDPClient,
+    getCDPClients: getCDPClients,
+    setCDPClients: setCDPClients,
+    addPendingCreatedTabUrl: addPendingCreatedTabUrl,
+    removePendingCreatedTabUrl: removePendingCreatedTabUrl,
+    hasPendingCreatedTabUrl: hasPendingCreatedTabUrl,
+    getScreencastSession: getScreencastSession,
+    setScreencastSession: setScreencastSession,
+    deleteScreencastSession: deleteScreencastSession,
+    addAutomatedTab: addAutomatedTab,
+    removeAutomatedTab: removeAutomatedTab,
+    getAutomatedTabs: getAutomatedTabs,
+    clearSessionState: clearSessionState,
+    clearAllState: clearAllState,
+    cleanupAllTabs: cleanupAllTabs
+  };
+})();

package/extension-new/core/websocket.js

@@ -0,0 +1,326 @@
+var WebSocketManager = (function() {
+  var _sendQueue = [];
+  var _isSending = false;
+  var _maxQueueSize = 100;
+  var _bufferThreshold = 512 * 1024;
+
+  function connect() {
+    var ws = State.getWs();
+    if (ws && (ws.readyState === WebSocket.CONNECTING || ws.readyState === WebSocket.OPEN)) {
+      return;
+    }
+
+    Config.getWsUrl(function(wsUrl) {
+      Logger.info('[WS] Connecting to', wsUrl);
+      setBadgeStatus('ON');
+
+      try {
+        ws = new WebSocket(wsUrl);
+        State.setWs(ws);
+
+        ws.onopen = function() {
+          Logger.info('[WS] Connected');
+          setBadgeStatus('ON');
+          State.clearReconnectTimer();
+          processQueue();
+          broadcastStateUpdate();
+        };
+
+        ws.onclose = function(event) {
+          Logger.info('[WS] Closed:', event.code, event.reason);
+          setBadgeStatus('OFF');
+          scheduleReconnect();
+          broadcastStateUpdate();
+        };
+
+        ws.onerror = function(error) {
+          Logger.error('[WS] Error:', error);
+          setBadgeStatus('ERR');
+          broadcastStateUpdate();
+        };
+
+        ws.onmessage = function(event) {
+          handleRawMessage(event.data);
+        };
+      } catch (error) {
+        Logger.error('[WS] Failed to create:', error);
+        setBadgeStatus('ERR');
+        scheduleReconnect();
+      }
+    });
+  }
+
+  function send(message) {
+    var ws = State.getWs();
+    if (!ws || ws.readyState !== WebSocket.OPEN) {
+      Logger.warn('[WS] Cannot send, WebSocket not open');
+      return false;
+    }
+
+    var jsonStr;
+    try {
+      jsonStr = JSON.stringify(message);
+    } catch (e) {
+      Logger.error('[WS] Failed to stringify message:', e);
+      return false;
+    }
+
+    var msgSize = jsonStr.length;
+    
+    if (msgSize > 1024 * 1024) {
+      Logger.warn('[WS] Large message:', msgSize, 'bytes, method:', message.method || message.type);
+    }
+
+    if (ws.bufferedAmount > _bufferThreshold) {
+      Logger.warn('[WS] Buffer full, queuing message. Buffered:', ws.bufferedAmount);
+      if (_sendQueue.length < _maxQueueSize) {
+        _sendQueue.push(jsonStr);
+      } else {
+        Logger.error('[WS] Queue full, dropping message');
+      }
+      return false;
+    }
+
+    try {
+      ws.send(jsonStr);
+      Logger.info('[WS] SEND: ' + jsonStr.substring(0, 200));
+      return true;
+    } catch (e) {
+      Logger.error('[WS] Send error:', e);
+      return false;
+    }
+  }
+
+  function processQueue() {
+    var ws = State.getWs();
+    if (!ws || ws.readyState !== WebSocket.OPEN) {
+      return;
+    }
+
+    while (_sendQueue.length > 0 && ws.bufferedAmount < _bufferThreshold) {
+      var data = _sendQueue.shift();
+      try {
+        ws.send(data);
+      } catch (e) {
+        Logger.error('[WS] Queue send error:', e);
+        break;
+      }
+    }
+
+    if (_sendQueue.length > 0) {
+      setTimeout(processQueue, 100);
+    }
+  }
+
+  function scheduleReconnect() {
+    State.clearReconnectTimer();
+    var timer = setTimeout(function() {
+      Logger.info('[WS] Attempting to reconnect...');
+      connect();
+    }, Config.RECONNECT_DELAY);
+    State.setReconnectTimer(timer);
+  }
+
+  function handleRawMessage(data) {
+    try {
+      if (data instanceof Blob) {
+        data.text().then(function(text) {
+          try {
+            handleMessage(JSON.parse(text));
+          } catch (e) {
+            Logger.error('[WS] Failed to parse Blob message:', e);
+          }
+        }).catch(function(e) {
+          Logger.error('[WS] Failed to read Blob:', e);
+        });
+      } else {
+        try {
+          handleMessage(JSON.parse(data));
+        } catch (e) {
+          Logger.error('[WS] Failed to parse message:', e);
+        }
+      }
+    } catch (e) {
+      Logger.error('[WS] handleRawMessage error:', e);
+    }
+  }
+
+  function handleMessage(message) {
+    var type = message.type;
+    var method = message.method;
+    var params = message.params;
+    var id = message.id;
+    var tabId = message.tabId;
+    var sessionId = message.sessionId;
+
+    switch (type) {
+      case 'connected':
+        if (message.fresh) {
+          Logger.info('[WS] Received fresh connection from server');
+          handleServerRestart();
+        }
+        break;
+
+      case 'ping':
+        send({ type: 'pong' });
+        break;
+
+      case 'attach':
+        var attachTabId = tabId || State.getCurrentTabId();
+        DebuggerManager.attach(attachTabId).then(function(success) {
+          send({ type: 'attach_result', tabId: attachTabId, success: success });
+        });
+        break;
+
+      case 'detach':
+        var detachTabId = tabId || State.getCurrentTabId();
+        DebuggerManager.detach(detachTabId).then(function() {
+          send({ type: 'detach_result', tabId: detachTabId, success: true });
+        });
+        break;
+
+      case 'browser-close':
+        handleBrowserClose(message.sessions);
+        break;
+
+      case 'client-connected':
+        Logger.info('[WS] Client connected, resuming event forwarding');
+        State.setHasConnectedClient(true);
+        State.addCDPClient(message.clientId, message.clientId);
+        broadcastStateUpdate();
+        break;
+
+      case 'client-disconnected':
+        Logger.info('[WS] Client disconnected:', message.clientId);
+        State.removeCDPClient(message.clientId);
+        if (State.getCDPClients().length === 0) {
+          State.setHasConnectedClient(false);
+        }
+        broadcastStateUpdate();
+        break;
+        
+      case 'client-list':
+        Logger.info('[WS] Received client list:', message.clients);
+        State.setCDPClients(message.clients || []);
+        State.setHasConnectedClient((message.clients || []).length > 0);
+        broadcastStateUpdate();
+        break;
+
+      case 'plugin-disconnected':
+        Logger.info('[WS] Plugin disconnected from server');
+        break;
+
+      case 'server-restart':
+        Logger.info('[WS] Server restart detected, cleaning up...');
+        handleServerRestart();
+        break;
+
+      case 'cdp':
+        if (method) {
+          routeCDPCommand({
+            id: id,
+            method: method,
+            params: params,
+            tabId: tabId,
+            sessionId: sessionId
+          });
+        }
+        break;
+
+      default:
+        if (method) {
+          routeCDPCommand({
+            id: id,
+            method: method,
+            params: params,
+            tabId: tabId,
+            sessionId: sessionId
+          });
+        }
+    }
+  }
+
+  function handleServerRestart() {
+    Logger.info('[WS] Server restarted, cleaning up all state...');
+
+    var attachedTabIds = State.getAttachedTabIds();
+    var promises = attachedTabIds.map(function(tabId) {
+      return chrome.debugger.detach({ tabId: tabId }).catch(function(e) {
+        Logger.info('[WS] Detach failed for tab', tabId, ':', e.message);
+      });
+    });
+
+    Promise.all(promises).then(function() {
+      State.clearAllState();
+      State.persist(null, false);
+      Logger.info('[WS] State cleaned up after server restart');
+    });
+  }
+
+  function handleBrowserClose(sessions) {
+    Logger.info('[WS] Browser.close received, cleaning up...');
+
+    var attachedTabIds = State.getAttachedTabIds();
+    var promises = attachedTabIds.map(function(tabId) {
+      return chrome.debugger.detach({ tabId: tabId }).catch(function(e) {
+        Logger.info('[WS] Detach failed for tab', tabId, ':', e.message);
+      });
+    });
+
+    Promise.all(promises).then(function() {
+      State.clearAllState();
+      State.persist(null, false);
+      Logger.info('[WS] Browser.close cleanup complete');
+    });
+  }
+
+  function setBadgeStatus(status) {
+    var colors = Config.BADGE_COLORS;
+    chrome.action.setBadgeText({ text: status });
+    chrome.action.setBadgeBackgroundColor({ color: colors[status] || colors.OFF });
+  }
+
+  function broadcastStateUpdate() {
+    var ws = State.getWs();
+    var isConnected = ws && ws.readyState === WebSocket.OPEN;
+    var cdpClients = State.getCDPClients() || [];
+    var attachedTabIds = State.getAttachedTabIds();
+    
+    var attachedPages = [];
+    attachedTabIds.forEach(function(tabId) {
+      chrome.tabs.get(tabId, function(tab) {
+        if (tab && !chrome.runtime.lastError) {
+          attachedPages.push({
+            tabId: tabId,
+            title: tab.title || 'Untitled',
+            url: tab.url || ''
+          });
+        }
+      });
+    });
+    
+    chrome.runtime.sendMessage({
+      type: 'stateUpdate',
+      connected: isConnected,
+      cdpClients: cdpClients,
+      attachedPages: attachedPages
+    }).catch(function() {});
+  }
+
+  function getQueueStats() {
+    return {
+      queueLength: _sendQueue.length,
+      maxQueueSize: _maxQueueSize,
+      bufferThreshold: _bufferThreshold
+    };
+  }
+
+  return {
+    connect: connect,
+    send: send,
+    scheduleReconnect: scheduleReconnect,
+    setBadgeStatus: setBadgeStatus,
+    getQueueStats: getQueueStats,
+    processQueue: processQueue
+  };
+})();