@whuanle/easytouch-windows 1.0.2 → 1.0.5

package/README.md

@@ -0,0 +1,434 @@
+# EasyTouch (et)
+
+跨平台系统自动化操作工具，支持 Windows、Linux、macOS。提供 CLI 命令行和 MCP 服务器两种使用方式，支持鼠标键盘控制、屏幕截图、窗口管理、系统信息查询、浏览器操作等功能。
+
+目前：
+
+- [x] Windows
+- [ ] Linux
+- [ ] MAC（目前缺少设备验证功能）
+
+
+
+## 功能概览
+
+| 模块 | 功能 |
+|------|------|
+| 🖱️ 鼠标控制 | 移动、点击、滚动、获取位置 |
+| ⌨️ 键盘控制 | 按键、组合键、文本输入 |
+| 📷 屏幕操作 | 截图、获取像素颜色、多显示器支持 |
+| 🪟 窗口管理 | 列出、查找、激活窗口 |
+| 🖥️ 系统信息 | CPU、内存、磁盘、进程 |
+| 📋 剪贴板 | 文本读写、文件列表 |
+| 🌐 浏览器控制 | 启动浏览器、页面导航、元素交互、截图 |
+
+
+
+提示：在 Linux 里，由于桌面环境差异很大，有些功能在某些桌面系统下可能不可用，详见 [Linux](#Linux) 环境说明。
+
+
+
+### 安装
+
+```bash
+# Windows
+npm i @whuanle/easytouch-windows
+
+# Linux
+npm i @whuanle/easytouch-linux
+
+# macOS
+npm i @whuanle/easytouch-mac
+```
+
+
+
+或者从[https://github.com/whuanle/EasyTouch/releases](https://github.com/whuanle/EasyTouch/releases)下载对应平台的可执行文件，并添加环境变量。
+
+
+
+执行 `et --help` 命令测试是否正常工作：
+
+```
+PS E:\workspace\EasyTouch> et --help
+EasyTouch Windows Automation Tool
+
+Usage: et <command> [options]
+
+Commands:
+  mouse_move --x <n> --y <n> [--relative] [--duration <ms>]
+  mouse_click [--button left|right|middle] [--double]
+  mouse_position
+  key_press --key <key>
+  type_text --text <text> [--interval <ms>] [--human]
+  screenshot [--output <path>] [--x <n>] [--y <n>] [--width <n>] [--height <n>]
+  pixel_color --x <n> --y <n>
+  window_list [--visible-only] [--filter <text>]
+  window_find [--title <text>] [--class <name>] [--pid <n>]
+  window_activate --title <text> | --handle <n>
+  window_foreground
+  os_info, cpu_info, memory_info, disk_list
+  process_list [--filter <text>]
+  clipboard_get_text, clipboard_set_text --text <text>
+
+  help       Show this help
+  version    Show version
+{"success":true}
+```
+
+
+
+### 浏览器操作支持
+
+Windows / Linux / macOS 三端都已统一使用 `Microsoft.Playwright`（.NET），不再依赖外部 Node.js Playwright 包。  
+支持浏览器：`chromium` / `firefox` / `webkit` / `edge`（`edge` 走 Chromium 通道 `msedge`）。
+
+首次使用浏览器功能时，程序会自动尝试安装对应浏览器内核（Chromium/Firefox/WebKit），无需手动执行 `npx playwright install`。
+
+如果你希望提前安装，可以直接执行一次浏览器命令触发安装：
+
+```bash
+et browser_launch --browser chromium --headless true
+```
+
+
+
+新增的 Web 自动化与测试能力（MCP）包括：
+
+- `browser_assert_text`：断言页面或元素文本（适合测试）
+- `browser_page_info`：读取页面标题、滚动位置、视口与文档尺寸
+- `browser_go_back` / `browser_go_forward` / `browser_reload`
+- `browser_scroll`：页面或元素滚动
+- `browser_select`：选择下拉项
+- `browser_upload`：文件上传
+- `browser_get_cookies` / `browser_set_cookie` / `browser_clear_cookies`
+- `browser_run_script`：执行本地 JS/TS Playwright 测试脚本文件
+
+`browser_run_script` 用于执行 AI 生成或手写的 Playwright 测试脚本（如 `.spec.ts` / `.spec.js`），并返回退出码。  
+常见参数：
+- `--script-path`：脚本文件路径（必填）
+- `--browser`：`chromium` / `firefox` / `webkit` / `edge`
+- `--headless`：是否无头（默认 `true`）
+- `--timeout`：测试超时（毫秒）
+- `--extra-args`：透传给 Playwright CLI 的额外参数，逗号分隔（例如 `--extra-args \"--reporter=list,--workers=1\"`）
+
+
+
+### 作为 MCP 工具使用
+
+在 Claude、Cursor 等工具中，配置 MCP 的方式都是大同小异。
+
+通过 npm/bun 等方式安装的 EasyTouch，程序文件在 `C:\Users\{用户名}\AppData\Roaming\npm` 下面。
+
+
+
+在配置文件中添加：
+
+**Windows**
+
+```json
+{
+  "mcpServers": {
+    "easytouch": {
+      "command": "C:\\path\\to\\et.exe",
+      "args": ["--mcp"]
+    }
+  }
+}
+```
+
+**NPM 安装方式**
+
+```json
+{
+  "mcpServers": {
+    "easytouch": {
+      "command": "npx",
+      "args": ["-y", "easytouch-windows", "--mcp"]
+    }
+  }
+}
+```
+
+**Linux / macOS**
+
+```json
+{
+  "mcpServers": {
+    "easytouch": {
+      "command": "/path/to/et",
+      "args": ["--mcp"]
+    }
+  }
+}
+```
+
+
+
+### 作为 Skills 给 AI 使用
+
+只需要执行命令安装 skills 即可。
+
+```bash
+npx skills add https://github.com/whuanle/EasyTouch/skills
+```
+
+
+
+## CLI 命令参考
+
+### 鼠标控制
+
+```bash
+# 移动鼠标（绝对坐标）
+et mouse_move --x 100 --y 200
+
+# 相对移动
+t mouse_move --x 50 --y -30 --relative
+
+# 平滑移动（500ms 动画）
+et mouse_move --x 100 --y 200 --duration 500
+
+# 左键单击（默认）
+et mouse_click
+
+# 右键双击
+t mouse_click --button right --double
+
+# 向上滚动3格
+t mouse_scroll --amount 3
+
+# 水平滚动
+t mouse_scroll --amount 3 --horizontal
+
+# 获取当前位置
+t mouse_position
+```
+
+### 键盘控制
+
+```bash
+# 按下单个键
+t key_press --key "enter"
+
+# 组合键
+t key_press --key "ctrl+c"
+t key_press --key "alt+tab"
+t key_press --key "win+d"
+
+# 输入文本
+t type_text --text "Hello World"
+
+# 模拟人工打字（带随机间隔）
+t type_text --text "Hello World" --human --interval 50
+```
+
+### 屏幕操作
+
+```bash
+# 全屏截图
+t screenshot --output screenshot.png
+
+# 区域截图
+t screenshot --x 100 --y 100 --width 800 --height 600 --output region.png
+
+# 获取像素颜色
+t pixel_color --x 100 --y 200
+
+# 列出显示器
+t screen_list
+```
+
+### 窗口管理
+
+```bash
+# 列出可见窗口
+t window_list
+
+# 按标题过滤
+t window_list --filter "Chrome"
+
+# 查找窗口
+t window_find --title "记事本"
+
+# 激活窗口
+t window_activate --title "记事本"
+
+# 获取前台窗口
+t window_foreground
+```
+
+### 系统信息
+
+```bash
+# 操作系统信息
+et os_info
+
+# CPU 信息
+et cpu_info
+
+# 内存信息
+et memory_info
+
+# 磁盘列表
+et disk_list
+
+# 进程列表
+et process_list --filter "chrome"
+
+# 锁定屏幕
+et lock_screen
+```
+
+### 剪贴板
+
+```bash
+# 获取文本
+et clipboard_get_text
+
+# 设置文本
+et clipboard_set_text --text "Hello World"
+
+# 清空
+et clipboard_clear
+
+# 获取文件列表
+et clipboard_get_files
+```
+
+
+
+### 浏览器控制
+
+
+
+使用 `et browser_launch --browser` 命令启动浏览器后（匿名模式），使用 `et browser_list` 获取浏览器实例列表，之后可以使用不同的命令控制浏览器，最后可以自行关闭或使用 `et browser_close` 关闭浏览器。
+
+
+
+```bash
+# 列出浏览器实例
+et browser_list
+
+# 启动 Chromium（无头模式）
+et browser_launch --browser chromium --headless
+
+# 启动 Edge（有界面）
+et browser_launch --browser edge --headless false
+
+# 打开页面
+et browser_navigate --browser-id <id> --url "https://example.com"
+
+# 导航控制
+et browser_go_back --browser-id <id>
+et browser_go_forward --browser-id <id>
+et browser_reload --browser-id <id>
+
+# 点击元素
+et browser_click --browser-id <id> --selector "#submit"
+
+# 输入内容
+et browser_fill --browser-id <id> --selector "input[name='q']" --value "EasyTouch"
+
+# 滚动页面（按像素）
+et browser_scroll --browser-id <id> --x 0 --y 800 --behavior smooth
+
+# 下拉选择
+et browser_select --browser-id <id> --selector "#city" --values "beijing"
+
+# 文件上传（多个文件用逗号分隔）
+et browser_upload --browser-id <id> --selector "input[type='file']" --files "a.txt,b.txt"
+
+# 页面截图
+et browser_screenshot --browser-id <id> --output page.png --full-page true
+
+# 执行脚本
+et browser_evaluate --browser-id <id> --script "document.title"
+
+# 读取页面信息
+et browser_page_info --browser-id <id>
+
+# Cookie 管理
+et browser_get_cookies --browser-id <id>
+et browser_set_cookie --browser-id <id> --name token --value abc --domain example.com --path / --http-only true --secure true --same-site lax
+et browser_clear_cookies --browser-id <id>
+
+# 执行本地 JS/TS Playwright 测试脚本
+et browser_run_script --script-path "./tests/example.spec.ts" --browser edge --headless true
+
+# 透传 Playwright CLI 参数（CSV）
+et browser_run_script --script-path "./tests/login.spec.ts" --browser chromium --extra-args "--reporter=list,--workers=1"
+
+# 文本断言（自动化测试）
+et browser_assert_text --browser-id <id> --selector "h1" --expected-text "Example Domain" --exact-match true
+
+# 关闭浏览器
+et browser_close --browser-id <id>
+```
+
+
+
+### MCP Tools
+
+| Tool | 描述 |
+|------|------|
+| `mouse_move` | 移动鼠标 |
+| `mouse_click` | 点击鼠标 |
+| `mouse_position` | 获取鼠标位置 |
+| `key_press` | 按下按键 |
+| `type_text` | 输入文本 |
+| `screenshot` | 截图 |
+| `pixel_color` | 获取像素颜色 |
+| `window_list` | 列出窗口 |
+| `window_find` | 查找窗口 |
+| `window_activate` | 激活窗口 |
+| `system_info` | 系统信息 |
+| `process_list` | 进程列表 |
+| `clipboard_get_text` | 获取剪贴板文本 |
+| `clipboard_set_text` | 设置剪贴板文本 |
+| `browser_launch` | 启动浏览器 |
+| `browser_navigate` | 页面导航 |
+| `browser_click` | 点击页面元素 |
+| `browser_fill` | 填充输入框 |
+| `browser_find` | 查找页面元素 |
+| `browser_get_text` | 获取页面文本 |
+| `browser_screenshot` | 浏览器截图 |
+| `browser_evaluate` | 执行页面脚本 |
+| `browser_wait_for` | 等待元素状态 |
+| `browser_assert_text` | 断言页面或元素文本 |
+| `browser_page_info` | 获取页面信息 |
+| `browser_go_back` / `browser_go_forward` / `browser_reload` | 页面导航控制 |
+| `browser_scroll` | 页面/元素滚动 |
+| `browser_select` | 下拉选择 |
+| `browser_upload` | 文件上传 |
+| `browser_get_cookies` / `browser_set_cookie` / `browser_clear_cookies` | Cookie 管理 |
+| `browser_run_script` | 执行 JS/TS Playwright 测试脚本 |
+| `browser_close` | 关闭浏览器 |
+| `browser_list` | 列出浏览器实例 |
+
+
+
+更多 MCP 使用文档见 [skills/SKILLS.md](skills/SKILLS.md)
+
+
+
+## 平台说明
+
+### Windows
+- 完全支持所有功能
+- 部分功能可能需要管理员权限
+
+### Linux
+- 需要 X11 显示服务器
+- 不支持 Wayland
+- 建议在图形界面环境中使用
+
+### macOS
+- 需要授予辅助功能权限（系统设置 → 隐私与安全性 → 辅助功能）
+- 截图功能需要屏幕录制权限
+
+
+
+## 许可证
+
+MIT License

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@whuanle/easytouch-windows",
-  "version": "1.0.2",
+  "version": "1.0.5",
   "description": "Windows system automation tool with MCP support",
   "author": "MaomiAgent Team",
   "license": "MIT",
@@ -31,9 +31,13 @@
       "--mcp"
     ]
   },
