@midscene/computer 1.12.2-beta-20260828072235.0 → 1.12.2

package/dist/es/cli.mjs

@@ -19,57 +19,6 @@ import node_assert from "node:assert";
 import { hasActiveCliInterruptWaiter } from "@midscene/shared/cli/interrupt";
 import { once } from "node:events";
 import { createInterface } from "node:readline";
-const MOUSE_COORDINATE_TOLERANCE_PX = 5;
-const MIN_CALIBRATION_AXIS_DELTA = 20;
-const MIN_VALID_CALIBRATION_SCALE = 0.1;
-const MAX_VALID_CALIBRATION_SCALE = 10;
-function assertValidMouseCalibrationBounds(bounds) {
-    if (!Number.isFinite(bounds.x) || !Number.isFinite(bounds.y) || !Number.isFinite(bounds.width) || !Number.isFinite(bounds.height) || bounds.width <= 0 || bounds.height <= 0) throw new Error(`Mouse calibration bounds are invalid: (${bounds.x}, ${bounds.y}, ${bounds.width}, ${bounds.height})`);
-}
-function mouseCalibrationPoint(bounds, ratio) {
-    return {
-        x: Math.round(bounds.x + bounds.width * ratio),
-        y: Math.round(bounds.y + bounds.height * ratio)
-    };
-}
-function calculateMouseCoordinateCalibration(firstInput, firstActual, secondInput, secondActual) {
-    const inputDeltaX = secondInput.x - firstInput.x;
-    const inputDeltaY = secondInput.y - firstInput.y;
-    if (Math.abs(inputDeltaX) < MIN_CALIBRATION_AXIS_DELTA || Math.abs(inputDeltaY) < MIN_CALIBRATION_AXIS_DELTA) throw new Error(`Mouse calibration points are too close: delta=(${inputDeltaX}, ${inputDeltaY})`);
-    const scaleX = (secondActual.x - firstActual.x) / inputDeltaX;
-    const scaleY = (secondActual.y - firstActual.y) / inputDeltaY;
-    if (!Number.isFinite(scaleX) || !Number.isFinite(scaleY) || scaleX < MIN_VALID_CALIBRATION_SCALE || scaleY < MIN_VALID_CALIBRATION_SCALE || scaleX > MAX_VALID_CALIBRATION_SCALE || scaleY > MAX_VALID_CALIBRATION_SCALE) throw new Error(`Mouse calibration produced invalid scale: (${scaleX}, ${scaleY})`);
-    return {
-        scaleX,
-        scaleY,
-        offsetX: firstActual.x - scaleX * firstInput.x,
-        offsetY: firstActual.y - scaleY * firstInput.y
-    };
-}
-function applyMouseCoordinateCalibration(point, calibration) {
-    return {
-        x: Math.round((point.x - calibration.offsetX) / calibration.scaleX),
-        y: Math.round((point.y - calibration.offsetY) / calibration.scaleY)
-    };
-}
-function mouseCoordinateCalibrationNeedsCorrection(calibration) {
-    return Math.abs(calibration.scaleX - 1) > 0.01 || Math.abs(calibration.scaleY - 1) > 0.01 || Math.abs(calibration.offsetX) > MOUSE_COORDINATE_TOLERANCE_PX || Math.abs(calibration.offsetY) > MOUSE_COORDINATE_TOLERANCE_PX;
-}
-function getMouseCoordinateDrift(expected, actual) {
-    return {
-        x: actual.x - expected.x,
-        y: actual.y - expected.y
-    };
-}
-function mouseCoordinateDriftIsWithinTolerance(drift) {
-    return Math.abs(drift.x) <= MOUSE_COORDINATE_TOLERANCE_PX && Math.abs(drift.y) <= MOUSE_COORDINATE_TOLERANCE_PX;
-}
-function mouseCoordinateCorrectionPoint(requested, drift) {
-    return {
-        x: requested.x - drift.x,
-        y: requested.y - drift.y
-    };
-}
 function _define_property(obj, key, value) {
     if (key in obj) Object.defineProperty(obj, key, {
         value: value,
@@ -80,9 +29,6 @@ function _define_property(obj, key, value) {
     else obj[key] = value;
     return obj;
 }
-const CALIBRATION_SETTLE_DELAY_MS = 80;
-const MOUSE_CORRECTION_SETTLE_DELAY_MS = 50;
-const MAX_MOUSE_CORRECTION_ATTEMPTS = 3;
 class ComputerInputDriver {
     destroy() {
         if (this.destroyed) return;
@@ -96,82 +42,7 @@ class ComputerInputDriver {
         return this.getLibnutOrThrow('getMousePos').getMousePos();
     }
     moveMouse(x, y) {
-        const target = this.mouseCoordinateCalibration ? applyMouseCoordinateCalibration({
-            x,
-            y
-        }, this.mouseCoordinateCalibration) : {
-            x,
-            y
-        };
-        this.getLibnutOrThrow('moveMouse').moveMouse(target.x, target.y);
-    }
-    async calibrateMouseCoordinates(bounds) {
-        this.assertActive('calibrateMouseCoordinates');
-        assertValidMouseCalibrationBounds(bounds);
-        const firstInput = mouseCalibrationPoint(bounds, 0.1);
-        const secondInput = mouseCalibrationPoint(bounds, 0.3);
-        const savedPosition = this.getMousePos();
-        this.mouseCoordinateCalibration = void 0;
-        try {
-            this.moveMouse(firstInput.x, firstInput.y);
-            await this.delay(CALIBRATION_SETTLE_DELAY_MS);
-            const firstActual = this.getMousePos();
-            this.moveMouse(secondInput.x, secondInput.y);
-            await this.delay(CALIBRATION_SETTLE_DELAY_MS);
-            const secondActual = this.getMousePos();
-            const calibration = calculateMouseCoordinateCalibration(firstInput, firstActual, secondInput, secondActual);
-            const needsCorrection = mouseCoordinateCalibrationNeedsCorrection(calibration);
-            this.mouseCoordinateCalibration = needsCorrection ? calibration : void 0;
-            let verificationDrift = {
-                x: 0,
-                y: 0
-            };
-            if (needsCorrection) {
-                const verificationTarget = mouseCalibrationPoint(bounds, 0.5);
-                this.moveMouse(verificationTarget.x, verificationTarget.y);
-                await this.delay(CALIBRATION_SETTLE_DELAY_MS);
-                verificationDrift = this.assertMousePosition(verificationTarget.x, verificationTarget.y, 'Mouse coordinate calibration verification');
-            }
-            this.options.debug(needsCorrection ? `Mouse coordinate calibration applied: scale=(${calibration.scaleX.toFixed(4)}, ${calibration.scaleY.toFixed(4)}), offset=(${calibration.offsetX.toFixed(1)}, ${calibration.offsetY.toFixed(1)}), verification drift=(${verificationDrift.x}, ${verificationDrift.y})` : 'Mouse coordinate calibration is identity');
-            this.moveMouse(savedPosition.x, savedPosition.y);
-        } catch (error) {
-            try {
-                this.moveMouse(savedPosition.x, savedPosition.y);
-            } finally{
-                this.mouseCoordinateCalibration = void 0;
-            }
-            throw error;
-        }
-    }
-    assertMousePosition(targetX, targetY, context) {
-        const current = this.getMousePos();
-        const drift = getMouseCoordinateDrift({
-            x: targetX,
-            y: targetY
-        }, current);
-        if (!mouseCoordinateDriftIsWithinTolerance(drift)) throw new Error(`${context}: expected (${targetX}, ${targetY}), got (${current.x}, ${current.y}), drift=(${drift.x}, ${drift.y})`);
-        return drift;
-    }
-    async correctMousePosition(targetX, targetY, context) {
-        const target = {
-            x: targetX,
-            y: targetY
-        };
-        let requested = target;
-        for(let attempt = 0; attempt <= MAX_MOUSE_CORRECTION_ATTEMPTS; attempt++){
-            const current = this.getMousePos();
-            const drift = getMouseCoordinateDrift(target, current);
-            if (mouseCoordinateDriftIsWithinTolerance(drift)) {
-                if (attempt > 0) this.options.debug(`${context}: pointer correction converged after ${attempt} attempt(s), drift=(${drift.x}, ${drift.y})`);
-                return drift;
-            }
-            if (attempt === MAX_MOUSE_CORRECTION_ATTEMPTS) return this.assertMousePosition(targetX, targetY, context);
-            requested = mouseCoordinateCorrectionPoint(requested, drift);
-            this.options.debug(`${context}: correcting pointer drift=(${drift.x}, ${drift.y}) with requested point=(${requested.x}, ${requested.y}), attempt=${attempt + 1}/${MAX_MOUSE_CORRECTION_ATTEMPTS}`);
-            this.moveMouse(requested.x, requested.y);
-            await this.delay(MOUSE_CORRECTION_SETTLE_DELAY_MS);
-        }
-        throw new Error(`${context}: mouse correction ended unexpectedly`);
+        this.getLibnutOrThrow('moveMouse').moveMouse(x, y);
     }
     focusActiveWindow() {
         const lib = this.getLibnutOrThrow('focusActiveWindow');
@@ -307,7 +178,6 @@ class ComputerInputDriver {
     constructor(options){
         _define_property(this, "options", void 0);
         _define_property(this, "destroyed", void 0);
-        _define_property(this, "mouseCoordinateCalibration", void 0);
         _define_property(this, "pendingInputDelayWaits", void 0);
         this.options = options;
         this.destroyed = false;
@@ -315,7 +185,50 @@ class ComputerInputDriver {
     }
 }
 const debugXvfb = getDebug('computer:xvfb');
-function createXvfbSigintCleanup(cleanup, source = process) {
+const xvfbCleanupMonitorScript = String.raw`
+const parentPid = Number(process.argv[1]);
+const xvfbPid = Number(process.argv[2]);
+const timer = setInterval(() => {
+  try {
+    process.kill(xvfbPid, 0);
+  } catch {
+    clearInterval(timer);
+    process.exit(0);
+  }
+  try {
+    process.kill(parentPid, 0);
+    return;
+  } catch {
+    // The owner is gone, so its X11 clients can no longer receive XIO errors.
+  }
+  try {
+    process.kill(xvfbPid, 'SIGTERM');
+  } catch {
+    // Xvfb may have already exited.
+  }
+  clearInterval(timer);
+}, 100);
+`;
+function scheduleXvfbStopAfterProcessExit(instance, parentPid = process.pid) {
+    const xvfbPid = instance.process.pid;
+    if (!xvfbPid) throw new Error('Cannot schedule Xvfb cleanup before its process starts');
+    const monitor = spawn(process.execPath, [
+        '-e',
+        xvfbCleanupMonitorScript,
+        String(parentPid),
+        String(xvfbPid)
+    ], {
+        detached: true,
+        stdio: 'ignore'
+    });
+    monitor.on('error', (error)=>{
+        debugXvfb(`Xvfb cleanup monitor failed: ${error.message}`);
+    });
+    instance.process.unref();
+    monitor.unref();
+    return monitor;
+}
+function createXvfbSignalCleanup(cleanup, source = process) {
     return ()=>{
         if (!hasActiveCliInterruptWaiter(source)) cleanup();
     };
@@ -548,33 +461,19 @@ function runPowershell(script) {
         windowsHide: true
     });
 }
-function readWindowsDisplayGeometries() {
+function listWindowsDisplays() {
     const script = `
 Add-Type -AssemblyName System.Windows.Forms
 $s = [System.Windows.Forms.Screen]::AllScreens | ForEach-Object {
-  $b = $_.Bounds
-  [PSCustomObject]@{
-    id = $_.DeviceName
-    name = $_.DeviceName
-    primary = $_.Primary
-    bounds = [PSCustomObject]@{ x = $b.X; y = $b.Y; width = $b.Width; height = $b.Height }
-  }
+  [PSCustomObject]@{ id = $_.DeviceName; name = $_.DeviceName; primary = $_.Primary }
 }
 ConvertTo-Json @($s) -Compress
 `.trim();
-    const output = runPowershell(script).trim();
-    if (!output) throw new Error('Windows display enumeration returned no data');
-    const parsed = JSON.parse(output);
-    if (!Array.isArray(parsed)) throw new Error('Windows display enumeration returned invalid data');
-    const displays = parsed.filter(isWindowsDisplayGeometry);
-    if (displays.length !== parsed.length || 0 === displays.length) throw new Error('Windows display enumeration returned invalid geometry');
-    return displays;
-}
-function listWindowsDisplays(geometries = readWindowsDisplayGeometries()) {
-    return geometries.map((display)=>({
-            id: display.id,
-            name: display.name,
-            primary: display.primary
+    const parsed = JSON.parse(runPowershell(script).trim());
+    return parsed.map((d)=>({
+            id: String(d.id),
+            name: d.name || String(d.id),
+            primary: d.primary || false
         }));
 }
 let device_libnut = null;
@@ -676,16 +575,6 @@ function getDisplayInfoBinary() {
 function isFiniteNumber(value) {
     return 'number' == typeof value && Number.isFinite(value);
 }
-function isDisplayBounds(value) {
-    if (!value || 'object' != typeof value) return false;
-    const bounds = value;
-    return isFiniteNumber(bounds.x) && isFiniteNumber(bounds.y) && isFiniteNumber(bounds.width) && isFiniteNumber(bounds.height) && bounds.width > 0 && bounds.height > 0;
-}
-function isWindowsDisplayGeometry(value) {
-    if (!value || 'object' != typeof value) return false;
-    const candidate = value;
-    return 'string' == typeof candidate.id && candidate.id.length > 0 && 'string' == typeof candidate.name && 'boolean' == typeof candidate.primary && isDisplayBounds(candidate.bounds);
-}
 function isDarwinDisplayGeometry(value) {
     if (!value || 'object' != typeof value) return false;
     const candidate = value;
@@ -729,11 +618,8 @@ function readDarwinFrontmostApplication() {
     }
 }
 async function pressMouseAtGlobalPoint(inputDriver, targetX, targetY, holdDuration, reason) {
+    await inputDriver.delay(CLICK_SETTLE_DELAY);
     const current = inputDriver.getMousePos();
-    const drift = {
-        x: current.x - targetX,
-        y: current.y - targetY
-    };
     debugComputerInput('tap mouse moved %o', {
         reason,
         target: {
@@ -741,7 +627,10 @@ async function pressMouseAtGlobalPoint(inputDriver, targetX, targetY, holdDurati
             y: targetY
         },
         current,
-        drift
+        drift: {
+            x: current.x - targetX,
+            y: current.y - targetY
+        }
     });
     await inputDriver.withMouseButton('left', async ()=>{
         debugComputerInput('tap mouse down %o', {
@@ -760,18 +649,9 @@ function resolveDarwinDisplayGeometryFromList(displayId, displays) {
     if (void 0 === displayId || '' === displayId) return displays.find((display)=>display.primary) || displays.find((display)=>0 === display.screenIndex) || displays[0];
     return displays.find((display)=>display.screenIndex === screenIndex) || displays.find((display)=>display.cgDisplayId === screenIndex);
 }
-function resolveWindowsDisplayGeometryFromList(displayId, displays) {
-    if (!displays.length) return;
-    if (void 0 === displayId || '' === displayId) return displays.find((display)=>display.primary) || displays[0];
-    return displays.find((display)=>display.id === displayId);
-}
-function resolveDisplayGeometry(displayId, windowsDisplays) {
-    if ('darwin' === process.platform) return resolveDarwinDisplayGeometryFromList(displayId, readDarwinDisplayGeometries());
-    if ('win32' === process.platform) {
-        const geometry = resolveWindowsDisplayGeometryFromList(displayId, windowsDisplays ?? readWindowsDisplayGeometries());
-        if (!geometry) throw new Error(displayId ? `Requested Windows display not found: ${displayId}` : 'No Windows displays were detected');
-        return geometry;
-    }
+function resolveDisplayGeometry(displayId) {
+    if ('darwin' !== process.platform) return;
+    return resolveDarwinDisplayGeometryFromList(displayId, readDarwinDisplayGeometries());
 }
 function mapDisplayLocalPointToGlobal(point, geometry) {
     if (!geometry) return point;
@@ -857,20 +737,6 @@ function normalizePrimaryKey(key) {
     return KEY_NAME_MAP[lowerKey] || lowerKey;
 }
 class ComputerDevice {
-    async moveGlobalPointer(point, context, smooth) {
-        const target = {
-            x: Math.round(point.x),
-            y: Math.round(point.y)
-        };
-        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(CLICK_SETTLE_DELAY);
-        if ('win32' === process.platform) await this.inputDriver.correctMousePosition(target.x, target.y, context);
-        return target;
-    }
-    moveDisplayPointer(point, context, smooth) {
-        return this.moveGlobalPointer(this.toGlobalPoint(point), context, smooth);
-    }
     async focusKeyboardTarget(element, delayMs) {
         const [x, y] = element.center;
         if ('darwin' === process.platform) await this.inputPrimitives.pointer.tap({
@@ -878,10 +744,11 @@ class ComputerDevice {
             y
         });
         else {
-            await this.moveDisplayPointer({
+            const point = this.toGlobalPoint({
                 x,
                 y
-            }, 'Mouse did not reach the keyboard focus target');
+            });
+            this.inputDriver.moveMouse(Math.round(point.x), Math.round(point.y));
             this.inputDriver.mouseClick('left');
         }
         await this.inputDriver.delay(delayMs);
@@ -900,7 +767,7 @@ class ComputerDevice {
                 }));
         } catch (error) {
             debugDevice(`Failed to list displays: ${error}`);
-            throw new Error(`Failed to list displays: ${error}`);
+            return [];
         }
     }
     async connect() {
@@ -912,24 +779,26 @@ class ComputerDevice {
                 this.xvfbInstance = await startXvfb({
                     resolution: this.options?.xvfbResolution
                 });
+                if (this.options?.keepXvfbAliveUntilProcessExit) scheduleXvfbStopAfterProcessExit(this.xvfbInstance);
                 process.env.DISPLAY = this.xvfbInstance.display;
                 debugDevice(`Xvfb started on display ${this.xvfbInstance.display}`);
-                this.xvfbCleanup = ()=>{
-                    if (this.xvfbInstance) {
-                        this.xvfbInstance.stop();
-                        this.xvfbInstance = void 0;
-                    }
-                };
-                this.xvfbSigintCleanup = createXvfbSigintCleanup(()=>this.xvfbCleanup?.());
-                process.on('exit', this.xvfbCleanup);
-                process.on('SIGINT', this.xvfbSigintCleanup);
-                process.on('SIGTERM', this.xvfbCleanup);
+                if (!this.options?.keepXvfbAliveUntilProcessExit) {
+                    this.xvfbCleanup = ()=>{
+                        if (this.xvfbInstance) {
+                            this.xvfbInstance.stop();
+                            this.xvfbInstance = void 0;
+                        }
+                    };
+                    this.xvfbSignalCleanup = createXvfbSignalCleanup(()=>this.xvfbCleanup?.());
+                    process.on('exit', this.xvfbCleanup);
+                    process.on('SIGINT', this.xvfbSignalCleanup);
+                    process.on('SIGTERM', this.xvfbSignalCleanup);
+                }
             }
             device_libnut = await getLibnut();
-            const windowsDisplayGeometries = 'win32' === process.platform ? readWindowsDisplayGeometries() : void 0;
-            this.displayGeometry = resolveDisplayGeometry(this.displayId, windowsDisplayGeometries);
+            this.displayGeometry = resolveDisplayGeometry(this.displayId);
             const size = await this.size();
-            const displays = windowsDisplayGeometries ? listWindowsDisplays(windowsDisplayGeometries) : await ComputerDevice.listDisplays();
+            const displays = await ComputerDevice.listDisplays();
             const headlessInfo = this.xvfbInstance ? `\nHeadless: true (Xvfb on ${this.xvfbInstance.display})` : '';
             this.description = `
 Type: Computer
@@ -939,28 +808,28 @@ Screen Size: ${size.width}x${size.height}
 Available Displays: ${displays.length > 0 ? displays.map((d)=>d.name).join(', ') : 'Unknown'}${headlessInfo}
 `;
             debugDevice('Computer device connected', this.description);
-            await this.healthCheck(displays);
+            await this.healthCheck();
         } catch (error) {
             if (this.xvfbInstance) {
-                this.xvfbInstance.stop();
+                if (!this.options?.keepXvfbAliveUntilProcessExit) this.xvfbInstance.stop();
                 this.xvfbInstance = void 0;
             }
             if (this.xvfbCleanup) {
                 process.removeListener('exit', this.xvfbCleanup);
-                process.removeListener('SIGTERM', this.xvfbCleanup);
                 this.xvfbCleanup = void 0;
             }
-            if (this.xvfbSigintCleanup) {
-                process.removeListener('SIGINT', this.xvfbSigintCleanup);
-                this.xvfbSigintCleanup = void 0;
+            if (this.xvfbSignalCleanup) {
+                process.removeListener('SIGINT', this.xvfbSignalCleanup);
+                process.removeListener('SIGTERM', this.xvfbSignalCleanup);
+                this.xvfbSignalCleanup = void 0;
             }
             debugDevice(`Failed to connect: ${error}`);
             throw new Error(`Unable to connect to computer device: ${error}`);
         }
     }
-    async healthCheck(displays) {
+    async healthCheck() {
         console.log('[HealthCheck] Starting health check...');
-        console.log("[HealthCheck] @midscene/computer v1.12.2-beta-20260828072235.0");
+        console.log("[HealthCheck] @midscene/computer v1.12.2");
         console.log('[HealthCheck] Taking screenshot...');
         const screenshotTimeout = 15000;
         let timeoutId;
@@ -972,27 +841,23 @@ Available Displays: ${displays.length > 0 ? displays.map((d)=>d.name).join(', ')
             timeoutPromise
         ]);
         console.log(`[HealthCheck] Screenshot succeeded (length=${base64.length})`);
-        console.log('[HealthCheck] Verifying mouse control...');
+        console.log('[HealthCheck] Moving mouse...');
         const startPos = this.inputDriver.getMousePos();
         console.log(`[HealthCheck] Current mouse position: (${startPos.x}, ${startPos.y})`);
-        if ('win32' === process.platform) {
-            if (!this.displayGeometry) throw new Error('Windows display geometry is unavailable');
-            await this.inputDriver.calibrateMouseCoordinates(this.displayGeometry.bounds);
-            console.log(`[HealthCheck] Mouse calibrated for display bounds (${this.displayGeometry.bounds.x}, ${this.displayGeometry.bounds.y}, ${this.displayGeometry.bounds.width}, ${this.displayGeometry.bounds.height})`);
-        } else {
-            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})...`);
-            try {
-                this.inputDriver.moveMouse(targetX, targetY);
-                await sleep(CLICK_SETTLE_DELAY);
-                this.inputDriver.assertMousePosition(targetX, targetY, 'Mouse health check failed');
-            } finally{
-                this.inputDriver.moveMouse(startPos.x, startPos.y);
-                console.log(`[HealthCheck] Mouse restored to (${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})...`);
+        this.inputDriver.moveMouse(targetX, targetY);
+        await sleep(50);
+        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);
+        if (deltaX > 5 || deltaY > 5) {
+            const msg = `[HealthCheck] WARNING: Mouse control may not be working. Expected (${targetX}, ${targetY}), got (${movedPos.x}, ${movedPos.y}), delta=(${deltaX}, ${deltaY})`;
+            warnDevice(msg);
         }
         if ('win32' === process.platform && !this.isRunningAsAdmin()) {
             const hint = [
@@ -1002,7 +867,10 @@ Available Displays: ${displays.length > 0 ? displays.map((d)=>d.name).join(', ')
             ].join(' ');
             warnDevice(`[HealthCheck] ${hint}`);
         }
+        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();
         if (displays.length > 0) {
             console.log(`[HealthCheck] Found ${displays.length} monitor(s):`);
             for (const display of displays){
@@ -1185,14 +1053,10 @@ $g.Dispose(); $bmp.Dispose(); $ms.Dispose()
     resolveUntargetedScrollPoint(screenSize) {
         if ('win32' === process.platform) {
             const activeWindowRect = this.inputDriver.getActiveWindowRect();
-            if (activeWindowRect) {
-                const activeWindowCenter = {
-                    x: activeWindowRect.x + activeWindowRect.width / 2,
-                    y: activeWindowRect.y + activeWindowRect.height / 2
-                };
-                const bounds = this.displayGeometry?.bounds;
-                if (!bounds || activeWindowCenter.x >= bounds.x && activeWindowCenter.x < bounds.x + bounds.width && activeWindowCenter.y >= bounds.y && activeWindowCenter.y < bounds.y + bounds.height) return activeWindowCenter;
-            }
+            if (activeWindowRect) return {
+                x: activeWindowRect.x + activeWindowRect.width / 2,
+                y: activeWindowRect.y + activeWindowRect.height / 2
+            };
         }
         return this.toGlobalPoint({
             x: screenSize.width / 2,
@@ -1203,16 +1067,17 @@ $g.Dispose(); $bmp.Dispose(); $ms.Dispose()
         if (param.locate) {
             const element = param.locate;
             const [x, y] = element.center;
-            await this.moveDisplayPointer({
+            const point = this.toGlobalPoint({
                 x,
                 y
-            }, 'Mouse did not reach the scroll target');
+            });
+            this.inputDriver.moveMouse(Math.round(point.x), Math.round(point.y));
             return;
         }
         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');
+        this.inputDriver.moveMouse(Math.round(point.x), Math.round(point.y));
         await this.inputDriver.delay(MOUSE_MOVE_EFFECT_WAIT);
         return screenSize;
     }
@@ -1301,18 +1166,19 @@ $g.Dispose(); $bmp.Dispose(); $ms.Dispose()
         if (this.destroyed) return;
         this.destroyed = true;
         this.inputDriver.destroy();
+        const keepXvfbAliveUntilProcessExit = this.options?.keepXvfbAliveUntilProcessExit === true;
         if (this.xvfbInstance) {
-            this.xvfbInstance.stop();
+            if (!keepXvfbAliveUntilProcessExit) this.xvfbInstance.stop();
             this.xvfbInstance = void 0;
         }
-        if (this.xvfbCleanup) {
+        if (this.xvfbCleanup && !keepXvfbAliveUntilProcessExit) {
             process.removeListener('exit', this.xvfbCleanup);
-            process.removeListener('SIGTERM', this.xvfbCleanup);
             this.xvfbCleanup = void 0;
         }
-        if (this.xvfbSigintCleanup) {
-            process.removeListener('SIGINT', this.xvfbSigintCleanup);
-            this.xvfbSigintCleanup = void 0;
+        if (this.xvfbSignalCleanup) {
+            process.removeListener('SIGINT', this.xvfbSignalCleanup);
+            process.removeListener('SIGTERM', this.xvfbSignalCleanup);
+            this.xvfbSignalCleanup = void 0;
         }
         debugDevice('Computer device destroyed');
     }
@@ -1328,7 +1194,7 @@ $g.Dispose(); $bmp.Dispose(); $ms.Dispose()
         device_define_property(this, "destroyed", false);
         device_define_property(this, "xvfbInstance", void 0);
         device_define_property(this, "xvfbCleanup", void 0);
-        device_define_property(this, "xvfbSigintCleanup", void 0);
+        device_define_property(this, "xvfbSignalCleanup", void 0);
         device_define_property(this, "inputDriver", new ComputerInputDriver({
             getLibnut: ()=>device_libnut,
             useAppleScript: ()=>this.useAppleScript,
@@ -1360,16 +1226,14 @@ $g.Dispose(); $bmp.Dispose(); $ms.Dispose()
                         },
                         holdDuration,
                         displayId: this.displayId,
-                        displayGeometry: this.displayGeometry
+                        displayGeometry: this.displayGeometry ? {
+                            screenIndex: this.displayGeometry.screenIndex,
+                            cgDisplayId: this.displayGeometry.cgDisplayId,
+                            bounds: this.displayGeometry.bounds
+                        } : void 0
                     });
                     const frontmostBefore = 'darwin' === process.platform ? readDarwinFrontmostApplication() : void 0;
-                    await this.moveGlobalPointer({
-                        x: targetX,
-                        y: targetY
-                    }, 'Mouse did not reach the tap target', {
-                        smoothSteps: SMOOTH_MOVE_STEPS_TAP,
-                        smoothDelay: SMOOTH_MOVE_DELAY_TAP
-                    });
+                    await this.inputDriver.smoothMoveMouse(targetX, targetY, SMOOTH_MOVE_STEPS_TAP, SMOOTH_MOVE_DELAY_TAP);
                     await pressMouseAtGlobalPoint(this.inputDriver, targetX, targetY, holdDuration, 'primary');
                     if (frontmostBefore && 'darwin' === process.platform) {
                         await sleep(CLICK_FOCUS_SETTLE_DELAY);
@@ -1381,43 +1245,42 @@ $g.Dispose(); $bmp.Dispose(); $ms.Dispose()
                             focusChanged
                         });
                         if (focusChanged) {
-                            await this.moveGlobalPointer({
-                                x: targetX,
-                                y: targetY
-                            }, 'Mouse did not reach the focus follow-up target');
+                            this.inputDriver.moveMouse(targetX, targetY);
                             await pressMouseAtGlobalPoint(this.inputDriver, targetX, targetY, holdDuration, 'focus-follow-up');
                         }
                     }
                 },
                 doubleClick: async ({ x, y })=>{
-                    await this.moveDisplayPointer({
+                    const target = this.toGlobalPoint({
                         x,
                         y
-                    }, 'Mouse did not reach the double-click target');
+                    });
+                    this.inputDriver.moveMouse(Math.round(target.x), Math.round(target.y));
                     this.inputDriver.mouseClick('left', true);
                 },
                 rightClick: async ({ x, y })=>{
-                    await this.moveDisplayPointer({
+                    const target = this.toGlobalPoint({
                         x,
                         y
-                    }, 'Mouse did not reach the right-click target');
+                    });
+                    this.inputDriver.moveMouse(Math.round(target.x), Math.round(target.y));
                     this.inputDriver.mouseClick('right');
                 },
                 hover: async ({ x, y })=>{
-                    await this.moveDisplayPointer({
+                    const target = this.toGlobalPoint({
                         x,
                         y
-                    }, 'Mouse did not reach the hover target', {
-                        smoothSteps: SMOOTH_MOVE_STEPS_MOUSE_MOVE,
-                        smoothDelay: SMOOTH_MOVE_DELAY_MOUSE_MOVE
                     });
+                    await this.inputDriver.smoothMoveMouse(Math.round(target.x), Math.round(target.y), SMOOTH_MOVE_STEPS_MOUSE_MOVE, SMOOTH_MOVE_DELAY_MOUSE_MOVE);
                     await this.inputDriver.delay(MOUSE_MOVE_EFFECT_WAIT);
                 },
                 dragAndDrop: async (from, to)=>{
-                    await this.moveDisplayPointer(from, 'Mouse did not reach the drag start target');
+                    const globalFrom = this.toGlobalPoint(from);
+                    const globalTo = this.toGlobalPoint(to);
+                    this.inputDriver.moveMouse(Math.round(globalFrom.x), Math.round(globalFrom.y));
                     await this.inputDriver.withMouseButton('left', async ()=>{
                         await this.inputDriver.delay(100);
-                        await this.moveDisplayPointer(to, 'Mouse did not reach the drag end target');
+                        this.inputDriver.moveMouse(Math.round(globalTo.x), Math.round(globalTo.y));
                         await this.inputDriver.delay(100);
                     });
                 }
@@ -2147,7 +2010,8 @@ function createLocalComputerDevice(opts) {
         keyboardTypeDelay: opts?.keyboardTypeDelay,
         keyboardDriver: opts?.keyboardDriver,
         headless: opts?.headless,
-        xvfbResolution: opts?.xvfbResolution
+        xvfbResolution: opts?.xvfbResolution,
+        keepXvfbAliveUntilProcessExit: opts?.keepXvfbAliveUntilProcessExit
     });
 }
 function createRDPComputerDevice(opts) {
@@ -2290,6 +2154,9 @@ class ComputerMidsceneTools extends BaseMidsceneTools {
             ...void 0 !== keyboardTypeDelay ? {
                 keyboardTypeDelay
             } : {},
+            ...this.options.keepXvfbAliveUntilProcessExit ? {
+                keepXvfbAliveUntilProcessExit: true
+            } : {},
             ...extractAgentBehaviorInitArgs(opts) ?? {},
             ...reportOptions ?? {}
         };
@@ -2355,21 +2222,23 @@ class ComputerMidsceneTools extends BaseMidsceneTools {
             }
         ];
     }
-    constructor(...args){
-        super(...args), agent_tools_define_property(this, "lastInitArgsSignature", void 0), agent_tools_define_property(this, "initArgSpec", {
+    constructor(options = {}){
+        super(), agent_tools_define_property(this, "options", void 0), agent_tools_define_property(this, "lastInitArgsSignature", void 0), agent_tools_define_property(this, "initArgSpec", void 0), this.options = options, this.initArgSpec = {
             namespace: 'computer',
             shape: computerInitArgShape,
             cli: {
                 preferBareKeys: true
             },
             adapt: (extracted)=>adaptComputerInitArgs(extracted)
-        });
+        };
     }
 }
-const tools = new ComputerMidsceneTools();
+const tools = new ComputerMidsceneTools({
+    keepXvfbAliveUntilProcessExit: true
+});
 runToolsCLI(tools, 'midscene-computer', {
     stripPrefix: 'computer_',
-    version: "1.12.2-beta-20260828072235.0",
+    version: "1.12.2",
     extraCommands: createReportCliCommands()
 }).catch((e)=>{
     process.exit(reportCLIError(e));