@midscene/computer 1.13.4-beta-20260928083351.0 → 1.14.0

package/dist/lib/cli.js

@@ -109,24 +109,6 @@ function sendKeyViaAppleScript(key, modifiers = []) {
         script
     ]);
 }
-const desktopPointerPolicy = {
-    uiSettleMs: 100,
-    moveSettleMs: 50,
-    defaultTapHoldMs: 100,
-    tapMoveSteps: 8,
-    tapMoveStepDelayMs: 8,
-    hoverMoveSteps: 10,
-    hoverMoveStepDelayMs: 10
-};
-const desktopKeyboardPolicy = {
-    focusBeforeTypeMs: 300,
-    focusBeforeClearMs: 300,
-    focusBeforeShortcutMs: 50,
-    afterClearMs: 150
-};
-function resolveTapHoldDuration(duration) {
-    return Math.max(0, Math.round(duration ?? desktopPointerPolicy.defaultTapHoldMs));
-}
 const external_node_assert_namespaceObject = require("node:assert");
 var external_node_assert_default = /*#__PURE__*/ __webpack_require__.n(external_node_assert_namespaceObject);
 function _define_property(obj, key, value) {
@@ -819,9 +801,18 @@ async function captureScreenshot(options) {
         });
     }
 }
+const SMOOTH_MOVE_STEPS_TAP = 8;
+const SMOOTH_MOVE_STEPS_MOUSE_MOVE = 10;
 const SMOOTH_MOVE_STEPS_DRAG = 20;
+const SMOOTH_MOVE_DELAY_TAP = 8;
+const SMOOTH_MOVE_DELAY_MOUSE_MOVE = 10;
 const SMOOTH_MOVE_DELAY_DRAG = 10;
+const MOUSE_MOVE_EFFECT_WAIT = 300;
+const CLICK_SETTLE_DELAY = 50;
+const CLICK_HOLD_DURATION = 100;
 const CLICK_FOCUS_SETTLE_DELAY = 120;
+const INPUT_FOCUS_DELAY = 300;
+const INPUT_CLEAR_DELAY = 150;
 const SCROLL_STEP_DELAY = 100;
 const SCROLL_COMPLETE_DELAY = 500;
 const EDGE_SCROLL_TOTAL_PX = 50000;
