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

package/dist/es/bin.mjs

@@ -11520,8 +11520,8 @@ class PlaygroundServer {
         }));
         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();
@@ -11540,6 +11540,22 @@ class PlaygroundServer {
         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({
@@ -11567,7 +11583,7 @@ class PlaygroundServer {
         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;
@@ -11616,7 +11632,12 @@ class PlaygroundServer {
             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;
@@ -11631,7 +11652,7 @@ class PlaygroundServer {
             };
             const startTime = Date.now();
             try {
-                const actionSpace = await this.page.actionSpace();
+                const actionSpace = await this.agent.interface.actionSpace();
                 const value = {
                     type,
                     prompt,
@@ -11658,7 +11679,10 @@ class PlaygroundServer {
             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;
@@ -11666,9 +11690,17 @@ class PlaygroundServer {
                 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';
@@ -11680,10 +11712,10 @@ class PlaygroundServer {
         });
         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()
@@ -11698,9 +11730,9 @@ class PlaygroundServer {
         });
         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
@@ -11768,6 +11800,11 @@ class PlaygroundServer {
         }
     }
     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)=>{
@@ -11796,24 +11833,30 @@ class PlaygroundServer {
             } 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 = getTmpDir();
-        this.page = page;
-        this.agent = agent;
         this.staticPath = staticPath;
         this.taskProgressTips = {};
         this.id = id || utils_uuid();
+        if ('function' == typeof agent) {
+            this.agentFactory = agent;
+            this.agent = null;
+        } else {
+            this.agent = agent;
+            this.agentFactory = null;
+        }
     }
 }
 __webpack_require__("../../node_modules/.pnpm/cors@2.8.5/node_modules/cors/lib/index.js");
@@ -12002,19 +12045,45 @@ class IOSWebDriverClient extends WebDriverClient {
     }
     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();
@@ -12160,8 +12229,7 @@ class device_IOSDevice {
                 await this.swipe(from.center[0], from.center[1], to.center[0], to.center[1]);
             }),
             defineActionKeyboardPress(async (param)=>{
-                const key = param.keyName;
-                await this.pressKey(key);
+                await this.pressKey(param.keyName);
             }),
             defineAction({
                 name: 'IOSHomeButton',
@@ -12317,23 +12385,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;
@@ -12356,49 +12424,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) {
@@ -12439,32 +12507,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;
         }
@@ -12491,7 +12559,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':
@@ -12528,9 +12596,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 sleep(800);
         } catch (error) {
@@ -12548,9 +12616,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 sleep(300);
@@ -12716,17 +12784,14 @@ const main = async ()=>{
             host: 'localhost',
             port: 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!");
@@ -12778,7 +12843,15 @@ const main = async ()=>{
 `);
             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_PLAYGROUND_SERVER_PORT);
         if (availablePlaygroundPort !== constants_PLAYGROUND_SERVER_PORT) console.log(`\u{26A0}\u{FE0F}  Port ${constants_PLAYGROUND_SERVER_PORT} is busy, using port ${availablePlaygroundPort} instead`);