@midscene/computer 1.9.3-beta-20260610061213.0 → 1.9.3-beta-20260610071913.0

package/README.md

@@ -22,19 +22,6 @@ const agent = await agentForRDPComputer({
 });
 ```
 
-When the machine running Midscene has multiple outbound routes, pass
-`localAddress` to bind the RDP TCP connection to a specific local source IP:
-
-```ts
-const agent = await agentForRDPComputer({
-  host: '10.0.0.10',
-  username: 'Admin',
-  password: 'secret',
-  localAddress: '10.0.0.20',
-  ignoreCertificate: true,
-});
-```
-
 RDP usage requires:
 
 - a reachable Windows machine with RDP enabled

package/dist/es/cli.mjs

@@ -40,6 +40,33 @@ class ComputerInputDriver {
     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);
@@ -52,6 +79,13 @@ class ComputerInputDriver {
     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);
@@ -230,13 +264,17 @@ const CLICK_HOLD_DURATION = 100;
 const CLICK_FOCUS_SETTLE_DELAY = 120;
 const INPUT_FOCUS_DELAY = 300;
 const INPUT_CLEAR_DELAY = 150;
-const SCROLL_REPEAT_COUNT = 10;
 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: {
@@ -244,7 +282,7 @@ const EDGE_SCROLL_SPEC = {
         key: 'home',
         libnut: [
             0,
-            10
+            1
         ]
     },
     scrollToBottom: {
@@ -252,14 +290,14 @@ const EDGE_SCROLL_SPEC = {
         key: 'end',
         libnut: [
             0,
-            -10
+            -1
         ]
     },
     scrollToLeft: {
         direction: 'left',
         key: 'home',
         libnut: [
-            -10,
+            -1,
             0
         ]
     },
@@ -267,7 +305,7 @@ const EDGE_SCROLL_SPEC = {
         direction: 'right',
         key: 'end',
         libnut: [
-            10,
+            1,
             0
         ]
     }
@@ -656,7 +694,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.9.3-beta-20260610061213.0");
+        console.log("[HealthCheck] @midscene/computer v1.9.3-beta-20260610071913.0");
         console.log('[HealthCheck] Taking screenshot...');
         const screenshotTimeout = 15000;
         let timeoutId;
@@ -834,7 +872,20 @@ Original error: ${lastRawMessage}`);
         });
         this.inputDriver.sendKey(key, modifiers);
     }
-    async performScroll(param) {
+    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;
@@ -843,7 +894,17 @@ Original error: ${lastRawMessage}`);
                 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) {
@@ -853,11 +914,8 @@ Original error: ${lastRawMessage}`);
                 await this.inputDriver.delay(SCROLL_COMPLETE_DELAY);
                 return;
             }
-            const [dx, dy] = edgeSpec.libnut;
-            for(let i = 0; i < SCROLL_REPEAT_COUNT; i++){
-                this.inputDriver.scrollMouse(dx, dy);
-                await this.inputDriver.delay(SCROLL_STEP_DELAY);
-            }
+            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) {
@@ -865,9 +923,8 @@ Original error: ${lastRawMessage}`);
             const isKnownDirection = 'up' === direction || 'down' === direction || 'left' === direction || 'right' === direction;
             const isHorizontal = 'left' === direction || 'right' === direction;
             let distance = param?.distance ?? void 0;
-            let screenSize;
             if (!distance) {
-                screenSize = await this.size();
+                screenSize ??= await this.size();
                 const base = isHorizontal ? screenSize.width : screenSize.height;
                 distance = Math.max(1, Math.round(base * DEFAULT_SCROLL_VIEWPORT_RATIO));
             }
@@ -886,30 +943,30 @@ Original error: ${lastRawMessage}`);
                 await this.inputDriver.delay(SCROLL_COMPLETE_DELAY);
                 return;
             }
-            const ticks = Math.ceil(distance / 100);
-            const directionMap = {
+            const detents = Math.min(LIBNUT_FALLBACK_MAX_DETENTS, Math.max(1, Math.ceil(distance / LIBNUT_FALLBACK_PIXELS_PER_DETENT)));
+            const directionUnit = {
                 up: [
                     0,
-                    ticks
+                    1
                 ],
                 down: [
                     0,
-                    -ticks
+                    -1
                 ],
                 left: [
-                    -ticks,
+                    -1,
                     0
                 ],
                 right: [
-                    ticks,
+                    1,
                     0
                 ]
             };
-            const [dx, dy] = directionMap[direction] || [
+            const [ux, uy] = directionUnit[direction] || [
                 0,
-                -ticks
+                -1
             ];
-            this.inputDriver.scrollMouse(dx, dy);
+            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;
         }
@@ -1114,27 +1171,6 @@ function createPlatformActions() {
         })
     };
 }
-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',
@@ -1182,14 +1218,14 @@ function backend_client_define_property(obj, key, value) {
 }
 const debug = getDebug('rdp:backend');
 const HELPER_SHUTDOWN_TIMEOUT_MS = 3000;
-const HELPER_WRITE_ERROR_DIAGNOSTIC_DELAY_MS = 50;
-const MAX_STDERR_CHARS = 16384;
+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: normalizeRdpConnectionConfig(config)
+            config
         });
         if ('connected' !== response.type) throw new Error(`Expected connected response, got ${response.type}`);
         this.connected = true;
