@midscene/computer 1.9.8-beta-20260618091332.0 → 1.10.0

package/dist/es/mcp-server.mjs

@@ -1,2088 +0,0 @@
-import { BaseMCPServer, createMCPServerLauncher } from "@midscene/shared/mcp";
-import { Agent } from "@midscene/core/agent";
-import { execFileSync, execSync, spawn, spawnSync } from "node:child_process";
-import { chmodSync, existsSync, statSync } from "node:fs";
-import { createRequire } from "node:module";
-import { dirname, resolve as external_node_path_resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-import { defineAction, defineActionsFromInputPrimitives } from "@midscene/core/device";
-import { sleep } from "@midscene/core/utils";
-import { createImgBase64ByFormat } from "@midscene/shared/img";
-import { getDebug } from "@midscene/shared/logger";
-import screenshot_desktop from "screenshot-desktop";
-import node_assert from "node:assert";
-import { once } from "node:events";
-import { createInterface } from "node:readline";
-import { z } from "@midscene/core";
-import { agentBehaviorInitArgShape, extractAgentBehaviorInitArgs, getAgentInitArgsSignature, shouldRebuildAgentForInitArgs } from "@midscene/shared/mcp/agent-behavior-init-args";
-import { BaseMidsceneTools } from "@midscene/shared/mcp/base-tools";
-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);
-    }
-    focusActiveWindow() {
-        const lib = this.getLibnutOrThrow('focusActiveWindow');
-        if ('function' != typeof lib.getActiveWindow || 'function' != typeof lib.focusWindow) return false;
-        try {
-            const handle = lib.getActiveWindow();
-            if (!handle) return false;
-            lib.focusWindow(handle);
-            return true;
-        } catch (error) {
-            this.options.debug(`focusActiveWindow failed: ${error}`);
-            return false;
-        }
-    }
-    getActiveWindowRect() {
-        const lib = this.getLibnutOrThrow('getActiveWindowRect');
-        if ('function' != typeof lib.getActiveWindow || 'function' != typeof lib.getWindowRect) return null;
-        try {
-            const handle = lib.getActiveWindow();
-            if (!handle) return null;
-            const rect = lib.getWindowRect(handle);
-            if (!Number.isFinite(rect.x) || !Number.isFinite(rect.y) || !Number.isFinite(rect.width) || !Number.isFinite(rect.height) || rect.width <= 0 || rect.height <= 0) return null;
-            return rect;
-        } catch (error) {
-            this.options.debug(`getActiveWindowRect failed: ${error}`);
-            return null;
-        }
-    }
-    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);
-    }
-    async emitScrollDetents(dx, dy, detents, delayMs) {
-        this.assertActive('emitScrollDetents');
-        for(let i = 0; i < detents; i++){
-            this.scrollMouse(dx, dy);
-            if (i < detents - 1) await this.delay(delayMs);
-        }
-    }
-    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();
-        node_assert(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();
-            node_assert(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 = getDebug('computer:xvfb');
-function checkXvfbInstalled() {
-    try {
-        execSync('which Xvfb', {
-            stdio: 'ignore'
-        });
-        return true;
-    } catch  {
-        return false;
-    }
-}
-function findAvailableDisplay(startFrom = 99) {
-    for(let n = startFrom; n < startFrom + 100; n++)if (!existsSync(`/tmp/.X${n}-lock`)) return n;
-    throw new Error(`No available display number found (checked ${startFrom} to ${startFrom + 99})`);
-}
-function startXvfb(options) {
-    const resolution = options?.resolution || '1920x1080x24';
-    const displayNum = options?.displayNumber ?? findAvailableDisplay();
-    const display = `:${displayNum}`;
-    return new Promise((resolve, reject)=>{
-        debugXvfb(`Starting Xvfb on display ${display} with resolution ${resolution}`);
-        const xvfbProcess = spawn('Xvfb', [
-            display,
-            '-screen',
-            '0',
-            resolution,
-            '-ac',
-            '-nolisten',
-            'tcp'
-        ], {
-            stdio: 'ignore'
-        });
-        let settled = false;
-        xvfbProcess.on('error', (err)=>{
-            if (!settled) {
-                settled = true;
-                reject(new Error(`Failed to start Xvfb: ${err.message}`));
-            }
-        });
-        xvfbProcess.on('exit', (code)=>{
-            if (!settled) {
-                settled = true;
-                reject(new Error(`Xvfb exited unexpectedly with code ${code}`));
-            }
-        });
-        const instance = {
-            process: xvfbProcess,
-            display,
-            stop () {
-                try {
-                    xvfbProcess.kill('SIGTERM');
-                } catch  {}
-            }
-        };
-        setTimeout(()=>{
-            if (!settled) {
-                settled = true;
-                debugXvfb(`Xvfb started on display ${display}`);
-                resolve(instance);
-            }
-        }, 500);
-    });
-}
-function needsXvfb(explicitOpt) {
-    if ('linux' !== process.platform) return false;
-    return true === explicitOpt;
-}
-function device_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;
-}
-const SMOOTH_MOVE_STEPS_TAP = 8;
-const SMOOTH_MOVE_STEPS_MOUSE_MOVE = 10;
-const SMOOTH_MOVE_DELAY_TAP = 8;
-const SMOOTH_MOVE_DELAY_MOUSE_MOVE = 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;
-const EDGE_SCROLL_STEPS = 400;
-const PHASED_PIXELS_PER_STEP = 30;
-const PHASED_MIN_STEPS = 10;
-const LIBNUT_FALLBACK_PIXELS_PER_DETENT = 100;
-const LIBNUT_FALLBACK_TICK_DELAY_MS = 30;
-const LIBNUT_FALLBACK_MAX_DETENTS = 200;
-const LIBNUT_FALLBACK_DETENT_AMOUNT = 'win32' === process.platform ? 120 : 1;
-const LIBNUT_FALLBACK_EDGE_DETENTS = Math.min(LIBNUT_FALLBACK_MAX_DETENTS, Math.max(1, Math.ceil(EDGE_SCROLL_TOTAL_PX / LIBNUT_FALLBACK_PIXELS_PER_DETENT)));
-const DEFAULT_SCROLL_VIEWPORT_RATIO = 0.7;
-const EDGE_SCROLL_SPEC = {
-    scrollToTop: {
-        direction: 'up',
-        key: 'home',
-        libnut: [
-            0,
-            1
-        ]
-    },
-    scrollToBottom: {
-        direction: 'down',
-        key: 'end',
-        libnut: [
-            0,
-            -1
-        ]
-    },
-    scrollToLeft: {
-        direction: 'left',
-        key: 'home',
-        libnut: [
-            -1,
-            0
-        ]
-    },
-    scrollToRight: {
-        direction: 'right',
-        key: 'end',
-        libnut: [
-            1,
-            0
-        ]
-    }
-};
-const APPLESCRIPT_KEY_CODE_MAP = {
-    return: 36,
-    enter: 36,
-    tab: 48,
-    space: 49,
-    backspace: 51,
-    delete: 51,
-    escape: 53,
-    forwarddelete: 117,
-    left: 123,
-    right: 124,
-    down: 125,
-    up: 126,
-    home: 115,
-    end: 119,
-    pageup: 116,
-    pagedown: 121,
-    f1: 122,
-    f2: 120,
-    f3: 99,
-    f4: 118,
-    f5: 96,
-    f6: 97,
-    f7: 98,
-    f8: 100,
-    f9: 101,
-    f10: 109,
-    f11: 103,
-    f12: 111
-};
-const APPLESCRIPT_MODIFIER_MAP = {
-    command: 'command down',
-    cmd: 'command down',
-    control: 'control down',
-    ctrl: 'control down',
-    shift: 'shift down',
-    alt: 'option down',
-    option: 'option down',
-    meta: 'command down'
-};
-function sendKeyViaAppleScript(key, modifiers = []) {
-    const lowerKey = key.toLowerCase();
-    const keyCode = APPLESCRIPT_KEY_CODE_MAP[lowerKey];
-    const modifierParts = modifiers.map((m)=>APPLESCRIPT_MODIFIER_MAP[m.toLowerCase()]).filter(Boolean);
-    const modifierStr = modifierParts.length > 0 ? ` using {${modifierParts.join(', ')}}` : '';
-    let script;
-    if (void 0 !== keyCode) script = `tell application "System Events" to key code ${keyCode}${modifierStr}`;
-    else {
-        const escapedKey = key.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
-        script = `tell application "System Events" to keystroke "${escapedKey}"${modifierStr}`;
-    }
-    debugDevice('sendKeyViaAppleScript', {
-        key,
-        modifiers,
-        script
-    });
-    execFileSync("osascript", [
-        '-e',
-        script
-    ]);
-}
-let device_libnut = null;
-let libnutLoadError = null;
-async function getLibnut() {
-    if (device_libnut) return device_libnut;
-    if (libnutLoadError) throw libnutLoadError;
-    try {
-        const require = createRequire(import.meta.url);
-        const libnutModule = require('@computer-use/libnut/dist/import_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}`);
-    }
-}
-const debugDevice = getDebug('computer:device');
-const warnDevice = getDebug('computer:device', {
-    console: true
-});
-const debugComputerInput = getDebug('computer:input', {
-    console: true
-});
-const WINDOWS_UIPI_DOC_URL = 'https://midscenejs.com/computer-getting-started#windows-clicks-have-no-effect-on-some-apps';
-function resolvePackageRoot(helperName) {
-    const require = createRequire(import.meta.url);
-    let pkgRoot = null;
-    try {
-        pkgRoot = dirname(require.resolve('@midscene/computer/package.json'));
-    } catch  {
-        const hereDir = dirname(fileURLToPath(import.meta.url));
-        for (const candidate of [
-            external_node_path_resolve(hereDir, '..'),
-            external_node_path_resolve(hereDir, '../..')
-        ])if (existsSync(external_node_path_resolve(candidate, 'package.json'))) {
-            pkgRoot = candidate;
-            break;
-        }
-    }
-    if (!pkgRoot) {
-        debugDevice(`${helperName}: cannot locate @midscene/computer package root`);
-        return null;
-    }
-    return pkgRoot;
-}
-let phasedScrollBinaryPath;
-function getPhasedScrollBinary() {
-    if (void 0 !== phasedScrollBinaryPath) return phasedScrollBinaryPath;
-    if ('darwin' !== process.platform) {
-        phasedScrollBinaryPath = null;
-        return null;
-    }
-    const pkgRoot = resolvePackageRoot('phased-scroll');
-    if (!pkgRoot) {
-        phasedScrollBinaryPath = null;
-        return null;
-    }
-    const binPath = external_node_path_resolve(pkgRoot, 'bin/darwin/phased-scroll');
-    if (!existsSync(binPath)) {
-        debugDevice('phased-scroll binary not found at', binPath);
-        phasedScrollBinaryPath = null;
-        return null;
-    }
-    try {
-        const st = statSync(binPath);
-        if ((73 & st.mode) === 0) {
-            chmodSync(binPath, 493);
-            debugDevice('phased-scroll: restored executable bit on', binPath);
-        }
-    } catch (err) {
-        debugDevice('phased-scroll: chmod self-heal failed', err);
-    }
-    phasedScrollBinaryPath = binPath;
-    return binPath;
-}
-let displayInfoBinaryPath;
-function getDisplayInfoBinary() {
-    if (void 0 !== displayInfoBinaryPath) return displayInfoBinaryPath;
-    if ('darwin' !== process.platform) {
-        displayInfoBinaryPath = null;
-        return null;
-    }
-    const pkgRoot = resolvePackageRoot('display-info');
-    if (!pkgRoot) {
-        displayInfoBinaryPath = null;
-        return null;
-    }
-    const binPath = external_node_path_resolve(pkgRoot, 'bin/darwin/display-info');
-    if (!existsSync(binPath)) {
-        debugDevice('display-info binary not found at', binPath);
-        displayInfoBinaryPath = null;
-        return null;
-    }
-    displayInfoBinaryPath = binPath;
-    return binPath;
-}
-function isFiniteNumber(value) {
-    return 'number' == typeof value && Number.isFinite(value);
-}
-function isDarwinDisplayGeometry(value) {
-    if (!value || 'object' != typeof value) return false;
-    const candidate = value;
-    return Number.isInteger(candidate.screenIndex) && Number.isInteger(candidate.cgDisplayId) && 'boolean' == typeof candidate.primary && !!candidate.bounds && isFiniteNumber(candidate.bounds.x) && isFiniteNumber(candidate.bounds.y) && isFiniteNumber(candidate.bounds.width) && isFiniteNumber(candidate.bounds.height);
-}
-function readDarwinDisplayGeometries() {
-    const bin = getDisplayInfoBinary();
-    if (!bin) return [];
-    try {
-        const output = execFileSync(bin, [], {
-            encoding: 'utf8',
-            stdio: [
-                'ignore',
-                'pipe',
-                'pipe'
-            ]
-        });
-        const parsed = JSON.parse(output);
-        return Array.isArray(parsed.displays) ? parsed.displays.filter(isDarwinDisplayGeometry) : [];
-    } catch (error) {
-        debugDevice('display-info helper failed:', error);
-        return [];
-    }
-}
-function readDarwinFrontmostApplication() {
-    try {
-        const output = execFileSync("osascript", [
-            '-e',
-            'tell application "System Events"\nset frontApp to first application process whose frontmost is true\nreturn (unix id of frontApp as string) & "	" & (name of frontApp as string)\nend tell'
-        ]).toString().trim();
-        const [pidText, ...nameParts] = output.split('\t');
-        const pid = Number(pidText);
-        if (!Number.isInteger(pid) || pid <= 0) return;
-        return {
-            pid,
-            name: nameParts.join('\t')
-        };
-    } catch (error) {
-        debugDevice('Failed to read macOS frontmost application:', error);
-        return;
-    }
-}
-async function pressMouseAtGlobalPoint(inputDriver, targetX, targetY, holdDuration, reason) {
-    await inputDriver.delay(CLICK_SETTLE_DELAY);
-    const current = inputDriver.getMousePos();
-    debugComputerInput('tap mouse moved %o', {
-        reason,
-        target: {
-            x: targetX,
-            y: targetY
-        },
-        current,
-        drift: {
-            x: current.x - targetX,
-            y: current.y - targetY
-        }
-    });
-    await inputDriver.withMouseButton('left', async ()=>{
-        debugComputerInput('tap mouse down %o', {
-            reason
-        });
-        await inputDriver.delay(holdDuration);
-    });
-    debugComputerInput('tap mouse up %o', {
-        reason
-    });
-}
-function resolveDarwinDisplayGeometryFromList(displayId, displays) {
-    if (!displays.length) return;
-    const screenIndex = void 0 === displayId || '' === displayId ? 0 : Number(displayId);
-    if (!Number.isInteger(screenIndex) || screenIndex < 0) return void debugDevice('Invalid macOS display id for display geometry:', displayId);
-    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 resolveDisplayGeometry(displayId) {
-    if ('darwin' !== process.platform) return;
-    return resolveDarwinDisplayGeometryFromList(displayId, readDarwinDisplayGeometries());
-}
-function mapDisplayLocalPointToGlobal(point, geometry) {
-    if (!geometry) return point;
-    return {
-        x: point.x + geometry.bounds.x,
-        y: point.y + geometry.bounds.y
-    };
-}
-let phasedScrollExecWarned = false;
-function runPhasedScroll(direction, pixels, steps) {
-    const bin = getPhasedScrollBinary();
-    if (!bin) return false;
-    try {
-        const res = spawnSync(bin, [
-            direction,
-            String(Math.max(1, Math.round(pixels))),
-            String(steps)
-        ], {
-            stdio: 'ignore'
-        });
-        if (0 === res.status) return true;
-        if (!phasedScrollExecWarned) {
-            phasedScrollExecWarned = true;
-            const hint = null === res.status ? `signal ${res.signal ?? 'unknown'}; the binary may not be executable (npm tarball extraction can drop the +x bit) or may be blocked by quarantine. Try: chmod +x "${bin}"` : 'this usually means Accessibility permission has not been granted to the host process (System Settings → Privacy & Security → Accessibility)';
-            console.warn(`[@midscene/computer] phased-scroll helper failed (exit=${res.status}, signal=${res.signal ?? 'none'}); falling back to keyboard/libnut. ${hint}`);
-        }
-        debugDevice('phased-scroll exited non-zero', res.status, res.signal, res.error);
-        return false;
-    } catch (err) {
-        if (!phasedScrollExecWarned) {
-            phasedScrollExecWarned = true;
-            console.warn(`[@midscene/computer] phased-scroll helper failed to spawn (${err?.message}); falling back to keyboard/libnut.`);
-        }
-        debugDevice('phased-scroll spawn failed', err);
-        return false;
-    }
-}
-const KEY_NAME_MAP = {
-    windows: 'win',
-    win: 'win',
-    ctrl: 'control',
-    esc: 'escape',
-    del: 'delete',
-    ins: 'insert',
-    pgup: 'pageup',
-    pgdn: 'pagedown',
-    arrowup: 'up',
-    arrowdown: 'down',
-    arrowleft: 'left',
-    arrowright: 'right',
-    volumedown: 'audio_vol_down',
-    volumeup: 'audio_vol_up',
-    mediavolumedown: 'audio_vol_down',
-    mediavolumeup: 'audio_vol_up',
-    mute: 'audio_mute',
-    mediamute: 'audio_mute',
-    mediaplay: 'audio_play',
-    mediapause: 'audio_pause',
-    mediaplaypause: 'audio_play',
-    mediastop: 'audio_stop',
-    medianexttrack: 'audio_next',
-    mediaprevioustrack: 'audio_prev',
-    medianext: 'audio_next',
-    mediaprev: 'audio_prev'
-};
-const PRIMARY_KEY_MAP = {
-    command: 'cmd',
-    cmd: 'cmd',
-    meta: 'meta',
-    control: 'control',
-    ctrl: 'control',
-    shift: 'shift',
-    alt: 'alt',
-    option: 'alt'
-};
-function normalizeKeyName(key) {
-    const lowerKey = key.toLowerCase();
-    return KEY_NAME_MAP[lowerKey] || lowerKey;
-}
-function normalizePrimaryKey(key) {
-    const lowerKey = key.toLowerCase();
-    if (PRIMARY_KEY_MAP[lowerKey]) return PRIMARY_KEY_MAP[lowerKey];
-    return KEY_NAME_MAP[lowerKey] || lowerKey;
-}
-class ComputerDevice {
-    describe() {
-        return this.description || 'Computer Device';
-    }
-    static async listDisplays() {
-        try {
-            const displays = await screenshot_desktop.listDisplays();
-            return displays.map((d)=>({
-                    id: String(d.id),
-                    name: d.name || `Display ${d.id}`,
-                    primary: d.primary || false
-                }));
-        } catch (error) {
-            debugDevice(`Failed to list displays: ${error}`);
-            return [];
-        }
-    }
-    async connect() {
-        debugDevice('Connecting to computer device');
-        try {
-            const headless = this.options?.headless ?? 'true' === process.env.MIDSCENE_COMPUTER_HEADLESS_LINUX;
-            if (needsXvfb(headless)) {
-                if (!checkXvfbInstalled()) throw new Error('Xvfb is required for headless mode but not installed. Install: sudo apt-get install xvfb');
-                this.xvfbInstance = await startXvfb({
-                    resolution: this.options?.xvfbResolution
-                });
-                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;
-                    }
-                };
-                process.on('exit', this.xvfbCleanup);
-                process.on('SIGINT', this.xvfbCleanup);
-                process.on('SIGTERM', this.xvfbCleanup);
-            }
-            device_libnut = await getLibnut();
-            this.displayGeometry = resolveDisplayGeometry(this.displayId);
-            const size = await this.size();
-            const displays = await ComputerDevice.listDisplays();
-            const headlessInfo = this.xvfbInstance ? `\nHeadless: true (Xvfb on ${this.xvfbInstance.display})` : '';
-            this.description = `
-Type: Computer
-Platform: ${process.platform}
-Display: ${this.displayId || 'Primary'}
-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();
-        } catch (error) {
-            if (this.xvfbInstance) {
-                this.xvfbInstance.stop();
-                this.xvfbInstance = void 0;
-            }
-            debugDevice(`Failed to connect: ${error}`);
-            throw new Error(`Unable to connect to computer device: ${error}`);
-        }
-    }
-    async healthCheck() {
-        console.log('[HealthCheck] Starting health check...');
-        console.log("[HealthCheck] @midscene/computer v1.9.8-beta-20260618091332.0");
-        console.log('[HealthCheck] Taking screenshot...');
-        const screenshotTimeout = 15000;
-        let timeoutId;
-        const timeoutPromise = new Promise((_, reject)=>{
-            timeoutId = setTimeout(()=>reject(new Error('Screenshot timed out')), screenshotTimeout);
-        });
-        const base64 = await Promise.race([
-            this.screenshotBase64().finally(()=>clearTimeout(timeoutId)),
-            timeoutPromise
-        ]);
-        console.log(`[HealthCheck] Screenshot succeeded (length=${base64.length})`);
-        console.log('[HealthCheck] Moving mouse...');
-        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})...`);
-        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 = [
-                'Heads-up: Midscene is not running as Administrator.',
-                'If clicks or key presses have no effect while the cursor still moves to the right position,',
-                `see the Windows permission troubleshooting guide: ${WINDOWS_UIPI_DOC_URL}`
-            ].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){
-                const primaryTag = display.primary ? ' (primary)' : '';
-                console.log(`[HealthCheck]   - id=${display.id}, name=${display.name}${primaryTag}`);
-            }
-        } else console.log('[HealthCheck] No monitors detected');
-        console.log('[HealthCheck] Health check passed');
-    }
-    isRunningAsAdmin() {
-        if ('win32' !== process.platform) return false;
-        if (void 0 !== this.adminCheckCache) return this.adminCheckCache;
-        try {
-            execSync('net session', {
-                stdio: 'pipe'
-            });
-            this.adminCheckCache = true;
-        } catch  {
-            this.adminCheckCache = false;
-        }
-        return this.adminCheckCache;
-    }
-    async screenshotBase64() {
-        if (this.destroyed) throw new Error('ComputerDevice has been destroyed');
-        debugDevice('Taking screenshot', {
-            displayId: this.displayId
-        });
-        const options = {
-            format: 'png'
-        };
-        if (void 0 !== this.displayId) if ('darwin' === process.platform) {
-            const screenIndex = Number(this.displayId);
-            if (!Number.isNaN(screenIndex)) options.screen = screenIndex;
-        } else options.screen = this.displayId;
-        debugDevice('Screenshot options', options);
-        const MAX_ATTEMPTS = 3;
-        const RETRY_DELAY_MS = 300;
-        let lastRawMessage = '';
-        for(let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++)try {
-            const buffer = await screenshot_desktop(options);
-            if (attempt > 1) debugDevice(`Screenshot succeeded on attempt ${attempt}`);
-            return createImgBase64ByFormat('png', buffer.toString('base64'));
-        } catch (error) {
-            lastRawMessage = error instanceof Error ? error.message : String(error);
-            const isMacTransient = 'darwin' === process.platform && /could not create image from display/i.test(lastRawMessage);
-            const willRetry = isMacTransient && attempt < MAX_ATTEMPTS;
-            debugDevice(`Screenshot attempt ${attempt} failed: ${lastRawMessage}${willRetry ? ' — retrying' : ''}`);
-            if (!willRetry) break;
-            await sleep(RETRY_DELAY_MS);
-        }
-        if ('darwin' === process.platform && /could not create image from display/i.test(lastRawMessage)) throw new Error(`Failed to take screenshot on macOS: the host process is missing Screen Recording permission, or the target display is locked/sleeping.
-
-Please follow these steps:
-1. Open System Settings > Privacy & Security > Screen Recording
-2. Enable the application running this script (e.g., Terminal, iTerm2, VS Code, WebStorm, or Midscene Studio)
-3. Fully quit and relaunch that application after granting permission — macOS only re-reads this permission on process launch.
-
-Original error: ${lastRawMessage}`);
-        throw new Error(`Failed to take screenshot: ${lastRawMessage}`);
-    }
-    async size() {
-        if (this.displayGeometry) return {
-            width: Math.round(this.displayGeometry.bounds.width),
-            height: Math.round(this.displayGeometry.bounds.height)
-        };
-        try {
-            const screenSize = this.inputDriver.getScreenSize();
-            return {
-                width: screenSize.width,
-                height: screenSize.height
-            };
-        } catch (error) {
-            debugDevice(`Failed to get screen size: ${error}`);
-            throw new Error(`Failed to get screen size: ${error}`);
-        }
-    }
-    toGlobalPoint(point) {
-        return mapDisplayLocalPointToGlobal(point, this.displayGeometry);
-    }
-    async typeViaClipboard(text) {
-        debugDevice('Using clipboard to input text', {
-            textLength: text.length,
-            preview: text.substring(0, 20)
-        });
-        const clipboardy = await import("clipboardy");
-        const oldClipboard = await clipboardy.default.read().catch(()=>'');
-        try {
-            await clipboardy.default.write(text);
-            await this.inputDriver.delay(50);
-            if (this.useAppleScript) this.inputDriver.sendKeyViaAppleScript('v', [
-                'command'
-            ]);
-            else {
-                const modifier = 'darwin' === process.platform ? 'command' : 'control';
-                this.inputDriver.keyTap('v', [
-                    modifier
-                ]);
-            }
-            await this.inputDriver.delay(100);
-        } finally{
-            if (oldClipboard) await clipboardy.default.write(oldClipboard).catch(()=>{
-                debugDevice('Failed to restore clipboard content');
-            });
-        }
-    }
-    async smartTypeString(text) {
-        await this.typeViaClipboard(text);
-    }
-    async selectAllAndDelete() {
-        if (this.useAppleScript) {
-            this.inputDriver.sendKeyViaAppleScript('a', [
-                'command'
-            ]);
-            await this.inputDriver.delay(50);
-            this.inputDriver.sendKeyViaAppleScript('backspace', []);
-            return;
-        }
-        const modifier = 'darwin' === process.platform ? 'command' : 'control';
-        this.inputDriver.keyTap('a', [
-            modifier
-        ]);
-        await this.inputDriver.delay(50);
-        this.inputDriver.keyTap('backspace');
-    }
-    async pressKeyboardShortcut(keyName) {
-        const keys = keyName.split('+');
-        const modifiers = keys.slice(0, -1).map(normalizeKeyName);
-        const key = normalizePrimaryKey(keys[keys.length - 1]);
-        debugDevice('KeyboardPress', {
-            original: keyName,
-            key,
-            modifiers,
-            driver: this.useAppleScript ? "applescript" : 'libnut'
-        });
-        this.inputDriver.sendKey(key, modifiers);
-    }
-    resolveUntargetedScrollPoint(screenSize) {
-        if ('win32' === process.platform) {
-            const activeWindowRect = this.inputDriver.getActiveWindowRect();
-            if (activeWindowRect) return {
-                x: activeWindowRect.x + activeWindowRect.width / 2,
-                y: activeWindowRect.y + activeWindowRect.height / 2
-            };
-        }
-        return this.toGlobalPoint({
-            x: screenSize.width / 2,
-            y: screenSize.height / 2
-        });
-    }
-    async moveMouseToScrollTarget(param) {
-        if (param.locate) {
-            const element = param.locate;
-            const [x, y] = element.center;
-            const point = this.toGlobalPoint({
-                x,
-                y
-            });
-            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);
-        this.inputDriver.moveMouse(Math.round(point.x), Math.round(point.y));
-        await this.inputDriver.delay(MOUSE_MOVE_EFFECT_WAIT);
-        return screenSize;
-    }
-    async performScroll(param) {
-        let screenSize = await this.moveMouseToScrollTarget(param);
-        const scrollType = param?.scrollType;
-        const edgeSpec = scrollType && scrollType in EDGE_SCROLL_SPEC ? EDGE_SCROLL_SPEC[scrollType] : null;
-        if (edgeSpec) {
-            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) {
-                this.inputDriver.sendKeyViaAppleScript(edgeSpec.key);
-                await this.inputDriver.delay(SCROLL_COMPLETE_DELAY);
-                return;
-            }
-            const [ux, uy] = edgeSpec.libnut;
-            await this.inputDriver.emitScrollDetents(ux * LIBNUT_FALLBACK_DETENT_AMOUNT, uy * LIBNUT_FALLBACK_DETENT_AMOUNT, LIBNUT_FALLBACK_EDGE_DETENTS, LIBNUT_FALLBACK_TICK_DELAY_MS);
-            return;
-        }
-        if ('singleAction' === scrollType || !scrollType) {
-            const direction = param?.direction || 'down';
-            const isKnownDirection = 'up' === direction || 'down' === direction || 'left' === direction || 'right' === direction;
-            const isHorizontal = 'left' === direction || 'right' === direction;
-            let distance = param?.distance ?? void 0;
-            if (!distance) {
-                screenSize ??= await this.size();
-                const base = isHorizontal ? screenSize.width : screenSize.height;
-                distance = Math.max(1, Math.round(base * DEFAULT_SCROLL_VIEWPORT_RATIO));
-            }
-            if (isKnownDirection) {
-                const steps = Math.max(PHASED_MIN_STEPS, Math.round(distance / PHASED_PIXELS_PER_STEP));
-                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++){
-                    this.inputDriver.sendKeyViaAppleScript(key);
-                    await this.inputDriver.delay(SCROLL_STEP_DELAY);
-                }
-                await this.inputDriver.delay(SCROLL_COMPLETE_DELAY);
-                return;
-            }
-            const detents = Math.min(LIBNUT_FALLBACK_MAX_DETENTS, Math.max(1, Math.ceil(distance / LIBNUT_FALLBACK_PIXELS_PER_DETENT)));
-            const directionUnit = {
-                up: [
-                    0,
-                    1
-                ],
-                down: [
-                    0,
-                    -1
-                ],
-                left: [
-                    -1,
-                    0
-                ],
-                right: [
-                    1,
-                    0
-                ]
-            };
-            const [ux, uy] = directionUnit[direction] || [
-                0,
-                -1
-            ];
-            await this.inputDriver.emitScrollDetents(ux * LIBNUT_FALLBACK_DETENT_AMOUNT, uy * LIBNUT_FALLBACK_DETENT_AMOUNT, detents, LIBNUT_FALLBACK_TICK_DELAY_MS);
-            await this.inputDriver.delay(SCROLL_COMPLETE_DELAY);
-            return;
-        }
-        throw new Error(`Unknown scroll type: ${scrollType}, param: ${JSON.stringify(param)}`);
-    }
-    actionSpace() {
-        const defaultActions = [
-            ...defineActionsFromInputPrimitives(this.inputPrimitives)
-        ];
-        const platformActions = Object.values(createPlatformActions());
-        const customActions = this.options?.customActions || [];
-        return [
-            ...defaultActions,
-            ...platformActions,
-            ...customActions
-        ];
-    }
-    async destroy() {
-        if (this.destroyed) return;
-        this.destroyed = true;
-        this.inputDriver.destroy();
-        if (this.xvfbInstance) {
-            this.xvfbInstance.stop();
-            this.xvfbInstance = void 0;
-        }
-        if (this.xvfbCleanup) {
-            process.removeListener('exit', this.xvfbCleanup);
-            process.removeListener('SIGINT', this.xvfbCleanup);
-            process.removeListener('SIGTERM', this.xvfbCleanup);
-            this.xvfbCleanup = void 0;
-        }
-        debugDevice('Computer device destroyed');
-    }
-    async url() {
-        return '';
-    }
-    constructor(options){
-        device_define_property(this, "interfaceType", 'computer');
-        device_define_property(this, "options", void 0);
-        device_define_property(this, "displayId", void 0);
-        device_define_property(this, "displayGeometry", 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, "adminCheckCache", void 0);
-        device_define_property(this, "uri", void 0);
-        device_define_property(this, "inputPrimitives", {
-            pointer: {
-                tap: async ({ x, y }, opts)=>{
-                    const target = this.toGlobalPoint({
-                        x,
-                        y
-                    });
-                    const targetX = Math.round(target.x);
-                    const targetY = Math.round(target.y);
-                    const holdDuration = Math.max(0, Math.round(opts?.duration ?? CLICK_HOLD_DURATION));
-                    debugComputerInput('tap start %o', {
-                        local: {
-                            x,
-                            y
-                        },
-                        global: {
-                            x: targetX,
-                            y: targetY
-                        },
-                        holdDuration,
-                        displayId: this.displayId,
-                        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.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);
-                        const frontmostAfter = readDarwinFrontmostApplication();
-                        const focusChanged = !!frontmostAfter && frontmostAfter.pid !== frontmostBefore.pid;
-                        debugComputerInput('tap focus check %o', {
-                            before: frontmostBefore,
-                            after: frontmostAfter,
-                            focusChanged
-                        });
-                        if (focusChanged) {
-                            this.inputDriver.moveMouse(targetX, targetY);
-                            await pressMouseAtGlobalPoint(this.inputDriver, targetX, targetY, holdDuration, 'focus-follow-up');
-                        }
-                    }
-                },
-                doubleClick: async ({ x, y })=>{
-                    const target = this.toGlobalPoint({
-                        x,
-                        y
-                    });
-                    this.inputDriver.moveMouse(Math.round(target.x), Math.round(target.y));
-                    this.inputDriver.mouseClick('left', true);
-                },
-                rightClick: async ({ x, y })=>{
-                    const target = this.toGlobalPoint({
-                        x,
-                        y
-                    });
-                    this.inputDriver.moveMouse(Math.round(target.x), Math.round(target.y));
-                    this.inputDriver.mouseClick('right');
-                },
-                hover: async ({ x, y })=>{
-                    const target = this.toGlobalPoint({
-                        x,
-                        y
-                    });
-                    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)=>{
-                    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);
-                        this.inputDriver.moveMouse(Math.round(globalTo.x), Math.round(globalTo.y));
-                        await this.inputDriver.delay(100);
-                    });
-                }
-            },
-            keyboard: {
-                typeText: async (value, opts)=>{
-                    const element = opts?.target;
-                    if (element) {
-                        const [x, y] = element.center;
-                        const target = this.toGlobalPoint({
-                            x,
-                            y
-                        });
-                        this.inputDriver.moveMouse(Math.round(target.x), Math.round(target.y));
-                        this.inputDriver.mouseClick('left');
-                        await this.inputDriver.delay(INPUT_FOCUS_DELAY);
-                        if (opts?.replace !== false) {
-                            await this.selectAllAndDelete();
-                            await this.inputDriver.delay(INPUT_CLEAR_DELAY);
-                        }
-                    }
-                    await this.smartTypeString(value);
-                },
-                keyboardPress: async (keyName, opts)=>{
-                    const target = opts?.target;
-                    if (target) {
-                        const [x, y] = target.center;
-                        const point = this.toGlobalPoint({
-                            x,
-                            y
-                        });
-                        this.inputDriver.moveMouse(Math.round(point.x), Math.round(point.y));
-                        this.inputDriver.mouseClick('left');
-                        await this.inputDriver.delay(50);
-                    }
-                    await this.pressKeyboardShortcut(keyName);
-                },
-                clearInput: async (target)=>{
-                    if (target) {
-                        const element = target;
-                        const [x, y] = element.center;
-                        const point = this.toGlobalPoint({
-                            x,
-                            y
-                        });
-                        this.inputDriver.moveMouse(Math.round(point.x), Math.round(point.y));
-                        this.inputDriver.mouseClick('left');
-                        await this.inputDriver.delay(100);
-                    }
-                    await this.selectAllAndDelete();
-                    await this.inputDriver.delay(50);
-                }
-            },
-            scroll: {
-                scroll: async (param)=>{
-                    await this.performScroll(param);
-                }
-            }
-        });
-        this.options = options;
-        this.displayId = options?.displayId;
-        this.useAppleScript = 'darwin' === process.platform && options?.keyboardDriver !== 'libnut';
-    }
-}
-function createPlatformActions() {
-    return {
-        ListDisplays: defineAction({
-            name: 'ListDisplays',
-            description: 'List all available displays/monitors',
-            call: async ()=>await ComputerDevice.listDisplays()
-        })
-    };
-}
-function normalizeRdpHost(host) {
-    const trimmed = host.trim();
-    if (trimmed.length >= 2 && trimmed.startsWith('[') && trimmed.endsWith(']') && trimmed.includes(':')) return trimmed.slice(1, -1);
-    return trimmed;
-}
-function formatRdpHost(host) {
-    const normalizedHost = normalizeRdpHost(host);
-    return normalizedHost.includes(':') ? `[${normalizedHost}]` : normalizedHost;
-}
-function formatRdpServerAddress(host, port) {
-    return `${formatRdpHost(host)}:${port}`;
-}
-function normalizeRdpConnectionConfig(config) {
-    return {
-        ...config,
-        host: normalizeRdpHost(config.host),
-        ...config.localAddress ? {
-            localAddress: config.localAddress.trim()
-        } : {}
-    };
-}
-const platformBinaryMap = {
-    darwin: {
-        directory: 'darwin',
-        fileName: 'rdp-helper'
-    },
-    linux: {
-        directory: 'linux',
-        fileName: 'rdp-helper'
-    },
-    win32: {
-        directory: 'win32',
-        fileName: 'rdp-helper.exe'
-    }
-};
-function getPlatformBinary(platform) {
-    if (platform in platformBinaryMap) return platformBinaryMap[platform];
-}
-function currentDirname() {
-    if ('undefined' != typeof __dirname) return __dirname;
-    return dirname(fileURLToPath(import.meta.url));
-}
-function getRdpHelperBinaryPath() {
-    const platformBinary = getPlatformBinary(process.platform);
-    if (!platformBinary) throw new Error(`@midscene/computer RDP helper does not support platform ${process.platform}`);
-    const hereDir = currentDirname();
-    const candidateRoots = [
-        external_node_path_resolve(hereDir, '../..'),
-        external_node_path_resolve(hereDir, '../../..')
-    ];
-    for (const root of candidateRoots){
-        const binaryPath = external_node_path_resolve(root, 'bin', platformBinary.directory, platformBinary.fileName);
-        if (existsSync(binaryPath)) return binaryPath;
-    }
-    throw new Error(`RDP helper binary not found for ${process.platform}. Run \`pnpm --filter @midscene/computer run build:native\` first.`);
-}
-function backend_client_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;
-}
-const debug = getDebug('rdp:backend');
-const HELPER_SHUTDOWN_TIMEOUT_MS = 3000;
-const HELPER_WRITE_ERROR_DIAGNOSTIC_DELAY_MS = 50;
-const MAX_STDERR_CHARS = 16384;
-class HelperProcessRDPBackendClient {
-    async connect(config) {
-        this.fatalHelperError = void 0;
-        const response = await this.send({
-            type: 'connect',
-            config: normalizeRdpConnectionConfig(config)
-        });
-        if ('connected' !== response.type) throw new Error(`Expected connected response, got ${response.type}`);
-        this.connected = true;
-        this.fatalHelperError = void 0;
-        return response.info;
-    }
-    async disconnect() {
-        const child = this.child;
-        if (!child) return;
-        let disconnectError;
-        if (this.connected && null === child.exitCode) try {
-            const response = await this.send({
-                type: 'disconnect'
-            });
-            this.expectOk(response, 'disconnect');
-        } catch (error) {
-            disconnectError = error instanceof Error ? error : new Error(String(error));
-        }
-        this.connected = false;
-        this.fatalHelperError = void 0;
-        await this.shutdownHelper();
-        if (disconnectError && !/RDP helper exited unexpectedly|RDP helper is not running|RDP helper shut down/u.test(disconnectError.message)) throw disconnectError;
-    }
-    async screenshotBase64() {
-        const response = await this.send({
-            type: 'screenshot'
-        });
-        if ('screenshot' !== response.type) throw new Error(`Expected screenshot response, got ${response.type}`);
-        return response.base64;
-    }
-    async size() {
-        const response = await this.send({
-            type: 'size'
-        });
-        if ('size' !== response.type) throw new Error(`Expected size response, got ${response.type}`);
-        return response.size;
-    }
-    async mouseMove(x, y) {
-        const response = await this.send({
-            type: 'mouseMove',
-            x,
-            y
-        });
-        this.expectOk(response, 'mouseMove');
-    }
-    async mouseButton(button, action) {
-        const response = await this.send({
-            type: 'mouseButton',
-            button,
-            action
-        });
-        this.expectOk(response, 'mouseButton');
-    }
-    async wheel(direction, amount, x, y) {
-        const response = await this.send({
-            type: 'wheel',
-            direction,
-            amount,
-            x,
-            y
-        });
-        this.expectOk(response, 'wheel');
-    }
-    async keyPress(keyName) {
-        const response = await this.send({
-            type: 'keyPress',
-            keyName
-        });
-        this.expectOk(response, 'keyPress');
-    }
-    async typeText(text) {
-        const response = await this.send({
-            type: 'typeText',
-            text
-        });
-        this.expectOk(response, 'typeText');
-    }
-    async clearInput() {
-        const response = await this.send({
-            type: 'clearInput'
-        });
-        this.expectOk(response, 'clearInput');
-    }
-    ensureHelperStarted() {
-        if (this.child && null === this.child.exitCode) return this.child;
-        const helperPath = this.resolveHelperPath();
-        debug('starting rdp helper', {
-            helperPath
-        });
-        const child = this.spawnFn(helperPath, [], {
-            stdio: [
-                'pipe',
-                'pipe',
-                'pipe'
-            ]
-        });
-        child.stdout.setEncoding('utf8');
-        child.stderr.setEncoding('utf8');
-        this.child = child;
-        const diagnostics = {
-            path: helperPath,
-            pid: child.pid,
-            stderrBuffer: ''
-        };
-        this.helperDiagnostics.set(child, diagnostics);
-        debug('started rdp helper', {
-            helperPath,
-            pid: child.pid
-        });
-        this.stdoutReader = createInterface({
-            input: child.stdout,
-            crlfDelay: 1 / 0
-        });
-        this.stdoutReader.on('line', (line)=>{
-            this.handleStdoutLine(child, line, diagnostics);
-        });
-        child.stderr.on('data', (chunk)=>{
-            this.captureStderrChunk(chunk, diagnostics);
-        });
-        child.stdin.on('error', (error)=>{
-            this.handleHelperStreamError(child, 'stdin', error, diagnostics);
-        });
-        child.stdout.on('error', (error)=>{
-            this.handleHelperStreamError(child, 'stdout', error, diagnostics);
-        });
-        child.stderr.on('error', (error)=>{
-            this.handleHelperStreamError(child, 'stderr', error, diagnostics);
-        });
-        child.on('exit', (code, signal)=>{
-            diagnostics.exit = {
-                code,
-                signal
-            };
-            debug('rdp helper exited', {
-                helperPath: diagnostics.path,
-                pid: diagnostics.pid,
-                code,
-                signal
-            });
-            const helperError = this.createHelperError(`RDP helper exited unexpectedly (code=${code}, signal=${signal})`, void 0, diagnostics);
-            this.rejectPendingForChild(child, helperError);
-            if (this.child === child) {
-                this.connected = false;
-                this.fatalHelperError = helperError;
-                this.disposeReaders();
-                this.child = void 0;
-            }
-        });
-        child.on('error', (error)=>{
-            const helperError = this.createHelperError(`Failed to start RDP helper: ${error.message}`, void 0, diagnostics);
-            this.rejectPendingForChild(child, helperError);
-            if (this.child === child) {
-                this.connected = false;
-                this.fatalHelperError = helperError;
-                this.disposeReaders();
-                this.child = void 0;
-            }
-        });
-        return child;
-    }
-    handleHelperStreamError(child, streamName, error, diagnostics) {
-        const nodeError = error;
-        const helperError = this.createHelperError(`RDP helper ${streamName} stream error: ${error.message}`, nodeError.code, diagnostics);
-        this.rejectPendingForChild(child, helperError);
-        if (this.child !== child) return;
-        this.connected = false;
-        this.fatalHelperError = helperError;
-        if (null === child.exitCode) child.kill('SIGTERM');
-        this.child = void 0;
-    }
-    handleStdoutLine(child, line, diagnostics) {
-        if (!line.trim()) return;
-        let parsed;
-        try {
-            parsed = JSON.parse(line);
-        } catch (error) {
-            const protocolError = this.createHelperError(`RDP helper emitted malformed JSON: ${line}`, void 0, diagnostics);
-            this.rejectPendingForChild(child, protocolError);
-            if (this.child === child) this.shutdownHelper(protocolError);
-            return;
-        }
-        const pending = this.pending.get(parsed.id);
-        if (!pending) return void debug('dropping response for unknown request id', parsed);
-        this.pending.delete(parsed.id);
-        if (parsed.ok) return void pending.resolve(parsed.payload);
-        pending.reject(this.createHelperError(parsed.error.message, parsed.error.code, diagnostics));
-    }
-    captureStderrChunk(chunk, diagnostics) {
-        const text = chunk.toString();
-        if (!text.trim()) return;
-        debug('rdp helper stderr', {
-            helperPath: diagnostics.path,
-            pid: diagnostics.pid,
-            stderr: text.trim()
-        });
-        diagnostics.stderrBuffer += text;
-        if (diagnostics.stderrBuffer.length > MAX_STDERR_CHARS) diagnostics.stderrBuffer = diagnostics.stderrBuffer.slice(-MAX_STDERR_CHARS);
-    }
-    async send(payload) {
-        if ('connect' !== payload.type && this.fatalHelperError && (!this.child || null !== this.child.exitCode)) throw this.fatalHelperError;
-        const child = this.ensureHelperStarted();
-        if (null !== child.exitCode) throw this.createHelperError('RDP helper is not running');
-        const id = `req-${++this.nextRequestId}`;
-        const diagnostics = this.helperDiagnostics.get(child);
-        const request = {
-            id,
-            payload
-        };
-        return new Promise((resolve, reject)=>{
-            this.pending.set(id, {
-                resolve,
-                reject,
-                child
-            });
-            child.stdin.write(`${JSON.stringify(request)}\n`, (error)=>{
-                if (!error) return;
-                this.pending.delete(id);
-                const nodeError = error;
-                const timer = setTimeout(()=>{
-                    reject(this.createHelperError(`Failed to send ${payload.type} request to RDP helper: ${error.message}`, nodeError.code, diagnostics));
-                }, HELPER_WRITE_ERROR_DIAGNOSTIC_DELAY_MS);
-                timer.unref?.();
-            });
-        });
-    }
-    expectOk(response, actionName) {
-        if ('ok' !== response.type) throw new Error(`Expected ok response for ${actionName}, got ${response.type}`);
-    }
-    rejectPending(error) {
-        for (const { reject } of this.pending.values())reject(error);
-        this.pending.clear();
-    }
-    rejectPendingForChild(child, error) {
-        for (const [id, pending] of this.pending)if (pending.child === child) {
-            pending.reject(error);
-            this.pending.delete(id);
-        }
-    }
-    createHelperError(message, code, diagnostics) {
-        const diagnosticParts = [
-            diagnostics?.path ? `path=${diagnostics.path}` : void 0,
-            'number' == typeof diagnostics?.pid ? `pid=${diagnostics.pid}` : void 0,
-            diagnostics?.exit ? `exitCode=${diagnostics.exit.code}, signal=${diagnostics.exit.signal}` : void 0
-        ].filter(Boolean);
-        const diagnosticsSuffix = diagnosticParts.length > 0 ? `\nHelper diagnostics: ${diagnosticParts.join(', ')}` : '';
-        const stderrSummary = diagnostics?.stderrBuffer.trim();
-        const stderrSuffix = stderrSummary ? `\nHelper stderr:\n${stderrSummary}` : '';
-        const error = new Error(`${message}${diagnosticsSuffix}${stderrSuffix}`);
-        if (code) error.name = code;
-        return error;
-    }
-    disposeReaders() {
-        this.stdoutReader?.close();
-        this.stdoutReader = void 0;
-    }
-    async shutdownHelper(rootError) {
-        const child = this.child;
-        this.child = void 0;
-        this.disposeReaders();
-        if (!child) return;
-        this.rejectPending(rootError || this.createHelperError('RDP helper shut down'));
-        if (null !== child.exitCode) return;
-        child.stdin.end();
-        const exited = Promise.race([
-            once(child, 'exit'),
-            new Promise((resolve)=>{
-                setTimeout(()=>resolve('timeout'), HELPER_SHUTDOWN_TIMEOUT_MS);
-            })
-        ]);
-        const result = await exited;
-        if ('timeout' !== result) return;
-        child.kill('SIGTERM');
-        const terminated = Promise.race([
-            once(child, 'exit'),
-            new Promise((resolve)=>{
-                setTimeout(()=>resolve('timeout'), HELPER_SHUTDOWN_TIMEOUT_MS);
-            })
-        ]);
-        const terminateResult = await terminated;
-        if ('timeout' !== terminateResult) return;
-        child.kill('SIGKILL');
-        await once(child, 'exit');
-    }
-    constructor(options){
-        backend_client_define_property(this, "spawnFn", void 0);
-        backend_client_define_property(this, "resolveHelperPath", void 0);
-        backend_client_define_property(this, "child", void 0);
-        backend_client_define_property(this, "stdoutReader", void 0);
-        backend_client_define_property(this, "pending", new Map());
-        backend_client_define_property(this, "helperDiagnostics", new WeakMap());
-        backend_client_define_property(this, "nextRequestId", 0);
-        backend_client_define_property(this, "connected", false);
-        backend_client_define_property(this, "fatalHelperError", void 0);
-        this.spawnFn = options?.spawnFn || spawn;
-        const overridePath = options?.helperPath;
-        this.resolveHelperPath = overridePath ? ()=>overridePath : getRdpHelperBinaryPath;
-    }
-}
-function createDefaultRDPBackendClient() {
-    return new HelperProcessRDPBackendClient();
-}
-function rdp_device_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;
-}
-const device_debug = getDebug('rdp:device');
-const device_SMOOTH_MOVE_STEPS_TAP = 8;
-const device_SMOOTH_MOVE_STEPS_MOUSE_MOVE = 10;
-const SMOOTH_MOVE_STEPS_DRAG = 12;
-const device_SMOOTH_MOVE_DELAY_TAP = 8;
-const device_SMOOTH_MOVE_DELAY_MOUSE_MOVE = 10;
-const 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;
-const device_DEFAULT_SCROLL_VIEWPORT_RATIO = 0.7;
-const device_EDGE_SCROLL_STEPS = 10;
-const DEFAULT_SCROLL_STEP_AMOUNT = 120;
-class RDPDevice {
-    describe() {
-        const port = this.options.port || 3389;
-        const server = formatRdpServerAddress(this.options.host, port);
-        const username = this.options.username ? ` as ${this.options.username}` : '';
-        const session = this.connectionInfo?.sessionId ? ` [session ${this.connectionInfo.sessionId}]` : '';
-        return `RDP Device ${server}${username}${session}`;
-    }
-    async connect() {
-        this.throwIfDestroyed();
-        device_debug('connecting to rdp backend', {
-            host: this.options.host,
-            port: this.options.port,
-            username: this.options.username
-        });
-        const { backend: _backend, customActions: _customActions, ...config } = this.options;
-        this.connectionInfo = await this.backend.connect(config);
-        this.cursorPosition = [
-            Math.round(this.connectionInfo.size.width / 2),
-            Math.round(this.connectionInfo.size.height / 2)
-        ];
-    }
-    async screenshotBase64() {
-        this.assertConnected();
-        return this.backend.screenshotBase64();
-    }
-    async size() {
-        this.assertConnected();
-        return this.backend.size();
-    }
-    async destroy() {
-        if (this.destroyed) return;
-        this.destroyed = true;
-        this.connectionInfo = void 0;
-        this.cursorPosition = void 0;
-        await this.backend.disconnect();
-    }
-    actionSpace() {
-        const defaultActions = [
-            ...defineActionsFromInputPrimitives(this.inputPrimitives),
-            defineAction({
-                name: 'ListDisplays',
-                description: 'List all available displays/monitors',
-                call: async ()=>{
-                    this.assertConnected();
-                    const size = await this.size();
-                    const server = this.connectionInfo?.server || formatRdpServerAddress(this.options.host, this.options.port || 3389);
-                    return [
-                        {
-                            id: this.connectionInfo?.sessionId || this.options.host,
-                            name: `RDP ${server} (${size.width}x${size.height})`,
-                            primary: true
-                        }
-                    ];
-                }
-            })
-        ];
-        return [
-            ...defaultActions,
-            ...this.options.customActions || []
-        ];
-    }
-    assertConnected() {
-        this.throwIfDestroyed();
-        if (!this.connectionInfo) throw new Error('RDPDevice is not connected');
-    }
-    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');
-        await this.backend.keyPress('Backspace');
-    }
-    edgeScrollDirection(scrollType) {
-        switch(scrollType){
-            case 'scrollToTop':
-                return 'up';
-            case 'scrollToBottom':
-                return 'down';
-            case 'scrollToLeft':
-                return 'left';
-            case 'scrollToRight':
-                return 'right';
-            case 'singleAction':
-                return 'down';
-            default:
-                throw new Error(`Unsupported scroll type: ${scrollType}`);
-        }
-    }
-    defaultScrollDistance(direction) {
-        const size = this.connectionInfo?.size;
-        if (!size) return DEFAULT_SCROLL_DISTANCE;
-        const isHorizontal = 'left' === direction || 'right' === direction;
-        const base = isHorizontal ? size.width : size.height;
-        return Math.max(1, Math.round(base * device_DEFAULT_SCROLL_VIEWPORT_RATIO));
-    }
-    async movePointer(targetX, targetY, options) {
-        this.assertConnected();
-        const start = this.cursorPosition || [
-            targetX,
-            targetY
-        ];
-        const steps = Math.max(1, options?.steps || 1);
-        const stepDelayMs = options?.stepDelayMs || 0;
-        for(let step = 1; step <= steps; step++){
-            const x = Math.round(start[0] + (targetX - start[0]) * step / steps);
-            const y = Math.round(start[1] + (targetY - start[1]) * step / steps);
-            await this.backend.mouseMove(x, y);
-            this.cursorPosition = [
-                x,
-                y
-            ];
-            if (stepDelayMs > 0 && step < steps) await sleep(stepDelayMs);
-        }
-        if (options?.settleDelayMs) await sleep(options.settleDelayMs);
-    }
-    async performWheel(direction, amount, x, y) {
-        let remaining = Math.abs(amount);
-        if (0 === remaining) remaining = DEFAULT_SCROLL_STEP_AMOUNT;
-        while(remaining > 0){
-            const chunk = Math.min(remaining, DEFAULT_SCROLL_STEP_AMOUNT);
-            await this.backend.wheel(direction, chunk, x, y);
-            remaining -= chunk;
-            if (remaining > 0) await sleep(device_SCROLL_STEP_DELAY);
-        }
-    }
-    constructor(options){
-        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), {
-                        steps: device_SMOOTH_MOVE_STEPS_TAP,
-                        stepDelayMs: device_SMOOTH_MOVE_DELAY_TAP
-                    });
-                    await this.backend.mouseButton('left', 'down');
-                    await 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: 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: 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: device_SMOOTH_MOVE_STEPS_MOUSE_MOVE,
-                        stepDelayMs: device_SMOOTH_MOVE_DELAY_MOUSE_MOVE,
-                        settleDelayMs: device_MOUSE_MOVE_EFFECT_WAIT
-                    });
-                },
-                dragAndDrop: async (from, to)=>{
-                    await this.movePointer(Math.round(from.x), Math.round(from.y), {
-                        steps: device_SMOOTH_MOVE_STEPS_TAP,
-                        stepDelayMs: device_SMOOTH_MOVE_DELAY_TAP
-                    });
-                    await this.backend.mouseButton('left', 'down');
-                    await sleep(DRAG_HOLD_DURATION);
-                    await this.movePointer(Math.round(to.x), Math.round(to.y), {
-                        steps: SMOOTH_MOVE_STEPS_DRAG,
-                        stepDelayMs: SMOOTH_MOVE_DELAY_DRAG
-                    });
-                    await sleep(DRAG_HOLD_DURATION);
-                    await this.backend.mouseButton('left', 'up');
-                }
-            },
-            keyboard: {
-                typeText: async (value, opts)=>{
-                    this.assertConnected();
-                    const target = opts?.target;
-                    if (target) {
-                        await this.inputPrimitives.pointer.tap({
-                            x: target.center[0],
-                            y: target.center[1]
-                        });
-                        await sleep(device_INPUT_FOCUS_DELAY);
-                    }
-                    if (opts?.replace !== false) {
-                        await this.clearInput();
-                        await sleep(device_INPUT_CLEAR_DELAY);
-                    }
-                    if (opts?.focusOnly || !value) return;
-                    await this.backend.typeText(value);
-                },
-                clearInput: async (target)=>{
-                    this.assertConnected();
-                    const element = target;
-                    if (element) {
-                        await this.inputPrimitives.pointer.tap({
-                            x: element.center[0],
-                            y: element.center[1]
-                        });
-                        await sleep(device_INPUT_FOCUS_DELAY);
-                    }
-                    await this.clearInput();
-                    await 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 this.backend.keyPress(keyName);
-                }
-            },
-            scroll: {
-                scroll: async (param)=>{
-                    this.assertConnected();
-                    const target = param.locate;
-                    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, target?.center[0], target?.center[1]);
-                        await sleep(device_SCROLL_COMPLETE_DELAY);
-                        return;
-                    }
-                    await this.performWheel(param.direction || 'down', param.distance || this.defaultScrollDistance(param.direction || 'down'), target?.center[0], target?.center[1]);
-                    await sleep(device_SCROLL_COMPLETE_DELAY);
-                }
-            }
-        });
-        const normalizedOptions = normalizeRdpConnectionConfig(options);
-        this.options = {
-            port: 3389,
-            securityProtocol: 'auto',
-            ignoreCertificate: false,
-            ...normalizedOptions
-        };
-        this.backend = options.backend || createDefaultRDPBackendClient();
-    }
-}
-class ComputerAgent extends Agent {
-}
-function createLocalComputerDevice(opts) {
-    return new ComputerDevice({
-        displayId: opts?.displayId,
-        customActions: opts?.customActions,
-        keyboardDriver: opts?.keyboardDriver,
-        headless: opts?.headless,
-        xvfbResolution: opts?.xvfbResolution
-    });
-}
-function createRDPComputerDevice(opts) {
-    return new RDPDevice({
-        host: opts.host,
-        port: opts.port,
-        username: opts.username,
-        password: opts.password,
-        domain: opts.domain,
-        localAddress: opts.localAddress,
-        adminSession: opts.adminSession,
-        ignoreCertificate: opts.ignoreCertificate,
-        securityProtocol: opts.securityProtocol,
-        desktopWidth: opts.desktopWidth,
-        desktopHeight: opts.desktopHeight,
-        backend: opts.backend,
-        customActions: opts.customActions
-    });
-}
-async function agentForComputer(opts) {
-    const device = createLocalComputerDevice(opts);
-    await device.connect();
-    return new ComputerAgent(device, opts);
-}
-const agentFromComputer = agentForComputer;
-async function agentForRDPComputer(opts) {
-    const device = createRDPComputerDevice(opts);
-    await device.connect();
-    return new ComputerAgent(device, opts);
-}
-function mcp_tools_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;
-}
-const mcp_tools_debug = getDebug('mcp:computer-tools');
-const RDP_SECURITY_PROTOCOLS = [
-    'auto',
-    'tls',
-    'nla',
-    'rdp'
-];
-const computerInitArgShape = {
-    displayId: z.string().optional().describe('Display ID for local mode (from computer_list_displays). Ignored when host is set.'),
-    headless: z.boolean().optional().describe('Start virtual display via Xvfb (Linux local mode only). Ignored when host is set.'),
-    host: z.string().optional().describe('RDP host (FQDN or IP). Set this to switch into RDP mode.'),
-    port: z.number().optional().describe('RDP port (default 3389). Requires host.'),
-    username: z.string().optional().describe('RDP username. Requires host.'),
-    password: z.string().optional().describe('RDP password. Requires host. Prefer setting via environment or a secrets manager.'),
-    domain: z.string().optional().describe('RDP domain. Requires host.'),
-    localAddress: z.string().optional().describe('Local source IP address for the RDP TCP connection. Requires host.'),
-    adminSession: z.boolean().optional().describe('Attach to the RDP admin/console session. Requires host.'),
-    ignoreCertificate: z.boolean().optional().describe('Skip TLS certificate validation. Requires host.'),
-    securityProtocol: z["enum"](RDP_SECURITY_PROTOCOLS).optional().describe('RDP security protocol negotiation (default auto). Requires host.'),
-    desktopWidth: z.number().optional().describe('Remote desktop width in pixels. Requires host.'),
-    desktopHeight: z.number().optional().describe('Remote desktop height in pixels. Requires host.'),
-    ...agentBehaviorInitArgShape
-};
-function adaptComputerInitArgs(extracted) {
-    if (!extracted || 0 === Object.keys(extracted).length) return;
-    if (extracted.host) {
-        const { displayId: _d, headless: _h, ...rdpFields } = extracted;
-        const host = normalizeRdpHost(extracted.host);
-        return {
-            mode: 'rdp',
-            ...rdpFields,
-            host
-        };
-    }
-    return {
-        mode: 'local',
-        displayId: extracted.displayId,
-        headless: extracted.headless,
-        ...extractAgentBehaviorInitArgs(extracted) ?? {}
-    };
-}
-function describeConnectTarget(opts) {
-    if (opts?.mode === 'rdp') {
-        const target = opts.port ? formatRdpServerAddress(opts.host, opts.port) : formatRdpHost(opts.host);
-        const userSuffix = opts.username ? ` as ${opts.username}` : '';
-        return ` via RDP (${target}${userSuffix})`;
-    }
-    if (opts?.mode === 'local' && opts.displayId) return ` (Display: ${opts.displayId})`;
-    return ' (Primary display)';
-}
-function getCliReportSessionTarget(opts) {
-    if (opts?.mode === 'rdp') return `rdp:${formatRdpHost(opts.host)}`;
-    if (opts?.mode === 'local' && opts.displayId) return opts.displayId;
-    return 'primary';
-}
-class ComputerMidsceneTools extends BaseMidsceneTools {
-    getCliReportSessionName() {
-        return 'midscene-computer';
-    }
-    createTemporaryDevice() {
-        return new ComputerDevice({});
-    }
-    async ensureAgent(opts) {
-        const nextSignature = getAgentInitArgsSignature(opts);
-        if (this.agent && shouldRebuildAgentForInitArgs(this.lastInitArgsSignature, nextSignature)) {
-            try {
-                await this.agent.destroy?.();
-            } catch (error) {
-                mcp_tools_debug('Failed to destroy agent during cleanup:', error);
-            }
-            this.agent = void 0;
-        }
-        if (this.agent) return this.agent;
-        const reportOptions = this.readCliReportAgentOptions();
-        if (opts?.mode === 'rdp') {
-            mcp_tools_debug('Creating RDP Computer agent for host:', opts.host);
-            const { mode: _mode, ...rdpFields } = opts;
-            const agent = await agentForRDPComputer({
-                ...rdpFields,
-                ...reportOptions ?? {}
-            });
-            this.agent = agent;
-            this.lastInitArgsSignature = nextSignature;
-            return agent;
-        }
-        const displayId = opts?.mode === 'local' ? opts.displayId : void 0;
-        const headless = opts?.mode === 'local' ? opts.headless : void 0;
-        mcp_tools_debug('Creating Computer agent with displayId:', displayId || 'primary');
-        const agentOpts = {
-            ...displayId ? {
-                displayId
-            } : {},
-            ...void 0 !== headless ? {
-                headless
-            } : {},
-            ...extractAgentBehaviorInitArgs(opts) ?? {},
-            ...reportOptions ?? {}
-        };
-        const agent = await agentFromComputer(Object.keys(agentOpts).length > 0 ? agentOpts : void 0);
-        this.agent = agent;
-        this.lastInitArgsSignature = nextSignature;
-        return agent;
-    }
-    preparePlatformTools() {
-        return [
-            {
-                name: 'computer_connect',
-                description: "Connect to a computer desktop. Default (local) mode controls the local machine; pass displayId to target a specific local display (see computer_list_displays). Pass host to switch to RDP mode and connect to a remote Windows desktop via the RDP helper binary. RDP-related options (port/username/password/domain/localAddress/securityProtocol/ignoreCertificate/adminSession/desktopWidth/desktopHeight) only take effect when host is set.",
-                schema: this.getAgentInitArgSchema(),
-                cli: this.getAgentInitArgCliMetadata(),
-                handler: async (args)=>{
-                    const initArgs = this.extractAgentInitParam(args);
-                    const reportSession = this.createNewCliReportSession(getCliReportSessionTarget(initArgs));
-                    this.commitCliReportSession(reportSession);
-                    if (this.agent) {
-                        try {
-                            await this.agent.destroy?.();
-                        } catch (error) {
-                            mcp_tools_debug('Failed to destroy agent during connect:', error);
-                        }
-                        this.agent = void 0;
-                        this.lastInitArgsSignature = void 0;
-                    }
-                    const agent = await this.ensureAgent(initArgs);
-                    const screenshot = await agent.interface.screenshotBase64();
-                    return {
-                        content: [
-                            {
-                                type: 'text',
-                                text: `Connected to computer${describeConnectTarget(initArgs)}`
-                            },
-                            ...this.buildScreenshotContent(screenshot)
-                        ]
-                    };
-                }
-            },
-            {
-                name: 'computer_disconnect',
-                description: 'Disconnect from computer and release resources',
-                schema: {},
-                handler: this.createDisconnectHandler('computer')
-            },
-            {
-                name: 'computer_list_displays',
-                description: 'List all available displays/monitors',
-                schema: {},
-                handler: async ()=>{
-                    const displays = await ComputerDevice.listDisplays();
-                    return {
-                        content: [
-                            {
-                                type: 'text',
-                                text: `Available displays:\n${displays.map((d)=>`- ${d.name} (ID: ${d.id})${d.primary ? ' [PRIMARY]' : ''}`).join('\n')}`
-                            }
-                        ]
-                    };
-                }
-            }
-        ];
-    }
-    constructor(...args){
-        super(...args), mcp_tools_define_property(this, "lastInitArgsSignature", void 0), mcp_tools_define_property(this, "initArgSpec", {
-            namespace: 'computer',
-            shape: computerInitArgShape,
-            cli: {
-                preferBareKeys: true
-            },
-            adapt: (extracted)=>adaptComputerInitArgs(extracted)
-        });
-    }
-}
-class ComputerMCPServer extends BaseMCPServer {
-    createToolsManager() {
-        return new ComputerMidsceneTools();
-    }
-    constructor(toolsManager){
-        super({
-            name: '@midscene/computer-mcp',
-            version: "1.9.8-beta-20260618091332.0",
-            description: 'Control the computer desktop using natural language commands'
-        }, toolsManager);
-    }
-}
-function mcpServerForAgent(agent) {
-    return createMCPServerLauncher({
-        agent,
-        platformName: 'Computer',
-        ToolsManagerClass: ComputerMidsceneTools,
-        MCPServerClass: ComputerMCPServer
-    });
-}
-async function mcpKitForAgent(agent) {
-    const toolsManager = new ComputerMidsceneTools();
-    const computerAgent = agent instanceof ComputerAgent ? agent : agent;
-    toolsManager.setAgent(computerAgent);
-    await toolsManager.initTools();
-    return {
-        description: 'Midscene MCP Kit for computer desktop automation',
-        tools: toolsManager.getToolDefinitions()
-    };
-}
-export { ComputerMCPServer, mcpKitForAgent, mcpServerForAgent };