cdp-tunnel 1.0.13 → 1.0.15

package/cli/index.js

@@ -275,6 +275,71 @@ program
     }
   });
 
+program
+  .command('update')
+  .description('自动更新 cdp-tunnel 并重启服务')
+  .option('-p, --port <port>', '重启时指定端口', parseInt)
+  .option('-w, --watchdog', '重启时启用看门狗')
+  .action(async (options) => {
+    const config = getConfig();
+    const wasRunning = isServerRunning();
+    const savedPort = options.port || config.port;
+    const savedWatchdog = options.watchdog;
+
+    console.log('');
+    log('cyan', '⬆  正在检查更新...');
+
+    try {
+      const beforeVersion = execSync('npm view cdp-tunnel version', { encoding: 'utf8' }).trim();
+      const localVersion = require(path.join(__dirname, '..', 'package.json')).version;
+      log('gray', '  当前版本: ' + localVersion);
+      log('gray', '  最新版本: ' + beforeVersion);
+
+      if (wasRunning) {
+        log('yellow', '  正在停止服务器...');
+        try {
+          const pid = getServerPid();
+          process.kill(pid, 'SIGTERM');
+          fs.unlinkSync(PID_FILE);
+          await new Promise(r => setTimeout(r, 1500));
+          log('green', '  ✓ 服务器已停止');
+        } catch (e) {
+          log('yellow', '  ⚠ 停止服务器失败: ' + e.message);
+        }
+      }
+
+      log('cyan', '  正在更新...');
+      execSync('npm update -g cdp-tunnel', { stdio: 'inherit' });
+
+      const afterVersion = require(path.join(__dirname, '..', 'package.json')).version;
+      if (afterVersion !== localVersion) {
+        log('green', '  ✓ 已更新: ' + localVersion + ' → ' + afterVersion);
+      } else {
+        log('green', '  ✓ 已是最新版本');
+      }
+
+      ensureConfigDir();
+      cleanupLogFile();
+      startServer(savedPort, savedWatchdog);
+      log('green', '  ✓ 服务器已重启 (端口: ' + savedPort + ')');
+      console.log('');
+    } catch (e) {
+      log('red', '✗ 更新失败: ' + e.message);
+      console.log('');
+      if (wasRunning) {
+        log('yellow', '正在尝试恢复服务器...');
+        try {
+          ensureConfigDir();
+          startServer(savedPort, savedWatchdog);
+          log('green', '✓ 服务器已恢复');
+        } catch (re) {
+          log('red', '✗ 恢复失败，请手动启动: cdp-tunnel start');
+        }
+      }
+      process.exit(1);
+    }
+  });
+
 program
   .command('status')
   .description('查看服务器状态')

package/extension-new/background.js

@@ -122,6 +122,7 @@ String.prototype.hashCode = function() {
     Logger.info('[Tabs] Tab removed:', tabId);
 
     State.removeAttachedTab(tabId);
+    var removedClientId = State.getClientIdByTabId(tabId);
     Screencast.stopPolling(tabId);
     AutomationBadge.remove(tabId);
 
@@ -134,6 +135,9 @@ String.prototype.hashCode = function() {
         targetId: targetId
       });
       State.unmapSession(sessionId);