@@ -1273,8 +1309,8 @@ class HelperProcessRDPBackendClient {
         });
         this.expectOk(response, 'clearInput');
     }
-    ensureHelperStarted() {
-        if (this.child && null === this.child.exitCode) return this.child;
+    async ensureHelperStarted() {
+        if (this.child && null === this.child.exitCode) return;
         const helperPath = this.resolveHelperPath();
         debug('starting rdp helper', {
             helperPath
@@ -1289,111 +1325,66 @@ class HelperProcessRDPBackendClient {
         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.stderrLines.length = 0;
         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);
+        this.stderrReader = createInterface({
+            input: child.stderr,
+            crlfDelay: 1 / 0
         });
-        child.stdout.on('error', (error)=>{
-            this.handleHelperStreamError(child, 'stdout', error, diagnostics);
+        this.stdoutReader.on('line', (line)=>{
+            this.handleStdoutLine(line);
         });
-        child.stderr.on('error', (error)=>{
-            this.handleHelperStreamError(child, 'stderr', error, diagnostics);
+        this.stderrReader.on('line', (line)=>{
+            this.captureStderrLine(line);
         });
         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;
-            }
+            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)=>{
-            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;
-            }
+            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;
         });
-        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) {
+    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}`, void 0, diagnostics);
-            this.rejectPendingForChild(child, protocolError);
-            if (this.child === child) this.shutdownHelper(protocolError);
+            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, 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);
+        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;
-        const child = this.ensureHelperStarted();
-        if (null !== child.exitCode) throw this.createHelperError('RDP helper is not running');
+        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 diagnostics = this.helperDiagnostics.get(child);
         const request = {
             id,
             payload
@@ -1401,17 +1392,12 @@ class HelperProcessRDPBackendClient {
         return new Promise((resolve, reject)=>{
             this.pending.set(id, {
                 resolve,
-                reject,
-                child
+                reject
             });
             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?.();
+                reject(this.createHelperError(`Failed to send ${payload.type} request to RDP helper: ${error.message}`));
             });
         });
     }
@@ -1422,28 +1408,18 @@ class HelperProcessRDPBackendClient {
         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}`);
+    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;
@@ -1478,8 +1454,9 @@ class HelperProcessRDPBackendClient {
         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, "helperDiagnostics", new WeakMap());
+        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);
@@ -1522,10 +1499,9 @@ 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}`;
+        return `RDP Device ${this.options.host}:${port}${username}${session}`;
     }
     async connect() {
         this.throwIfDestroyed();
@@ -1565,11 +1541,10 @@ class RDPDevice {
                 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})`,
+                            name: `RDP ${this.connectionInfo?.server || this.options.host} (${size.width}x${size.height})`,
                             primary: true
                         }
                     ];
@@ -1767,12 +1742,11 @@ class RDPDevice {
                 }
             }
         });
-        const normalizedOptions = normalizeRdpConnectionConfig(options);
         this.options = {
             port: 3389,
             securityProtocol: 'auto',
             ignoreCertificate: false,
-            ...normalizedOptions
+            ...options
         };
         this.backend = options.backend || createDefaultRDPBackendClient();
     }
@@ -1795,7 +1769,6 @@ function createRDPComputerDevice(opts) {
         username: opts.username,
         password: opts.password,
         domain: opts.domain,
-        localAddress: opts.localAddress,
         adminSession: opts.adminSession,
         ignoreCertificate: opts.ignoreCertificate,
         securityProtocol: opts.securityProtocol,
@@ -1841,7 +1814,6 @@ const computerInitArgShape = {
     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.'),
@@ -1852,11 +1824,10 @@ 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
+            host: extracted.host
         };
     }
     return {
@@ -1872,15 +1843,15 @@ function shouldRetargetAgent(opts) {
 }
 function describeConnectTarget(opts) {
     if (opts?.mode === 'rdp') {
-        const target = opts.port ? formatRdpServerAddress(opts.host, opts.port) : formatRdpHost(opts.host);
+        const portSuffix = opts.port ? `:${opts.port}` : '';
         const userSuffix = opts.username ? ` as ${opts.username}` : '';
-        return ` via RDP (${target}${userSuffix})`;
+        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:${formatRdpHost(opts.host)}`;
+    if (opts?.mode === 'rdp') return `rdp:${opts.host}`;
     if (opts?.mode === 'local' && opts.displayId) return opts.displayId;
     return 'primary';
 }
@@ -1932,7 +1903,7 @@ class ComputerMidsceneTools extends BaseMidsceneTools {
         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.",
+                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)=>{
@@ -1998,7 +1969,7 @@ class ComputerMidsceneTools extends BaseMidsceneTools {
 const tools = new ComputerMidsceneTools();
 runToolsCLI(tools, 'midscene-computer', {
     stripPrefix: 'computer_',
-    version: "1.9.3-beta-20260610061213.0",
+    version: "1.9.3-beta-20260610071913.0",
     extraCommands: createReportCliCommands()
 }).catch((e)=>{
     process.exit(reportCLIError(e));