@aiscene/aiserver 1.0.0

package/dist/debug/websocket-server.js

@@ -0,0 +1,681 @@
+import { WebSocketServer } from 'ws';
+import { fork } from 'child_process';
+import { URL } from 'url';
+import { createLogger } from '../core/logger.js';
+import { sessionManager } from './session-manager.js';
+import { dumpManager } from './dump-manager.js';
+import { screencastManager } from './screencast.js';
+import { webScreencastManager } from './web-screencast.js';
+import { ExecutorFactory } from '../executor/executor-factory.js';
+const logger = createLogger('DebugWebSocket');
+export class DebugWebSocketServer {
+    wss = null;
+    config;
+    port;
+    isStarted = false;
+    constructor(port = 8002) {
+        this.port = port;
+    }
+    async start(config) {
+        this.config = config;
+        if (this.isStarted) {
+            logger.info('Debug WebSocket server already running');
+            return;
+        }
+        this.wss = new WebSocketServer({
+            host: config.server.host,
+            port: this.port,
+            perMessageDeflate: false,
+        });
+        this.wss.on('connection', (ws, req) => {
+            let parsedUrl;
+            try {
+                parsedUrl = new URL(req.url || '/', `ws://${req.headers.host || 'localhost'}`);
+            }
+            catch {
+                ws.close(1008, 'invalid url');
+                return;
+            }
+            const pathname = parsedUrl.pathname;
+            if (pathname === '/screencast') {
+                const sessionId = parsedUrl.searchParams.get('sessionId');
+                if (!sessionId) {
+                    ws.close(1008, 'missing sessionId');
+                    return;
+                }
+                // 先尝试 web screencast，再尝试 android screencast
+                const ok = webScreencastManager.addViewer(sessionId, ws) || screencastManager.addViewer(sessionId, ws);
+                if (!ok) {
+                    ws.close(1008, 'screencast session not found');
+                    return;
+                }
+                logger.info(`Screencast viewer joined: sessionId=${sessionId}`);
+                return;
+            }
+            this.handleControlConnection(ws);
+        });
+        this.isStarted = true;
+        logger.info(`Debug WebSocket server started on ${config.server.host}:${this.port}`);
+        logger.info(`  Control:    ws://${config.server.host}:${this.port}`);
+        logger.info(`  Screencast: ws://${config.server.host}:${this.port}/screencast?sessionId=<id>`);
+    }
+    handleControlConnection(ws) {
+        logger.info('[Control] New connection');
+        ws.on('message', async (data) => {
+            try {
+                const message = JSON.parse(data.toString());
+                await this.handleMessage(ws, message);
+            }
+            catch (error) {
+                this.sendError(ws, 'Invalid message format');
+            }
+        });
+        ws.on('close', () => {
+            logger.info('[Control] Connection closed');
+            for (const sessionId of sessionManager.findByClient(ws)) {
+                this.cleanupSession(sessionId);
+            }
+        });
+        ws.on('error', (error) => {
+            logger.error(`[Control] WebSocket error: ${error.message}`);
+        });
+    }
+    async handleMessage(ws, message) {
+        switch (message.type) {
+            case 'start_debug':
+                await this.handleStartDebug(ws, message);
+                break;
+            case 'stop_debug':
+                await this.handleStopDebug(ws, message);
+                break;
+            case 'get_logs':
+                await this.handleGetLogs(ws, message);
+                break;
+            case 'execute_action':
+                await this.handleExecuteAction(ws, message);
+                break;
+            case 'execute_ai_act':
+                await this.handleExecuteAiAct(ws, message);
+                break;
+            case 'execute_web_action':
+                await this.handleExecuteWebAction(ws, message);
+                break;
+            case 'start_screencast':
+                await this.handleStartScreencast(ws, message);
+                break;
+            case 'stop_screencast':
+                await this.handleStopScreencast(ws, message);
+                break;
+            case 'close_web_session':
+                await this.handleCloseWebSession(ws, message);
+                break;
+            default:
+                this.sendError(ws, `Unknown message type: ${message.type}`);
+        }
+    }
+    // ==================== Start Debug (fork worker process) ====================
+    async handleStartDebug(ws, request) {
+        const sessionId = `debug-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+        const session = sessionManager.create(sessionId, ws, request.deviceId);
+        this.sendMessage(ws, { type: 'session_created', sessionId }, request.deviceId);
+        try {
+            sessionManager.updateStatus(sessionId, 'running');
+            this.sendMessage(ws, { type: 'debug_started', sessionId }, request.deviceId);
+            // Build executor config from debug request
+            const execConfig = {
+                type: request.platform || 'android',
+                testName: 'debugtest',
+                url: request.url,
+                udid: request.deviceId,
+                packageName: request.packageName,
+                bundleId: request.bundleId,
+                mobileMode: request.mobileMode,
+                requirement: request.naturalLanguage,
+                executionId: sessionId,
+                taskId: sessionId,
+                nodeId: this.config.task.nodeId,
+            };
+            // Fork worker process for long-running debug
+            const workerPath = new URL('../executor/worker-entry.js', import.meta.url).pathname;
+            const workerEnv = {
+                ...process.env,
+                WORKER_CONFIG: JSON.stringify(execConfig),
+                OPENAI_BASE_URL: this.config.ai.baseUrl,
+                OPENAI_API_KEY: this.config.ai.apiKey,
+                MIDSCENE_MODEL_NAME: this.config.ai.modelName,
+                MIDSCENE_USE_QWEN3_VL: this.config.ai.useQwen3Vl ? '1' : '0',
+            };
+            const childProcess = fork(workerPath, ['--worker'], {
+                env: workerEnv,
+                stdio: ['inherit', 'inherit', 'inherit', 'ipc'],
+            });
+            session.process = childProcess;
+            childProcess.stdout?.on('data', (data) => {
+                const output = data.toString();
+                sessionManager.addLog(sessionId, output);
+                this.sendMessage(ws, { type: 'log_output', sessionId, content: output }, request.deviceId);
+            });
+            childProcess.stderr?.on('data', (data) => {
+                const errorOutput = data.toString();
+                sessionManager.addLog(sessionId, `ERROR: ${errorOutput}`);
+                this.sendMessage(ws, { type: 'log_output', sessionId, content: `ERROR: ${errorOutput}`, level: 'error' }, request.deviceId);
+            });
+            childProcess.on('exit', (code) => {
+                const success = code === 0;
+                sessionManager.updateStatus(sessionId, success ? 'completed' : 'failed');
+                this.sendMessage(ws, { type: 'debug_completed', sessionId, success, exitCode: code }, request.deviceId);
+            });
+            childProcess.on('message', (message) => {
+                this.sendMessage(ws, { type: 'execution_result', sessionId, ...(typeof message === 'object' && message ? message : {}) }, request.deviceId);
+            });
+            childProcess.on('error', (error) => {
+                sessionManager.updateStatus(sessionId, 'failed');
+                this.sendMessage(ws, { type: 'debug_error', sessionId, error: error.message }, request.deviceId);
+            });
+        }
+        catch (error) {
+            sessionManager.updateStatus(sessionId, 'failed');
+            this.sendMessage(ws, { type: 'debug_error', sessionId, error: error.message }, request.deviceId);
+        }
+    }
+    // ==================== Execute Action (direct in-process) ====================
+    async handleExecuteAction(ws, request) {
+        const sessionId = `action-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+        const session = sessionManager.create(sessionId, ws, request.deviceId);
+        try {
+            this.sendMessage(ws, { type: 'action_started', sessionId, actionType: request.actionType }, request.deviceId);
+            const executor = ExecutorFactory.create('action', {
+                sessionId,
+                onLog: (msg) => {
+                    sessionManager.addLog(sessionId, msg);
+                    this.sendMessage(ws, { type: 'log_output', sessionId, content: msg }, request.deviceId);
+                },
+                onDump: (dump) => {
+                    this.sendMessage(ws, { type: 'action_dump', sessionId, dump }, request.deviceId);
+                },
+                onExecutionLine: (line) => {
+                    this.sendMessage(ws, { type: 'execution_line', sessionId, line }, request.deviceId);
+                },
+            });
+            const config = {
+                type: request.platform || 'android',
+                testName: `action-${request.actionType}`,
+                actionType: request.actionType,
+                locatePrompt: request.locatePrompt,
+                actionParams: request.actionParams,
+                udid: request.deviceId,
+                packageName: request.packageName,
+                testUrl: request.testUrl,
+                modelConfig: request.modelConfig,
+            };
+            const result = await executor.execute(config);
+            sessionManager.updateStatus(sessionId, result.success ? 'completed' : 'failed');
+            this.sendMessage(ws, {
+                type: 'action_result',
+                sessionId,
+                success: result.success,
+                result: result.result,
+                dump: result.dump || '',
+                reportHTML: result.reportHTML || '',
+                error: result.errorMessage,
+            }, request.deviceId);
+        }
+        catch (error) {
+            sessionManager.updateStatus(sessionId, 'failed');
+            this.sendMessage(ws, {
+                type: 'action_result',
+                sessionId,
+                success: false,
+                error: error.message,
+            }, request.deviceId);
+        }
+    }
+    // ==================== Execute AI Act ====================
+    async handleExecuteAiAct(ws, request) {
+        const sessionId = `aiact-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+        const session = sessionManager.create(sessionId, ws, request.deviceId);
+        try {
+            this.sendMessage(ws, { type: 'ai_act_started', sessionId }, request.deviceId);
+            const executor = ExecutorFactory.create('action', {
+                sessionId,
+                onLog: (msg) => {
+                    sessionManager.addLog(sessionId, msg);
+                    this.sendMessage(ws, { type: 'log_output', sessionId, content: msg }, request.deviceId);
+                },
+                onDump: (dump) => {
+                    this.sendMessage(ws, { type: 'action_dump', sessionId, dump }, request.deviceId);
+                },
+            });
+            const config = {
+                type: request.platform || 'android',
+                testName: 'ai-act',
+                actionType: 'aiAct',
+                naturalLanguage: request.naturalLanguage,
+                udid: request.deviceId,
+                packageName: request.packageName,
+                modelConfig: request.modelConfig,
+                actionParams: {
+                    deepLocate: request.deepLocate,
+                    deepThink: request.deepThink,
+                },
+            };
+            const result = await executor.execute(config);
+            sessionManager.updateStatus(sessionId, result.success ? 'completed' : 'failed');
+            this.sendMessage(ws, {
+                type: 'ai_act_result',
+                sessionId,
+                success: result.success,
+                result: result.result,
+                dump: result.dump || '',
+                reportHTML: result.reportHTML || '',
+                error: result.errorMessage,
+            }, request.deviceId);
+        }
+        catch (error) {
+            sessionManager.updateStatus(sessionId, 'failed');
+            this.sendMessage(ws, {
+                type: 'ai_act_result',
+                sessionId,
+                success: false,
+                error: error.message,
+            }, request.deviceId);
+        }
+    }
+    // ==================== Execute Web Action (Playwright + Midscene, with screencast) ====================
+    async handleExecuteWebAction(ws, request) {
+        const sessionId = request.sessionId || `web-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+        let session = sessionManager.get(sessionId);
+        const isNewSession = !session;
+        if (isNewSession) {
+            session = sessionManager.create(sessionId, ws);
+            session.platform = 'web';
+        }
+        try {
+            this.sendMessage(ws, { type: 'web_action_started', sessionId, actionType: request.actionType });
+            // 懒启动浏览器（每个 session 只启一次）
+            if (!session.browser) {
+                logger.info(`[WebAction] Launching browser for new session: ${sessionId}`);
+                // 动态导入 playwright / @midscene/web
+                const playwright = await import('playwright');
+                const midscene = await import('@midscene/web/playwright');
+                const browser = await playwright.chromium.launch({
+                    headless: request.headless ?? false,
+                });
+                const context = await browser.newContext({
+                    viewport: request.viewport || { width: 1280, height: 800 },
+                });
+                const page = await context.newPage();
+                session.browser = browser;
+                session.context = context;
+                session.page = page;
+                session.webAgent = new midscene.PlaywrightAgent(page, {
+                    modelConfig: request.modelConfig,
+                });
+                logger.info(`[WebAction] Browser launched, web session ready: ${sessionId}`);
+                // 自动开启投屏
+                if (request.screencast) {
+                    const options = typeof request.screencast === 'object' ? request.screencast : {};
+                    await webScreencastManager.createSession(sessionId, ws, browser, context, page, options);
+                    session.screencastEnabled = true;
+                    const localIp = this.config.server.host;
+                    this.sendMessage(ws, {
+                        type: 'screencast_ready',
+                        sessionId,
+                        wsUrl: `ws://${localIp}:${this.port}/screencast?sessionId=${encodeURIComponent(sessionId)}`,
+                    });
+                }
+            }
+            // 取出 agent / page
+            const agent = session.webAgent;
+            const page = session.page;
+            // ===== 周期 dump（与移动端 handleExecuteAction 行为一致） =====
+            const sendDump = (dump) => {
+                if (dump && dump.trim().length > 0) {
+                    this.sendMessage(ws, {
+                        type: 'action_dump',
+                        sessionId,
+                        dump,
+                        platform: 'web',
+                    });
+                }
+            };
+            const sendInitialWebDump = async () => {
+                try {
+                    if (agent && typeof agent.dumpDataString === 'function') {
+                        const initialDump = agent.dumpDataString({ inlineScreenshots: true });
+                        sendDump(initialDump);
+                    }
+                }
+                catch (dumpError) {
+                    logger.warn(`[WebAction] initial dump failed: ${dumpError.message}`);
+                }
+            };
+            // 如果旧的定时器还在，先清掉
+            if (session.dumpIntervalId) {
+                clearInterval(session.dumpIntervalId);
+                session.dumpIntervalId = undefined;
+            }
+            const startWebDumpInterval = () => {
+                const id = setInterval(() => {
+                    try {
+                        if (agent && typeof agent.dumpDataString === 'function') {
+                            const intervalDump = agent.dumpDataString({ inlineScreenshots: true });
+                            sendDump(intervalDump);
+                        }
+                    }
+                    catch (dumpError) {
+                        logger.warn(`[WebAction] interval dump failed: ${dumpError.message}`);
+                    }
+                }, 5000);
+                session.dumpIntervalId = id;
+            };
+            const stopWebDumpInterval = () => {
+                if (session.dumpIntervalId) {
+                    clearInterval(session.dumpIntervalId);
+                    session.dumpIntervalId = undefined;
+                }
+            };
+            // 立即发一次初始 dump，再启动周期
+            await sendInitialWebDump();
+            startWebDumpInterval();
+            // 按 actionType 分发执行
+            let result;
+            switch (request.actionType) {
+                case 'goto': {
+                    if (!request.url)
+                        throw new Error('goto requires url parameter');
+                    result = await page.goto(request.url, { waitUntil: 'networkidle' });
+                    break;
+                }
+                case 'aiAction': {
+                    const text = request.naturalLanguage || request.locatePrompt || '';
+                    if (!text)
+                        throw new Error('aiAction requires naturalLanguage or locatePrompt');
+                    result = await agent.aiAction(text);
+                    break;
+                }
+                case 'aiInput': {
+                    const value = request.actionParams?.value || '';
+                    result = await agent.aiInput(value, request.locatePrompt || '');
+                    break;
+                }
+                case 'aiTap':
+                    result = await agent.aiTap(request.locatePrompt || '');
+                    break;
+                case 'aiHover':
+                    result = await agent.aiHover(request.locatePrompt || '');
+                    break;
+                case 'aiAssert':
+                    result = await agent.aiAssert(request.locatePrompt || '');
+                    break;
+                case 'aiQuery':
+                    result = await agent.aiQuery(request.locatePrompt || '');
+                    break;
+                case 'aiWaitFor':
+                    result = await agent.aiWaitFor(request.locatePrompt || '', request.actionParams);
+                    break;
+                case 'aiScroll':
+                    result = await agent.aiScroll(request.actionParams || {}, request.locatePrompt);
+                    break;
+                case 'runCode': {
+                    const code = request.actionParams?.code || '';
+                    if (!code)
+                        throw new Error('runCode requires actionParams.code');
+                    const AsyncFunctionCtor = async function () { }.constructor;
+                    const ctx = {
+                        agent,
+                        page,
+                        sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+                        console: {
+                            log: (...args) => {
+                                sessionManager.addLog(sessionId, args.map(String).join(' '));
+                                this.sendMessage(ws, { type: 'log_output', sessionId, content: args.map(String).join(' ') });
+                            },
+                        },
+                    };
+                    const fn = new AsyncFunctionCtor(code);
+                    result = await fn.call(ctx);
+                    break;
+                }
+                default:
+                    throw new Error(`Unknown web action type: ${request.actionType}`);
+            }
+            // 拉取报告
+            let dumpString = '';
+            let reportHTML = '';
+            try {
+                if (typeof agent.dumpDataString === 'function') {
+                    dumpString = agent.dumpDataString({ inlineScreenshots: true });
+                }
+                if (typeof agent.reportHTMLString === 'function') {
+                    reportHTML = agent.reportHTMLString({ inlineScreenshots: true });
+                }
+            }
+            catch (e) {
+                logger.warn(`[WebAction] dump/report extract failed: ${e.message}`);
+            }
+            sessionManager.updateStatus(sessionId, 'completed');
+            stopWebDumpInterval();
+            // 发送 web_action_result
+            this.sendMessage(ws, {
+                type: 'web_action_result',
+                sessionId,
+                actionType: request.actionType,
+                success: true,
+                result,
+                dump: dumpString || '',
+                reportHTML: reportHTML || '',
+            });
+            // 与移动端对齐：同步发一份 action_result，供 debugLogManager 走报告链路
+            this.sendMessage(ws, {
+                type: 'action_result',
+                sessionId,
+                actionType: request.actionType,
+                success: true,
+                result,
+                dump: dumpString || '',
+                reportHTML: reportHTML || '',
+                platform: 'web',
+            });
+        }
+        catch (error) {
+            logger.error(`[WebAction] error: ${error.message}`);
+            sessionManager.updateStatus(sessionId, 'failed');
+            // 失败时也要停止周期 dump
+            if (session.dumpIntervalId) {
+                clearInterval(session.dumpIntervalId);
+                session.dumpIntervalId = undefined;
+            }
+            // 失败时也尝试提取 dump / reportHTML
+            let dumpString = '';
+            let reportHTML = '';
+            const agentForReport = session?.webAgent;
+            try {
+                if (agentForReport && typeof agentForReport.dumpDataString === 'function') {
+                    dumpString = agentForReport.dumpDataString({ inlineScreenshots: true });
+                }
+            }
+            catch (dumpErr) {
+                logger.warn(`[WebAction] (error case) dump extract failed: ${dumpErr.message}`);
+            }
+            try {
+                if (agentForReport && typeof agentForReport.reportHTMLString === 'function') {
+                    reportHTML = agentForReport.reportHTMLString({ inlineScreenshots: true });
+                }
+            }
+            catch (reportErr) {
+                logger.warn(`[WebAction] (error case) report extract failed: ${reportErr.message}`);
+            }
+            this.sendMessage(ws, {
+                type: 'web_action_result',
+                sessionId,
+                actionType: request.actionType,
+                success: false,
+                error: error.message,
+                dump: dumpString || '',
+                reportHTML: reportHTML || '',
+                agentStatus: session?.webAgent ? 'initialized' : 'not_initialized',
+            });
+            // 与移动端对齐：同步发一份 action_result
+            this.sendMessage(ws, {
+                type: 'action_result',
+                sessionId,
+                actionType: request.actionType,
+                success: false,
+                error: error.message,
+                dump: dumpString || '',
+                reportHTML: reportHTML || '',
+                agentStatus: session?.webAgent ? 'initialized' : 'not_initialized',
+                platform: 'web',
+            });
+        }
+    }
+    // ==================== Start Screencast (for existing web session) ====================
+    async handleStartScreencast(ws, request) {
+        const session = sessionManager.get(request.sessionId);
+        if (!session || !session.browser || !session.context || !session.page) {
+            this.sendError(ws, `Web session not found or browser not initialized: ${request.sessionId}`);
+            return;
+        }
+        try {
+            await webScreencastManager.createSession(request.sessionId, ws, session.browser, session.context, session.page, request.options);
+            session.screencastEnabled = true;
+            const localIp = this.config.server.host;
+            this.sendMessage(ws, {
+                type: 'screencast_ready',
+                sessionId: request.sessionId,
+                wsUrl: `ws://${localIp}:${this.port}/screencast?sessionId=${encodeURIComponent(request.sessionId)}`,
+            });
+        }
+        catch (error) {
+            this.sendError(ws, `Start screencast failed: ${error.message}`);
+        }
+    }
+    // ==================== Stop Screencast (keep browser open) ====================
+    async handleStopScreencast(ws, request) {
+        try {
+            // 停止周期 dump
+            const preSession = sessionManager.get(request.sessionId);
+            if (preSession?.dumpIntervalId) {
+                clearInterval(preSession.dumpIntervalId);
+                preSession.dumpIntervalId = undefined;
+            }
+            // 仅停止 CDP 投屏帧推送，保留浏览器以便继续动作
+            const screencast = webScreencastManager.getSession(request.sessionId);
+            if (screencast) {
+                await webScreencastManager.stopSession(request.sessionId);
+            }
+            if (preSession) {
+                preSession.screencastEnabled = false;
+            }
+            this.sendMessage(ws, { type: 'screencast_stopped', sessionId: request.sessionId });
+        }
+        catch (error) {
+            this.sendError(ws, `Stop screencast failed: ${error.message}`);
+        }
+    }
+    // ==================== Close Web Session (close browser + screencast) ====================
+    async handleCloseWebSession(ws, request) {
+        const session = sessionManager.get(request.sessionId);
+        if (!session) {
+            this.sendError(ws, `Session not found: ${request.sessionId}`);
+            return;
+        }
+        // 停止周期 dump
+        if (session.dumpIntervalId) {
+            clearInterval(session.dumpIntervalId);
+            session.dumpIntervalId = undefined;
+        }
+        // 停止 web screencast
+        if (webScreencastManager.hasSession(request.sessionId)) {
+            await webScreencastManager.stopSession(request.sessionId);
+        }
+        // 关闭浏览器
+        try {
+            await session.browser?.close?.();
+        }
+        catch {
+            // ignore
+        }
+        session.browser = undefined;
+        session.context = undefined;
+        session.page = undefined;
+        session.webAgent = undefined;
+        session.screencastEnabled = false;
+        sessionManager.updateStatus(request.sessionId, 'stopped');
+        this.sendMessage(ws, { type: 'web_session_closed', sessionId: request.sessionId });
+    }
+    // ==================== Stop Debug ====================
+    async handleStopDebug(ws, request) {
+        const session = sessionManager.get(request.sessionId);
+        if (!session) {
+            this.sendError(ws, `Session not found: ${request.sessionId}`);
+            return;
+        }
+        // Stop child process
+        if (session.process) {
+            session.process.kill('SIGTERM');
+        }
+        // Stop dump
+        dumpManager.stopPeriodicDump(request.sessionId);
+        // Destroy agent if exists
+        if (session.agent && typeof session.agent.destroy === 'function') {
+            try {
+                await session.agent.destroy();
+            }
+            catch (error) {
+                logger.warn(`Agent destroy error: ${error.message}`);
+            }
+        }
+        sessionManager.updateStatus(request.sessionId, 'stopped');
+        this.sendMessage(ws, { type: 'debug_stopped', sessionId: request.sessionId });
+    }
+    // ==================== Get Logs ====================
+    async handleGetLogs(ws, request) {
+        const session = sessionManager.get(request.sessionId);
+        if (!session) {
+            this.sendError(ws, `Session not found: ${request.sessionId}`);
+            return;
+        }
+        this.sendMessage(ws, { type: 'all_logs', sessionId: request.sessionId, logs: session.logs });
+    }
+    // ==================== Utilities ====================
+    sendMessage(ws, message, deviceId) {
+        try {
+            const msg = {
+                ...message,
+                deviceId,
+                timestamp: new Date().toISOString(),
+            };
+            if (ws.readyState === ws.OPEN) {
+                ws.send(JSON.stringify(msg));
+            }
+        }
+        catch (error) {
+            logger.error(`Send message error: ${error.message}`);
+        }
+    }
+    sendError(ws, error) {
+        this.sendMessage(ws, { type: 'error', error });
+    }
+    cleanupSession(sessionId) {
+        dumpManager.stopPeriodicDump(sessionId);
+        sessionManager.remove(sessionId);
+    }
+    // ==================== Public API ====================
+    getSessions() {
+        return sessionManager.getAll();
+    }
+    async close() {
+        await screencastManager.closeAll();
+        await webScreencastManager.closeAll();
+        dumpManager.stopAll();
+        if (this.wss) {
+            this.wss.close();
+            this.wss = null;
+            this.isStarted = false;
+        }
+        logger.info('Debug WebSocket server closed');
+    }
+}
+//# sourceMappingURL=websocket-server.js.map