+      if (removedClientId) {
+        SpecialHandler.updateTabGroupName(removedClientId);
+      }
     }
 
     if (State.getCurrentTabId() === tabId) {
@@ -260,7 +264,8 @@ String.prototype.hashCode = function() {
                   
                   chrome.tabGroups.update(groupId, {
                     title: groupName,
-                    color: groupColor
+                    color: groupColor,
+                    collapsed: true
                   }, function(group) {
                     if (chrome.runtime.lastError) {
                       Logger.error('[TabGroup] Failed to update group:', chrome.runtime.lastError.message);

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

@@ -117,74 +117,88 @@ var SpecialHandler = (function() {
     Logger.info('[TabGroup] Starting addTabToAutomationGroup for tabId:', tabId, 'clientId:', clientId);
 
     var groupName;
+    var groupClientId = clientId;
 
-    // 如果有指定的clientId，使用该clientId作为组名
     if (clientId) {
       groupName = 'CDP-' + clientId.substring(0, 8);
-      Logger.info('[TabGroup] Using specific clientId for group name:', groupName);
     } else {
-      // 如果没有clientId，回退到使用第一个CDP客户端的ID
       var cdpClients = State.getCDPClients() || [];
       if (cdpClients.length > 0 && cdpClients[0] && cdpClients[0].id) {
         groupName = 'CDP-' + cdpClients[0].id.substring(0, 8);
-        Logger.info('[TabGroup] Using first CDP client ID for group name:', groupName);
+        groupClientId = cdpClients[0].id;
       } else {
-        // 如果没有CDP客户端，使用固定的组名
         groupName = 'CDP-Automation';
-        Logger.info('[TabGroup] No CDP client, using default group name:', groupName);
       }
     }
     
-    // 添加延迟等待，确保标签页完全加载后再分组
     setTimeout(function() {
       Logger.info('[TabGroup] Executing group operation after delay...');
       
-      // 查找或创建标签组
-      chrome.tabGroups.query({ title: groupName }, function(groups) {
-        Logger.info('[TabGroup] Found groups:', groups);
-        
+      chrome.tabGroups.query({}, function(allGroups) {
+        var groups = allGroups.filter(function(g) {
+          return g.title && g.title.indexOf(groupName) === 0;
+        });
         if (groups.length > 0) {
-          // 找到现有的组，将标签页添加到组
-          Logger.info('[TabGroup] Adding tab to existing group:', groups[0].id);
-          chrome.tabs.group({ tabIds: tabId, groupId: groups[0].id }, function(groupId) {
+          chrome.tabs.group({ tabIds: tabId, groupId: groups[0].id }, function(result) {
             if (chrome.runtime.lastError) {
               Logger.error('[TabGroup] Failed to add tab to group:', chrome.runtime.lastError.message);
             } else {
-              Logger.info('[TabGroup] Tab added to group:', groupId, 'Group name:', groupName);
+              State.setGroupIdForClient(groupClientId, groups[0].id);
+              updateTabGroupName(groupClientId);
             }
           });
         } else {
-          // 创建新组并添加标签页
-          Logger.info('[TabGroup] Creating new group...');
           chrome.tabs.group({ tabIds: tabId }, function(groupId) {
             if (chrome.runtime.lastError) {
               Logger.error('[TabGroup] Failed to create group:', chrome.runtime.lastError.message);
               return;
             }
-            // 更新组的标题和颜色
             if (groupId) {
-              Logger.info('[TabGroup] Group created with ID:', groupId);
-              // 为不同的组使用不同的颜色
               var colors = ['blue', 'red', 'yellow', 'green', 'pink', 'purple', 'cyan', 'orange'];
               var colorIndex = Math.abs(groupName.hashCode ? groupName.hashCode() : 0) % colors.length;
-              var groupColor = colors[colorIndex];
               
-              Logger.info('[TabGroup] Updating group with title:', groupName, 'color:', groupColor);
               chrome.tabGroups.update(groupId, {
                 title: groupName,
-                color: groupColor
-              }, function(group) {
+                color: colors[colorIndex],
+                collapsed: true
+              }, function() {
                 if (chrome.runtime.lastError) {
                   Logger.error('[TabGroup] Failed to update group:', chrome.runtime.lastError.message);
                 } else {
-                  Logger.info('[TabGroup] Group created and updated:', group);
+                  State.setGroupIdForClient(groupClientId, groupId);
+                  updateTabGroupName(groupClientId);
                 }
               });
             }
           });
         }
       });
-    }, 2000); // 等待2秒
+    }, 2000);
+  }
+
+  function updateTabGroupName(clientId) {
+    if (!clientId) return;
+    
+    var groupId = State.getGroupIdForClient(clientId);
+    if (!groupId) return;
+    
+    chrome.tabs.query({ groupId: groupId }, function(tabs) {
+      if (chrome.runtime.lastError || !tabs) return;
+      
+      var count = tabs.length;
+      var baseName = 'CDP-' + clientId.substring(0, 8);
+      var newName = baseName + ' (' + count + ')';
+      
+      chrome.tabGroups.update(groupId, {
+        title: newName
+      }, function() {
+        if (chrome.runtime.lastError) {
+          Logger.error('[TabGroup] Failed to update group name:', chrome.runtime.lastError.message);
+        } else {
+          Logger.info('[TabGroup] Updated group name:', newName);
+        }
+      });
+    });
   }
   
   // 为字符串添加hashCode方法（用于生成颜色索引）
@@ -219,8 +233,13 @@ var SpecialHandler = (function() {
     if (targetId) {
       var tabId = State.getTabIdByTargetId(targetId);
       if (tabId) {
+        State.removeAttachedTab(tabId);
+        var closeClientId = State.getClientIdByTabId(tabId);
         return new Promise(function(resolve) {
           chrome.tabs.remove(tabId, function() {
+            if (closeClientId) {
+              updateTabGroupName(closeClientId);
+            }
             resolve({ success: true });
           });
         }).catch(function() {
@@ -540,6 +559,7 @@ function checkTabVisibility(tabId) {
     pageCreateIsolatedWorld: pageCreateIsolatedWorld,
     pageAddScriptToEvaluateOnNewDocument: pageAddScriptToEvaluateOnNewDocument,
     runtimeRunIfWaitingForDebugger: runtimeRunIfWaitingForDebugger,
-    domSetFileInputFiles: domSetFileInputFiles
+    domSetFileInputFiles: domSetFileInputFiles,
+    updateTabGroupName: updateTabGroupName
   };
 })();

package/extension-new/core/state.js

@@ -23,7 +23,8 @@ var State = (function() {
     pendingCreatedTabUrls: new Set(),
     clientIdToTabId: new Map(),
     clientIdToSessionId: new Map(),
-    tabIdToClientId: new Map()
+    tabIdToClientId: new Map(),
+    clientIdToGroupId: new Map()
   };
 
   function mapSession(sessionId, tabId, targetId) {
@@ -261,17 +262,59 @@ var State = (function() {
     };
     _state.discoverTargetsEnabled = false;
     _state.hasConnectedClient = false;
+    _state.tabIdToClientId.clear();
+    _state.clientIdToGroupId.clear();
   }
 
   function cleanupAllTabs() {
     return new Promise(function(resolve) {
       var tabIds = Array.from(_state.attachedTabIds);
-      var promises = tabIds.map(function(tabId) {
+      
+      var detachPromises = tabIds.map(function(tabId) {
         return chrome.debugger.detach({ tabId: tabId }).catch(function() {});
       });
-      Promise.all(promises).then(function() {
-        clearAllState();
-        persist(null, false).then(resolve);
+      
+      Promise.all(detachPromises).then(function() {
+        chrome.tabGroups.query({}, function(groups) {
+          if (!groups || groups.length === 0) {
+            clearAllState();
+            persist(null, false).then(resolve);
+            return;
+          }
+          
+          var cdpGroups = groups.filter(function(g) {
+            return g.title && g.title.indexOf('CDP-') === 0;
+          });
+          
+          if (cdpGroups.length === 0) {
+            clearAllState();
+            persist(null, false).then(resolve);
+            return;
+          }
+          
+          var closePromises = cdpGroups.map(function(group) {
+            return new Promise(function(res) {
+              chrome.tabs.query({ groupId: group.id }, function(tabs) {
+                if (!tabs || tabs.length === 0) {
+                  res();
+                  return;
+                }
+                var ids = tabs.map(function(t) { return t.id; });
+                chrome.tabs.remove(ids, function() {
+                  if (chrome.runtime.lastError) {
+                    console.error('[State] Failed to close tabs:', chrome.runtime.lastError.message);
+                  }
+                  res();
+                });
+              });
+            });
+          });
+          
+          Promise.all(closePromises).then(function() {
+            clearAllState();
+            persist(null, false).then(resolve);
+          });
+        });
       });
     });
   }
@@ -291,6 +334,18 @@ var State = (function() {
     return _state.tabIdToClientId.get(tabId);
   }
 
+  function setGroupIdForClient(clientId, groupId) {
+    _state.clientIdToGroupId.set(clientId, groupId);
+  }
+
+  function getGroupIdForClient(clientId) {
+    return _state.clientIdToGroupId.get(clientId);
+  }
+
+  function removeGroupForClient(clientId) {
+    _state.clientIdToGroupId.delete(clientId);
+  }
+
   function getTabIdByClientId(clientId) {
     return _state.clientIdToTabId.get(clientId);
   }
@@ -390,6 +445,9 @@ var State = (function() {
     clearAllState: clearAllState,
     cleanupAllTabs: cleanupAllTabs,
     setTabIdToClientId: setTabIdToClientId,
-    getClientIdByTabId: getClientIdByTabId
+    getClientIdByTabId: getClientIdByTabId,
+    setGroupIdForClient: setGroupIdForClient,
+    getGroupIdForClient: getGroupIdForClient,
+    removeGroupForClient: removeGroupForClient
   };
 })();

package/extension-new/core/websocket.js

@@ -181,7 +181,7 @@ var WebSocketManager = (function() {
         break;
 
       case 'browser-close':
-        handleBrowserClose(message.sessions);
+        handleBrowserClose(message.sessions, message.clientId);
         break;
 
       case 'client-connected':
@@ -193,11 +193,18 @@ var WebSocketManager = (function() {
 
       case 'client-disconnected':
         Logger.info('[WS] Client disconnected:', message.clientId);
-        State.removeCDPClient(message.clientId);
-        if (State.getCDPClients().length === 0) {
-          State.setHasConnectedClient(false);
-        }
-        broadcastStateUpdate();
+        var discClientId = message.clientId;
+        closeTabGroupByClientId(discClientId).then(function() {
+          return new Promise(function(resolve) {
+            closeTabsByClientId(discClientId, resolve);
+          });
+        }).then(function() {
+          State.removeCDPClient(discClientId);
+          if (State.getCDPClients().length === 0) {
+            State.setHasConnectedClient(false);
+          }
+          broadcastStateUpdate();
+        });
         break;
         
       case 'client-list':
@@ -243,6 +250,103 @@ var WebSocketManager = (function() {
     }
   }
 
+  function closeTabGroupByClientId(clientId) {
+    if (!clientId) return Promise.resolve();
+    
+    Logger.info('[WS] Closing tab group for client:', clientId);
+    
+    return new Promise(function(resolve) {
+        var groupId = State.getGroupIdForClient(clientId);
+        
+        if (groupId) {
+            closeGroupById(groupId, clientId, resolve);
+        } else {
+            var groupName = 'CDP-' + clientId.substring(0, 8);
+            chrome.tabGroups.query({ title: groupName }, function(groups) {
+                if (!groups || groups.length === 0) {
+                    chrome.tabGroups.query({}, function(allGroups) {
+                        if (allGroups) {
+                            var match = allGroups.find(function(g) {
+                                return g.title && g.title.indexOf(groupName) === 0;
+                            });
+                            if (match) {
+                                closeGroupById(match.id, clientId, resolve);
+                            } else {
+                                Logger.info('[WS] No tab group found, closing tabs by clientId:', clientId);
+                                closeTabsByClientId(clientId, resolve);
+                            }
+                        } else {
+                            resolve();
+                        }
+                    });
+                } else {
+                    closeGroupById(groups[0].id, clientId, resolve);
+                }
+            });
+        }
+    });
+  }
+
+  function closeGroupById(groupId, clientId, resolve) {
+    chrome.tabs.query({ groupId: groupId }, function(tabs) {
+        if (!tabs || tabs.length === 0) {
+            Logger.info('[WS] No tabs in group:', groupId);
+            State.removeGroupForClient(clientId);
+            resolve();
+            return;
+        }
+        
+        var tabIds = tabs.map(function(tab) { return tab.id; });
+        Logger.info('[WS] Closing ' + tabIds.length + ' tabs in group:', groupId);
+        
+        chrome.tabs.remove(tabIds, function() {
+            if (chrome.runtime.lastError) {
+                Logger.error('[WS] Failed to close tabs:', chrome.runtime.lastError.message);
+            } else {
+                Logger.info('[WS] Successfully closed ' + tabIds.length + ' tabs');
+            }
+            
+            tabIds.forEach(function(tabId) {
+                chrome.debugger.detach({ tabId: tabId }).catch(function() {});
+            });
+            
+            State.removeGroupForClient(clientId);
+            resolve();
+        });
+    });
+  }
+
+  function closeTabsByClientId(clientId, resolve) {
+    var attachedTabs = State.getAttachedTabIds();
+    var tabsToClose = [];
+    
+    attachedTabs.forEach(function(tabId) {
+      if (State.getClientIdByTabId(tabId) === clientId) {
+        tabsToClose.push(tabId);
+      }
+    });
+    
+    if (tabsToClose.length === 0) {
+      Logger.info('[WS] No attached tabs found for clientId:', clientId);
+      resolve();
+      return;
+    }
+    
+    Logger.info('[WS] Closing ' + tabsToClose.length + ' attached tabs for clientId:', clientId);
+    
+    tabsToClose.forEach(function(tabId) {
+      chrome.tabs.remove(tabId, function() {
+        if (chrome.runtime.lastError) {
+          Logger.info('[WS] Tab already closed:', tabId);
+        }
+      });
+      chrome.debugger.detach({ tabId: tabId }).catch(function() {});
+      State.removeAttachedTab(tabId);
+    });
+    
+    resolve();
+  }
+
   function handleServerRestart() {
     Logger.info('[WS] Server restarted, cleaning up all state...');
 
@@ -260,20 +364,21 @@ var WebSocketManager = (function() {
     });
   }
 
-  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);
+  function handleBrowserClose(sessions, clientId) {
+    Logger.info('[WS] Browser.close received, cleaning up... clientId:', clientId);
+    
+    closeTabGroupByClientId(clientId).then(function() {
+      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');
       });
-    });
-
-    Promise.all(promises).then(function() {
-      State.clearAllState();
-      State.persist(null, false);
-      Logger.info('[WS] Browser.close cleanup complete');
     });
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cdp-tunnel",
-  "version": "1.0.13",
+  "version": "1.0.15",
   "description": "Chrome Extension CDP Proxy - 通过 Chrome 扩展将 chrome.debugger API 暴露为 WebSocket 端点",
   "main": "server/proxy-server.js",
   "bin": "./cli/index.js",
@@ -25,14 +25,21 @@
   ],
   "author": "dyyz1993",
   "license": "Apache-2.0",
+  "files": [
+    "server/",
+    "cli/",
+    "extension-new/",
+    "README.md",
+    "LICENSE"
+  ],
   "dependencies": {
     "commander": "^12.0.0",
-    "playwright": "^1.58.2",
     "ws": "^8.16.0"
   },
   "devDependencies": {
     "lz-string": "^1.5.0",
     "pako": "^2.1.0",
+    "playwright": "^1.58.2",
     "playwright-core": "^1.58.2",
     "puppeteer-core": "^22.0.0",
     "sharp": "^0.34.0"

package/server/proxy-server.js

@@ -369,9 +369,20 @@ function handlePluginConnection(ws, clientInfo) {
 
                 rewriteBrowserContextId(cdpMsg);
                 const cdpData = JSON.stringify(cdpMsg);
-                logCDP('BROADCAST', `Broadcasting ${parsed.method}, full data: ${cdpData}`, parsed?.sessionId);
-                broadcastToClients(cdpData, null);
-                logCDP('BROADCAST', `Done broadcasting ${parsed.method}`, parsed?.sessionId);
+
+                const targetId = parsed.params?.targetInfo?.targetId;
+                const eventClientId = targetId ? targetIdToClientId.get(targetId) : null;
+
+                if (eventClientId) {
+                    const clientWs = clientById.get(eventClientId);
+                    if (clientWs && clientWs.readyState === WebSocket.OPEN) {
+                        clientWs.send(cdpData);
+                        console.log(`[TARGET EVENT ROUTED] ${parsed.method} targetId=${targetId?.substring(0,8)} -> clientId=${eventClientId}`);
+                    }
+                } else {
+                    console.log(`[TARGET EVENT BROADCAST] ${parsed.method} targetId=${targetId?.substring(0,8) || 'none'} (no owner, broadcasting)`);
+                    broadcastToClients(cdpData, null);
+                }
             }
             
             // 对于 Target.attachedToTarget 事件，建立 sessionId -> clientId 映射
@@ -462,6 +473,23 @@ function handlePluginConnection(ws, clientInfo) {
                             console.log(`[ATTACHED EVENT] Sent cached event to client: ${mapping.clientId}`);
                         }
                     }
+                    // 过滤 Target.getTargets 响应，只返回该客户端拥有的 target
+                    if (mapping.isGetTargets && parsed.result && parsed.result.targetInfos) {
+                        const clientId = mapping.clientId;
+                        parsed.result.targetInfos = parsed.result.targetInfos.filter(t => {
+                            if (t.type !== 'page') return true;
+                            const ownerClient = targetIdToClientId.get(t.targetId);
+                            return !ownerClient || ownerClient === clientId;
+                        });
+                        console.log(`[GET TARGETS FILTERED] client=${clientId} returned ${parsed.result.targetInfos.filter(t => t.type === 'page').length} page targets`);
+                    }
+                    // 清理 Target.closeTarget 成功后的映射
+                    if (parsed.result && parsed.result.success !== undefined && mapping.method === 'Target.closeTarget') {
+                        if (mapping.closeTargetId) {
+                            targetIdToClientId.delete(mapping.closeTargetId);
+                            console.log(`[CLOSE TARGET CLEANUP] removed targetId=${mapping.closeTargetId?.substring(0,8)} from mapping`);
+                        }
+                    }
                     
                     // 然后发送响应给客户端
                     const originalId = mapping.originalId;
@@ -731,6 +759,13 @@ function handleClientConnection(ws, clientInfo, customClientId = null) {
             }
             console.log(`[PENDING CREATE TARGET] Request id=${parsed.id} from client=${id}`);
         }
+        if (parsed && parsed.method === 'Target.closeTarget' && parsed.id !== undefined) {
+            const currentMapping = globalRequestIdMap.get(parsed.id);
+            if (currentMapping) {
+                currentMapping.method = 'Target.closeTarget';
+                currentMapping.closeTargetId = parsed.params?.targetId;
+            }
+        }
         
         // 记录 Target.createBrowserContext 请求，用于后续建立 browserContextId -> clientId 映射
         if (parsed && parsed.method === 'Target.createBrowserContext' && parsed.id !== undefined) {
@@ -740,41 +775,17 @@ function handleClientConnection(ws, clientInfo, customClientId = null) {
             }
             console.log(`[PENDING CREATE CONTEXT] Request id=${parsed.id} from client=${id}`);
         }
+        if (parsed && parsed.method === 'Target.getTargets' && parsed.id !== undefined) {
+            const currentMapping = globalRequestIdMap.get(parsed.id);
+            if (currentMapping) {
+                currentMapping.isGetTargets = true;
+            }
+        }
 
-        // 拦截 Browser.close - 清理会话状态
         if (parsed && parsed.method === 'Browser.close') {
             if (shouldLog('info')) {
-                console.log(`\n[BROWSER CLOSE] Client ${id} requested Browser.close`);
+                console.log(`\n[BROWSER CLOSE] Client ${id} requested Browser.close, forwarding to plugin`);
             }
-            
-            // 清理该客户端的所有 session 映射
-            const sessionsToClean = [];
-            for (const [sessionId, clientId] of sessionToClientId.entries()) {
-                if (clientId === id) {
-                    sessionsToClean.push(sessionId);
-                    sessionToClientId.delete(sessionId);
-                }
-            }
-            if (shouldLog('info')) {
-                console.log(`  - Cleaned ${sessionsToClean.length} sessions`);
-            }
-            
-            // 通知扩展清理状态
-            if (ws.pairedPlugin && ws.pairedPlugin.readyState === WebSocket.OPEN) {
-                ws.pairedPlugin.send(JSON.stringify({
-                    type: 'browser-close',
-                    clientId: id,
-                    sessions: sessionsToClean
-                }));
-            }
-            
-            // 返回 mock 响应（包含 sessionId）
-            const response = { id: parsed.id, result: {} };
-            if (parsed.sessionId) {
-                response.sessionId = parsed.sessionId;
-            }
-            ws.send(JSON.stringify(response));
-            return;
         }
 
         if (parsed && parsed.method) {