@@ -1142,7 +1133,7 @@ function normalizePrimaryKey(key) {
     return KEY_NAME_MAP[lowerKey] || lowerKey;
 }
 class ComputerDevice {
-    async moveGlobalPointer(point, context, options) {
+    async moveGlobalPointer(point, context, smooth) {
         if (this.destroyed) throw new Error('ComputerDevice has been destroyed');
         const target = {
             x: Math.round(point.x),
@@ -1150,21 +1141,21 @@ class ComputerDevice {
         };
         if ('win32' === process.platform) {
             const actual = this.windowsPointerDriver.moveTo(target, {
-                smoothSteps: options?.smoothSteps,
-                smoothDelayMs: options?.smoothDelay
+                smoothSteps: smooth?.smoothSteps,
+                smoothDelayMs: smooth?.smoothDelay
             });
             const drift = windowsPointerDrift(target, actual);
             if (!windowsPointerIsWithinTolerance(drift)) throw new Error(`${context}: expected (${target.x}, ${target.y}), got (${actual.x}, ${actual.y}), drift=(${drift.x}, ${drift.y})`);
-            await this.inputDriver.delay(options?.settleDelayMs ?? desktopPointerPolicy.moveSettleMs);
+            await this.inputDriver.delay(CLICK_SETTLE_DELAY);
             return actual;
         }
-        if (options?.smoothSteps !== void 0 && void 0 !== options.smoothDelay) await this.inputDriver.smoothMoveMouse(target.x, target.y, options.smoothSteps, options.smoothDelay);
+        if (smooth) await this.inputDriver.smoothMoveMouse(target.x, target.y, smooth.smoothSteps, smooth.smoothDelay);
         else this.inputDriver.moveMouse(target.x, target.y);
-        await this.inputDriver.delay(options?.settleDelayMs ?? desktopPointerPolicy.moveSettleMs);
+        await this.inputDriver.delay(CLICK_SETTLE_DELAY);
         return this.inputDriver.getMousePos();
     }
-    moveDisplayPointer(point, context, options) {
-        return this.moveGlobalPointer(this.toGlobalPoint(point), context, options);
+    moveDisplayPointer(point, context, smooth) {
+        return this.moveGlobalPointer(this.toGlobalPoint(point), context, smooth);
     }
     async performPointerDrag(from, to, duration) {
         const screenSize = await this.size();
@@ -1190,9 +1181,7 @@ class ComputerDevice {
             await this.moveDisplayPointer({
                 x,
                 y
-            }, 'Mouse did not reach the keyboard focus target', {
-                settleDelayMs: desktopPointerPolicy.uiSettleMs
-            });
+            }, 'Mouse did not reach the keyboard focus target');
             this.inputDriver.mouseClick('left');
         }
         await this.inputDriver.delay(delayMs);
@@ -1274,7 +1263,7 @@ Available Displays: ${displays.length > 0 ? displays.map((d)=>d.name).join(', ')
     }
     async healthCheck(displays) {
         console.log('[HealthCheck] Starting health check...');
-        console.log("[HealthCheck] @midscene/computer v1.13.4-beta-20260928083351.0");
+        console.log("[HealthCheck] @midscene/computer v1.14.0");
         console.log('[HealthCheck] Taking screenshot...');
         const screenshotTimeout = 15000;
         let timeoutId;
@@ -1312,7 +1301,7 @@ Available Displays: ${displays.length > 0 ? displays.map((d)=>d.name).join(', ')
             console.log(`[HealthCheck] Moving mouse to (${targetX}, ${targetY})...`);
             try {
                 this.inputDriver.moveMouse(targetX, targetY);
-                await (0, utils_namespaceObject.sleep)(desktopPointerPolicy.moveSettleMs);
+                await (0, utils_namespaceObject.sleep)(CLICK_SETTLE_DELAY);
                 this.inputDriver.assertMousePosition(targetX, targetY, 'Mouse health check failed');
             } finally{
                 this.inputDriver.moveMouse(startPos.x, startPos.y);
@@ -1547,9 +1536,8 @@ $g.Dispose(); $bmp.Dispose(); $ms.Dispose()
         const screenSize = await this.size();
         if ('win32' === process.platform && this.inputDriver.focusActiveWindow()) await this.inputDriver.delay(CLICK_FOCUS_SETTLE_DELAY);
         const point = this.resolveUntargetedScrollPoint(screenSize);
-        await this.moveGlobalPointer(point, 'Mouse did not reach the scroll viewport', {
-            settleDelayMs: desktopPointerPolicy.uiSettleMs
-        });
+        await this.moveGlobalPointer(point, 'Mouse did not reach the scroll viewport');
+        await this.inputDriver.delay(MOUSE_MOVE_EFFECT_WAIT);
         return screenSize;
     }
     async performScroll(param) {
@@ -1690,7 +1678,7 @@ $g.Dispose(); $bmp.Dispose(); $ms.Dispose()
                     });
                     const targetX = Math.round(target.x);
                     const targetY = Math.round(target.y);
-                    const holdDuration = resolveTapHoldDuration(opts?.duration);
+                    const holdDuration = Math.max(0, Math.round(opts?.duration ?? CLICK_HOLD_DURATION));
                     debugComputerInput('tap start %o', {
                         local: {
                             x,
@@ -1709,9 +1697,8 @@ $g.Dispose(); $bmp.Dispose(); $ms.Dispose()
                         x: targetX,
                         y: targetY
                     }, 'Mouse did not reach the tap target', {
-                        smoothSteps: desktopPointerPolicy.tapMoveSteps,
-                        smoothDelay: desktopPointerPolicy.tapMoveStepDelayMs,
-                        settleDelayMs: desktopPointerPolicy.uiSettleMs
+                        smoothSteps: SMOOTH_MOVE_STEPS_TAP,
+                        smoothDelay: SMOOTH_MOVE_DELAY_TAP
                     });
                     await pressMouseAtGlobalPoint(this.inputDriver, targetX, targetY, current, holdDuration, 'primary');
                     if (frontmostBefore && 'darwin' === process.platform) {
@@ -1727,9 +1714,7 @@ $g.Dispose(); $bmp.Dispose(); $ms.Dispose()
                             const followUpCurrent = await this.moveGlobalPointer({
                                 x: targetX,
                                 y: targetY
-                            }, 'Mouse did not reach the focus follow-up target', {
-                                settleDelayMs: desktopPointerPolicy.uiSettleMs
-                            });
+                            }, 'Mouse did not reach the focus follow-up target');
                             await pressMouseAtGlobalPoint(this.inputDriver, targetX, targetY, followUpCurrent, holdDuration, 'focus-follow-up');
                         }
                     }
@@ -1738,18 +1723,14 @@ $g.Dispose(); $bmp.Dispose(); $ms.Dispose()
                     await this.moveDisplayPointer({
                         x,
                         y
-                    }, 'Mouse did not reach the double-click target', {
-                        settleDelayMs: desktopPointerPolicy.uiSettleMs
-                    });
+                    }, 'Mouse did not reach the double-click target');
                     this.inputDriver.mouseClick('left', true);
                 },
                 rightClick: async ({ x, y })=>{
                     await this.moveDisplayPointer({
                         x,
                         y
-                    }, 'Mouse did not reach the right-click target', {
-                        settleDelayMs: desktopPointerPolicy.uiSettleMs
-                    });
+                    }, 'Mouse did not reach the right-click target');
                     this.inputDriver.mouseClick('right');
                 },
                 hover: async ({ x, y })=>{
@@ -1757,10 +1738,10 @@ $g.Dispose(); $bmp.Dispose(); $ms.Dispose()
                         x,
                         y
                     }, 'Mouse did not reach the hover target', {
-                        smoothSteps: desktopPointerPolicy.hoverMoveSteps,
-                        smoothDelay: desktopPointerPolicy.hoverMoveStepDelayMs,
-                        settleDelayMs: desktopPointerPolicy.uiSettleMs
+                        smoothSteps: SMOOTH_MOVE_STEPS_MOUSE_MOVE,
+                        smoothDelay: SMOOTH_MOVE_DELAY_MOUSE_MOVE
                     });
