@midscene/computer 1.2.3-beta-20260122071913.0 → 1.2.3-beta-20260122082712.0

package/dist/es/index.mjs

@@ -5,6 +5,7 @@ import { actionHoverParamSchema, defineAction, defineActionClearInput, defineAct
 import { sleep } from "@midscene/core/utils";
 import { createImgBase64ByFormat } from "@midscene/shared/img";
 import { getDebug } from "@midscene/shared/logger";
+import clipboardy from "clipboardy";
 import screenshot_desktop from "screenshot-desktop";
 import { Agent } from "@midscene/core/agent";
 import { overrideAIConfig } from "@midscene/shared/env";
@@ -29,6 +30,8 @@ const INPUT_CLEAR_DELAY = 150;
 const SCROLL_REPEAT_COUNT = 10;
 const SCROLL_STEP_DELAY = 100;
 const SCROLL_COMPLETE_DELAY = 500;
+const INPUT_STRATEGY_ALWAYS_CLIPBOARD = 'always-clipboard';
+const INPUT_STRATEGY_CLIPBOARD_FOR_NON_ASCII = 'clipboard-for-non-ascii';
 let device_libnut = null;
 let libnutLoadError = null;
 async function getLibnut() {
@@ -173,6 +176,40 @@ Available Displays: ${displays.length > 0 ? displays.map((d)=>d.name).join(', ')
             throw new Error(`Failed to get screen size: ${error}`);
         }
     }
+    shouldUseClipboardForText(text) {
+        const hasNonAscii = /[\x80-\uFFFF]/.test(text);
+        return hasNonAscii;
+    }
+    async typeViaClipboard(text) {
+        node_assert(device_libnut, 'libnut not initialized');
+        debugDevice('Using clipboard to input text', {
+            textLength: text.length,
+            preview: text.substring(0, 20)
+        });
+        const oldClipboard = await clipboardy.read().catch(()=>'');
+        try {
+            await clipboardy.write(text);
+            await sleep(50);
+            const modifier = 'darwin' === process.platform ? 'command' : 'control';
+            device_libnut.keyTap('v', [
+                modifier
+            ]);
+            await sleep(100);
+        } finally{
+            if (oldClipboard) await clipboardy.write(oldClipboard).catch(()=>{
+                debugDevice('Failed to restore clipboard content');
+            });
+        }
+    }
+    async smartTypeString(text) {
+        node_assert(device_libnut, 'libnut not initialized');
+        if ('darwin' === process.platform) return void device_libnut.typeString(text);
+        const inputStrategy = this.options?.inputStrategy ?? INPUT_STRATEGY_CLIPBOARD_FOR_NON_ASCII;
+        if (inputStrategy === INPUT_STRATEGY_ALWAYS_CLIPBOARD) return void await this.typeViaClipboard(text);
+        const shouldUseClipboard = this.shouldUseClipboardForText(text);
+        if (shouldUseClipboard) await this.typeViaClipboard(text);
+        else device_libnut.typeString(text);
+    }
     actionSpace() {
         const defaultActions = [
             defineActionTap(async (param)=>{
@@ -250,7 +287,7 @@ Available Displays: ${displays.length > 0 ? displays.map((d)=>d.name).join(', ')
                     }
                     if ('clear' === param.mode) return;
                     if (!param.value) return;
-                    device_libnut.typeString(param.value);
+                    await this.smartTypeString(param.value);
                 }
             }),
             defineActionScroll(async (param)=>{

package/dist/es/mcp-server.mjs

@@ -7,6 +7,7 @@ import { actionHoverParamSchema, defineAction, defineActionClearInput, defineAct
 import { sleep } from "@midscene/core/utils";
 import { createImgBase64ByFormat } from "@midscene/shared/img";
 import { getDebug } from "@midscene/shared/logger";
+import clipboardy from "clipboardy";
 import screenshot_desktop from "screenshot-desktop";
 function _define_property(obj, key, value) {
     if (key in obj) Object.defineProperty(obj, key, {
@@ -29,6 +30,8 @@ const INPUT_CLEAR_DELAY = 150;
 const SCROLL_REPEAT_COUNT = 10;
 const SCROLL_STEP_DELAY = 100;
 const SCROLL_COMPLETE_DELAY = 500;
+const INPUT_STRATEGY_ALWAYS_CLIPBOARD = 'always-clipboard';
+const INPUT_STRATEGY_CLIPBOARD_FOR_NON_ASCII = 'clipboard-for-non-ascii';
 let libnut = null;
 let libnutLoadError = null;
 async function getLibnut() {
@@ -173,6 +176,40 @@ Available Displays: ${displays.length > 0 ? displays.map((d)=>d.name).join(', ')
             throw new Error(`Failed to get screen size: ${error}`);
         }
     }
+    shouldUseClipboardForText(text) {
+        const hasNonAscii = /[\x80-\uFFFF]/.test(text);
+        return hasNonAscii;
+    }
+    async typeViaClipboard(text) {
+        node_assert(libnut, 'libnut not initialized');
+        debugDevice('Using clipboard to input text', {
+            textLength: text.length,
+            preview: text.substring(0, 20)
+        });
+        const oldClipboard = await clipboardy.read().catch(()=>'');
+        try {
+            await clipboardy.write(text);
+            await sleep(50);
+            const modifier = 'darwin' === process.platform ? 'command' : 'control';
+            libnut.keyTap('v', [
+                modifier
+            ]);
+            await sleep(100);
+        } finally{
+            if (oldClipboard) await clipboardy.write(oldClipboard).catch(()=>{
+                debugDevice('Failed to restore clipboard content');
+            });
+        }
+    }
+    async smartTypeString(text) {
+        node_assert(libnut, 'libnut not initialized');
+        if ('darwin' === process.platform) return void libnut.typeString(text);
+        const inputStrategy = this.options?.inputStrategy ?? INPUT_STRATEGY_CLIPBOARD_FOR_NON_ASCII;
+        if (inputStrategy === INPUT_STRATEGY_ALWAYS_CLIPBOARD) return void await this.typeViaClipboard(text);
+        const shouldUseClipboard = this.shouldUseClipboardForText(text);
+        if (shouldUseClipboard) await this.typeViaClipboard(text);
+        else libnut.typeString(text);
+    }
     actionSpace() {
         const defaultActions = [
             defineActionTap(async (param)=>{
@@ -250,7 +287,7 @@ Available Displays: ${displays.length > 0 ? displays.map((d)=>d.name).join(', ')
                     }
                     if ('clear' === param.mode) return;
                     if (!param.value) return;
-                    libnut.typeString(param.value);
+                    await this.smartTypeString(param.value);
                 }
             }),
             defineActionScroll(async (param)=>{

package/dist/lib/index.js

@@ -51,6 +51,8 @@ const device_namespaceObject = require("@midscene/core/device");
 const utils_namespaceObject = require("@midscene/core/utils");
 const img_namespaceObject = require("@midscene/shared/img");
 const logger_namespaceObject = require("@midscene/shared/logger");
+const external_clipboardy_namespaceObject = require("clipboardy");
+var external_clipboardy_default = /*#__PURE__*/ __webpack_require__.n(external_clipboardy_namespaceObject);
 const external_screenshot_desktop_namespaceObject = require("screenshot-desktop");
 var external_screenshot_desktop_default = /*#__PURE__*/ __webpack_require__.n(external_screenshot_desktop_namespaceObject);
 function _define_property(obj, key, value) {
@@ -74,6 +76,8 @@ const INPUT_CLEAR_DELAY = 150;
 const SCROLL_REPEAT_COUNT = 10;
 const SCROLL_STEP_DELAY = 100;
 const SCROLL_COMPLETE_DELAY = 500;
+const INPUT_STRATEGY_ALWAYS_CLIPBOARD = 'always-clipboard';
+const INPUT_STRATEGY_CLIPBOARD_FOR_NON_ASCII = 'clipboard-for-non-ascii';
 let device_libnut = null;
 let libnutLoadError = null;
 async function getLibnut() {
@@ -218,6 +222,40 @@ Available Displays: ${displays.length > 0 ? displays.map((d)=>d.name).join(', ')
             throw new Error(`Failed to get screen size: ${error}`);
         }
     }
+    shouldUseClipboardForText(text) {
+        const hasNonAscii = /[\x80-\uFFFF]/.test(text);
+        return hasNonAscii;
+    }
+    async typeViaClipboard(text) {
+        external_node_assert_default()(device_libnut, 'libnut not initialized');
+        debugDevice('Using clipboard to input text', {
+            textLength: text.length,
+            preview: text.substring(0, 20)
+        });
+        const oldClipboard = await external_clipboardy_default().read().catch(()=>'');
+        try {
+            await external_clipboardy_default().write(text);
+            await (0, utils_namespaceObject.sleep)(50);
+            const modifier = 'darwin' === process.platform ? 'command' : 'control';
+            device_libnut.keyTap('v', [
+                modifier
+            ]);
+            await (0, utils_namespaceObject.sleep)(100);
+        } finally{
+            if (oldClipboard) await external_clipboardy_default().write(oldClipboard).catch(()=>{
+                debugDevice('Failed to restore clipboard content');
+            });
+        }
+    }
+    async smartTypeString(text) {
+        external_node_assert_default()(device_libnut, 'libnut not initialized');
+        if ('darwin' === process.platform) return void device_libnut.typeString(text);
+        const inputStrategy = this.options?.inputStrategy ?? INPUT_STRATEGY_CLIPBOARD_FOR_NON_ASCII;
+        if (inputStrategy === INPUT_STRATEGY_ALWAYS_CLIPBOARD) return void await this.typeViaClipboard(text);
+        const shouldUseClipboard = this.shouldUseClipboardForText(text);
+        if (shouldUseClipboard) await this.typeViaClipboard(text);
+        else device_libnut.typeString(text);
+    }
     actionSpace() {
         const defaultActions = [
             (0, device_namespaceObject.defineActionTap)(async (param)=>{
@@ -295,7 +333,7 @@ Available Displays: ${displays.length > 0 ? displays.map((d)=>d.name).join(', ')
                     }
                     if ('clear' === param.mode) return;
                     if (!param.value) return;
-                    device_libnut.typeString(param.value);
+                    await this.smartTypeString(param.value);
                 }
             }),
             (0, device_namespaceObject.defineActionScroll)(async (param)=>{

package/dist/lib/mcp-server.js

@@ -50,6 +50,8 @@ const device_namespaceObject = require("@midscene/core/device");
 const utils_namespaceObject = require("@midscene/core/utils");
 const img_namespaceObject = require("@midscene/shared/img");
 const logger_namespaceObject = require("@midscene/shared/logger");
+const external_clipboardy_namespaceObject = require("clipboardy");
+var external_clipboardy_default = /*#__PURE__*/ __webpack_require__.n(external_clipboardy_namespaceObject);
 const external_screenshot_desktop_namespaceObject = require("screenshot-desktop");
 var external_screenshot_desktop_default = /*#__PURE__*/ __webpack_require__.n(external_screenshot_desktop_namespaceObject);
 function _define_property(obj, key, value) {
@@ -73,6 +75,8 @@ const INPUT_CLEAR_DELAY = 150;
 const SCROLL_REPEAT_COUNT = 10;
 const SCROLL_STEP_DELAY = 100;
 const SCROLL_COMPLETE_DELAY = 500;
+const INPUT_STRATEGY_ALWAYS_CLIPBOARD = 'always-clipboard';
+const INPUT_STRATEGY_CLIPBOARD_FOR_NON_ASCII = 'clipboard-for-non-ascii';
 let libnut = null;
 let libnutLoadError = null;
 async function getLibnut() {
@@ -217,6 +221,40 @@ Available Displays: ${displays.length > 0 ? displays.map((d)=>d.name).join(', ')
             throw new Error(`Failed to get screen size: ${error}`);
         }
     }
+    shouldUseClipboardForText(text) {
+        const hasNonAscii = /[\x80-\uFFFF]/.test(text);
+        return hasNonAscii;
+    }
+    async typeViaClipboard(text) {
+        external_node_assert_default()(libnut, 'libnut not initialized');
+        debugDevice('Using clipboard to input text', {
+            textLength: text.length,
+            preview: text.substring(0, 20)
+        });
+        const oldClipboard = await external_clipboardy_default().read().catch(()=>'');
+        try {
+            await external_clipboardy_default().write(text);
+            await (0, utils_namespaceObject.sleep)(50);
+            const modifier = 'darwin' === process.platform ? 'command' : 'control';
+            libnut.keyTap('v', [
+                modifier
+            ]);
+            await (0, utils_namespaceObject.sleep)(100);
+        } finally{
+            if (oldClipboard) await external_clipboardy_default().write(oldClipboard).catch(()=>{
+                debugDevice('Failed to restore clipboard content');
+            });
+        }
+    }
+    async smartTypeString(text) {
+        external_node_assert_default()(libnut, 'libnut not initialized');
+        if ('darwin' === process.platform) return void libnut.typeString(text);
+        const inputStrategy = this.options?.inputStrategy ?? INPUT_STRATEGY_CLIPBOARD_FOR_NON_ASCII;
+        if (inputStrategy === INPUT_STRATEGY_ALWAYS_CLIPBOARD) return void await this.typeViaClipboard(text);
+        const shouldUseClipboard = this.shouldUseClipboardForText(text);
+        if (shouldUseClipboard) await this.typeViaClipboard(text);
+        else libnut.typeString(text);
+    }
     actionSpace() {
         const defaultActions = [
             (0, device_namespaceObject.defineActionTap)(async (param)=>{
@@ -294,7 +332,7 @@ Available Displays: ${displays.length > 0 ? displays.map((d)=>d.name).join(', ')
                     }
                     if ('clear' === param.mode) return;
                     if (!param.value) return;
-                    libnut.typeString(param.value);
+                    await this.smartTypeString(param.value);
                 }
             }),
             (0, device_namespaceObject.defineActionScroll)(async (param)=>{

package/dist/types/index.d.ts

@@ -37,6 +37,26 @@ export declare class ComputerDevice implements AbstractInterface {
     connect(): Promise<void>;
     screenshotBase64(): Promise<string>;
     size(): Promise<Size>;
+    /**
+     * Check if text contains non-ASCII characters
+     * Matches: Chinese, Japanese, Korean, Latin extended characters (café, niño), emoji, etc.
+     */
+    private shouldUseClipboardForText;
+    /**
+     * Type text via clipboard (paste)
+     * This method:
+     * 1. Saves the old clipboard content
+     * 2. Writes new content to clipboard
+     * 3. Simulates paste shortcut (Ctrl+V / Cmd+V)
+     * 4. Restores old clipboard content
+     */
+    private typeViaClipboard;
+    /**
+     * Smart type string with platform-specific strategy
+     * - macOS: Always use libnut (native support for non-ASCII)
+     * - Windows/Linux: Use clipboard for non-ASCII characters
+     */
+    private smartTypeString;
     actionSpace(): DeviceAction<any>[];
     destroy(): Promise<void>;
     url(): Promise<string>;
@@ -45,6 +65,7 @@ export declare class ComputerDevice implements AbstractInterface {
 export declare interface ComputerDeviceOpt {
     displayId?: string;
     customActions?: DeviceAction<any>[];
+    inputStrategy?: 'always-clipboard' | 'clipboard-for-non-ascii';
 }
 
 export declare interface DisplayInfo {

package/dist/types/mcp-server.d.ts

@@ -29,6 +29,26 @@ declare class ComputerDevice implements AbstractInterface {
     connect(): Promise<void>;
     screenshotBase64(): Promise<string>;
     size(): Promise<Size>;
+    /**
+     * Check if text contains non-ASCII characters
+     * Matches: Chinese, Japanese, Korean, Latin extended characters (café, niño), emoji, etc.
+     */
+    private shouldUseClipboardForText;
+    /**
+     * Type text via clipboard (paste)
+     * This method:
+     * 1. Saves the old clipboard content
+     * 2. Writes new content to clipboard
+     * 3. Simulates paste shortcut (Ctrl+V / Cmd+V)
+     * 4. Restores old clipboard content
+     */
+    private typeViaClipboard;
+    /**
+     * Smart type string with platform-specific strategy
+     * - macOS: Always use libnut (native support for non-ASCII)
+     * - Windows/Linux: Use clipboard for non-ASCII characters
+     */
+    private smartTypeString;
     actionSpace(): DeviceAction<any>[];
     destroy(): Promise<void>;
     url(): Promise<string>;
@@ -37,6 +57,7 @@ declare class ComputerDevice implements AbstractInterface {
 declare interface ComputerDeviceOpt {
     displayId?: string;
     customActions?: DeviceAction<any>[];
+    inputStrategy?: 'always-clipboard' | 'clipboard-for-non-ascii';
 }
 
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@midscene/computer",
-  "version": "1.2.3-beta-20260122071913.0",
+  "version": "1.2.3-beta-20260122082712.0",
   "description": "Midscene.js Computer Desktop Automation",
   "license": "MIT",
   "repository": {
@@ -26,9 +26,10 @@
   },
   "dependencies": {
     "@computer-use/libnut": "^4.2.0",
+    "clipboardy": "^4.0.0",
     "screenshot-desktop": "^1.15.3",
-    "@midscene/core": "1.2.3-beta-20260122071913.0",
-    "@midscene/shared": "1.2.3-beta-20260122071913.0"
+    "@midscene/core": "1.2.3-beta-20260122082712.0",
+    "@midscene/shared": "1.2.3-beta-20260122082712.0"
   },
   "devDependencies": {
     "@rslib/core": "^0.18.3",

package/src/device.ts

@@ -25,6 +25,7 @@ import {
 import { sleep } from '@midscene/core/utils';
 import { createImgBase64ByFormat } from '@midscene/shared/img';
 import { getDebug } from '@midscene/shared/logger';
+import clipboardy from 'clipboardy';
 import screenshot from 'screenshot-desktop';
 
 // Type definitions
@@ -63,6 +64,10 @@ const SCROLL_REPEAT_COUNT = 10;
 const SCROLL_STEP_DELAY = 100;
 const SCROLL_COMPLETE_DELAY = 500;
 
+// Input strategy constants
+const INPUT_STRATEGY_ALWAYS_CLIPBOARD = 'always-clipboard';
+const INPUT_STRATEGY_CLIPBOARD_FOR_NON_ASCII = 'clipboard-for-non-ascii';
+
 // Lazy load libnut with fallback
 let libnut: LibNut | null = null;
 let libnutLoadError: Error | null = null;
@@ -185,6 +190,7 @@ export interface ComputerDeviceOpt {
   displayId?: string;
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   customActions?: DeviceAction<any>[];
+  inputStrategy?: 'always-clipboard' | 'clipboard-for-non-ascii';
 }
 
 export class ComputerDevice implements AbstractInterface {
@@ -289,6 +295,87 @@ Available Displays: ${displays.length > 0 ? displays.map((d) => d.name).join(',
     }
   }
 
+  /**
+   * Check if text contains non-ASCII characters
+   * Matches: Chinese, Japanese, Korean, Latin extended characters (café, niño), emoji, etc.
+   */
+  private shouldUseClipboardForText(text: string): boolean {
+    // Check for any character with code point >= 128 (non-ASCII)
+    const hasNonAscii = /[\x80-\uFFFF]/.test(text);
+    return hasNonAscii;
+  }
+
+  /**
+   * Type text via clipboard (paste)
+   * This method:
+   * 1. Saves the old clipboard content
+   * 2. Writes new content to clipboard
+   * 3. Simulates paste shortcut (Ctrl+V / Cmd+V)
+   * 4. Restores old clipboard content
+   */
+  private async typeViaClipboard(text: string): Promise<void> {
+    assert(libnut, 'libnut not initialized');
+    debugDevice('Using clipboard to input text', {
+      textLength: text.length,
+      preview: text.substring(0, 20),
+    });
+
+    // 1. Save old clipboard content
+    const oldClipboard = await clipboardy.read().catch(() => '');
+
+    try {
+      // 2. Write new content to clipboard
+      await clipboardy.write(text);
+      await sleep(50);
+
+      // 3. Simulate paste shortcut
+      const modifier = process.platform === 'darwin' ? 'command' : 'control';
+      libnut.keyTap('v', [modifier]);
+      await sleep(100);
+    } finally {
+      // 4. Restore old clipboard content
+      if (oldClipboard) {
+        await clipboardy.write(oldClipboard).catch(() => {
+          // Silent fail - don't affect main flow
+          debugDevice('Failed to restore clipboard content');
+        });
+      }
+    }
+  }
+
+  /**
+   * Smart type string with platform-specific strategy
+   * - macOS: Always use libnut (native support for non-ASCII)
+   * - Windows/Linux: Use clipboard for non-ASCII characters
+   */
+  private async smartTypeString(text: string): Promise<void> {
+    assert(libnut, 'libnut not initialized');
+
+    // macOS: use libnut directly (native Chinese support)
+    if (process.platform === 'darwin') {
+      libnut.typeString(text);
+      return;
+    }
+
+    // Windows/Linux: use smart strategy
+    const inputStrategy =
+      this.options?.inputStrategy ?? INPUT_STRATEGY_CLIPBOARD_FOR_NON_ASCII;
+
+    if (inputStrategy === INPUT_STRATEGY_ALWAYS_CLIPBOARD) {
+      await this.typeViaClipboard(text);
+      return;
+    }
+
+    // clipboard-for-non-ascii strategy: intelligent detection
+    const shouldUseClipboard = this.shouldUseClipboardForText(text);
+
+    if (shouldUseClipboard) {
+      await this.typeViaClipboard(text);
+    } else {
+      libnut.typeString(text);
+    }
+  }
+
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   actionSpace(): DeviceAction<any>[] {
     const defaultActions: DeviceAction<any>[] = [
@@ -401,7 +488,7 @@ Available Displays: ${displays.length > 0 ? displays.map((d) => d.name).join(',
             return;
           }
 
-          libnut.typeString(param.value);
+          await this.smartTypeString(param.value);
         },
       }),
 

package/tests/ai/chinese-input.test.ts

@@ -0,0 +1,153 @@
+import { sleep } from '@midscene/core/utils';
+import { beforeAll, describe, it, vi } from 'vitest';
+import { ComputerAgent, ComputerDevice } from '../../src';
+
+vi.setConfig({
+  testTimeout: 240 * 1000,
+});
+
+describe('chinese and non-ASCII input', () => {
+  let agent: ComputerAgent;
+
+  beforeAll(async () => {
+    const device = new ComputerDevice({
+      inputStrategy: 'clipboard-for-non-ascii',
+    });
+    agent = new ComputerAgent(device, {
+      aiActionContext:
+        'You are testing text input on a desktop computer. Focus on testing Chinese and other non-ASCII character input.',
+    });
+    await device.connect();
+  });
+
+  it(
+    'should input Chinese text in browser search',
+    async () => {
+      const isMac = process.platform === 'darwin';
+
+      // Open browser (using platform-specific shortcuts)
+      if (isMac) {
+        await agent.aiAct('press Cmd+Space to open Spotlight');
+        await sleep(1000);
+        await agent.aiAct('type "Safari" and press Enter');
+      } else {
+        await agent.aiAct('press Windows key');
+        await sleep(1000);
+        await agent.aiAct('type "Chrome" or "Edge" and press Enter');
+      }
+
+      await sleep(3000);
+
+      // Wait for browser to open
+      await agent.aiWaitFor('Browser window is open');
+
+      // Navigate to a search engine
+      await agent.aiAct('click on address bar');
+      await sleep(500);
+      await agent.aiAct('type "google.com" and press Enter');
+
+      await sleep(3000);
+
+      // Test Chinese input
+      await agent.aiAct('click on search box');
+      await sleep(500);
+
+      // Input Chinese text
+      await agent.aiAct('type "你好世界"');
+      await sleep(1000);
+
+      // Verify Chinese text was input correctly
+      await agent.aiAssert('The search box contains Chinese text "你好世界"');
+
+      // Clear and test Japanese
+      await agent.aiAct('clear the search box');
+      await sleep(500);
+      await agent.aiAct('type "こんにちは"');
+      await sleep(1000);
+
+      // Verify Japanese text
+      await agent.aiAssert('The search box contains Japanese text');
+
+      // Clear and test emoji
+      await agent.aiAct('clear the search box');
+      await sleep(500);
+      await agent.aiAct('type "Hello 😀🎉"');
+      await sleep(1000);
+
+      // Verify emoji input
+      await agent.aiAssert('The search box contains text with emoji');
+
+      // Clear and test mixed text
+      await agent.aiAct('clear the search box');
+      await sleep(500);
+      await agent.aiAct('type "Hello 你好 World"');
+      await sleep(1000);
+
+      // Verify mixed text
+      await agent.aiAssert(
+        'The search box contains mixed English and Chinese text',
+      );
+
+      // Close browser
+      if (isMac) {
+        await agent.aiAct('press Cmd+Q to close Safari');
+      } else {
+        await agent.aiAct('press Alt+F4 to close browser');
+      }
+    },
+    720 * 1000,
+  );
+
+  it(
+    'should use always-clipboard strategy',
+    async () => {
+      // Create a new device with always-clipboard strategy
+      const deviceAlways = new ComputerDevice({
+        inputStrategy: 'always-clipboard',
+      });
+      const agentAlways = new ComputerAgent(deviceAlways, {
+        aiActionContext: 'You are testing text input using clipboard.',
+      });
+      await deviceAlways.connect();
+
+      const isMac = process.platform === 'darwin';
+
+      // Open a text editor
+      if (isMac) {
+        await agentAlways.aiAct('press Cmd+Space to open Spotlight');
+        await sleep(1000);
+        await agentAlways.aiAct('type "TextEdit" and press Enter');
+      } else {
+        await agentAlways.aiAct('press Windows key');
+        await sleep(1000);
+        await agentAlways.aiAct('type "Notepad" and press Enter');
+      }
+
+      await sleep(2000);
+
+      // Wait for text editor to open
+      await agentAlways.aiWaitFor('Text editor is open');
+
+      // Test ASCII input (should also use clipboard with always-clipboard strategy)
+      await agentAlways.aiAct('type "Hello World"');
+      await sleep(1000);
+
+      // Verify ASCII text
+      await agentAlways.aiAssert('The text editor contains "Hello World"');
+
+      // Close text editor without saving
+      if (isMac) {
+        await agentAlways.aiAct('press Cmd+Q');
+        await sleep(500);
+        await agentAlways.aiAct('click "Don\'t Save" button if it appears');
+      } else {
+        await agentAlways.aiAct('press Alt+F4');
+        await sleep(500);
+        await agentAlways.aiAct('click "Don\'t Save" button if it appears');
+      }
+
+      await deviceAlways.destroy();
+    },
+    720 * 1000,
+  );
+});