@aiscene/android 1.3.6 → 1.6.0-cache

package/dist/lib/index.js

@@ -24,24 +24,26 @@ var __webpack_modules__ = {
             return obj;
         }
         const debugScrcpy = (0, _midscene_shared_logger__rspack_import_3.getDebug)('android:scrcpy');
+        const warnScrcpy = (0, _midscene_shared_logger__rspack_import_3.getDebug)('android:scrcpy', {
+            console: true
+        });
         const NAL_TYPE_IDR = 5;
         const NAL_TYPE_SPS = 7;
         const NAL_TYPE_PPS = 8;
         const NAL_TYPE_MASK = 0x1f;
-        const START_CODE_4_BYTE = Buffer.from([
-            0x00,
-            0x00,
-            0x00,
-            0x01
-        ]);
         const DEFAULT_MAX_SIZE = 0;
-        const DEFAULT_VIDEO_BIT_RATE = 2000000;
+        const DEFAULT_VIDEO_BIT_RATE = 100000000;
+        const MAX_VIDEO_BIT_RATE = 100000000;
         const DEFAULT_IDLE_TIMEOUT_MS = 30000;
         const MAX_KEYFRAME_WAIT_MS = 5000;
         const FRESH_FRAME_TIMEOUT_MS = 300;
         const KEYFRAME_POLL_INTERVAL_MS = 200;
         const MAX_SCAN_BYTES = 1000;
         const CONNECTION_WAIT_MS = 1000;
