@midscene/computer 1.8.6 → 1.8.7-beta-20260527113633.0

package/dist/lib/cli.js

@@ -29,8 +29,6 @@ const cli_namespaceObject = require("@midscene/shared/cli");
 const logger_namespaceObject = require("@midscene/shared/logger");
 const base_tools_namespaceObject = require("@midscene/shared/mcp/base-tools");
 const agent_namespaceObject = require("@midscene/core/agent");
-const external_node_assert_namespaceObject = require("node:assert");
-var external_node_assert_default = /*#__PURE__*/ __webpack_require__.n(external_node_assert_namespaceObject);
 const external_node_child_process_namespaceObject = require("node:child_process");
 const external_node_fs_namespaceObject = require("node:fs");
 const external_node_module_namespaceObject = require("node:module");
@@ -41,6 +39,136 @@ const utils_namespaceObject = require("@midscene/core/utils");
 const img_namespaceObject = require("@midscene/shared/img");
 const external_screenshot_desktop_namespaceObject = require("screenshot-desktop");
 var external_screenshot_desktop_default = /*#__PURE__*/ __webpack_require__.n(external_screenshot_desktop_namespaceObject);
+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) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+class ComputerInputDriver {
+    destroy() {
+        if (this.destroyed) return;
+        this.destroyed = true;
+        this.rejectPendingInputDelays();
+    }
+    getScreenSize() {
+        return this.getLibnutOrThrow('getScreenSize').getScreenSize();
+    }
+    getMousePos() {
+        return this.getLibnutOrThrow('getMousePos').getMousePos();
+    }
+    moveMouse(x, y) {
+        this.getLibnutOrThrow('moveMouse').moveMouse(x, y);
+    }
+    mouseClick(button, double) {
+        const lib = this.getLibnutOrThrow('mouseClick');
+        if (void 0 !== double) lib.mouseClick(button, double);
+        else if (void 0 !== button) lib.mouseClick(button);
+        else lib.mouseClick();
+    }
+    mouseToggle(state, button = 'left') {
+        this.getLibnutOrThrow('mouseToggle').mouseToggle(state, button);
+    }
+    scrollMouse(x, y) {
+        this.getLibnutOrThrow('scrollMouse').scrollMouse(x, y);
+    }
+    keyTap(key, modifiers) {
+        const lib = this.getLibnutOrThrow('keyTap');
+        if (void 0 !== modifiers) lib.keyTap(key, modifiers);
+        else lib.keyTap(key);
+    }
+    sendKeyViaAppleScript(key, modifiers = []) {
+        this.assertActive('sendKeyViaAppleScript');
+        this.options.sendKeyViaAppleScript(key, modifiers);
+    }
+    sendKey(key, modifiers = []) {
+        if (this.options.useAppleScript()) return void this.sendKeyViaAppleScript(key, modifiers);
+        if (modifiers.length > 0) this.keyTap(key, modifiers);
+        else this.keyTap(key);
+    }
+    runPhasedScroll(direction, pixels, steps) {
+        this.assertActive('runPhasedScroll');
+        return this.options.runPhasedScroll(direction, pixels, steps);
+    }
+    async delay(ms) {
+        this.assertActive('delay');
+        return new Promise((resolve, reject)=>{
+            const waitRef = {
+                timeoutId: setTimeout(()=>{
+                    this.pendingInputDelayWaits.delete(waitRef);
+                    try {
+                        this.assertActive('delay');
+                        resolve();
+                    } catch (error) {
+                        reject(error);
+                    }
+                }, ms),
+                reject
+            };
+            this.pendingInputDelayWaits.add(waitRef);
+        });
+    }
+    async smoothMoveMouse(targetX, targetY, steps, stepDelay) {
+        const currentPos = this.getMousePos();
+        for(let i = 1; i <= steps; i++){
+            const stepX = Math.round(currentPos.x + (targetX - currentPos.x) * i / steps);
+            const stepY = Math.round(currentPos.y + (targetY - currentPos.y) * i / steps);
+            this.moveMouse(stepX, stepY);
+            await this.delay(stepDelay);
+        }
+    }
+    async withMouseButton(button, run) {
+        this.mouseToggle('down', button);
+        try {
+            return await run();
+        } finally{
+            this.releaseMouseButton(button);
+        }
+    }
+    getLibnutOrThrow(methodName) {
+        this.assertActive(methodName);
+        const libnut = this.options.getLibnut();
+        external_node_assert_default()(libnut, 'libnut not initialized');
+        return libnut;
+    }
+    assertActive(methodName) {
+        if (this.destroyed) throw this.createDestroyedError(methodName);
+    }
+    createDestroyedError(methodName) {
+        return new Error(`ComputerDevice has been destroyed (cannot run ${methodName})`);
+    }
+    releaseMouseButton(button) {
+        try {
+            const libnut = this.options.getLibnut();
+            external_node_assert_default()(libnut, 'libnut not initialized');
+            libnut.mouseToggle('up', button);
+        } catch (error) {
+            this.options.debug(`Failed to release mouse button ${button}: ${error}`);
+        }
+    }
+    rejectPendingInputDelays() {
+        const error = this.createDestroyedError('in-flight input');
+        for (const waitRef of this.pendingInputDelayWaits){
+            clearTimeout(waitRef.timeoutId);
+            waitRef.reject(error);
+        }
+        this.pendingInputDelayWaits.clear();
+    }
+    constructor(options){
+        _define_property(this, "options", void 0);
+        _define_property(this, "destroyed", void 0);
+        _define_property(this, "pendingInputDelayWaits", void 0);
+        this.options = options;
+        this.destroyed = false;
+        this.pendingInputDelayWaits = new Set();
+    }
+}
 const debugXvfb = (0, logger_namespaceObject.getDebug)('computer:xvfb');
 function checkXvfbInstalled() {
     try {
@@ -108,7 +236,7 @@ function needsXvfb(explicitOpt) {
     if ('linux' !== process.platform) return false;
     return true === explicitOpt;
 }
-function _define_property(obj, key, value) {
+function device_define_property(obj, key, value) {
     if (key in obj) Object.defineProperty(obj, key, {
         value: value,
         enumerable: true,
@@ -229,17 +357,17 @@ function sendKeyViaAppleScript(key, modifiers = []) {
         script
     ]);
 }
-let libnut = null;
+let device_libnut = null;
 let libnutLoadError = null;
 async function getLibnut() {
-    if (libnut) return libnut;
+    if (device_libnut) return device_libnut;
     if (libnutLoadError) throw libnutLoadError;
     try {
         const require1 = (0, external_node_module_namespaceObject.createRequire)(__rslib_import_meta_url__);
         const libnutModule = require1('@computer-use/libnut/dist/import_libnut');
-        libnut = libnutModule.libnut;
-        if (!libnut) throw new Error('libnut module loaded but libnut object is undefined');
-        return libnut;
+        device_libnut = libnutModule.libnut;
+        if (!device_libnut) throw new Error('libnut module loaded but libnut object is undefined');
+        return device_libnut;
     } catch (error) {
         libnutLoadError = error;
         throw new Error(`Failed to load @computer-use/libnut. Make sure it is properly installed and compiled for your platform. Error: ${error}`);
@@ -309,16 +437,6 @@ function runPhasedScroll(direction, pixels, steps) {
         return false;
     }
 }
-async function smoothMoveMouse(targetX, targetY, steps, stepDelay) {
-    external_node_assert_default()(libnut, 'libnut not initialized');
-    const currentPos = libnut.getMousePos();
-    for(let i = 1; i <= steps; i++){
-        const stepX = Math.round(currentPos.x + (targetX - currentPos.x) * i / steps);
-        const stepY = Math.round(currentPos.y + (targetY - currentPos.y) * i / steps);
-        libnut.moveMouse(stepX, stepY);
-        await (0, utils_namespaceObject.sleep)(stepDelay);
-    }
-}
 const KEY_NAME_MAP = {
     windows: 'win',
     win: 'win',
@@ -404,7 +522,7 @@ class ComputerDevice {
                 process.on('SIGINT', this.xvfbCleanup);
                 process.on('SIGTERM', this.xvfbCleanup);
             }
-            libnut = await getLibnut();
+            device_libnut = await getLibnut();
             const size = await this.size();
             const displays = await ComputerDevice.listDisplays();
             const headlessInfo = this.xvfbInstance ? `\nHeadless: true (Xvfb on ${this.xvfbInstance.display})` : '';
@@ -428,7 +546,7 @@ Available Displays: ${displays.length > 0 ? displays.map((d)=>d.name).join(', ')
     }
     async healthCheck() {
         console.log('[HealthCheck] Starting health check...');
-        console.log("[HealthCheck] @midscene/computer v1.8.6");
+        console.log("[HealthCheck] @midscene/computer v1.8.7-beta-20260527113633.0");
         console.log('[HealthCheck] Taking screenshot...');
         const screenshotTimeout = 15000;
         let timeoutId;
@@ -441,17 +559,16 @@ Available Displays: ${displays.length > 0 ? displays.map((d)=>d.name).join(', ')
         ]);
         console.log(`[HealthCheck] Screenshot succeeded (length=${base64.length})`);
         console.log('[HealthCheck] Moving mouse...');
-        external_node_assert_default()(libnut, 'libnut not initialized');
-        const startPos = libnut.getMousePos();
+        const startPos = this.inputDriver.getMousePos();
         console.log(`[HealthCheck] Current mouse position: (${startPos.x}, ${startPos.y})`);
         const offsetX = Math.floor(40 * Math.random()) + 10;
         const offsetY = Math.floor(40 * Math.random()) + 10;
         const targetX = startPos.x + offsetX;
         const targetY = startPos.y + offsetY;
         console.log(`[HealthCheck] Moving mouse to (${targetX}, ${targetY})...`);
-        libnut.moveMouse(targetX, targetY);
+        this.inputDriver.moveMouse(targetX, targetY);
         await (0, utils_namespaceObject.sleep)(50);
-        const movedPos = libnut.getMousePos();
+        const movedPos = this.inputDriver.getMousePos();
         console.log(`[HealthCheck] Mouse position after move: (${movedPos.x}, ${movedPos.y})`);
         const deltaX = Math.abs(movedPos.x - targetX);
         const deltaY = Math.abs(movedPos.y - targetY);
@@ -465,7 +582,7 @@ Available Displays: ${displays.length > 0 ? displays.map((d)=>d.name).join(', ')
                 debugDevice(hint);
             }
         }
-        libnut.moveMouse(startPos.x, startPos.y);
+        this.inputDriver.moveMouse(startPos.x, startPos.y);
         console.log(`[HealthCheck] Mouse restored to (${startPos.x}, ${startPos.y})`);
         console.log('[HealthCheck] Listing monitors...');
         const displays = await ComputerDevice.listDisplays();
@@ -528,9 +645,8 @@ Original error: ${lastRawMessage}`);
         throw new Error(`Failed to take screenshot: ${lastRawMessage}`);
     }
     async size() {
-        external_node_assert_default()(libnut, 'libnut not initialized');
         try {
-            const screenSize = libnut.getScreenSize();
+            const screenSize = this.inputDriver.getScreenSize();
             return {
                 width: screenSize.width,
                 height: screenSize.height
@@ -541,7 +657,6 @@ Original error: ${lastRawMessage}`);
         }
     }
     async typeViaClipboard(text) {
-        external_node_assert_default()(libnut, 'libnut not initialized');
         debugDevice('Using clipboard to input text', {
             textLength: text.length,
             preview: text.substring(0, 20)
@@ -550,17 +665,17 @@ Original error: ${lastRawMessage}`);
         const oldClipboard = await clipboardy.default.read().catch(()=>'');
         try {
             await clipboardy.default.write(text);
-            await (0, utils_namespaceObject.sleep)(50);
-            if (this.useAppleScript) sendKeyViaAppleScript('v', [
+            await this.inputDriver.delay(50);
+            if (this.useAppleScript) this.inputDriver.sendKeyViaAppleScript('v', [
                 'command'
             ]);
             else {
                 const modifier = 'darwin' === process.platform ? 'command' : 'control';
-                libnut.keyTap('v', [
+                this.inputDriver.keyTap('v', [
                     modifier
                 ]);
             }
-            await (0, utils_namespaceObject.sleep)(100);
+            await this.inputDriver.delay(100);
         } finally{
             if (oldClipboard) await clipboardy.default.write(oldClipboard).catch(()=>{
                 debugDevice('Failed to restore clipboard content');
@@ -568,28 +683,25 @@ Original error: ${lastRawMessage}`);
         }
     }
     async smartTypeString(text) {
-        external_node_assert_default()(libnut, 'libnut not initialized');
         await this.typeViaClipboard(text);
     }
     async selectAllAndDelete() {
-        external_node_assert_default()(libnut, 'libnut not initialized');
         if (this.useAppleScript) {
-            sendKeyViaAppleScript('a', [
+            this.inputDriver.sendKeyViaAppleScript('a', [
                 'command'
             ]);
-            await (0, utils_namespaceObject.sleep)(50);
-            sendKeyViaAppleScript('backspace', []);
+            await this.inputDriver.delay(50);
+            this.inputDriver.sendKeyViaAppleScript('backspace', []);
             return;
         }
         const modifier = 'darwin' === process.platform ? 'command' : 'control';
-        libnut.keyTap('a', [
+        this.inputDriver.keyTap('a', [
             modifier
         ]);
-        await (0, utils_namespaceObject.sleep)(50);
-        libnut.keyTap('backspace');
+        await this.inputDriver.delay(50);
+        this.inputDriver.keyTap('backspace');
     }
     async pressKeyboardShortcut(keyName) {
-        external_node_assert_default()(libnut, 'libnut not initialized');
         const keys = keyName.split('+');
         const modifiers = keys.slice(0, -1).map(normalizeKeyName);
         const key = normalizePrimaryKey(keys[keys.length - 1]);
@@ -599,30 +711,27 @@ Original error: ${lastRawMessage}`);
             modifiers,
             driver: this.useAppleScript ? "applescript" : 'libnut'
         });
-        if (this.useAppleScript) sendKeyViaAppleScript(key, modifiers);
-        else if (modifiers.length > 0) libnut.keyTap(key, modifiers);
-        else libnut.keyTap(key);
+        this.inputDriver.sendKey(key, modifiers);
     }
     async performScroll(param) {
-        external_node_assert_default()(libnut, 'libnut not initialized');
         if (param.locate) {
             const element = param.locate;
             const [x, y] = element.center;
-            libnut.moveMouse(Math.round(x), Math.round(y));
+            this.inputDriver.moveMouse(Math.round(x), Math.round(y));
         }
         const scrollType = param?.scrollType;
         const edgeSpec = scrollType && scrollType in EDGE_SCROLL_SPEC ? EDGE_SCROLL_SPEC[scrollType] : null;
         if (edgeSpec) {
-            if (runPhasedScroll(edgeSpec.direction, EDGE_SCROLL_TOTAL_PX, EDGE_SCROLL_STEPS)) return void await (0, utils_namespaceObject.sleep)(SCROLL_COMPLETE_DELAY);
+            if (this.inputDriver.runPhasedScroll(edgeSpec.direction, EDGE_SCROLL_TOTAL_PX, EDGE_SCROLL_STEPS)) return void await this.inputDriver.delay(SCROLL_COMPLETE_DELAY);
             if (this.useAppleScript) {
-                sendKeyViaAppleScript(edgeSpec.key);
-                await (0, utils_namespaceObject.sleep)(SCROLL_COMPLETE_DELAY);
+                this.inputDriver.sendKeyViaAppleScript(edgeSpec.key);
+                await this.inputDriver.delay(SCROLL_COMPLETE_DELAY);
                 return;
             }
             const [dx, dy] = edgeSpec.libnut;
             for(let i = 0; i < SCROLL_REPEAT_COUNT; i++){
-                libnut.scrollMouse(dx, dy);
-                await (0, utils_namespaceObject.sleep)(SCROLL_STEP_DELAY);
+                this.inputDriver.scrollMouse(dx, dy);
+                await this.inputDriver.delay(SCROLL_STEP_DELAY);
             }
             return;
         }
@@ -639,17 +748,17 @@ Original error: ${lastRawMessage}`);
             }
             if (isKnownDirection) {
                 const steps = Math.max(PHASED_MIN_STEPS, Math.round(distance / PHASED_PIXELS_PER_STEP));
-                if (runPhasedScroll(direction, distance, steps)) return void await (0, utils_namespaceObject.sleep)(SCROLL_COMPLETE_DELAY);
+                if (this.inputDriver.runPhasedScroll(direction, distance, steps)) return void await this.inputDriver.delay(SCROLL_COMPLETE_DELAY);
             }
             if (this.useAppleScript && ('up' === direction || 'down' === direction)) {
                 if (!screenSize) screenSize = await this.size();
                 const pages = Math.max(1, Math.round(distance / screenSize.height));
                 const key = 'up' === direction ? 'pageup' : 'pagedown';
                 for(let i = 0; i < pages; i++){
-                    sendKeyViaAppleScript(key);
-                    await (0, utils_namespaceObject.sleep)(SCROLL_STEP_DELAY);
+                    this.inputDriver.sendKeyViaAppleScript(key);
+                    await this.inputDriver.delay(SCROLL_STEP_DELAY);
                 }
-                await (0, utils_namespaceObject.sleep)(SCROLL_COMPLETE_DELAY);
+                await this.inputDriver.delay(SCROLL_COMPLETE_DELAY);
                 return;
             }
             const ticks = Math.ceil(distance / 100);
@@ -675,8 +784,8 @@ Original error: ${lastRawMessage}`);
                 0,
                 -ticks
             ];
-            libnut.scrollMouse(dx, dy);
-            await (0, utils_namespaceObject.sleep)(SCROLL_COMPLETE_DELAY);
+            this.inputDriver.scrollMouse(dx, dy);
+            await this.inputDriver.delay(SCROLL_COMPLETE_DELAY);
             return;
         }
         throw new Error(`Unknown scroll type: ${scrollType}, param: ${JSON.stringify(param)}`);
@@ -695,6 +804,8 @@ Original error: ${lastRawMessage}`);
     }
     async destroy() {
         if (this.destroyed) return;
+        this.destroyed = true;
+        this.inputDriver.destroy();
         if (this.xvfbInstance) {
             this.xvfbInstance.stop();
             this.xvfbInstance = void 0;
@@ -705,96 +816,94 @@ Original error: ${lastRawMessage}`);
             process.removeListener('SIGTERM', this.xvfbCleanup);
             this.xvfbCleanup = void 0;
         }
-        this.destroyed = true;
         debugDevice('Computer device destroyed');
     }
     async url() {
         return '';
     }
     constructor(options){
-        _define_property(this, "interfaceType", 'computer');
-        _define_property(this, "options", void 0);
-        _define_property(this, "displayId", void 0);
-        _define_property(this, "description", void 0);
-        _define_property(this, "destroyed", false);
-        _define_property(this, "xvfbInstance", void 0);
-        _define_property(this, "xvfbCleanup", void 0);
-        _define_property(this, "useAppleScript", void 0);
-        _define_property(this, "uri", void 0);
-        _define_property(this, "inputPrimitives", {
+        device_define_property(this, "interfaceType", 'computer');
+        device_define_property(this, "options", void 0);
+        device_define_property(this, "displayId", void 0);
+        device_define_property(this, "description", void 0);
+        device_define_property(this, "destroyed", false);
+        device_define_property(this, "xvfbInstance", void 0);
+        device_define_property(this, "xvfbCleanup", void 0);
+        device_define_property(this, "inputDriver", new ComputerInputDriver({
+            getLibnut: ()=>device_libnut,
+            useAppleScript: ()=>this.useAppleScript,
+            sendKeyViaAppleScript,
+            runPhasedScroll,
+            debug: (message)=>debugDevice(message)
+        }));
+        device_define_property(this, "useAppleScript", void 0);
+        device_define_property(this, "uri", void 0);
+        device_define_property(this, "inputPrimitives", {
             pointer: {
                 tap: async ({ x, y })=>{
-                    external_node_assert_default()(libnut, 'libnut not initialized');
                     const targetX = Math.round(x);
                     const targetY = Math.round(y);
-                    await smoothMoveMouse(targetX, targetY, SMOOTH_MOVE_STEPS_TAP, SMOOTH_MOVE_DELAY_TAP);
-                    libnut.mouseToggle('down', 'left');
-                    await (0, utils_namespaceObject.sleep)(CLICK_HOLD_DURATION);
-                    libnut.mouseToggle('up', 'left');
+                    await this.inputDriver.smoothMoveMouse(targetX, targetY, SMOOTH_MOVE_STEPS_TAP, SMOOTH_MOVE_DELAY_TAP);
+                    await this.inputDriver.withMouseButton('left', async ()=>{
+                        await this.inputDriver.delay(CLICK_HOLD_DURATION);
+                    });
                 },
                 doubleClick: async ({ x, y })=>{
-                    external_node_assert_default()(libnut, 'libnut not initialized');
-                    libnut.moveMouse(Math.round(x), Math.round(y));
-                    libnut.mouseClick('left', true);
+                    this.inputDriver.moveMouse(Math.round(x), Math.round(y));
+                    this.inputDriver.mouseClick('left', true);
                 },
                 rightClick: async ({ x, y })=>{
-                    external_node_assert_default()(libnut, 'libnut not initialized');
-                    libnut.moveMouse(Math.round(x), Math.round(y));
-                    libnut.mouseClick('right');
+                    this.inputDriver.moveMouse(Math.round(x), Math.round(y));
+                    this.inputDriver.mouseClick('right');
                 },
                 hover: async ({ x, y })=>{
-                    external_node_assert_default()(libnut, 'libnut not initialized');
-                    await smoothMoveMouse(Math.round(x), Math.round(y), SMOOTH_MOVE_STEPS_MOUSE_MOVE, SMOOTH_MOVE_DELAY_MOUSE_MOVE);
-                    await (0, utils_namespaceObject.sleep)(MOUSE_MOVE_EFFECT_WAIT);
+                    await this.inputDriver.smoothMoveMouse(Math.round(x), Math.round(y), SMOOTH_MOVE_STEPS_MOUSE_MOVE, SMOOTH_MOVE_DELAY_MOUSE_MOVE);
+                    await this.inputDriver.delay(MOUSE_MOVE_EFFECT_WAIT);
                 },
                 dragAndDrop: async (from, to)=>{
-                    external_node_assert_default()(libnut, 'libnut not initialized');
-                    libnut.moveMouse(Math.round(from.x), Math.round(from.y));
-                    libnut.mouseToggle('down', 'left');
-                    await (0, utils_namespaceObject.sleep)(100);
-                    libnut.moveMouse(Math.round(to.x), Math.round(to.y));
-                    await (0, utils_namespaceObject.sleep)(100);
-                    libnut.mouseToggle('up', 'left');
+                    this.inputDriver.moveMouse(Math.round(from.x), Math.round(from.y));
+                    await this.inputDriver.withMouseButton('left', async ()=>{
+                        await this.inputDriver.delay(100);
+                        this.inputDriver.moveMouse(Math.round(to.x), Math.round(to.y));
+                        await this.inputDriver.delay(100);
+                    });
                 }
             },
             keyboard: {
                 typeText: async (value, opts)=>{
-                    external_node_assert_default()(libnut, 'libnut not initialized');
                     const element = opts?.target;
                     if (element) {
                         const [x, y] = element.center;
-                        libnut.moveMouse(Math.round(x), Math.round(y));
-                        libnut.mouseClick('left');
-                        await (0, utils_namespaceObject.sleep)(INPUT_FOCUS_DELAY);
+                        this.inputDriver.moveMouse(Math.round(x), Math.round(y));
+                        this.inputDriver.mouseClick('left');
+                        await this.inputDriver.delay(INPUT_FOCUS_DELAY);
                         if (opts?.replace !== false) {
                             await this.selectAllAndDelete();
-                            await (0, utils_namespaceObject.sleep)(INPUT_CLEAR_DELAY);
+                            await this.inputDriver.delay(INPUT_CLEAR_DELAY);
                         }
                     }
                     await this.smartTypeString(value);
                 },
                 keyboardPress: async (keyName, opts)=>{
-                    external_node_assert_default()(libnut, 'libnut not initialized');
                     const target = opts?.target;
                     if (target) {
                         const [x, y] = target.center;
-                        libnut.moveMouse(Math.round(x), Math.round(y));
-                        libnut.mouseClick('left');
-                        await (0, utils_namespaceObject.sleep)(50);
+                        this.inputDriver.moveMouse(Math.round(x), Math.round(y));
+                        this.inputDriver.mouseClick('left');
+                        await this.inputDriver.delay(50);
                     }
                     await this.pressKeyboardShortcut(keyName);
                 },
                 clearInput: async (target)=>{
-                    external_node_assert_default()(libnut, 'libnut not initialized');
                     if (target) {
                         const element = target;
                         const [x, y] = element.center;
-                        libnut.moveMouse(Math.round(x), Math.round(y));
-                        libnut.mouseClick('left');
-                        await (0, utils_namespaceObject.sleep)(100);
+                        this.inputDriver.moveMouse(Math.round(x), Math.round(y));
+                        this.inputDriver.mouseClick('left');
+                        await this.inputDriver.delay(100);
                     }
                     await this.selectAllAndDelete();
-                    await (0, utils_namespaceObject.sleep)(50);
+                    await this.inputDriver.delay(50);
                 }
             },
             scroll: {
@@ -1115,7 +1224,7 @@ class HelperProcessRDPBackendClient {
 function createDefaultRDPBackendClient() {
     return new HelperProcessRDPBackendClient();
 }
-function device_define_property(obj, key, value) {
+function rdp_device_define_property(obj, key, value) {
     if (key in obj) Object.defineProperty(obj, key, {
         value: value,
         enumerable: true,
@@ -1274,14 +1383,14 @@ class RDPDevice {
         }
     }
     constructor(options){
-        device_define_property(this, "interfaceType", 'rdp');
-        device_define_property(this, "options", void 0);
-        device_define_property(this, "backend", void 0);
-        device_define_property(this, "connectionInfo", void 0);
-        device_define_property(this, "destroyed", false);
-        device_define_property(this, "cursorPosition", void 0);
-        device_define_property(this, "uri", void 0);
-        device_define_property(this, "inputPrimitives", {
+        rdp_device_define_property(this, "interfaceType", 'rdp');
+        rdp_device_define_property(this, "options", void 0);
+        rdp_device_define_property(this, "backend", void 0);
+        rdp_device_define_property(this, "connectionInfo", void 0);
+        rdp_device_define_property(this, "destroyed", false);
+        rdp_device_define_property(this, "cursorPosition", void 0);
+        rdp_device_define_property(this, "uri", void 0);
+        rdp_device_define_property(this, "inputPrimitives", {
             pointer: {
                 tap: async ({ x, y })=>{
                     await this.movePointer(Math.round(x), Math.round(y), {
@@ -1615,7 +1724,7 @@ class ComputerMidsceneTools extends base_tools_namespaceObject.BaseMidsceneTools
 const tools = new ComputerMidsceneTools();
 (0, cli_namespaceObject.runToolsCLI)(tools, 'midscene-computer', {
     stripPrefix: 'computer_',
-    version: "1.8.6",
+    version: "1.8.7-beta-20260527113633.0",
     extraCommands: (0, core_namespaceObject.createReportCliCommands)()
 }).catch((e)=>{
     process.exit((0, cli_namespaceObject.reportCLIError)(e));