@aiscene/android 1.3.6 → 1.6.0-cache

package/dist/es/index.mjs

@@ -1,4 +1,3 @@
-import * as __rspack_external__ffmpeg_installer_ffmpeg_acfac5f1 from "@ffmpeg-installer/ffmpeg";
 import * as __rspack_external__midscene_shared_logger_b1dc2426 from "@midscene/shared/logger";
 import * as __rspack_external_node_fs_5ea92f0c from "node:fs";
 import * as __rspack_external_node_module_ab9f2194 from "node:module";
@@ -12,6 +11,7 @@ import { createImgBase64ByFormat, isValidPNGImageBuffer } from "@midscene/shared
 import { mergeAndNormalizeAppNameMapping, normalizeForComparison, repeat } from "@midscene/shared/utils";
 import { ADB } from "appium-adb";
 import { Agent } from "@midscene/core/agent";
+import { BaseMidsceneTools } from "@midscene/shared/mcp";
 var __webpack_modules__ = {
     "./src/scrcpy-manager.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
         __webpack_require__.d(__webpack_exports__, {
@@ -33,24 +33,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,
@@ -90,21 +92,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;
@@ -132,7 +134,8 @@ var __webpack_modules__ = {
             }
             getFfmpegPath() {
                 try {
-                    const ffmpegInstaller = __webpack_require__("@ffmpeg-installer/ffmpeg");
+                    const dynamicRequire = (0, node_module__rspack_import_1.createRequire)(import.meta.url);
+                    const ffmpegInstaller = dynamicRequire('@ffmpeg-installer/ffmpeg');
                     debugScrcpy(`Using ffmpeg from npm package: ${ffmpegInstaller.path}`);
                     return ffmpegInstaller.path;
                 } catch (error) {
@@ -147,22 +150,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([
@@ -173,23 +201,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();
@@ -219,7 +231,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)`);
@@ -282,7 +294,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 = [
@@ -295,7 +307,9 @@ var __webpack_modules__ = {
                         '-f',
                         'image2pipe',
                         '-vcodec',
-                        'png',
+                        'mjpeg',
+                        '-q:v',
+                        '5',
                         '-loglevel',
                         'error',
                         'pipe:1'
@@ -318,13 +332,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)=>{
@@ -356,7 +370,6 @@ var __webpack_modules__ = {
                 this.spsHeader = null;
                 this.lastRawKeyframe = null;
                 this.isInitialized = false;
-                this.h264SearchConfigFn = null;
                 this.keyframeResolvers = [];
                 if (reader) try {
                     reader.cancel();
@@ -384,20 +397,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 = __rspack_external__ffmpeg_installer_ffmpeg_acfac5f1;
-    },
     "@midscene/shared/logger" (module) {
         module.exports = __rspack_external__midscene_shared_logger_b1dc2426;
     },
@@ -465,18 +477,13 @@ class ScrcpyDeviceAdapter {
     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;
     }
@@ -511,8 +518,8 @@ class ScrcpyDeviceAdapter {
     }
     async screenshotBase64(deviceInfo) {
         const manager = await this.ensureManager(deviceInfo);
-        const screenshotBuffer = await manager.getScreenshotPng();
-        return createImgBase64ByFormat('png', screenshotBuffer.toString('base64'));
+        const screenshotBuffer = await manager.getScreenshotJpeg();
+        return createImgBase64ByFormat('jpeg', screenshotBuffer.toString('base64'));
     }
     getResolution() {
         return this.manager?.getResolution() ?? null;
@@ -523,8 +530,7 @@ class ScrcpyDeviceAdapter {
         debugAdapter(`Using scrcpy resolution: ${resolution.width}x${resolution.height}`);
         return {
             width: resolution.width,
-            height: resolution.height,
-            dpr: deviceInfo.dpr
+            height: resolution.height
         };
     }
     getScalingRatio(physicalWidth) {
@@ -543,16 +549,14 @@ class ScrcpyDeviceAdapter {
         }
         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;
@@ -779,7 +783,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() {
@@ -1025,8 +1029,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) {
@@ -1804,4 +1807,58 @@ async function agentFromAdbDevice(deviceId, opts) {
     await device.connect();
     return new AndroidAgent(device, opts);
 }
-export { AndroidAgent, AndroidDevice, agentFromAdbDevice, getConnectedDevices, overrideAIConfig };
+const debug = (0, logger_.getDebug)('mcp:android-tools');
+class AndroidMidsceneTools extends 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: 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')
+            }
+        ];
+    }
+}
+export { AndroidAgent, AndroidDevice, AndroidMidsceneTools, ScrcpyDeviceAdapter, agentFromAdbDevice, getConnectedDevices, overrideAIConfig };