@aiscene/aiserver 1.8.3 → 1.8.5

package/dist/debug/websocket-server.js

@@ -41,6 +41,7 @@ export class DebugWebSocketServer {
     config;
     port;
     isStarted = false;
+    activeBatchSessionIds = new Set();
     // 任务日志订阅: taskId -> Set of WebSocket clients
     taskLogSubscribers = new Map();
     // 记录客户端订阅的所有任务（用于断开时清理）
@@ -258,6 +259,13 @@ export class DebugWebSocketServer {
             }
             for (const sessionId of sessionManager.findByClient(ws)) {
                 const s = sessionManager.get(sessionId);
+                // 本地批量执行已经交给 AIServer 后台顺序跑，前端页面断开不应中断执行。
+                if (this.activeBatchSessionIds.has(sessionId)) {
+                    if (s)
+                        s.client = undefined;
+                    logger.info(`[BatchAction] Client disconnected, keep active batch session running: ${sessionId}`);
+                    continue;
+                }
                 // Web 调试会话：客户端断开不销毁浏览器/投屏，仅解绑 client，由 TTL 在 30 分钟无活动时自动回收
                 if (s && s.platform === 'web' && this.webSessionsActivity.has(sessionId)) {
                     s.client = undefined;
@@ -295,6 +303,12 @@ export class DebugWebSocketServer {
             case 'execute_web_action':
                 await this.handleExecuteWebAction(ws, message);
                 break;
+            case 'batch_action':
+                await this.handleBatchAction(ws, message);
+                break;
+            case 'stop_batch':
+                await this.handleStopBatch(ws, message);
+                break;
             case 'start_screencast':
                 await this.handleStartScreencast(ws, message);
                 break;
@@ -2074,6 +2088,508 @@ export class DebugWebSocketServer {
             }
         }
     }
+    // ==================== Batch Action (逐条执行一批用例，支持 web / android / ios) ====================
+    batchAbortControllers = new Map();
+    async handleBatchAction(ws, request) {
+        const { batchId, cases, platform } = request;
+        if (!batchId || !Array.isArray(cases) || cases.length === 0) {
+            this.sendError(ws, 'batch_action requires batchId and non-empty cases array');
+            return;
+        }
+        // 创建 AbortController 用于取消批次
+        const abortController = new AbortController();
+        this.batchAbortControllers.set(batchId, abortController);
+        // 批次级别配置
+        const batchLoginContext = request.loginContext;
+        const batchModelConfig = request.modelConfig;
+        // 通知前端：批次开始
+        this.sendMessage(ws, {
+            type: 'batch_started',
+            batchId,
+            totalCases: cases.length,
+            platform,
+        });
+        const results = [];
+        // Web 相关状态
+        let browserLaunched = false;
+        let sharedSessionId = '';
+        try {
+            for (let i = 0; i < cases.length; i++) {
+                // 检查是否已取消
+                if (abortController.signal.aborted) {
+                    logger.info(`[BatchAction] Batch ${batchId} aborted, skipping remaining ${cases.length - i} cases`);
+                    break;
+                }
+                const tc = cases[i];
+                const caseLabel = `[Batch ${batchId} case ${i + 1}/${cases.length}] ${tc.id}${tc.title ? ` - ${tc.title}` : ''}`;
+                logger.info(`${caseLabel}: starting (platform=${platform})`);
+                // 通知前端：当前用例开始
+                this.sendMessage(ws, {
+                    type: 'batch_case_started',
+                    batchId,
+                    caseId: tc.id,
+                    caseIndex: i,
+                    totalCases: cases.length,
+                });
+                await this.postBatchCallback(request, `/test-batches/${encodeURIComponent(batchId)}/items/${encodeURIComponent(tc.id)}`, {
+                    status: 'running',
+                    caseIndex: i,
+                    totalCases: cases.length,
+                });
+                let caseSuccess = false;
+                let caseError;
+                let caseReportUrl;
+                let caseCaptureDataUrl;
+                let caseSessionId;
+                const caseStartedAt = Date.now();
+                try {
+                    if (platform === 'web') {
+                        // ============ Web 路径 ============
+                        const result = await this.executeBatchWebCase(ws, request, tc, i, caseLabel, batchLoginContext, batchModelConfig, sharedSessionId, browserLaunched);
+                        caseSuccess = result.success;
+                        caseError = result.error;
+                        caseReportUrl = result.reportUrl;
+                        caseCaptureDataUrl = result.captureDataUrl;
+                        caseSessionId = result.sessionId;
+                        sharedSessionId = result.sessionId;
+                        browserLaunched = result.browserLaunched;
+                    }
+                    else {
+                        // ============ App (Android/iOS) 路径 ============
+                        const result = await this.executeBatchAppCase(ws, request, tc, i, caseLabel, batchLoginContext, batchModelConfig);
+                        caseSuccess = result.success;
+                        caseError = result.error;
+                        caseReportUrl = result.reportUrl;
+                        caseCaptureDataUrl = result.captureDataUrl;
+                        caseSessionId = result.sessionId;
+                    }
+                    if (caseSuccess) {
+                        logger.info(`${caseLabel}: completed successfully`);
+                    }
+                }
+                catch (err) {
+                    caseError = err.message;
+                    caseSuccess = false;
+                    logger.warn(`${caseLabel}: failed - ${caseError}`);
+                }
+                const caseResult = {
+                    id: tc.id,
+                    success: caseSuccess,
+                    error: caseError,
+                    reportUrl: caseReportUrl,
+                    captureDataUrl: caseCaptureDataUrl,
+                };
+                results.push(caseResult);
+                // 通知前端：当前用例完成
+                this.sendMessage(ws, {
+                    type: 'batch_case_completed',
+                    batchId,
+                    caseId: tc.id,
+                    caseIndex: i,
+                    totalCases: cases.length,
+                    success: caseSuccess,
+                    error: caseError,
+                    reportUrl: caseReportUrl,
+                    captureDataUrl: caseCaptureDataUrl,
+                });
+                await this.postBatchCallback(request, `/test-batches/${encodeURIComponent(batchId)}/items/${encodeURIComponent(tc.id)}`, {
+                    status: caseSuccess ? 'completed' : 'failed',
+                    success: caseSuccess,
+                    error: caseError,
+                    reportUrl: caseReportUrl,
+                    captureDataUrl: caseCaptureDataUrl,
+                    sessionId: caseSessionId,
+                    deviceId: tc.deviceId || request.deviceId,
+                    durationMs: Date.now() - caseStartedAt,
+                });
+            }
+        }
+        finally {
+            // 清理 AbortController
+            this.batchAbortControllers.delete(batchId);
+            // 关闭浏览器（仅 web）
+            if (platform === 'web' && sharedSessionId && browserLaunched) {
+                try {
+                    await this.closeWebSession(sharedSessionId);
+                }
+                catch { /* ignore */ }
+            }
+            // 通知前端：批次完成
+            this.sendMessage(ws, {
+                type: 'batch_completed',
+                batchId,
+                totalCases: cases.length,
+                completedCases: results.length,
+                results,
+            });
+            await this.postBatchCallback(request, `/test-batches/${encodeURIComponent(batchId)}/finalize`, {
+                status: 'completed',
+                totalCases: cases.length,
+                completedCases: results.length,
+                results,
+            });
+        }
+    }
+    /** 批次执行 - 单条 Web 用例 */
+    async executeBatchWebCase(ws, request, tc, caseIndex, caseLabel, batchLoginContext, batchModelConfig, sharedSessionId, browserLaunched) {
+        // 构造单条 WebActionExecuteRequest
+        const webActionRequest = {
+            type: 'execute_web_action',
+            actionType: tc.actionType || 'aiAction',
+            url: tc.url || request.url,
+            naturalLanguage: tc.naturalLanguage,
+            actionParams: tc.actionParams,
+            sessionId: sharedSessionId || undefined,
+            mobileMode: request.mobileMode,
+            deviceName: request.deviceName,
+            viewport: request.viewport,
+            headless: request.headless,
+            screencast: request.screencast,
+            modelConfig: batchModelConfig,
+            loginContext: tc.loginContext || batchLoginContext,
+        };
+        let caseSuccess = false;
+        let caseError;
+        let caseReportUrl;
+        let caseCaptureDataUrl;
+        // 如果 freshBrowserPerCase 或首次执行，需要完整启动浏览器
+        if (!browserLaunched || request.freshBrowserPerCase) {
+            // 关闭之前的浏览器（如果有）
+            if (sharedSessionId && browserLaunched) {
+                try {
+                    await this.closeWebSession(sharedSessionId);
+                }
+                catch { /* ignore */ }
+            }
+            sharedSessionId = `batch-${request.batchId}-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+            webActionRequest.sessionId = sharedSessionId;
+        }
+        else {
+            // 复用浏览器
+            webActionRequest.sessionId = sharedSessionId;
+        }
+        const sessionId = sharedSessionId;
+        const reportGroupName = tc.title || tc.id || `batch-${request.batchId}-case-${caseIndex + 1}`;
+        let session = sessionManager.get(sessionId);
+        const isNewSession = !session || !session.browser;
+        if (isNewSession) {
+            if (!session)
+                session = sessionManager.create(sessionId, ws);
+            session.platform = 'web';
+            // 并发上限保护
+            if (this.webSessionsActivity.size >= this.webSessionMaxConcurrency) {
+                throw new Error(`Web 调试会话数已达上限 (${this.webSessionMaxConcurrency})，请稍后重试`);
+            }
+            const playwright = await import('playwright');
+            const midscene = await import('@aiscene/web/playwright');
+            let browser;
+            let context;
+            let page;
+            let releaseBrowser = null;
+            if (request.mobileMode) {
+                const deviceName = request.deviceName || 'iPhone 13';
+                const deviceDescriptor = playwright.devices[deviceName];
+                browser = await playwright.chromium.launch({ headless: false });
+                if (deviceDescriptor) {
+                    context = await browser.newContext(deviceDescriptor);
+                }
+                else {
+                    context = await browser.newContext({
+                        viewport: { width: 375, height: 667 }, isMobile: true,
+                        hasTouch: true, deviceScaleFactor: 2,
+                        userAgent: 'Mozilla/5.0 (iPhone; CPU iPhone OS 15_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.0 Mobile/15E148 Safari/604.1',
+                    });
+                }
+                page = await context.newPage();
+                releaseBrowser = async () => { try {
+                    await context.close();
+                }
+                catch { /* ignore */ } try {
+                    await browser.close();
+                }
+                catch { /* ignore */ } };
+            }
+            else {
+                browser = await playwright.chromium.launch({ headless: false });
+                context = await browser.newContext({ viewport: request.viewport || { width: 1280, height: 800 } });
+                page = await context.newPage();
+                releaseBrowser = async () => { try {
+                    await context.close();
+                }
+                catch { /* ignore */ } try {
+                    await browser.close();
+                }
+                catch { /* ignore */ } };
+            }
+            if (request.mobileMode) {
+                await page.addInitScript(() => {
+                    const origAdd = EventTarget.prototype.addEventListener;
+                    EventTarget.prototype.addEventListener = function (type, listener, options) {
+                        if (['touchstart', 'touchmove', 'wheel'].includes(type)) {
+                            if (typeof options === 'boolean')
+                                options = { capture: options, passive: false };
+                            else if (options && typeof options === 'object')
+                                options = { ...options, passive: false };
+                            else
+                                options = { passive: false };
+                        }
+                        return origAdd.call(this, type, listener, options);
+                    };
+                });
+            }
+            session.browser = browser;
+            session.context = context;
+            session.page = page;
+            session.releaseBrowser = releaseBrowser;
+            session.webAgent = new midscene.PlaywrightAgent(page, {
+                outputFormat: 'html-and-external-assets',
+                groupName: reportGroupName,
+                modelConfig: this.applyModelConfig(batchModelConfig),
+            });
+            this.registerWebSession(sessionId);
+            browserLaunched = true;
+            logger.info(`[BatchAction] Browser launched for session: ${sessionId}`);
+        }
+        // 确保 session 存在
+        if (!session)
+            throw new Error('Session not available');
+        // 复用时重建 agent（每条用例独立报告）
+        const midscene = await import('@aiscene/web/playwright');
+        session.webAgent = new midscene.PlaywrightAgent(session.page, {
+            outputFormat: 'html-and-external-assets',
+            groupName: reportGroupName,
+            modelConfig: this.applyModelConfig(batchModelConfig),
+        });
+        const agent = session.webAgent;
+        const page = session.page;
+        // 检查浏览器存活
+        const browserRef = session.browser;
+        if (browserRef && typeof browserRef.isConnected === 'function' && !browserRef.isConnected()) {
+            throw new Error('Browser has been disconnected');
+        }
+        if (page && typeof page.isClosed === 'function' && page.isClosed()) {
+            throw new Error('Page has been closed');
+        }
+        this.touchWebSession(sessionId);
+        session.webActionRunning = true;
+        try {
+            // 执行登录（仅首条或 freshBrowserPerCase 时）
+            const effectiveLoginContext = tc.loginContext || batchLoginContext;
+            if (effectiveLoginContext && (caseIndex === 0 || request.freshBrowserPerCase || !request.loginContext)) {
+                await executeWebLogin({
+                    source: { loginContext: effectiveLoginContext },
+                    page,
+                    logPrefix: caseLabel,
+                });
+            }
+            // 导航到目标URL
+            const targetUrl = tc.url || request.url;
+            if (targetUrl && webActionRequest.actionType !== 'goto') {
+                await this.safeWebGoto(page, targetUrl, `${caseLabel} Navigate`);
+            }
+            // 执行动作
+            const actionType = tc.actionType || 'aiAction';
+            if (actionType === 'aiAction' || actionType === 'aiAct') {
+                const text = tc.naturalLanguage || '';
+                if (!text)
+                    throw new Error('aiAction requires naturalLanguage');
+                await agent.aiAct(text);
+            }
+            else if (actionType === 'goto') {
+                if (!targetUrl)
+                    throw new Error('goto requires url');
+                await this.safeWebGoto(page, targetUrl, `${caseLabel} goto`);
+            }
+            else if (actionType === 'runCode') {
+                const code = tc.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)),
+                    nativeSwipe: (direction, duration) => playwrightSwipe(page, { direction, duration: duration || 300 }),
+                    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);
+                await fn.call(ctx);
+            }
+            caseSuccess = true;
+            // 提取报告
+            let reportFile = '';
+            try {
+                const reportSess = sessionManager.get(sessionId);
+                if (reportSess?.webAgent && typeof reportSess.webAgent.reportFile === 'string') {
+                    reportFile = reportSess.webAgent.reportFile || '';
+                }
+            }
+            catch { /* ignore */ }
+            caseReportUrl = (await this.safeUploadReport(reportFile, `${request.batchId}-${tc.id}`)) ?? undefined;
+            // 停止抓包
+            try {
+                const capturedRequests = await whistleManager.stopCapture(sessionId);
+                if (capturedRequests.length > 0) {
+                    const uploadResult = await this.saveAndUploadCaptureData(capturedRequests, `${request.batchId}-${tc.id}`);
+                    if (uploadResult)
+                        caseCaptureDataUrl = uploadResult;
+                }
+            }
+            catch { /* ignore */ }
+        }
+        finally {
+            // 无论成功/失败/异常，都必须重置执行标记，否则 closeWebSession 会因 webActionRunning=true 跳过关闭，导致会话名额泄漏
+            const sess = sessionManager.get(sessionId);
+            if (sess)
+                sess.webActionRunning = false;
+        }
+        return { success: caseSuccess, error: caseError, reportUrl: caseReportUrl, captureDataUrl: caseCaptureDataUrl, sessionId, browserLaunched };
+    }
+    /** 批次执行 - 单条 App (Android/iOS) 用例 */
+    async executeBatchAppCase(ws, request, tc, caseIndex, caseLabel, batchLoginContext, batchModelConfig) {
+        const { platform, batchId } = request;
+        const effectiveDeviceId = tc.deviceId || request.deviceId;
+        const effectivePackageName = tc.packageName || request.packageName;
+        const effectiveBundleId = tc.bundleId || request.bundleId;
+        const effectiveLoginContext = tc.loginContext || batchLoginContext;
+        const caseSessionId = `batch-${batchId}-case-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+        const session = sessionManager.create(caseSessionId, ws, effectiveDeviceId);
+        this.activeBatchSessionIds.add(caseSessionId);
+        const caseAbortController = new AbortController();
+        session.abortController = caseAbortController;
+        // 应用模型配置
+        const fullModelConfig = this.applyModelConfig(batchModelConfig);
+        let caseSuccess = false;
+        let caseError;
+        let caseReportUrl;
+        let caseCaptureDataUrl;
+        try {
+            sessionManager.updateStatus(caseSessionId, 'running');
+            // 执行 Android 登录
+            if (platform === 'android') {
+                await executeAndroidLogin({
+                    source: { loginContext: effectiveLoginContext },
+                    deviceId: effectiveDeviceId,
+                    platform,
+                    logPrefix: caseLabel,
+                });
+            }
+            // 创建 Executor
+            const executor = ExecutorFactory.create('action', {
+                sessionId: caseSessionId,
+                onLog: (msg) => {
+                    sessionManager.addLog(caseSessionId, msg);
+                    this.sendMessage(ws, { type: 'log_output', sessionId: caseSessionId, content: msg }, effectiveDeviceId);
+                },
+                onDump: (dump) => {
+                    this.sendMessage(ws, { type: 'action_dump', sessionId: caseSessionId, dump }, effectiveDeviceId);
+                },
+                onExecutionLine: (line) => {
+                    this.sendMessage(ws, { type: 'execution_line', sessionId: caseSessionId, line }, effectiveDeviceId);
+                },
+            });
+            session.executor = executor;
+            // 启动抓包
+            try {
+                await whistleManager.startCapture(caseSessionId, undefined, 3000, request.proxyAccount);
+                logger.info(`[BatchAction] Whistle capture started: sessionId=${caseSessionId}`);
+            }
+            catch (captureErr) {
+                logger.warn(`[BatchAction] Failed to start capture: ${captureErr.message}`);
+            }
+            // 构造 ExecuteConfig
+            const actionType = tc.actionType || 'aiAct';
+            const config = {
+                type: platform,
+                testName: tc.title || tc.id || `batch-${batchId}-case-${caseIndex + 1}`,
+                actionType,
+                naturalLanguage: tc.naturalLanguage,
+                locatePrompt: tc.actionParams?.locatePrompt,
+                actionParams: tc.actionParams,
+                udid: effectiveDeviceId,
+                packageName: effectivePackageName,
+                bundleId: effectiveBundleId,
+                modelConfig: fullModelConfig,
+                executionId: caseSessionId,
+                skipAppRestart: request.skipAppRestart,
+                proxyPort: request.proxyPort,
+                proxyAccount: request.proxyAccount,
+            };
+            // 使用 AbortSignal 监听停止
+            const executePromise = executor.execute(config);
+            const abortPromise = new Promise((resolve) => {
+                caseAbortController.signal.addEventListener('abort', () => {
+                    resolve({ success: false, errorMessage: 'Action stopped by user' });
+                }, { once: true });
+            });
+            const result = await Promise.race([executePromise, abortPromise]);
+            // 清理 executor
+            if (executor && typeof executor.destroy === 'function') {
+                try {
+                    await executor.destroy();
+                }
+                catch { /* ignore */ }
+            }
+            session.executor = undefined;
+            caseSuccess = result.success;
+            if (!result.success && result.errorMessage)
+                caseError = result.errorMessage;
+            // 上传报告
+            const reportFile = result.reportFile || '';
+            caseReportUrl = (await this.safeUploadReport(reportFile, `${batchId}-${tc.id}`)) ?? undefined;
+            // 停止抓包
+            try {
+                const capturedRequests = await whistleManager.stopCapture(caseSessionId);
+                if (capturedRequests.length > 0) {
+                    const uploadResult = await this.saveAndUploadCaptureData(capturedRequests, `${batchId}-${tc.id}`);
+                    if (uploadResult)
+                        caseCaptureDataUrl = uploadResult;
+                }
+            }
+            catch { /* ignore */ }
+        }
+        catch (err) {
+            caseError = err.message;
+            caseSuccess = false;
+            // 清理 executor
+            if (session.executor && typeof session.executor.destroy === 'function') {
+                try {
+                    await session.executor.destroy();
+                }
+                catch { /* ignore */ }
+            }
+            session.executor = undefined;
+        }
+        sessionManager.updateStatus(caseSessionId, caseSuccess ? 'completed' : 'failed');
+        this.activeBatchSessionIds.delete(caseSessionId);
+        try {
+            await this.cleanupSession(caseSessionId);
+        }
+        catch (cleanupError) {
+            logger.warn(`[BatchAction] Session cleanup failed: sessionId=${caseSessionId}, error=${cleanupError.message}`);
+        }
+        return { success: caseSuccess, error: caseError, reportUrl: caseReportUrl, captureDataUrl: caseCaptureDataUrl, sessionId: caseSessionId };
+    }
+    // ==================== Stop Batch ====================
+    async handleStopBatch(ws, request) {
+        const { batchId } = request;
+        const abortController = this.batchAbortControllers.get(batchId);
+        if (abortController) {
+            abortController.abort();
+            this.batchAbortControllers.delete(batchId);
+            this.sendMessage(ws, { type: 'batch_stopped', batchId });
+        }
+        else {
+            this.sendMessage(ws, {
+                type: 'error',
+                message: `No active batch found with id: ${batchId}`,
+            });
+        }
+    }
     // ==================== Start Screencast (for existing web session) ====================
     async handleStartScreencast(ws, request) {
         const session = sessionManager.get(request.sessionId);
@@ -2380,6 +2896,18 @@ export class DebugWebSocketServer {
                     logger.info(`[ModelConfig] Applied ${key} = ${value}`);
                 }
             }
+            // 数值型环境变量：前端可能传 string 或 number
+            const numericEnvKeys = [
+                'MIDSCENE_REPLANNING_CYCLE_LIMIT',
+            ];
+            for (const key of numericEnvKeys) {
+                const raw = modelConfig[key];
+                const value = raw != null ? String(raw) : undefined;
+                if (value) {
+                    process.env[key] = value;
+                    logger.info(`[ModelConfig] Applied ${key} = ${value}`);
+                }
+            }
         }
         // 2. Always force-apply Planning model config from server config
         const planningDefaults = {
@@ -2412,6 +2940,31 @@ export class DebugWebSocketServer {
         logger.info(`[ModelConfig] Model config applied successfully`);
         return result;
     }
+    async postBatchCallback(request, pathName, payload) {
+        const baseUrl = request.callback?.baseUrl?.trim();
+        if (!baseUrl)
+            return;
+        try {
+            const relativePath = pathName.replace(/^\/+/, '');
+            const url = new URL(relativePath, baseUrl.endsWith('/') ? baseUrl : `${baseUrl}/`);
+            const headers = { 'Content-Type': 'application/json' };
+            const token = request.callback?.token?.trim();
+            if (token)
+                headers.Authorization = token.startsWith('Bearer ') ? token : `Bearer ${token}`;
+            const response = await fetch(url.toString(), {
+                method: 'POST',
+                headers,
+                body: JSON.stringify(payload),
+            });
+            if (!response.ok) {
+                const text = await response.text().catch(() => '');
+                logger.warn(`[BatchAction] Callback failed: ${response.status} ${response.statusText}, path=${pathName}, body=${text.slice(0, 300)}`);
+            }
+        }
+        catch (error) {
+            logger.warn(`[BatchAction] Callback error: path=${pathName}, error=${error.message}`);
+        }
+    }
     sendMessage(ws, message, deviceId) {
         try {
             const msg = {