+        const BUSY_LOOP_WINDOW_MS = 1000;
+        const BUSY_LOOP_MAX_READS = 500;
+        const BUSY_LOOP_COOLDOWN_MS = 50;
+        const BUSY_LOOP_WARN_INTERVAL_MS = 5000;
         const DEFAULT_SCRCPY_CONFIG = {
             enabled: false,
             maxSize: DEFAULT_MAX_SIZE,
@@ -81,21 +83,21 @@ var __webpack_modules__ = {
                 try {
                     this.isConnecting = true;
                     debugScrcpy('Starting scrcpy connection...');
-                    const { AdbScrcpyClient, AdbScrcpyOptions2_1 } = await import("@yume-chan/adb-scrcpy");
+                    const { AdbScrcpyClient, AdbScrcpyOptions3_3_3 } = await import("@yume-chan/adb-scrcpy");
                     const { ReadableStream } = await import("@yume-chan/stream-extra");
-                    const { ScrcpyOptions3_1, DefaultServerPath, h264SearchConfiguration } = await import("@yume-chan/scrcpy");
-                    this.h264SearchConfigFn = h264SearchConfiguration;
+                    const { DefaultServerPath } = await import("@yume-chan/scrcpy");
                     const serverBinPath = this.resolveServerBinPath();
                     await AdbScrcpyClient.pushServer(this.adb, ReadableStream.from((0, node_fs__rspack_import_0.createReadStream)(serverBinPath)));
-                    const scrcpyOptions = new ScrcpyOptions3_1({
+                    const scrcpyOptions = new AdbScrcpyOptions3_3_3({
                         audio: false,
                         control: false,
                         maxSize: this.options.maxSize,
                         videoBitRate: this.options.videoBitRate,
-                        sendFrameMeta: false,
-                        videoCodecOptions: 'i-frame-interval=0'
+                        maxFps: 10,
+                        sendFrameMeta: true,
+                        videoCodecOptions: 'i-frame-interval=0,bitrate-mode=2'
                     });
-                    this.scrcpyClient = await AdbScrcpyClient.start(this.adb, DefaultServerPath, new AdbScrcpyOptions2_1(scrcpyOptions));
+                    this.scrcpyClient = await AdbScrcpyClient.start(this.adb, DefaultServerPath, scrcpyOptions);
                     const videoStreamPromise = this.scrcpyClient.videoStream;
                     if (!videoStreamPromise) throw new Error('Scrcpy client did not provide video stream');
                     this.videoStream = await videoStreamPromise;
@@ -123,7 +125,8 @@ var __webpack_modules__ = {
             }
             getFfmpegPath() {
                 try {
-                    const ffmpegInstaller = __webpack_require__("@ffmpeg-installer/ffmpeg");
+                    const dynamicRequire = (0, node_module__rspack_import_1.createRequire)(__rslib_import_meta_url__);
+                    const ffmpegInstaller = dynamicRequire('@ffmpeg-installer/ffmpeg');
                     debugScrcpy(`Using ffmpeg from npm package: ${ffmpegInstaller.path}`);
                     return ffmpegInstaller.path;
                 } catch (error) {
@@ -138,22 +141,47 @@ var __webpack_modules__ = {
                 this.consumeFramesLoop(reader);
             }
             async consumeFramesLoop(reader) {
+                let readCount = 0;
+                let windowStart = Date.now();
+                let lastBusyWarn = 0;
+                let totalReads = 0;
                 try {
                     while(true){
                         const { done, value } = await reader.read();
                         if (done) break;
+                        totalReads++;
+                        readCount++;
+                        const now = Date.now();
+                        const elapsed = now - windowStart;
+                        if (elapsed >= BUSY_LOOP_WINDOW_MS) {
+                            const readsPerSec = readCount / elapsed * 1000;
+                            if (readCount > BUSY_LOOP_MAX_READS) {
+                                if (now - lastBusyWarn >= BUSY_LOOP_WARN_INTERVAL_MS) {
+                                    warnScrcpy(`[CPU-DIAG] Possible busy loop detected! ${readCount} reads in ${elapsed}ms (${readsPerSec.toFixed(0)} reads/sec). Total reads: ${totalReads}. Throttling with ${BUSY_LOOP_COOLDOWN_MS}ms delay.`);
+                                    lastBusyWarn = now;
+                                }
+                                await new Promise((resolve)=>setTimeout(resolve, BUSY_LOOP_COOLDOWN_MS));
+                            } else debugScrcpy(`[CPU-DIAG] Frame loop stats: ${readCount} reads in ${elapsed}ms (${readsPerSec.toFixed(1)} reads/sec), total: ${totalReads}`);
+                            readCount = 0;
+                            windowStart = Date.now();
+                        }
                         this.processFrame(value);
                     }
                 } catch (error) {
-                    debugScrcpy(`Frame consumer error: ${error}`);
+                    debugScrcpy(`Frame consumer error (total reads: ${totalReads}): ${error}`);
                     await this.disconnect();
                 }
+                debugScrcpy(`Frame consumer loop ended normally (total reads: ${totalReads})`);
             }
             processFrame(packet) {
+                if ('configuration' === packet.type) {
+                    this.spsHeader = Buffer.from(packet.data);
+                    debugScrcpy(`Received SPS/PPS configuration: ${this.spsHeader.length}B`);
+                    return;
+                }
                 const frameBuffer = Buffer.from(packet.data);
-                const actualKeyFrame = detectH264KeyFrame(frameBuffer);
-                if (actualKeyFrame && !this.spsHeader) this.extractSpsHeader(frameBuffer);
-                if (actualKeyFrame && this.spsHeader) {
+                const isKeyFrame = detectH264KeyFrame(frameBuffer);
+                if (isKeyFrame && this.spsHeader) {
                     this.lastRawKeyframe = frameBuffer;
                     if (this.keyframeResolvers.length > 0) {
                         const combined = Buffer.concat([
@@ -164,23 +192,7 @@ var __webpack_modules__ = {
                     }
                 }
             }
-            extractSpsHeader(frameBuffer) {
-                if (!this.h264SearchConfigFn) return;
-                try {
-                    const config = this.h264SearchConfigFn(new Uint8Array(frameBuffer));
-                    if (!config.sequenceParameterSet || !config.pictureParameterSet) return;
-                    this.spsHeader = Buffer.concat([
-                        START_CODE_4_BYTE,
-                        Buffer.from(config.sequenceParameterSet),
-                        START_CODE_4_BYTE,
-                        Buffer.from(config.pictureParameterSet)
-                    ]);
-                    debugScrcpy(`Extracted SPS/PPS: SPS=${config.sequenceParameterSet.length}B, PPS=${config.pictureParameterSet.length}B, total=${this.spsHeader.length}B`);
-                } catch (error) {
-                    debugScrcpy(`Failed to extract SPS/PPS from keyframe: ${error}`);
-                }
-            }
-            async getScreenshotPng() {
+            async getScreenshotJpeg() {
                 const perfStart = Date.now();
                 const t1 = Date.now();
                 await this.ensureConnected();
@@ -210,7 +222,7 @@ var __webpack_modules__ = {
                 this.resetIdleTimer();
                 debugScrcpy(`Decoding H.264 stream: ${keyframeBuffer.length} bytes (${frameSource})`);
                 const t4 = Date.now();
-                const result = await this.decodeH264ToPng(keyframeBuffer);
+                const result = await this.decodeH264ToJpeg(keyframeBuffer);
                 const decodeTime = Date.now() - t4;
                 const totalTime = Date.now() - perfStart;
                 debugScrcpy(`Performance: total=${totalTime}ms (connect=${connectTime}ms, spsWait=${spsWaitTime}ms, frameWait=${frameWaitTime}ms[${frameSource}], decode=${decodeTime}ms)`);
@@ -273,7 +285,7 @@ var __webpack_modules__ = {
                     return false;
                 }
             }
-            async decodeH264ToPng(h264Buffer) {
+            async decodeH264ToJpeg(h264Buffer) {
                 const { spawn } = await import("node:child_process");
                 return new Promise((resolve, reject)=>{
                     const ffmpegArgs = [
@@ -286,7 +298,9 @@ var __webpack_modules__ = {
                         '-f',
                         'image2pipe',
                         '-vcodec',
-                        'png',
+                        'mjpeg',
+                        '-q:v',
+                        '5',
                         '-loglevel',
                         'error',
                         'pipe:1'
@@ -309,13 +323,13 @@ var __webpack_modules__ = {
                     });
                     ffmpeg.on('close', (code)=>{
                         if (0 === code && chunks.length > 0) {
-                            const pngBuffer = Buffer.concat(chunks);
-                            debugScrcpy(`FFmpeg decode successful, PNG size: ${pngBuffer.length} bytes`);
-                            resolve(pngBuffer);
+                            const jpegBuffer = Buffer.concat(chunks);
+                            debugScrcpy(`FFmpeg decode successful, JPEG size: ${jpegBuffer.length} bytes`);
+                            resolve(jpegBuffer);
                         } else {
                             const errorMsg = stderrOutput || `FFmpeg exited with code ${code}`;
                             debugScrcpy(`FFmpeg decode failed: ${errorMsg}`);
-                            reject(new Error(`H.264 to PNG decode failed: ${errorMsg}`));
+                            reject(new Error(`H.264 to JPEG decode failed: ${errorMsg}`));
                         }
                     });
                     ffmpeg.on('error', (error)=>{
@@ -347,7 +361,6 @@ var __webpack_modules__ = {
                 this.spsHeader = null;
                 this.lastRawKeyframe = null;
                 this.isInitialized = false;
-                this.h264SearchConfigFn = null;
                 this.keyframeResolvers = [];
                 if (reader) try {
                     reader.cancel();
@@ -375,20 +388,19 @@ var __webpack_modules__ = {
                 _define_property(this, "keyframeResolvers", []);
                 _define_property(this, "lastRawKeyframe", null);
                 _define_property(this, "videoResolution", null);
-                _define_property(this, "h264SearchConfigFn", null);
                 _define_property(this, "streamReader", null);
                 this.adb = adb;
+                const requestedBitRate = options.videoBitRate ?? DEFAULT_VIDEO_BIT_RATE;
+                const clampedBitRate = Math.min(requestedBitRate, MAX_VIDEO_BIT_RATE);
+                if (requestedBitRate > MAX_VIDEO_BIT_RATE) warnScrcpy(`videoBitRate ${requestedBitRate} exceeds maximum ${MAX_VIDEO_BIT_RATE}, clamped to ${clampedBitRate}`);
                 this.options = {
                     maxSize: options.maxSize ?? DEFAULT_MAX_SIZE,
-                    videoBitRate: options.videoBitRate ?? DEFAULT_VIDEO_BIT_RATE,
+                    videoBitRate: clampedBitRate,
                     idleTimeoutMs: options.idleTimeoutMs ?? DEFAULT_IDLE_TIMEOUT_MS
                 };
             }
         }
     },
-    "@ffmpeg-installer/ffmpeg" (module) {
-        module.exports = require("@ffmpeg-installer/ffmpeg");
-    },
     "@midscene/shared/logger" (module) {
         module.exports = require("@midscene/shared/logger");
     },
@@ -446,10 +458,12 @@ var __webpack_exports__ = {};
 (()=>{
     __webpack_require__.r(__webpack_exports__);
     __webpack_require__.d(__webpack_exports__, {
+        AndroidMidsceneTools: ()=>AndroidMidsceneTools,
         getConnectedDevices: ()=>getConnectedDevices,
         overrideAIConfig: ()=>env_namespaceObject.overrideAIConfig,
         AndroidAgent: ()=>AndroidAgent,
         agentFromAdbDevice: ()=>agentFromAdbDevice,
+        ScrcpyDeviceAdapter: ()=>ScrcpyDeviceAdapter,
         AndroidDevice: ()=>AndroidDevice
     });
     const external_node_assert_namespaceObject = require("node:assert");
@@ -496,18 +510,13 @@ var __webpack_exports__ = {};
         resolveConfig(deviceInfo) {
             if (this.resolvedConfig) return this.resolvedConfig;
             const config = this.scrcpyConfig;
-            let maxSize = config?.maxSize ?? scrcpy_manager.o.maxSize;
-            if (config?.maxSize === void 0) {
-                const physicalMax = Math.max(deviceInfo.physicalWidth, deviceInfo.physicalHeight);
-                const scale = this.screenshotResizeScale ?? 1 / deviceInfo.dpr;
-                maxSize = Math.round(physicalMax * scale);
-                debugAdapter(`Auto-calculated maxSize: ${maxSize} (physical=${physicalMax}, scale=${scale.toFixed(3)}, ${void 0 !== this.screenshotResizeScale ? 'from screenshotResizeScale' : 'from 1/dpr'})`);
-            }
+            const maxSize = config?.maxSize ?? scrcpy_manager.o.maxSize;
+            const videoBitRate = config?.videoBitRate ?? scrcpy_manager.o.videoBitRate;
             this.resolvedConfig = {
                 enabled: this.isEnabled(),
                 maxSize,
                 idleTimeoutMs: config?.idleTimeoutMs ?? scrcpy_manager.o.idleTimeoutMs,
-                videoBitRate: config?.videoBitRate ?? scrcpy_manager.o.videoBitRate
+                videoBitRate
             };
             return this.resolvedConfig;
         }
@@ -542,8 +551,8 @@ var __webpack_exports__ = {};
         }
         async screenshotBase64(deviceInfo) {
             const manager = await this.ensureManager(deviceInfo);
-            const screenshotBuffer = await manager.getScreenshotPng();
-            return (0, img_namespaceObject.createImgBase64ByFormat)('png', screenshotBuffer.toString('base64'));
+            const screenshotBuffer = await manager.getScreenshotJpeg();
+            return (0, img_namespaceObject.createImgBase64ByFormat)('jpeg', screenshotBuffer.toString('base64'));
         }
         getResolution() {
             return this.manager?.getResolution() ?? null;
@@ -554,8 +563,7 @@ var __webpack_exports__ = {};
             debugAdapter(`Using scrcpy resolution: ${resolution.width}x${resolution.height}`);
             return {
                 width: resolution.width,
-                height: resolution.height,
-                dpr: deviceInfo.dpr
+                height: resolution.height
             };
         }
         getScalingRatio(physicalWidth) {
@@ -574,16 +582,14 @@ var __webpack_exports__ = {};
             }
             this.resolvedConfig = null;
         }
-        constructor(deviceId, scrcpyConfig, screenshotResizeScale){
+        constructor(deviceId, scrcpyConfig){
             _define_property(this, "deviceId", void 0);
             _define_property(this, "scrcpyConfig", void 0);
-            _define_property(this, "screenshotResizeScale", void 0);
             _define_property(this, "manager", void 0);
             _define_property(this, "resolvedConfig", void 0);
             _define_property(this, "initFailed", void 0);
             this.deviceId = deviceId;
             this.scrcpyConfig = scrcpyConfig;
-            this.screenshotResizeScale = screenshotResizeScale;
             this.manager = null;
             this.resolvedConfig = null;
             this.initFailed = false;
@@ -810,7 +816,7 @@ ${Object.keys(size).filter((key)=>size[key]).map((key)=>`  ${key} size: ${size[k
             });
         }
         getScrcpyAdapter() {
-            if (!this.scrcpyAdapter) this.scrcpyAdapter = new ScrcpyDeviceAdapter(this.deviceId, this.options?.scrcpyConfig, this.options?.screenshotResizeScale);
+            if (!this.scrcpyAdapter) this.scrcpyAdapter = new ScrcpyDeviceAdapter(this.deviceId, this.options?.scrcpyConfig);
             return this.scrcpyAdapter;
         }
         async getDevicePhysicalInfo() {
@@ -1056,8 +1062,7 @@ ${Object.keys(size).filter((key)=>size[key]).map((key)=>`  ${key} size: ${size[k
             const logicalHeight = Math.round(height * scale);
             return {
                 width: logicalWidth,
-                height: logicalHeight,
-                dpr: this.devicePixelRatio
+                height: logicalHeight
             };
         }
         async cacheFeatureForPoint(center, options) {
@@ -1836,15 +1841,74 @@ ${Object.keys(size).filter((key)=>size[key]).map((key)=>`  ${key} size: ${size[k
         await device.connect();
         return new AndroidAgent(device, opts);
     }
+    const mcp_namespaceObject = require("@midscene/shared/mcp");
+    const debug = (0, logger_.getDebug)('mcp:android-tools');
+    class AndroidMidsceneTools extends mcp_namespaceObject.BaseMidsceneTools {
+        createTemporaryDevice() {
+            return new AndroidDevice('temp-for-action-space', {});
+        }
+        async ensureAgent(deviceId) {
+            if (this.agent && deviceId) {
+                try {
+                    await this.agent.destroy?.();
+                } catch (error) {
+                    debug('Failed to destroy agent during cleanup:', error);
+                }
+                this.agent = void 0;
+            }
+            if (this.agent) return this.agent;
+            debug('Creating Android agent with deviceId:', deviceId || 'auto-detect');
+            const agent = await agentFromAdbDevice(deviceId, {
+                autoDismissKeyboard: false
+            });
+            this.agent = agent;
+            return agent;
+        }
+        preparePlatformTools() {
+            return [
+                {
+                    name: 'android_connect',
+                    description: 'Connect to Android device via ADB. If deviceId not provided, uses the first available device.',
+                    schema: {
+                        deviceId: core_namespaceObject.z.string().optional().describe('Android device ID (from adb devices)')
+                    },
+                    handler: async ({ deviceId })=>{
+                        const agent = await this.ensureAgent(deviceId);
+                        const screenshot = await agent.page.screenshotBase64();
+                        return {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: `Connected to Android device${deviceId ? `: ${deviceId}` : ' (auto-detected)'}`
+                                },
+                                ...this.buildScreenshotContent(screenshot)
+                            ],
+                            isError: false
+                        };
+                    }
+                },
+                {
+                    name: 'android_disconnect',
+                    description: 'Disconnect from current Android device and release ADB resources',
+                    schema: {},
+                    handler: this.createDisconnectHandler('Android device')
+                }
+            ];
+        }
+    }
 })();
 exports.AndroidAgent = __webpack_exports__.AndroidAgent;
 exports.AndroidDevice = __webpack_exports__.AndroidDevice;
+exports.AndroidMidsceneTools = __webpack_exports__.AndroidMidsceneTools;
+exports.ScrcpyDeviceAdapter = __webpack_exports__.ScrcpyDeviceAdapter;
 exports.agentFromAdbDevice = __webpack_exports__.agentFromAdbDevice;
 exports.getConnectedDevices = __webpack_exports__.getConnectedDevices;
 exports.overrideAIConfig = __webpack_exports__.overrideAIConfig;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "AndroidAgent",
     "AndroidDevice",
+    "AndroidMidsceneTools",
+    "ScrcpyDeviceAdapter",
     "agentFromAdbDevice",
     "getConnectedDevices",
     "overrideAIConfig"