+  "dependencies": {
+    "playwright": "^1.50.0"
+  },
   "files": [
     "et.exe",
     "et-launcher.js",
+    "scripts/",
     "SKILL.md"
   ],
   "repository": {

package/scripts/playwright-bridge.js

@@ -0,0 +1,560 @@
+#!/usr/bin/env node
+
+const net = require('net');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { execSync, spawn } = require('child_process');
+let chromium;
+let firefox;
+let webkit;
+
+function loadPlaywright() {
+  try {
+    return require('playwright');
+  } catch {
+    try {
+      const globalRoot = execSync('npm root -g', {
+        encoding: 'utf8',
+        windowsHide: true
+      }).trim();
+      return require(path.join(globalRoot, 'playwright'));
+    } catch {
+      throw new Error(
+        'Playwright package not found. Run: npm install -g playwright && npx playwright install chromium'
+      );
+    }
+  }
+}
+
+const playwright = loadPlaywright();
+chromium = playwright.chromium;
+firefox = playwright.firefox;
+webkit = playwright.webkit;
+
+const DAEMON_FILE = path.join(os.tmpdir(), 'easytouch-playwright-daemon.json');
+const browserTypeMap = {
+  chromium,
+  chrome: chromium,
+  firefox,
+  webkit,
+  safari: webkit
+};
+
+const browsers = new Map();
+
+function parseArg(args, key) {
+  const idx = args.indexOf(key);
+  if (idx >= 0 && idx + 1 < args.length) {
+    return args[idx + 1];
+  }
+  return null;
+}
+
+function safeJsonParse(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
+}
+
+function writeJsonLine(socket, obj) {
+  socket.write(JSON.stringify(obj) + '\n');
+}
+
+async function ensureDaemon() {
+  if (fs.existsSync(DAEMON_FILE)) {
+    const existing = safeJsonParse(fs.readFileSync(DAEMON_FILE, 'utf8'));
+    if (existing && existing.port) {
+      try {
+        await sendRequest(existing.port, { command: 'ping', args: [] }, 800);
+        return existing;
+      } catch {}
+    }
+  }
+
+  const child = spawn(process.execPath, [__filename, 'daemon'], {
+    detached: true,
+    stdio: 'ignore',
+    windowsHide: true
+  });
+  child.unref();
+
+  const deadline = Date.now() + 5000;
+  while (Date.now() < deadline) {
+    if (fs.existsSync(DAEMON_FILE)) {
+      const created = safeJsonParse(fs.readFileSync(DAEMON_FILE, 'utf8'));
+      if (created && created.port) {
+        try {
+          await sendRequest(created.port, { command: 'ping', args: [] }, 800);
+          return created;
+        } catch {}
+      }
+    }
+    await new Promise((r) => setTimeout(r, 100));
+  }
+
+  throw new Error('Failed to start Playwright bridge daemon');
+}
+
+function sendRequest(port, payload, timeoutMs = 30000) {
+  return new Promise((resolve, reject) => {
+    const socket = net.createConnection({ host: '127.0.0.1', port }, () => {
+      writeJsonLine(socket, payload);
+    });
+
+    let buffer = '';
+    let done = false;
+
+    const timer = setTimeout(() => {
+      if (done) return;
+      done = true;
+      socket.destroy();
+      reject(new Error('Bridge request timeout'));
+    }, timeoutMs);
+
+    socket.on('data', (chunk) => {
+      buffer += chunk.toString();
+      const lineEnd = buffer.indexOf('\n');
+      if (lineEnd === -1) return;
+      const line = buffer.slice(0, lineEnd).trim();
+      if (!line || done) return;
+      done = true;
+      clearTimeout(timer);
+      socket.end();
+      const parsed = safeJsonParse(line);
+      if (!parsed) {
+        reject(new Error('Invalid bridge response'));
+        return;
+      }
+      resolve(parsed);
+    });
+
+    socket.on('error', (err) => {
+      if (done) return;
+      done = true;
+      clearTimeout(timer);
+      reject(err);
+    });
+  });
+}
+
+function getLauncher(type) {
+  const launcher = browserTypeMap[(type || 'chromium').toLowerCase()];
+  return launcher || chromium;
+}
+
+async function getPrimaryPage(browser) {
+  let context = browser.contexts()[0];
+  if (!context) {
+    context = await browser.newContext();
+  }
+  let page = context.pages()[0];
+  if (!page) {
+    page = await context.newPage();
+  }
+  return page;
+}
+
+async function runLaunch(args) {
+  const browserId = parseArg(args, '--browser-id');
+  if (!browserId) throw new Error('Missing --browser-id');
+
+  const browserType = (parseArg(args, '--browser') || 'chromium').toLowerCase();
+  const headless = args.includes('--headless');
+  const executablePath = parseArg(args, '--executable');
+  const url = parseArg(args, '--url');
+
+  const launcher = getLauncher(browserType);
+  const browser = await launcher.launch({
+    headless,
+    ...(executablePath ? { executablePath } : {})
+  });
+
+  const page = await getPrimaryPage(browser);
+  if (url) {
+    await page.goto(url, { waitUntil: 'load', timeout: 30000 });
+  }
+
+  browsers.set(browserId, {
+    id: browserId,
+    type: browserType,
+    browser,
+    createdAt: Date.now()
+  });
+
+  return {
+    BrowserId: browserId,
+    BrowserType: browserType,
+    Version: browser.version()
+  };
+}
+
+function getBrowserOrThrow(browserId) {
+  const instance = browsers.get(browserId);
+  if (!instance) throw new Error(`Browser not found: ${browserId}`);
+  return instance;
+}
+
+async function runNavigate(args) {
+  const browserId = parseArg(args, '--browser-id');
+  const url = parseArg(args, '--url');
+  if (!browserId || !url) throw new Error('Missing --browser-id or --url');
+
+  const waitUntil = parseArg(args, '--wait-until') || 'load';
+  const timeout = Number.parseInt(parseArg(args, '--timeout') || '30000', 10);
+
+  const instance = getBrowserOrThrow(browserId);
+  const page = await getPrimaryPage(instance.browser);
+  const response = await page.goto(url, { waitUntil, timeout });
+
+  return {
+    Url: page.url(),
+    Title: await page.title(),
+    StatusCode: response ? response.status() : 0
+  };
+}
+
+async function runClick(args) {
+  const browserId = parseArg(args, '--browser-id');
+  const selector = parseArg(args, '--selector');
+  if (!browserId || !selector) throw new Error('Missing --browser-id or --selector');
+
+  const selectorType = parseArg(args, '--selector-type') || 'css';
+  const button = Number.parseInt(parseArg(args, '--button') || '0', 10);
+  const clickCount = Number.parseInt(parseArg(args, '--click-count') || '1', 10);
+  const timeout = Number.parseInt(parseArg(args, '--timeout') || '30000', 10);
+
+  const buttonMap = ['left', 'middle', 'right'];
+  const instance = getBrowserOrThrow(browserId);
+  const page = await getPrimaryPage(instance.browser);
+  const locator = getLocator(page, selector, selectorType);
+
+  await locator.click({
+    button: buttonMap[button] || 'left',
+    clickCount,
+    timeout
+  });
+  return { Message: 'OK' };
+}
+
+async function runFill(args) {
+  const browserId = parseArg(args, '--browser-id');
+  const selector = parseArg(args, '--selector');
+  const value = parseArg(args, '--value') ?? '';
+  if (!browserId || !selector) throw new Error('Missing --browser-id or --selector');
+
+  const selectorType = parseArg(args, '--selector-type') || 'css';
+  const timeout = Number.parseInt(parseArg(args, '--timeout') || '30000', 10);
+  const noClear = args.includes('--no-clear');
+
+  const instance = getBrowserOrThrow(browserId);
+  const page = await getPrimaryPage(instance.browser);
+  const locator = getLocator(page, selector, selectorType);
+
+  if (!noClear) {
+    await locator.clear({ timeout });
+  }
+  await locator.fill(value, { timeout });
+  return { Message: 'OK' };
+}
+
+async function runFind(args) {
+  const browserId = parseArg(args, '--browser-id');
+  const selector = parseArg(args, '--selector');
+  if (!browserId || !selector) throw new Error('Missing --browser-id or --selector');
+
+  const selectorType = parseArg(args, '--selector-type') || 'css';
+  const timeout = Number.parseInt(parseArg(args, '--timeout') || '5000', 10);
+
+  const instance = getBrowserOrThrow(browserId);
+  const page = await getPrimaryPage(instance.browser);
+  const locator = getLocator(page, selector, selectorType);
+
+  await locator.first.waitFor({ timeout, state: 'attached' }).catch(() => {});
+  const count = await locator.count();
+  if (count === 0) return { Found: false };
+
+  const element = locator.first;
+  const tagName = await element.evaluate((el) => el.tagName.toLowerCase());
+  const text = await element.textContent();
+  const value = await element.inputValue().catch(() => null);
+  const bbox = await element.boundingBox();
+
+  return {
+    Found: true,
+    TagName: tagName,
+    Text: text,
+    Value: value,
+    BoundingBox: bbox
+      ? { X: bbox.x, Y: bbox.y, Width: bbox.width, Height: bbox.height }
+      : null
+  };
+}
+
+async function runGetText(args) {
+  const browserId = parseArg(args, '--browser-id');
+  if (!browserId) throw new Error('Missing --browser-id');
+
+  const selector = parseArg(args, '--selector');
+  const selectorType = parseArg(args, '--selector-type') || 'css';
+
+  const instance = getBrowserOrThrow(browserId);
+  const page = await getPrimaryPage(instance.browser);
+  if (!selector) {
+    return { Text: await page.content(), Selector: null };
+  }
+
+  const locator = getLocator(page, selector, selectorType);
+  return { Text: (await locator.textContent()) || '', Selector: selector };
+}
+
+async function runScreenshot(args) {
+  const browserId = parseArg(args, '--browser-id');
+  if (!browserId) throw new Error('Missing --browser-id');
+
+  const output = parseArg(args, '--output');
+  if (!output) throw new Error('Missing --output');
+
+  const selector = parseArg(args, '--selector');
+  const selectorType = parseArg(args, '--selector-type') || 'css';
+  const type = (parseArg(args, '--type') || 'png').toLowerCase();
+  const fullPage = args.includes('--full-page');
+  const quality = parseArg(args, '--quality');
+
+  const instance = getBrowserOrThrow(browserId);
+  const page = await getPrimaryPage(instance.browser);
+
+  const options = {
+    path: output,
+    type: type === 'jpeg' ? 'jpeg' : 'png'
+  };
+  if (quality && options.type === 'jpeg') {
+    options.quality = Number.parseInt(quality, 10);
+  }
+
+  if (selector) {
+    const locator = getLocator(page, selector, selectorType);
+    await locator.screenshot(options);
+  } else {
+    await page.screenshot({ ...options, fullPage });
+  }
+
+  return { ImagePath: output, Width: 0, Height: 0 };
+}
+
+async function runEvaluate(args) {
+  const browserId = parseArg(args, '--browser-id');
+  const scriptFile = parseArg(args, '--script-file');
+  if (!browserId || !scriptFile) throw new Error('Missing --browser-id or --script-file');
+
+  const script = fs.readFileSync(scriptFile, 'utf8');
+  const instance = getBrowserOrThrow(browserId);
+  const page = await getPrimaryPage(instance.browser);
+  const result = await page.evaluate(script);
+
+  return {
+    Result: result,
+    ResultType: typeof result
+  };
+}
+
+async function runWaitFor(args) {
+  const browserId = parseArg(args, '--browser-id');
+  const selector = parseArg(args, '--selector');
+  if (!browserId || !selector) throw new Error('Missing --browser-id or --selector');
+
+  const selectorType = parseArg(args, '--selector-type') || 'css';
+  const state = parseArg(args, '--state') || 'visible';
+  const timeout = Number.parseInt(parseArg(args, '--timeout') || '30000', 10);
+
+  const instance = getBrowserOrThrow(browserId);
+  const page = await getPrimaryPage(instance.browser);
+  const locator = getLocator(page, selector, selectorType);
+  await locator.waitFor({ state, timeout });
+
+  return { Message: 'OK' };
+}
+
+async function runList() {
+  const list = [];
+  for (const [id, instance] of browsers) {
+    let currentUrl = '';
+    let currentTitle = '';
+    let connected = false;
+    try {
+      connected = instance.browser.isConnected();
+      if (connected) {
+        const page = await getPrimaryPage(instance.browser);
+        currentUrl = page.url();
+        currentTitle = await page.title();
+      }
+    } catch {
+      connected = false;
+    }
+
+    list.push({
+      Id: id,
+      Type: instance.type,
+      Version: instance.browser.version(),
+      CurrentUrl: currentUrl,
+      CurrentTitle: currentTitle,
+      IsConnected: connected
+    });
+  }
+  return { Browsers: list };
+}
+
+async function runClose(args) {
+  const browserId = parseArg(args, '--browser-id');
+  if (!browserId) throw new Error('Missing --browser-id');
+
+  const instance = browsers.get(browserId);
+  if (!instance) {
+    return { Message: 'OK' };
+  }
+
+  try {
+    await instance.browser.close();
+  } catch {}
+  browsers.delete(browserId);
+  return { Message: 'OK' };
+}
+
+function getLocator(page, selector, selectorType) {
+  switch ((selectorType || 'css').toLowerCase()) {
+    case 'xpath':
+      return page.locator(`xpath=${selector}`);
+    case 'text':
+      return page.getByText(selector);
+    case 'id':
+      return page.locator(`#${selector}`);
+    default:
+      return page.locator(selector);
+  }
+}
+
+async function executeCommand(command, args) {
+  switch (command) {
+    case 'ping':
+      return { Message: 'pong' };
+    case 'launch':
+      return runLaunch(args);
+    case 'list':
+      return runList();
+    case 'navigate':
+      return runNavigate(args);
+    case 'click':
+      return runClick(args);
+    case 'fill':
+      return runFill(args);
+    case 'find':
+      return runFind(args);
+    case 'get-text':
+      return runGetText(args);
+    case 'screenshot':
+      return runScreenshot(args);
+    case 'evaluate':
+      return runEvaluate(args);
+    case 'wait-for':
+      return runWaitFor(args);
+    case 'close':
+      return runClose(args);
+    default:
+      throw new Error(`Unknown command: ${command}`);
+  }
+}
+
+async function runDaemon() {
+  const server = net.createServer((socket) => {
+    let buffer = '';
+    socket.on('data', async (chunk) => {
+      buffer += chunk.toString();
+      const lineEnd = buffer.indexOf('\n');
+      if (lineEnd === -1) return;
+
+      const line = buffer.slice(0, lineEnd).trim();
+      buffer = '';
+      const req = safeJsonParse(line);
+      if (!req || !req.command) {
+        writeJsonLine(socket, { ok: false, error: 'Invalid request' });
+        return;
+      }
+
+      try {
+        const data = await executeCommand(req.command, req.args || []);
+        writeJsonLine(socket, { ok: true, data });
+      } catch (err) {
+        writeJsonLine(socket, { ok: false, error: err.message || String(err) });
+      }
+    });
+  });
+
+  server.listen(0, '127.0.0.1', () => {
+    const port = server.address().port;
+    fs.writeFileSync(DAEMON_FILE, JSON.stringify({ pid: process.pid, port }));
+  });
+
+  const shutdown = async () => {
+    for (const instance of browsers.values()) {
+      try {
+        await instance.browser.close();
+      } catch {}
+    }
+    try {
+      fs.unlinkSync(DAEMON_FILE);
+    } catch {}
+    process.exit(0);
+  };
+
+  process.on('SIGINT', shutdown);
+  process.on('SIGTERM', shutdown);
+}
+
+async function runClient(command, args) {
+  const daemon = await ensureDaemon();
+  const result = await sendRequest(daemon.port, { command, args });
+  if (!result.ok) {
+    throw new Error(result.error || 'Bridge command failed');
+  }
+
+  const data = result.data;
+  if (data === undefined || data === null) {
+    return;
+  }
+  if (typeof data === 'string') {
+    console.log(data);
+    return;
+  }
+  console.log(JSON.stringify(data));
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+  const command = args[0];
+
+  if (!command) {
+    console.error('ERROR: Missing command');
+    process.exit(1);
+  }
+
+  if (command === 'daemon') {
+    await runDaemon();
+    return;
+  }
+
+  if (command === '--version' || command === '-v') {
+    console.log('EasyTouch Playwright Bridge v2.0.0');
+    return;
+  }
+
+  try {
+    await runClient(command, args.slice(1));
+  } catch (err) {
+    console.error(`ERROR: ${err.message || String(err)}`);
+    process.exit(1);
+  }
+}
+
+main();