@midscene/ios 0.30.6-beta-20251022112352.0 → 0.30.6-beta-20251023082056.0

package/dist/lib/bin.js

@@ -11649,8 +11649,8 @@ var __webpack_exports__ = {};
             }));
             this._app.use((req, _res, next)=>{
                 const { context } = req.body || {};
-                if (context && 'updateContext' in this.page && 'function' == typeof this.page.updateContext) {
-                    this.page.updateContext(context);
+                if (context && 'updateContext' in this.agent.interface && 'function' == typeof this.agent.interface.updateContext) {
+                    this.agent.interface.updateContext(context);
                     console.log('Context updated by PlaygroundServer middleware');
                 }
                 next();
@@ -11669,6 +11669,22 @@ var __webpack_exports__ = {};
             (0, external_node_fs_namespaceObject.writeFileSync)(tmpFile, context);
             return tmpFile;
         }
+        async recreateAgent() {
+            if (!this.agentFactory) return void console.warn('Cannot recreate agent: factory function not provided. Agent recreation is only available when using factory mode.');
+            console.log('Recreating agent to cancel current task...');
+            try {
+                if (this.agent && 'function' == typeof this.agent.destroy) await this.agent.destroy();
+            } catch (error) {
+                console.warn('Failed to destroy old agent:', error);
+            }
+            try {
+                this.agent = await this.agentFactory();
+                console.log('Agent recreated successfully');
+            } catch (error) {
+                console.error('Failed to recreate agent:', error);
+                throw error;
+            }
+        }
         setupRoutes() {
             this._app.get('/status', async (req, res)=>{
                 res.send({
@@ -11696,7 +11712,7 @@ var __webpack_exports__ = {};
             this._app.post('/action-space', async (req, res)=>{
                 try {
                     let actionSpace = [];
-                    actionSpace = await this.page.actionSpace();
+                    actionSpace = await this.agent.interface.actionSpace();
                     const processedActionSpace = actionSpace.map((action)=>{
                         if (action && 'object' == typeof action && 'paramSchema' in action) {
                             const typedAction = action;
@@ -11745,7 +11761,12 @@ var __webpack_exports__ = {};
                 if (!type) return res.status(400).json({
                     error: 'type is required'
                 });
+                if (this.currentTaskId) return res.status(409).json({
+                    error: 'Another task is already running',
+                    currentTaskId: this.currentTaskId
+                });
                 if (requestId) {
+                    this.currentTaskId = requestId;
                     this.taskProgressTips[requestId] = '';
                     this.agent.onTaskStartTip = (tip)=>{
                         this.taskProgressTips[requestId] = tip;
@@ -11760,7 +11781,7 @@ var __webpack_exports__ = {};
                 };
                 const startTime = Date.now();
                 try {
-                    const actionSpace = await this.page.actionSpace();
+                    const actionSpace = await this.agent.interface.actionSpace();
                     const value = {
                         type,
                         prompt,
@@ -11787,7 +11808,10 @@ var __webpack_exports__ = {};
                 const timeCost = Date.now() - startTime;
                 if (response.error) console.error(`handle request failed after ${timeCost}ms: requestId: ${requestId}, ${response.error}`);
                 else console.log(`handle request done after ${timeCost}ms: requestId: ${requestId}`);
-                if (requestId) delete this.taskProgressTips[requestId];
+                if (requestId) {
+                    delete this.taskProgressTips[requestId];
+                    if (this.currentTaskId === requestId) this.currentTaskId = null;
+                }
             });
             this._app.post('/cancel/:requestId', async (req, res)=>{
                 const { requestId } = req.params;
@@ -11795,9 +11819,17 @@ var __webpack_exports__ = {};
                     error: 'requestId is required'
                 });
                 try {
-                    if (this.taskProgressTips[requestId]) delete this.taskProgressTips[requestId];
+                    if (this.currentTaskId !== requestId) return res.json({
+                        status: 'not_found',
+                        message: 'Task not found or already completed'
+                    });
+                    console.log(`Cancelling task: ${requestId}`);
+                    await this.recreateAgent();
+                    delete this.taskProgressTips[requestId];
+                    this.currentTaskId = null;
                     res.json({
-                        status: 'cancelled'
+                        status: 'cancelled',
+                        message: 'Task cancelled successfully by recreating agent'
                     });
                 } catch (error) {
                     const errorMessage = error instanceof Error ? error.message : 'Unknown error';
@@ -11809,10 +11841,10 @@ var __webpack_exports__ = {};
             });
             this._app.get('/screenshot', async (_req, res)=>{
                 try {
-                    if ('function' != typeof this.page.screenshotBase64) return res.status(500).json({
+                    if ('function' != typeof this.agent.interface.screenshotBase64) return res.status(500).json({
                         error: 'Screenshot method not available on current interface'
                     });
-                    const base64Screenshot = await this.page.screenshotBase64();
+                    const base64Screenshot = await this.agent.interface.screenshotBase64();
                     res.json({
                         screenshot: base64Screenshot,
                         timestamp: Date.now()
@@ -11827,9 +11859,9 @@ var __webpack_exports__ = {};
             });
             this._app.get('/interface-info', async (_req, res)=>{
                 try {
-                    var _this_page_describe, _this_page;
-                    const type = this.page.interfaceType || 'Unknown';
-                    const description = (null == (_this_page_describe = (_this_page = this.page).describe) ? void 0 : _this_page_describe.call(_this_page)) || void 0;
+                    var _this_agent_interface_describe, _this_agent_interface;
+                    const type = this.agent.interface.interfaceType || 'Unknown';
+                    const description = (null == (_this_agent_interface_describe = (_this_agent_interface = this.agent.interface).describe) ? void 0 : _this_agent_interface_describe.call(_this_agent_interface)) || void 0;
                     res.json({
                         type,
                         description
@@ -11897,6 +11929,11 @@ var __webpack_exports__ = {};
             }
         }
         async launch(port) {
+            if (this.agentFactory) {
+                console.log('Initializing agent from factory function...');
+                this.agent = await this.agentFactory();
+                console.log('Agent initialized successfully');
+            }
             this.initializeApp();
             this.port = port || defaultPort;
             return new Promise((resolve)=>{
@@ -11925,24 +11962,30 @@ var __webpack_exports__ = {};
                 } else resolve();
             });
         }
-        constructor(page, agent, staticPath = STATIC_PATH, id){
+        constructor(agent, staticPath = STATIC_PATH, id){
             _define_property(this, "_app", void 0);
             _define_property(this, "tmpDir", void 0);
             _define_property(this, "server", void 0);
             _define_property(this, "port", void 0);
-            _define_property(this, "page", void 0);
             _define_property(this, "agent", void 0);
             _define_property(this, "staticPath", void 0);
             _define_property(this, "taskProgressTips", void 0);
             _define_property(this, "id", void 0);
             _define_property(this, "_initialized", false);
+            _define_property(this, "agentFactory", void 0);
+            _define_property(this, "currentTaskId", null);
             this._app = express_default()();
             this.tmpDir = (0, utils_namespaceObject.getTmpDir)();
-            this.page = page;
-            this.agent = agent;
             this.staticPath = staticPath;
             this.taskProgressTips = {};
             this.id = id || (0, shared_utils_namespaceObject.uuid)();
+            if ('function' == typeof agent) {
+                this.agentFactory = agent;
+                this.agent = null;
+            } else {
+                this.agent = agent;
+                this.agentFactory = null;
+            }
         }
     }
     const external_node_child_process_namespaceObject = require("node:child_process");
@@ -12140,19 +12183,45 @@ var __webpack_exports__ = {};
         }
         async swipe(fromX, fromY, toX, toY, duration = 500) {
             this.ensureSession();
-            try {
-                await this.makeRequest('POST', `/session/${this.sessionId}/wda/dragfromtoforduration`, {
-                    fromX,
-                    fromY,
-                    toX,
-                    toY,
-                    duration: duration / 1000
-                });
-                debugIOS(`Swiped from (${fromX}, ${fromY}) to (${toX}, ${toY}) in ${duration}ms`);
-            } catch (error) {
-                debugIOS(`Failed to swipe from (${fromX}, ${fromY}) to (${toX}, ${toY}): ${error}`);
-                throw new Error(`Failed to swipe: ${error}`);
-            }
+            const actions = {
+                actions: [
+                    {
+                        type: 'pointer',
+                        id: 'finger1',
+                        parameters: {
+                            pointerType: 'touch'
+                        },
+                        actions: [
+                            {
+                                type: 'pointerMove',
+                                duration: 0,
+                                x: fromX,
+                                y: fromY
+                            },
+                            {
+                                type: 'pointerDown',
+                                button: 0
+                            },
+                            {
+                                type: 'pause',
+                                duration: 100
+                            },
+                            {
+                                type: 'pointerMove',
+                                duration,
+                                x: toX,
+                                y: toY
+                            },
+                            {
+                                type: 'pointerUp',
+                                button: 0
+                            }
+                        ]
+                    }
+                ]
+            };
+            await this.makeRequest('POST', `/session/${this.sessionId}/actions`, actions);
+            debugIOS(`Swiped using W3C Actions from (${fromX}, ${fromY}) to (${toX}, ${toY}) in ${duration}ms`);
         }
         async longPress(x, y, duration = 1000) {
             this.ensureSession();
@@ -12298,8 +12367,7 @@ var __webpack_exports__ = {};
                     await this.swipe(from.center[0], from.center[1], to.center[0], to.center[1]);
                 }),
                 (0, device_namespaceObject.defineActionKeyboardPress)(async (param)=>{
-                    const key = param.keyName;
-                    await this.pressKey(key);
+                    await this.pressKey(param.keyName);
                 }),
                 (0, device_namespaceObject.defineAction)({
                     name: 'IOSHomeButton',
@@ -12455,23 +12523,23 @@ ScreenSize: ${size.width}x${size.height} (DPR: ${size.scale})
             return '';
         }
         async tap(x, y) {
-            await this.wdaBackend.tap(x, y);
+            await this.wdaBackend.tap(Math.round(x), Math.round(y));
         }
         async mouseClick(x, y) {
             debugDevice(`mouseClick at coordinates (${x}, ${y})`);
             await this.tap(x, y);
         }
         async doubleTap(x, y) {
-            await this.wdaBackend.doubleTap(x, y);
+            await this.wdaBackend.doubleTap(Math.round(x), Math.round(y));
         }
         async tripleTap(x, y) {
-            await this.wdaBackend.tripleTap(x, y);
+            await this.wdaBackend.tripleTap(Math.round(x), Math.round(y));
         }
         async longPress(x, y, duration = 1000) {
-            await this.wdaBackend.longPress(x, y, duration);
+            await this.wdaBackend.longPress(Math.round(x), Math.round(y), duration);
         }
         async swipe(fromX, fromY, toX, toY, duration = 500) {
-            await this.wdaBackend.swipe(fromX, fromY, toX, toY, duration);
+            await this.wdaBackend.swipe(Math.round(fromX), Math.round(fromY), Math.round(toX), Math.round(toY), duration);
         }
         async typeText(text, options) {
             var _this_options;
@@ -12494,49 +12562,49 @@ ScreenSize: ${size.width}x${size.height} (DPR: ${size.scale})
         async scrollUp(distance, startPoint) {
             const { width, height } = await this.size();
             const start = startPoint ? {
-                x: startPoint.left,
-                y: startPoint.top
+                x: Math.round(startPoint.left),
+                y: Math.round(startPoint.top)
             } : {
-                x: width / 2,
-                y: height / 2
+                x: Math.round(width / 2),
+                y: Math.round(height / 2)
             };
-            const scrollDistance = distance || height / 3;
+            const scrollDistance = Math.round(distance || height / 3);
             await this.swipe(start.x, start.y, start.x, start.y + scrollDistance);
         }
         async scrollDown(distance, startPoint) {
             const { width, height } = await this.size();
             const start = startPoint ? {
-                x: startPoint.left,
-                y: startPoint.top
+                x: Math.round(startPoint.left),
+                y: Math.round(startPoint.top)
             } : {
-                x: width / 2,
-                y: height / 2
+                x: Math.round(width / 2),
+                y: Math.round(height / 2)
             };
-            const scrollDistance = distance || height / 3;
+            const scrollDistance = Math.round(distance || height / 3);
             await this.swipe(start.x, start.y, start.x, start.y - scrollDistance);
         }
         async scrollLeft(distance, startPoint) {
             const { width, height } = await this.size();
             const start = startPoint ? {
-                x: startPoint.left,
-                y: startPoint.top
+                x: Math.round(startPoint.left),
+                y: Math.round(startPoint.top)
             } : {
-                x: width / 2,
-                y: height / 2
+                x: Math.round(width / 2),
+                y: Math.round(height / 2)
             };
-            const scrollDistance = distance || width / 3;
+            const scrollDistance = Math.round(distance || 0.7 * width);
             await this.swipe(start.x, start.y, start.x + scrollDistance, start.y);
         }
         async scrollRight(distance, startPoint) {
             const { width, height } = await this.size();
             const start = startPoint ? {
-                x: startPoint.left,
-                y: startPoint.top
+                x: Math.round(startPoint.left),
+                y: Math.round(startPoint.top)
             } : {
-                x: width / 2,
-                y: height / 2
+                x: Math.round(width / 2),
+                y: Math.round(height / 2)
             };
-            const scrollDistance = distance || width / 3;
+            const scrollDistance = Math.round(distance || 0.7 * width);
             await this.swipe(start.x, start.y, start.x - scrollDistance, start.y);
         }
         async scrollUntilTop(startPoint) {
@@ -12577,32 +12645,32 @@ ScreenSize: ${size.width}x${size.height} (DPR: ${size.scale})
             const { width, height } = await this.size();
             let start;
             if (startPoint) start = {
-                x: startPoint.left,
-                y: startPoint.top
+                x: Math.round(startPoint.left),
+                y: Math.round(startPoint.top)
             };
             else switch(direction){
                 case 'up':
                     start = {
-                        x: width / 2,
-                        y: 0.2 * height
+                        x: Math.round(width / 2),
+                        y: Math.round(0.2 * height)
                     };
                     break;
                 case 'down':
                     start = {
-                        x: width / 2,
-                        y: 0.8 * height
+                        x: Math.round(width / 2),
+                        y: Math.round(0.8 * height)
                     };
                     break;
                 case 'left':
                     start = {
-                        x: 0.8 * width,
-                        y: height / 2
+                        x: Math.round(0.8 * width),
+                        y: Math.round(height / 2)
                     };
                     break;
                 case 'right':
                     start = {
-                        x: 0.2 * width,
-                        y: height / 2
+                        x: Math.round(0.2 * width),
+                        y: Math.round(height / 2)
                     };
                     break;
             }
@@ -12629,7 +12697,7 @@ ScreenSize: ${size.width}x${size.height} (DPR: ${size.scale})
                     break;
                 }
                 lastScreenshot = currentScreenshot;
-                const scrollDistance = 'left' === direction || 'right' === direction ? 0.6 * width : 0.6 * height;
+                const scrollDistance = Math.round('left' === direction || 'right' === direction ? 0.6 * width : 0.6 * height);
                 debugDevice(`Performing scroll: ${direction}, distance: ${scrollDistance}`);
                 switch(direction){
                     case 'up':
@@ -12666,9 +12734,9 @@ ScreenSize: ${size.width}x${size.height} (DPR: ${size.scale})
             try {
                 debugDevice('Triggering app switcher with slow swipe up gesture');
                 const { width, height } = await this.size();
-                const centerX = width / 2;
-                const startY = height - 5;
-                const endY = 0.5 * height;
+                const centerX = Math.round(width / 2);
+                const startY = Math.round(height - 5);
+                const endY = Math.round(0.5 * height);
                 await this.wdaBackend.swipe(centerX, startY, centerX, endY, 1500);
                 await (0, utils_namespaceObject.sleep)(800);
             } catch (error) {
@@ -12686,9 +12754,9 @@ ScreenSize: ${size.width}x${size.height} (DPR: ${size.scale})
                     return true;
                 }
                 const windowSize = await this.wdaBackend.getWindowSize();
-                const centerX = windowSize.width / 2;
-                const startY = 0.33 * windowSize.height;
-                const endY = 0.33 * windowSize.height + 10;
+                const centerX = Math.round(windowSize.width / 2);
+                const startY = Math.round(0.33 * windowSize.height);
+                const endY = Math.round(0.33 * windowSize.height + 10);
                 await this.swipe(centerX, startY, centerX, endY, 50);
                 debugDevice('Dismissed keyboard with swipe down gesture at screen one-third position');
                 await (0, utils_namespaceObject.sleep)(300);
@@ -12856,17 +12924,14 @@ ScreenSize: ${size.width}x${size.height} (DPR: ${size.scale})
                 host: 'localhost',
                 port: constants_namespaceObject.DEFAULT_WDA_PORT
             };
-            let device;
-            let agent;
             let connected = false;
             while(!connected)try {
-                device = new device_IOSDevice({
+                const device = new device_IOSDevice({
                     wdaHost: wdaConfig.host,
                     wdaPort: wdaConfig.port
                 });
                 console.log(`\u{1F50C} Connecting to WebDriverAgent at ${wdaConfig.host}:${wdaConfig.port}...`);
                 await device.connect();
-                agent = new IOSAgent(device);
                 connected = true;
                 const deviceInfo = await device.getConnectedDeviceInfo();
                 console.log("\u2705 Connected to WebDriverAgent successfully!");
@@ -12918,7 +12983,15 @@ ScreenSize: ${size.width}x${size.height} (DPR: ${size.scale})
 `);
                 else if ('configure' === action) wdaConfig = await configureWebDriverAgent();
             }
-            const playgroundServer = new PlaygroundServer(device, agent, staticDir);
+            const agentFactory = async ()=>{
+                const newDevice = new device_IOSDevice({
+                    wdaHost: wdaConfig.host,
+                    wdaPort: wdaConfig.port
+                });
+                await newDevice.connect();
+                return new IOSAgent(newDevice);
+            };
+            const playgroundServer = new PlaygroundServer(agentFactory, staticDir);
             console.log("\uD83D\uDE80 Starting server...");
             const availablePlaygroundPort = await findAvailablePort(constants_namespaceObject.PLAYGROUND_SERVER_PORT);
             if (availablePlaygroundPort !== constants_namespaceObject.PLAYGROUND_SERVER_PORT) console.log(`\u{26A0}\u{FE0F}  Port ${constants_namespaceObject.PLAYGROUND_SERVER_PORT} is busy, using port ${availablePlaygroundPort} instead`);