@midscene/computer 1.8.0 → 1.8.1-beta-20260513084557.0

package/dist/lib/mcp-server.js

@@ -452,7 +452,7 @@ Available Displays: ${displays.length > 0 ? displays.map((d)=>d.name).join(', ')
     }
     async healthCheck() {
         console.log('[HealthCheck] Starting health check...');
-        console.log("[HealthCheck] @midscene/computer v1.8.0");
+        console.log("[HealthCheck] @midscene/computer v1.8.1-beta-20260513084557.0");
         console.log('[HealthCheck] Taking screenshot...');
         const screenshotTimeout = 15000;
         let timeoutId;
@@ -851,10 +851,600 @@ function createPlatformActions() {
         })
     };
 }
-require("node:events");
-require("node:readline");
-(0, logger_namespaceObject.getDebug)('rdp:backend');
-(0, logger_namespaceObject.getDebug)('rdp:device');
+const external_node_events_namespaceObject = require("node:events");
+const external_node_readline_namespaceObject = require("node:readline");
+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() {
+    return __dirname;
+}
+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 = [
+        (0, external_node_path_namespaceObject.resolve)(hereDir, '../..'),
+        (0, external_node_path_namespaceObject.resolve)(hereDir, '../../..')
+    ];
+    for (const root of candidateRoots){
+        const binaryPath = (0, external_node_path_namespaceObject.resolve)(root, 'bin', platformBinary.directory, platformBinary.fileName);
+        if ((0, external_node_fs_namespaceObject.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 = (0, logger_namespaceObject.getDebug)('rdp:backend');
+const HELPER_SHUTDOWN_TIMEOUT_MS = 3000;
+const MAX_STDERR_LINES = 40;
+class HelperProcessRDPBackendClient {
+    async connect(config) {
+        this.fatalHelperError = void 0;
+        await this.ensureHelperStarted();
+        const response = await this.send({
+            type: 'connect',
+            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');
+    }
+    async ensureHelperStarted() {
+        if (this.child && null === this.child.exitCode) return;
+        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;
+        this.stderrLines.length = 0;
+        this.stdoutReader = (0, external_node_readline_namespaceObject.createInterface)({
+            input: child.stdout,
+            crlfDelay: 1 / 0
+        });
+        this.stderrReader = (0, external_node_readline_namespaceObject.createInterface)({
+            input: child.stderr,
+            crlfDelay: 1 / 0
+        });
+        this.stdoutReader.on('line', (line)=>{
+            this.handleStdoutLine(line);
+        });
+        this.stderrReader.on('line', (line)=>{
+            this.captureStderrLine(line);
+        });
+        child.on('exit', (code, signal)=>{
+            this.connected = false;
+            const error = this.createHelperError(`RDP helper exited unexpectedly (code=${code}, signal=${signal})`);
+            this.fatalHelperError = error;
+            this.rejectPending(error);
+            this.disposeReaders();
+            this.child = void 0;
+        });
+        child.on('error', (error)=>{
+            this.connected = false;
+            const helperError = this.createHelperError(`Failed to start RDP helper: ${error.message}`);
+            this.fatalHelperError = helperError;
+            this.rejectPending(helperError);
+            this.disposeReaders();
+            this.child = void 0;
+        });
+    }
+    handleStdoutLine(line) {
+        if (!line.trim()) return;
+        let parsed;
+        try {
+            parsed = JSON.parse(line);
+        } catch (error) {
+            const protocolError = this.createHelperError(`RDP helper emitted malformed JSON: ${line}`);
+            this.rejectPending(protocolError);
+            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));
+    }
+    captureStderrLine(line) {
+        if (!line.trim()) return;
+        this.stderrLines.push(line);
+        if (this.stderrLines.length > MAX_STDERR_LINES) this.stderrLines.shift();
+    }
+    async send(payload) {
+        if ('connect' !== payload.type && this.fatalHelperError && (!this.child || null !== this.child.exitCode)) throw this.fatalHelperError;
+        await this.ensureHelperStarted();
+        const child = this.child;
+        if (!child || null !== child.exitCode) throw this.createHelperError('RDP helper is not running');
+        const id = `req-${++this.nextRequestId}`;
+        const request = {
+            id,
+            payload
+        };
+        return new Promise((resolve, reject)=>{
+            this.pending.set(id, {
+                resolve,
+                reject
+            });
+            child.stdin.write(`${JSON.stringify(request)}\n`, (error)=>{
+                if (!error) return;
+                this.pending.delete(id);
+                reject(this.createHelperError(`Failed to send ${payload.type} request to RDP helper: ${error.message}`));
+            });
+        });
+    }
+    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();
+    }
+    createHelperError(message, code) {
+        const stderrSummary = this.stderrLines.join('\n').trim();
+        const suffix = stderrSummary ? `\nHelper stderr:\n${stderrSummary}` : '';
+        const error = new Error(`${message}${suffix}`);
+        if (code) error.name = code;
+        return error;
+    }
+    disposeReaders() {
+        this.stdoutReader?.close();
+        this.stderrReader?.close();
+        this.stdoutReader = void 0;
+        this.stderrReader = 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([
+            (0, external_node_events_namespaceObject.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([
+            (0, external_node_events_namespaceObject.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 (0, external_node_events_namespaceObject.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, "stderrReader", void 0);
+        backend_client_define_property(this, "pending", new Map());
+        backend_client_define_property(this, "stderrLines", []);
+        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 || external_node_child_process_namespaceObject.spawn;
+        const overridePath = options?.helperPath;
+        this.resolveHelperPath = overridePath ? ()=>overridePath : getRdpHelperBinaryPath;
+    }
+}
+function createDefaultRDPBackendClient() {
+    return new HelperProcessRDPBackendClient();
+}
+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 device_debug = (0, logger_namespaceObject.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_EDGE_SCROLL_STEPS = 10;
+const DEFAULT_SCROLL_STEP_AMOUNT = 120;
+class RDPDevice {
+    describe() {
+        const port = this.options.port || 3389;
+        const username = this.options.username ? ` as ${this.options.username}` : '';
+        const session = this.connectionInfo?.sessionId ? ` [session ${this.connectionInfo.sessionId}]` : '';
+        return `RDP Device ${this.options.host}:${port}${username}${session}`;
+    }
+    async connect() {
+        this.throwIfDestroyed();
+        device_debug('connecting to rdp backend', {
+            host: this.options.host,
+            port: this.options.port,
+            username: this.options.username
+        });
+        this.connectionInfo = await this.backend.connect(this.options);
+        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 = [
+            (0, device_namespaceObject.defineActionTap)(async ({ locate })=>{
+                const element = this.requireLocate(locate, 'tap');
+                await this.moveToElement(element, {
+                    steps: device_SMOOTH_MOVE_STEPS_TAP,
+                    stepDelayMs: device_SMOOTH_MOVE_DELAY_TAP
+                });
+                await this.backend.mouseButton('left', 'down');
+                await (0, utils_namespaceObject.sleep)(device_CLICK_HOLD_DURATION);
+                await this.backend.mouseButton('left', 'up');
+            }),
+            (0, device_namespaceObject.defineActionDoubleClick)(async ({ locate })=>{
+                const element = this.requireLocate(locate, 'double click');
+                await this.moveToElement(element, {
+                    steps: device_SMOOTH_MOVE_STEPS_TAP,
+                    stepDelayMs: device_SMOOTH_MOVE_DELAY_TAP
+                });
+                await this.backend.mouseButton('left', 'doubleClick');
+            }),
+            (0, device_namespaceObject.defineActionRightClick)(async ({ locate })=>{
+                const element = this.requireLocate(locate, 'right click');
+                await this.moveToElement(element, {
+                    steps: device_SMOOTH_MOVE_STEPS_TAP,
+                    stepDelayMs: device_SMOOTH_MOVE_DELAY_TAP
+                });
+                await this.backend.mouseButton('right', 'click');
+            }),
+            (0, device_namespaceObject.defineActionHover)(async ({ locate })=>{
+                const element = this.requireLocate(locate, 'hover');
+                await this.moveToElement(element, {
+                    steps: device_SMOOTH_MOVE_STEPS_MOUSE_MOVE,
+                    stepDelayMs: device_SMOOTH_MOVE_DELAY_MOUSE_MOVE,
+                    settleDelayMs: device_MOUSE_MOVE_EFFECT_WAIT
+                });
+            }),
+            (0, device_namespaceObject.defineActionInput)(async (param)=>{
+                this.assertConnected();
+                if (param.locate) {
+                    await this.moveToElement(param.locate, {
+                        steps: device_SMOOTH_MOVE_STEPS_TAP,
+                        stepDelayMs: device_SMOOTH_MOVE_DELAY_TAP
+                    });
+                    await this.backend.mouseButton('left', 'click');
+                    await (0, utils_namespaceObject.sleep)(device_INPUT_FOCUS_DELAY);
+                }
+                if ('typeOnly' !== param.mode) {
+                    await this.clearInput();
+                    await (0, utils_namespaceObject.sleep)(device_INPUT_CLEAR_DELAY);
+                }
+                if ('clear' === param.mode) return;
+                if (param.value) await this.backend.typeText(param.value);
+            }),
+            (0, device_namespaceObject.defineActionClearInput)(async ({ locate })=>{
+                this.assertConnected();
+                if (locate) {
+                    await this.moveToElement(locate, {
+                        steps: device_SMOOTH_MOVE_STEPS_TAP,
+                        stepDelayMs: device_SMOOTH_MOVE_DELAY_TAP
+                    });
+                    await this.backend.mouseButton('left', 'click');
+                    await (0, utils_namespaceObject.sleep)(device_INPUT_FOCUS_DELAY);
+                }
+                await this.clearInput();
+                await (0, utils_namespaceObject.sleep)(device_INPUT_CLEAR_DELAY);
+            }),
+            (0, device_namespaceObject.defineActionKeyboardPress)(async ({ locate, keyName })=>{
+                this.assertConnected();
+                if (locate) {
+                    await this.moveToElement(locate, {
+                        steps: device_SMOOTH_MOVE_STEPS_TAP,
+                        stepDelayMs: device_SMOOTH_MOVE_DELAY_TAP
+                    });
+                    await this.backend.mouseButton('left', 'click');
+                }
+                await this.backend.keyPress(keyName);
+            }),
+            (0, device_namespaceObject.defineActionScroll)(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 (0, utils_namespaceObject.sleep)(device_SCROLL_COMPLETE_DELAY);
+                    return;
+                }
+                await this.performWheel(param.direction || 'down', param.distance || DEFAULT_SCROLL_DISTANCE, target?.center[0], target?.center[1]);
+                await (0, utils_namespaceObject.sleep)(device_SCROLL_COMPLETE_DELAY);
+            }),
+            (0, device_namespaceObject.defineActionDragAndDrop)(async ({ from, to })=>{
+                this.assertConnected();
+                const source = this.requireLocate(from, 'drag source');
+                const target = this.requireLocate(to, 'drag target');
+                await this.moveToElement(source, {
+                    steps: device_SMOOTH_MOVE_STEPS_TAP,
+                    stepDelayMs: device_SMOOTH_MOVE_DELAY_TAP
+                });
+                await this.backend.mouseButton('left', 'down');
+                await (0, utils_namespaceObject.sleep)(DRAG_HOLD_DURATION);
+                await this.moveToElement(target, {
+                    steps: SMOOTH_MOVE_STEPS_DRAG,
+                    stepDelayMs: SMOOTH_MOVE_DELAY_DRAG
+                });
+                await (0, utils_namespaceObject.sleep)(DRAG_HOLD_DURATION);
+                await this.backend.mouseButton('left', 'up');
+            }),
+            (0, device_namespaceObject.defineAction)({
+                name: 'MiddleClick',
+                description: 'Middle click the element',
+                sample: {
+                    locate: {
+                        prompt: 'the browser tab close target'
+                    }
+                },
+                paramSchema: device_namespaceObject.actionTapParamSchema,
+                call: async ({ locate })=>{
+                    const element = this.requireLocate(locate, 'middle click');
+                    await this.moveToElement(element, {
+                        steps: device_SMOOTH_MOVE_STEPS_TAP,
+                        stepDelayMs: device_SMOOTH_MOVE_DELAY_TAP
+                    });
+                    await this.backend.mouseButton('middle', 'click');
+                }
+            }),
+            (0, device_namespaceObject.defineAction)({
+                name: 'ListDisplays',
+                description: 'List all available displays/monitors',
+                call: async ()=>{
+                    this.assertConnected();
+                    const size = await this.size();
+                    return [
+                        {
+                            id: this.connectionInfo?.sessionId || this.options.host,
+                            name: `RDP ${this.connectionInfo?.server || this.options.host} (${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');
+    }
+    requireLocate(locate, actionName) {
+        if (!locate) throw new Error(`Missing target element for ${actionName}`);
+        return locate;
+    }
+    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}`);
+        }
+    }
+    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 (0, utils_namespaceObject.sleep)(stepDelayMs);
+        }
+        if (options?.settleDelayMs) await (0, utils_namespaceObject.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 (0, utils_namespaceObject.sleep)(device_SCROLL_STEP_DELAY);
+        }
+    }
+    constructor(options){
+        device_define_property(this, "interfaceType", 'rdp');
+        device_define_property(this, "options", void 0);
+        device_define_property(this, "backend", void 0);
+        device_define_property(this, "connectionInfo", void 0);
+        device_define_property(this, "destroyed", false);
+        device_define_property(this, "cursorPosition", void 0);
+        device_define_property(this, "uri", void 0);
+        this.options = {
+            port: 3389,
+            securityProtocol: 'auto',
+            ignoreCertificate: false,
+            ...options
+        };
+        this.backend = options.backend || createDefaultRDPBackendClient();
+    }
+}
 class ComputerAgent extends agent_namespaceObject.Agent {
 }
 function createLocalComputerDevice(opts) {
@@ -866,12 +1456,33 @@ function createLocalComputerDevice(opts) {
         xvfbResolution: opts?.xvfbResolution
     });
 }
+function createRDPComputerDevice(opts) {
+    return new RDPDevice({
+        host: opts.host,
+        port: opts.port,
+        username: opts.username,
+        password: opts.password,
+        domain: opts.domain,
+        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);
+}
 const base_tools_namespaceObject = require("@midscene/shared/mcp/base-tools");
 function mcp_tools_define_property(obj, key, value) {
     if (key in obj) Object.defineProperty(obj, key, {
@@ -884,10 +1495,61 @@ function mcp_tools_define_property(obj, key, value) {
     return obj;
 }
 const mcp_tools_debug = (0, logger_namespaceObject.getDebug)('mcp:computer-tools');
+const RDP_SECURITY_PROTOCOLS = [
+    'auto',
+    'tls',
+    'nla',
+    'rdp'
+];
 const computerInitArgShape = {
-    displayId: core_namespaceObject.z.string().optional().describe('Display ID (from computer_list_displays)'),
-    headless: core_namespaceObject.z.boolean().optional().describe('Start virtual display via Xvfb (Linux only)')
+    displayId: core_namespaceObject.z.string().optional().describe('Display ID for local mode (from computer_list_displays). Ignored when host is set.'),
+    headless: core_namespaceObject.z.boolean().optional().describe('Start virtual display via Xvfb (Linux local mode only). Ignored when host is set.'),
+    host: core_namespaceObject.z.string().optional().describe('RDP host (FQDN or IP). Set this to switch into RDP mode.'),
+    port: core_namespaceObject.z.number().optional().describe('RDP port (default 3389). Requires host.'),
+    username: core_namespaceObject.z.string().optional().describe('RDP username. Requires host.'),
+    password: core_namespaceObject.z.string().optional().describe('RDP password. Requires host. Prefer setting via environment or a secrets manager.'),
+    domain: core_namespaceObject.z.string().optional().describe('RDP domain. Requires host.'),
+    adminSession: core_namespaceObject.z.boolean().optional().describe('Attach to the RDP admin/console session. Requires host.'),
+    ignoreCertificate: core_namespaceObject.z.boolean().optional().describe('Skip TLS certificate validation. Requires host.'),
+    securityProtocol: core_namespaceObject.z["enum"](RDP_SECURITY_PROTOCOLS).optional().describe('RDP security protocol negotiation (default auto). Requires host.'),
+    desktopWidth: core_namespaceObject.z.number().optional().describe('Remote desktop width in pixels. Requires host.'),
+    desktopHeight: core_namespaceObject.z.number().optional().describe('Remote desktop height in pixels. Requires host.')
 };
+function adaptComputerInitArgs(extracted) {
+    if (!extracted || 0 === Object.keys(extracted).length) return;
+    if (extracted.host) {
+        const { displayId: _d, headless: _h, ...rdpFields } = extracted;
+        return {
+            mode: 'rdp',
+            ...rdpFields,
+            host: extracted.host
+        };
+    }
+    return {
+        mode: 'local',
+        displayId: extracted.displayId,
+        headless: extracted.headless
+    };
+}
+function shouldRetargetAgent(opts) {
+    if (!opts) return false;
+    if ('rdp' === opts.mode) return true;
+    return void 0 !== opts.displayId || void 0 !== opts.headless;
+}
+function describeConnectTarget(opts) {
+    if (opts?.mode === 'rdp') {
+        const portSuffix = opts.port ? `:${opts.port}` : '';
+        const userSuffix = opts.username ? ` as ${opts.username}` : '';
+        return ` via RDP (${opts.host}${portSuffix}${userSuffix})`;
+    }
+    if (opts?.mode === 'local' && opts.displayId) return ` (Display: ${opts.displayId})`;
+    return ' (Primary display)';
+}
+function getCliReportSessionTarget(opts) {
+    if (opts?.mode === 'rdp') return `rdp:${opts.host}`;
+    if (opts?.mode === 'local' && opts.displayId) return opts.displayId;
+    return 'primary';
+}
 class ComputerMidsceneTools extends base_tools_namespaceObject.BaseMidsceneTools {
     getCliReportSessionName() {
         return 'midscene-computer';
@@ -896,9 +1558,7 @@ class ComputerMidsceneTools extends base_tools_namespaceObject.BaseMidsceneTools
         return new ComputerDevice({});
     }
     async ensureAgent(opts) {
-        const displayId = opts?.displayId;
-        const headless = opts?.headless;
-        if (this.agent && (void 0 !== displayId || void 0 !== headless)) {
+        if (this.agent && shouldRetargetAgent(opts)) {
             try {
                 await this.agent.destroy?.();
             } catch (error) {
@@ -907,8 +1567,20 @@ class ComputerMidsceneTools extends base_tools_namespaceObject.BaseMidsceneTools
             this.agent = void 0;
         }
         if (this.agent) return this.agent;
-        mcp_tools_debug('Creating Computer agent with displayId:', displayId || 'primary');
         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;
+            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
@@ -926,12 +1598,12 @@ class ComputerMidsceneTools extends base_tools_namespaceObject.BaseMidsceneTools
         return [
             {
                 name: 'computer_connect',
-                description: 'Connect to computer desktop. Provide displayId to connect to a specific display (use computer_list_displays to get available IDs). If not provided, uses the primary display.',
+                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/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(initArgs?.displayId ?? 'primary');
+                    const reportSession = this.createNewCliReportSession(getCliReportSessionTarget(initArgs));
                     this.commitCliReportSession(reportSession);
                     if (this.agent) {
                         try {
@@ -947,7 +1619,7 @@ class ComputerMidsceneTools extends base_tools_namespaceObject.BaseMidsceneTools
                         content: [
                             {
                                 type: 'text',
-                                text: `Connected to computer${initArgs?.displayId ? ` (Display: ${initArgs.displayId})` : ' (Primary display)'}`
+                                text: `Connected to computer${describeConnectTarget(initArgs)}`
                             },
                             ...this.buildScreenshotContent(screenshot)
                         ]
@@ -985,7 +1657,7 @@ class ComputerMidsceneTools extends base_tools_namespaceObject.BaseMidsceneTools
             cli: {
                 preferBareKeys: true
             },
-            adapt: (extracted)=>extracted
+            adapt: (extracted)=>adaptComputerInitArgs(extracted)
         });
     }
 }
@@ -996,7 +1668,7 @@ class ComputerMCPServer extends mcp_namespaceObject.BaseMCPServer {
     constructor(toolsManager){
         super({
             name: '@midscene/computer-mcp',
-            version: "1.8.0",
+            version: "1.8.1-beta-20260513084557.0",
             description: 'Control the computer desktop using natural language commands'
         }, toolsManager);
     }