+                    await this.inputDriver.delay(MOUSE_MOVE_EFFECT_WAIT);
                 },
                 dragAndDrop: async (from, to)=>{
                     await this.performPointerDrag(from, to);
@@ -1775,25 +1756,23 @@ $g.Dispose(); $bmp.Dispose(); $ms.Dispose()
                     const resolvedInputOptions = (0, device_namespaceObject.resolveTextInputOptions)(opts, this.options);
                     const element = opts?.target;
                     if (element) {
-                        await this.focusKeyboardTarget(element, desktopKeyboardPolicy.focusBeforeTypeMs);
-                        if (opts?.focusOnly) return;
+                        await this.focusKeyboardTarget(element, INPUT_FOCUS_DELAY);
                         if (opts?.replace !== false) {
                             await this.selectAllAndDelete();
-                            await this.inputDriver.delay(desktopKeyboardPolicy.afterClearMs);
+                            await this.inputDriver.delay(INPUT_CLEAR_DELAY);
                         }
                     }
-                    if (opts?.focusOnly || !value) return;
                     await this.smartTypeString(value, resolvedInputOptions);
                 },
                 keyboardPress: async (keyName, opts)=>{
                     const target = opts?.target;
-                    if (target) await this.focusKeyboardTarget(target, desktopKeyboardPolicy.focusBeforeShortcutMs);
+                    if (target) await this.focusKeyboardTarget(target, 50);
                     await this.pressKeyboardShortcut(keyName);
                 },
                 clearInput: async (target)=>{
-                    if (target) await this.focusKeyboardTarget(target, desktopKeyboardPolicy.focusBeforeClearMs);
+                    if (target) await this.focusKeyboardTarget(target, 100);
                     await this.selectAllAndDelete();
-                    await this.inputDriver.delay(desktopKeyboardPolicy.afterClearMs);
+                    await this.inputDriver.delay(50);
                 }
             },
             scroll: {
@@ -2207,9 +2186,17 @@ function rdp_device_define_property(obj, key, value) {
     return obj;
 }
 const device_debug = (0, logger_namespaceObject.getDebug)('rdp:device');
+const device_SMOOTH_MOVE_STEPS_TAP = 8;
+const device_SMOOTH_MOVE_STEPS_MOUSE_MOVE = 10;
 const device_SMOOTH_MOVE_STEPS_DRAG = 12;
+const device_SMOOTH_MOVE_DELAY_TAP = 8;
+const device_SMOOTH_MOVE_DELAY_MOUSE_MOVE = 10;
 const device_SMOOTH_MOVE_DELAY_DRAG = 10;
+const device_MOUSE_MOVE_EFFECT_WAIT = 300;
+const device_CLICK_HOLD_DURATION = 50;
 const DRAG_HOLD_DURATION = 100;
+const device_INPUT_FOCUS_DELAY = 300;
+const device_INPUT_CLEAR_DELAY = 150;
 const device_SCROLL_STEP_DELAY = 100;
 const device_SCROLL_COMPLETE_DELAY = 500;
 const DEFAULT_SCROLL_DISTANCE = 480;
@@ -2295,6 +2282,12 @@ class RDPDevice {
     throwIfDestroyed() {
         if (this.destroyed) throw new Error('RDPDevice has been destroyed');
     }
+    async moveToElement(element, options) {
+        this.assertConnected();
+        const targetX = Math.round(element.center[0]);
+        const targetY = Math.round(element.center[1]);
+        await this.movePointer(targetX, targetY, options);
+    }
     async clearInput() {
         if (this.backend.clearInput) return void await this.backend.clearInput();
         await this.backend.keyPress('Control+A');
@@ -2348,8 +2341,8 @@ class RDPDevice {
         const boundedFrom = clampPointerPointToSize(from, screenSize);
         const boundedTo = clampPointerPointToSize(to, screenSize);
         await this.movePointer(Math.round(boundedFrom.x), Math.round(boundedFrom.y), {
-            steps: desktopPointerPolicy.tapMoveSteps,
-            stepDelayMs: desktopPointerPolicy.tapMoveStepDelayMs
+            steps: device_SMOOTH_MOVE_STEPS_TAP,
+            stepDelayMs: device_SMOOTH_MOVE_DELAY_TAP
         });
         await this.backend.mouseButton('left', 'down');
         try {
@@ -2385,40 +2378,34 @@ class RDPDevice {
         rdp_device_define_property(this, "uri", void 0);
         rdp_device_define_property(this, "inputPrimitives", {
             pointer: {
-                tap: async ({ x, y }, opts)=>{
+                tap: async ({ x, y })=>{
                     await this.movePointer(Math.round(x), Math.round(y), {
-                        steps: desktopPointerPolicy.tapMoveSteps,
-                        stepDelayMs: desktopPointerPolicy.tapMoveStepDelayMs,
-                        settleDelayMs: desktopPointerPolicy.uiSettleMs
+                        steps: device_SMOOTH_MOVE_STEPS_TAP,
+                        stepDelayMs: device_SMOOTH_MOVE_DELAY_TAP
                     });
                     await this.backend.mouseButton('left', 'down');
-                    try {
-                        await (0, utils_namespaceObject.sleep)(resolveTapHoldDuration(opts?.duration));
-                    } finally{
-                        await this.backend.mouseButton('left', 'up');
-                    }
+                    await (0, utils_namespaceObject.sleep)(device_CLICK_HOLD_DURATION);
+                    await this.backend.mouseButton('left', 'up');
                 },
                 doubleClick: async ({ x, y })=>{
                     await this.movePointer(Math.round(x), Math.round(y), {
-                        steps: desktopPointerPolicy.tapMoveSteps,
-                        stepDelayMs: desktopPointerPolicy.tapMoveStepDelayMs,
-                        settleDelayMs: desktopPointerPolicy.uiSettleMs
+                        steps: device_SMOOTH_MOVE_STEPS_TAP,
+                        stepDelayMs: device_SMOOTH_MOVE_DELAY_TAP
                     });
                     await this.backend.mouseButton('left', 'doubleClick');
                 },
                 rightClick: async ({ x, y })=>{
                     await this.movePointer(Math.round(x), Math.round(y), {
-                        steps: desktopPointerPolicy.tapMoveSteps,
-                        stepDelayMs: desktopPointerPolicy.tapMoveStepDelayMs,
-                        settleDelayMs: desktopPointerPolicy.uiSettleMs
+                        steps: device_SMOOTH_MOVE_STEPS_TAP,
+                        stepDelayMs: device_SMOOTH_MOVE_DELAY_TAP
                     });
                     await this.backend.mouseButton('right', 'click');
                 },
                 hover: async ({ x, y })=>{
                     await this.movePointer(Math.round(x), Math.round(y), {
-                        steps: desktopPointerPolicy.hoverMoveSteps,
-                        stepDelayMs: desktopPointerPolicy.hoverMoveStepDelayMs,
-                        settleDelayMs: desktopPointerPolicy.uiSettleMs
+                        steps: device_SMOOTH_MOVE_STEPS_MOUSE_MOVE,
+                        stepDelayMs: device_SMOOTH_MOVE_DELAY_MOUSE_MOVE,
+                        settleDelayMs: device_MOUSE_MOVE_EFFECT_WAIT
                     });
                 },
                 dragAndDrop: async (from, to)=>{
@@ -2439,12 +2426,11 @@ class RDPDevice {
                             x: target.center[0],
                             y: target.center[1]
                         });
-                        await (0, utils_namespaceObject.sleep)(desktopKeyboardPolicy.focusBeforeTypeMs);
-                        if (opts?.focusOnly) return;
-                        if (opts?.replace !== false) {
-                            await this.clearInput();
-                            await (0, utils_namespaceObject.sleep)(desktopKeyboardPolicy.afterClearMs);
-                        }
+                        await (0, utils_namespaceObject.sleep)(device_INPUT_FOCUS_DELAY);
+                    }
+                    if (opts?.replace !== false) {
+                        await this.clearInput();
+                        await (0, utils_namespaceObject.sleep)(device_INPUT_CLEAR_DELAY);
                     }
                     if (opts?.focusOnly || !value) return;
                     await this.typeText(value, resolvedInputOptions);
@@ -2457,21 +2443,18 @@ class RDPDevice {
                             x: element.center[0],
                             y: element.center[1]
                         });
-                        await (0, utils_namespaceObject.sleep)(desktopKeyboardPolicy.focusBeforeClearMs);
+                        await (0, utils_namespaceObject.sleep)(device_INPUT_FOCUS_DELAY);
                     }
                     await this.clearInput();
-                    await (0, utils_namespaceObject.sleep)(desktopKeyboardPolicy.afterClearMs);
+                    await (0, utils_namespaceObject.sleep)(device_INPUT_CLEAR_DELAY);
                 },
                 keyboardPress: async (keyName, opts)=>{
                     this.assertConnected();
                     const target = opts?.target;
-                    if (target) {
-                        await this.inputPrimitives.pointer.tap({
-                            x: target.center[0],
-                            y: target.center[1]
-                        });
-                        await (0, utils_namespaceObject.sleep)(desktopKeyboardPolicy.focusBeforeShortcutMs);
-                    }
+                    if (target) await this.inputPrimitives.pointer.tap({
+                        x: target.center[0],
+                        y: target.center[1]
+                    });
                     await this.backend.keyPress(keyName);
                 }
             },
@@ -2479,27 +2462,17 @@ class RDPDevice {
                 scroll: async (param)=>{
                     this.assertConnected();
                     const target = param.locate;
-                    let scrollPoint;
-                    if (target) scrollPoint = target.center;
-                    else {
-                        const size = await this.size();
-                        scrollPoint = [
-                            Math.round(size.width / 2),
-                            Math.round(size.height / 2)
-                        ];
-                    }
-                    await this.movePointer(Math.round(scrollPoint[0]), Math.round(scrollPoint[1]), {
-                        steps: desktopPointerPolicy.hoverMoveSteps,
-                        stepDelayMs: desktopPointerPolicy.hoverMoveStepDelayMs,
-                        settleDelayMs: target ? desktopPointerPolicy.moveSettleMs : desktopPointerPolicy.uiSettleMs
+                    if (target) await this.moveToElement(target, {
+                        steps: device_SMOOTH_MOVE_STEPS_MOUSE_MOVE,
+                        stepDelayMs: device_SMOOTH_MOVE_DELAY_MOUSE_MOVE
                     });
                     if (param.scrollType && 'singleAction' !== param.scrollType) {
                         const direction = this.edgeScrollDirection(param.scrollType);
-                        for(let i = 0; i < device_EDGE_SCROLL_STEPS; i++)await this.performWheel(direction, DEFAULT_SCROLL_DISTANCE, scrollPoint[0], scrollPoint[1]);
+                        for(let i = 0; i < device_EDGE_SCROLL_STEPS; i++)await this.performWheel(direction, DEFAULT_SCROLL_DISTANCE, target?.center[0], target?.center[1]);
                         await (0, utils_namespaceObject.sleep)(device_SCROLL_COMPLETE_DELAY);
                         return;
                     }
-                    await this.performWheel(param.direction || 'down', param.distance || this.defaultScrollDistance(param.direction || 'down'), scrollPoint[0], scrollPoint[1]);
+                    await this.performWheel(param.direction || 'down', param.distance || this.defaultScrollDistance(param.direction || 'down'), target?.center[0], target?.center[1]);
                     await (0, utils_namespaceObject.sleep)(device_SCROLL_COMPLETE_DELAY);
                 }
             }
@@ -2780,7 +2753,7 @@ const tools = new ComputerMidsceneTools({
 });
 (0, cli_namespaceObject.runToolsCLI)(tools, 'midscene-computer', {
     stripPrefix: 'computer_',
-    version: "1.13.4-beta-20260928083351.0",
+    version: "1.14.0",
     extraCommands: (0, core_namespaceObject.createReportCliCommands)()
 }).catch((e)=>{
     process.exit((0, cli_namespaceObject.reportCLIError)(e));