@rvaim/deveco-mobile-mcp 0.1.0-rvaim.1

package/lib/harmony.js

@@ -0,0 +1,805 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HarmonyDeviceManager = exports.HarmonyRobot = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = require("node:fs");
+const robot_1 = require("./robot");
+const utils_1 = require("./utils");
+const getHdcPath = () => {
+    const exeName = process.platform === "win32" ? "hdc.exe" : "hdc";
+    if (process.env.DEVECO_PATH) {
+        const sdkPath = node_path_1.default.join(process.env.DEVECO_PATH, "sdk", "default", "openharmony", "toolchains", exeName);
+        if ((0, node_fs_1.existsSync)(sdkPath)) {
+            return sdkPath;
+        }
+    }
+    return exeName;
+};
+// HarmonyOS uiInput keyEvent 支持的按键映射
+// 参考：hdc shell uitest uiInput --help
+// 支持的符号名称：Back, Home, Power
+// 其他按键需要使用数字键码值（KeyEvent 键值）
+const BUTTON_MAP = {
+    "BACK": "Back", // 返回键
+    "HOME": "Home", // 主页键
+    "VOLUME_UP": "24", // 音量加键码
+    "VOLUME_DOWN": "25", // 音量减键码
+    "ENTER": "2054", // 回车键码
+    "DEL": "2055", // 删除键码
+    "DPAD_CENTER": "23", // 方向键中心确认
+    "DPAD_UP": "19", // 方向键上
+    "DPAD_DOWN": "20", // 方向键下
+    "DPAD_LEFT": "21", // 方向键左
+    "DPAD_RIGHT": "22", // 方向键右
+};
+const TIMEOUT = 30000;
+const MAX_BUFFER_SIZE = 1024 * 1024 * 8;
+class HarmonyRobot {
+    deviceId;
+    constructor(deviceId) {
+        this.deviceId = deviceId;
+    }
+    hdc(...args) {
+        return (0, node_child_process_1.execFileSync)(getHdcPath(), ["-t", this.deviceId, ...args], {
+            maxBuffer: MAX_BUFFER_SIZE,
+            timeout: TIMEOUT,
+        });
+    }
+    /**
+     * 异步执行 hdc 命令，使用流式读取避免 ENOBUFS 错误
+     */
+    async hdcAsync(...args) {
+        return new Promise((resolve, reject) => {
+            const child = (0, node_child_process_1.spawn)(getHdcPath(), ["-t", this.deviceId, ...args], {
+                stdio: ["ignore", "pipe", "pipe"],
+            });
+            let stdout = "";
+            let stderr = "";
+            let settled = false;
+            const timeoutId = setTimeout(() => {
+                if (!settled) {
+                    settled = true;
+                    child.kill();
+                    reject(new Error(`Command timeout after ${TIMEOUT}ms`));
+                }
+            }, TIMEOUT);
+            child.stdout?.on("data", (chunk) => {
+                stdout += chunk.toString();
+            });
+            child.stderr?.on("data", (chunk) => {
+                stderr += chunk.toString();
+            });
+            child.on("close", code => {
+                if (!settled) {
+                    clearTimeout(timeoutId);
+                    settled = true;
+                    if (code === 0) {
+                        resolve(stdout);
+                    }
+                    else {
+                        reject(new Error(stderr || `Command exited with code ${code}`));
+                    }
+                }
+            });
+            child.on("error", err => {
+                if (!settled) {
+                    clearTimeout(timeoutId);
+                    settled = true;
+                    reject(err);
+                }
+            });
+        });
+    }
+    /**
+     * 获取屏幕尺寸
+     * 使用 hidumper 命令获取 WindowManagerService 的窗口信息，遍历所有窗口找到最大尺寸作为屏幕分辨率
+     */
+    async getScreenSize() {
+        try {
+            const output = this.hdc("shell", "hidumper", "-s", "WindowManagerService", "-a", "-a").toString();
+            // 解析窗口信息，遍历所有窗口找到最大的 w × h 作为屏幕分辨率
+            // 格式：WindowName ... [ x    y    w    h    ]
+            const lines = output.split("\n");
+            let maxWidth = 0;
+            let maxHeight = 0;
+            for (const line of lines) {
+                // 跳过表头和非窗口行
+                if (!line.includes("[")) {
+                    continue;
+                }
+                const rectMatch = line.match(/\[\s*(\d+)\s+(\d+)\s+(\d+)\s+(\d+)\s*\]/);
+                if (!rectMatch) {
+                    continue;
+                }
+                const width = parseInt(rectMatch[3], 10);
+                const height = parseInt(rectMatch[4], 10);
+                // 记录最大的窗口尺寸
+                if (width > maxWidth) {
+                    maxWidth = width;
+                }
+                if (height > maxHeight) {
+                    maxHeight = height;
+                }
+            }
+            // 返回找到的最大尺寸作为屏幕分辨率
+            if (maxWidth > 0 && maxHeight > 0) {
+                return { width: maxWidth, height: maxHeight, scale: 1 };
+            }
+        }
+        catch (error) { }
+        throw new robot_1.ActionableError("Failed to get screen size");
+    }
+    async listApps() {
+        try {
+            const output = this.hdc("shell", "bm", "dump", "-a").toString();
+            const lines = output.split("\n");
+            const apps = [];
+            const seenPackages = new Set();
+            for (const line of lines) {
+                // 匹配以 tab 开头的包名行（格式：\tcom.xxx.xxx）
+                const bundleMatch = line.match(/^\t([a-zA-Z0-9_.]+)/);
+                if (bundleMatch) {
+                    const bundleName = bundleMatch[1];
+                    if (seenPackages.has(bundleName)) {
+                        continue;
+                    }
+                    seenPackages.add(bundleName);
+                    apps.push({ packageName: bundleName, appName: bundleName });
+                }
+            }
+            return apps;
+        }
+        catch (error) {
+            throw new robot_1.ActionableError("Failed to list installed apps");
+        }
+    }
+    /**
+     * 启动应用
+     * @param packageName 应用包名
+     * @param locale 语言环境（可选，当前版本暂未使用，保留参数兼容性）
+     *
+     * 使用 bm dump 获取应用的 mainAbility 信息，然后使用 aa start 启动应用
+     */
+    async launchApp(packageName, locale) {
+        (0, utils_1.validatePackageName)(packageName);
+        if (locale) {
+            (0, utils_1.validateLocale)(locale);
+        }
+        try {
+            // 使用 bm dump 获取应用的 mainAbility
+            const bundleOutput = this.hdc("shell", "bm", "dump", "-n", packageName).toString();
+            const abilityMatch = bundleOutput.match(/"mainAbility"\s*:\s*"([^"]+)"/);
+            if (!abilityMatch) {
+                throw new robot_1.ActionableError(`Failed to find mainAbility for package "${packageName}"`);
+            }
+            const abilityName = abilityMatch[1];
+            // 使用 aa start 启动应用
+            this.hdc("shell", "aa", "start", "-a", abilityName, "-b", packageName);
+        }
+        catch (error) {
+            throw new robot_1.ActionableError(`Failed launching app: ${error.message}`);
+        }
+    }
+    async terminateApp(packageName) {
+        (0, utils_1.validatePackageName)(packageName);
+        try {
+            this.hdc("shell", "aa", "force-stop", packageName);
+        }
+        catch (error) { }
+    }
+    async installApp(filePath) {
+        try {
+            this.hdc("install", "-r", filePath);
+        }
+        catch (error) {
+            const stdout = error.stdout ? error.stdout.toString() : "";
+            const stderr = error.stderr ? error.stderr.toString() : "";
+            const output = (stdout + stderr).trim();
+            throw new robot_1.ActionableError(output || error.message);
+        }
+    }
+    async uninstallApp(bundleId) {
+        try {
+            this.hdc("uninstall", bundleId);
+        }
+        catch (error) {
+            const stdout = error.stdout ? error.stdout.toString() : "";
+            const stderr = error.stderr ? error.stderr.toString() : "";
+            const output = (stdout + stderr).trim();
+            throw new robot_1.ActionableError(output || error.message);
+        }
+    }
+    async openUrl(url) {
+        // 使用引号包裹参数，确保特殊字符和URL参数正确传递
+        const quotedUrl = `'${url}'`;
+        const shellCmd = `aa start -U ${quotedUrl} -A 'ohos.want.action.viewData' -e 'entity.system.browsable'`;
+        // 对于支付宝链接，先尝试显式启动支付宝应用
+        if (url.startsWith("alipays://")) {
+            try {
+                this.hdc("shell", `aa start -a EntryAbility -b com.alipay.mobile.client -U ${quotedUrl}`);
+                return;
+            }
+            catch (error) {
+                // 如果失败，尝试隐式启动
+            }
+        }
+        // 使用隐式启动
+        try {
+            this.hdc("shell", shellCmd);
+        }
+        catch (error) {
+            // 如果失败，尝试不使用 -A -e 参数
+            try {
+                this.hdc("shell", `aa start -U ${quotedUrl}`);
+            }
+            catch (fallbackError) {
+                throw new robot_1.ActionableError(`Failed to open URL: ${url}`);
+            }
+        }
+    }
+    /**
+     * 发送文字输入
+     * @param text 要输入的文字
+     * @param x 输入框的 x 坐标（可选，默认屏幕中心）
+     * @param y 输入框的 y 坐标（可选，默认屏幕中心）
+     *
+     * 注意：鸿蒙的 uitest uiInput inputText 需要指定输入框的坐标位置
+     * 建议先点击输入框获取焦点，然后传入输入框坐标调用此方法
+     */
+    async sendKeys(text, x, y) {
+        if (text === "") {
+            return;
+        }
+        try {
+            // 如果没有传入坐标，使用屏幕中心
+            let inputX = x;
+            let inputY = y;
+            if (inputX === undefined || inputY === undefined) {
+                const screenSize = await this.getScreenSize();
+                inputX = inputX ?? Math.floor(screenSize.width / 2);
+                inputY = inputY ?? Math.floor(screenSize.height / 2);
+            }
+            const cmd = ["shell", "uitest", "uiInput", "inputText", `${inputX}`, `${inputY}`, text];
+            this.hdc(...cmd);
+        }
+        catch (error) {
+            throw new robot_1.ActionableError(`Failed to send keys: ${text}`);
+        }
+    }
+    async pressButton(button) {
+        if (!BUTTON_MAP[button]) {
+            throw new robot_1.ActionableError(`Button "${button}" is not supported on HarmonyOS`);
+        }
+        try {
+            const mapped = BUTTON_MAP[button];
+            this.hdc("shell", "uitest", "uiInput", "keyEvent", mapped);
+        }
+        catch (error) {
+            throw new robot_1.ActionableError(`Failed to press button: ${button}`);
+        }
+    }
+    async tap(x, y) {
+        try {
+            this.hdc("shell", "uitest", "uiInput", "click", `${x}`, `${y}`);
+        }
+        catch (error) {
+            throw new robot_1.ActionableError(`Failed to tap at coordinates: ${x}, ${y}`);
+        }
+    }
+    async doubleTap(x, y) {
+        try {
+            await this.tap(x, y);
+            await new Promise(resolve => setTimeout(resolve, 100));
+            await this.tap(x, y);
+        }
+        catch (error) {
+            throw new robot_1.ActionableError(`Failed to double-tap at coordinates: ${x}, ${y}`);
+        }
+    }
+    async longPress(x, y, duration) {
+        try {
+            this.hdc("shell", "uitest", "uiInput", "longClick", `${x}`, `${y}`);
+            await new Promise(resolve => setTimeout(resolve, duration));
+        }
+        catch (error) {
+            throw new robot_1.ActionableError(`Failed to long-press at coordinates: ${x}, ${y}`);
+        }
+    }
+    async swipe(direction) {
+        // 使用基于坐标的 swipe 命令，从屏幕中心滑动
+        // velocity: 滑动速度 (px/s)，范围 200-40000，默认 600
+        try {
+            const screenSize = await this.getScreenSize();
+            const centerX = Math.floor(screenSize.width / 2);
+            const centerY = Math.floor(screenSize.height / 2);
+            const distance = Math.floor(Math.min(screenSize.width, screenSize.height) * 0.4); // 滑动距离为屏幕短边的 40%
+            let fromX, fromY, toX, toY;
+            switch (direction) {
+                case "left":
+                    fromX = centerX + Math.floor(distance / 2);
+                    fromY = centerY;
+                    toX = centerX - Math.floor(distance / 2);
+                    toY = centerY;
+                    break;
+                case "right":
+                    fromX = centerX - Math.floor(distance / 2);
+                    fromY = centerY;
+                    toX = centerX + Math.floor(distance / 2);
+                    toY = centerY;
+                    break;
+                case "up":
+                    fromX = centerX;
+                    fromY = centerY + Math.floor(distance / 2);
+                    toX = centerX;
+                    toY = centerY - Math.floor(distance / 2);
+                    break;
+                case "down":
+                    fromX = centerX;
+                    fromY = centerY - Math.floor(distance / 2);
+                    toX = centerX;
+                    toY = centerY + Math.floor(distance / 2);
+                    break;
+                default:
+                    throw new robot_1.ActionableError(`Swipe direction "${direction}" is not supported`);
+            }
+            // 使用 swipe 命令：swipe <fromX> <fromY> <toX> <toY> [velocity]
+            this.hdc("shell", "uitest", "uiInput", "swipe", `${fromX}`, `${fromY}`, `${toX}`, `${toY}`, "600");
+        }
+        catch (error) {
+            throw new robot_1.ActionableError(`Failed to swipe ${direction}`);
+        }
+    }
+    async swipeFromCoordinate(x, y, direction, distance) {
+        // 使用基于坐标的 swipe 命令，从指定位置开始滑动
+        // velocity: 滑动速度 (px/s)，范围 200-40000，默认 600
+        const swipeDistance = distance || 300;
+        let toX, toY;
+        switch (direction) {
+            case "left":
+                toX = x - swipeDistance;
+                toY = y;
+                break;
+            case "right":
+                toX = x + swipeDistance;
+                toY = y;
+                break;
+            case "up":
+                toX = x;
+                toY = y - swipeDistance;
+                break;
+            case "down":
+                toX = x;
+                toY = y + swipeDistance;
+                break;
+            default:
+                throw new robot_1.ActionableError(`Swipe direction "${direction}" is not supported`);
+        }
+        try {
+            // 使用 swipe 命令：swipe <fromX> <fromY> <toX> <toY> [velocity]
+            this.hdc("shell", "uitest", "uiInput", "swipe", `${x}`, `${y}`, `${toX}`, `${toY}`, "600");
+        }
+        catch (error) {
+            throw new robot_1.ActionableError(`Failed to swipe ${direction} from coordinates: ${x}, ${y}`);
+        }
+    }
+    /**
+     * 获取屏幕截图
+     *
+     * 注意：由于鸿蒙系统的隐私保护机制，部分应用（如银行类、支付类、安全类应用）
+     * 的界面可能无法被截图，会显示为黑屏。
+     * 如果遇到截图黑屏的情况，建议使用 getElementsOnScreen() 接口获取页面元素信息作为替代方案。
+     *
+     * @returns 截图的 Buffer 数据
+     */
+    async getScreenshot() {
+        try {
+            const timestamp = Date.now();
+            const devicePath = `/data/local/tmp/screenshot_${timestamp}.jpeg`;
+            this.hdc("shell", "snapshot_display", "-f", devicePath);
+            // Use temp file instead of stdout since hdc file recv doesn't support "-"
+            const localPath = node_path_1.default.join(node_os_1.default.tmpdir(), `screenshot_${timestamp}.jpeg`);
+            this.hdc("file", "recv", devicePath, localPath);
+            const buffer = (0, node_fs_1.readFileSync)(localPath);
+            (0, node_fs_1.unlinkSync)(localPath);
+            return buffer;
+        }
+        catch (error) {
+            throw new robot_1.ActionableError("Failed to get screenshot");
+        }
+    }
+    /**
+     * 获取屏幕上可见的元素信息
+     *
+     * 此接口通过 hidumper 获取当前窗口的 UI 元素树，可以用于：
+     * 1. 替代截图：当应用因隐私保护无法截图时，可使用此接口获取页面元素信息
+     * 2. 元素定位：获取元素的层级结构和属性，用于自动化测试
+     *
+     * @returns 元素 dump 文件的路径
+     */
+    async getElementsOnScreen() {
+        try {
+            // Step 1: Get the highlighted window ID using hidumper (async)
+            const windowListOutput = await this.hdcAsync("shell", "hidumper", "-s", "WindowManagerService", "-a", "-a");
+            const windowIdMatch = windowListOutput.match(/Highlighted\s+windows:\s*(\d+)/);
+            if (!windowIdMatch) {
+                throw new robot_1.ActionableError("Failed to find highlighted window ID");
+            }
+            const windowId = windowIdMatch[1];
+            // Step 2: Set test mode for inspector
+            await this.hdcAsync("shell", "param", "set", "persist.ace.testmode.enabled", "1");
+            // Step 3: Get element dump using hidumper with -w windowId -inspector (async)
+            const elementOutput = await this.hdcAsync("shell", "hidumper", "-s", "WindowManagerService", "-a", `-w ${windowId} -inspector`);
+            // Step 4: Save raw dump to file and return file path
+            const timestamp = new Date().toISOString().replace(/[-:T]/g, "").replace(/\..+/, "").replace("Z", "");
+            const fileName = `harmony_elements_${timestamp}.txt`;
+            const filePath = node_path_1.default.join(node_os_1.default.tmpdir(), fileName);
+            (0, node_fs_1.writeFileSync)(filePath, elementOutput, "utf-8");
+            return filePath;
+        }
+        catch (error) {
+            throw new robot_1.ActionableError(`Failed to get elements on screen: ${error.message}`);
+        }
+    }
+    async setOrientation(orientation) {
+        try {
+            const value = orientation === "portrait" ? 0 : 1;
+            this.hdc("shell", "settings", "put", "system", "user_rotation", `${value}`);
+        }
+        catch (error) {
+            throw new robot_1.ActionableError(`Failed to set orientation to ${orientation}`);
+        }
+    }
+    async getOrientation() {
+        try {
+            const output = this.hdc("shell", "settings", "get", "system", "user_rotation").toString().trim();
+            return output === "0" ? "portrait" : "landscape";
+        }
+        catch (error) {
+            throw new robot_1.ActionableError("Failed to get orientation");
+        }
+    }
+    /**
+         * 获取应用进程 ID
+         * 通过 `aa dump -a` 命令查找应用进程
+         * @param bundleName - 应用包名
+         * @returns 进程 ID，如果未找到返回 null
+         */
+    async getAppPid(bundleName) {
+        try {
+            const output = await this.hdcAsync("shell", "aa", "dump", "-a");
+            // 解析输出查找应用进程
+            // 格式示例：
+            // AppRunningRecord ID #9
+            //   process name [com.example.myapplication]
+            //   pid #3820  uid #20020059
+            const lines = output.split("\n");
+            let currentBundleName = "";
+            for (const line of lines) {
+                const processMatch = line.match(/process name \[(.+)\]/);
+                if (processMatch) {
+                    currentBundleName = processMatch[1];
+                }
+                if (currentBundleName === bundleName) {
+                    const pidMatch = line.match(/pid #(\d+)/);
+                    if (pidMatch) {
+                        return parseInt(pidMatch[1], 10);
+                    }
+                }
+            }
+            return null;
+        }
+        catch (error) {
+            return null;
+        }
+    }
+    /**
+         * 获取设备日志 (hilog)
+         * 参考: hdc shell hilog -P {pid} 查看应用日志
+         * @param options - 可选的过滤选项
+         * @param options.bundleName - 按应用包名过滤（自动获取进程ID）
+         * @param options.pid - 按进程 ID 过滤
+         * @param options.level - 最低日志级别 (D/I/W/E/F)
+         * @param options.lines - 获取最近 N 行日志 (默认: 200)
+         * @param options.clear - 获取前清除日志缓冲区
+         */
+    async getDeviceLogs(options) {
+        try {
+            // 如果需要清除日志
+            if (options?.clear) {
+                await this.hdcAsync("shell", "hilog", "-r");
+            }
+            // 构建 hilog 命令参数
+            const args = ["shell", "hilog", "-x"]; // -x 表示非阻塞模式
+            // 添加行数限制
+            const lines = options?.lines || 200;
+            args.push("-n", lines.toString());
+            // 添加日志级别过滤
+            if (options?.level) {
+                args.push("-L", options.level.toUpperCase());
+            }
+            // 添加进程 ID 过滤（优先使用 bundleName 自动获取 pid）
+            let pid = options?.pid;
+            if (!pid && options?.bundleName) {
+                const appPid = await this.getAppPid(options.bundleName);
+                if (appPid !== null) {
+                    pid = appPid;
+                }
+            }
+            if (pid) {
+                args.push("-P", pid.toString());
+            }
+            const output = await this.hdcAsync(...args);
+            return output;
+        }
+        catch (error) {
+            throw new robot_1.ActionableError(`Failed to get device logs: ${error.message}`);
+        }
+    }
+}
+exports.HarmonyRobot = HarmonyRobot;
+/**
+ * HarmonyOS 设备管理器
+ *
+ * 启动模拟器步骤：
+ * 1. emulator -list -details  获取模拟器详情（JSON）
+ * 2. emulator -hvd <name> -path <parentDir> -imageRoot <sdkPath>  启动模拟器
+ *
+ * 关键字段（从 -list -details 获取）：
+ * - instancePath: 模拟器实例路径，-path 参数取其父目录
+ * - imageRoot: SDK 路径
+ * - name: 模拟器名称
+ */
+class HarmonyDeviceManager {
+    getEmulatorExecPath() {
+        const exeName = process.platform === "win32" ? "emulator.exe" : "emulator";
+        // 1. Try to find emulator in PATH using "which" command
+        try {
+            const whichCmd = process.platform === "win32" ? "where" : "which";
+            const result = (0, node_child_process_1.execFileSync)(whichCmd, [exeName], {
+                encoding: "utf-8",
+                timeout: 5000,
+            }).toString().trim();
+            if (result && (0, node_fs_1.existsSync)(result)) {
+                return result;
+            }
+        }
+        catch {
+            // which command failed, continue to other methods
+        }
+        // 2. Check PATH environment variable directly
+        if (process.env.PATH) {
+            const pathDirs = process.env.PATH.split(process.platform === "win32" ? ";" : ":");
+            for (const dir of pathDirs) {
+                const emulatorPath = node_path_1.default.join(dir, exeName);
+                if ((0, node_fs_1.existsSync)(emulatorPath)) {
+                    return emulatorPath;
+                }
+            }
+        }
+        // 3. Check common DevEco Studio installation paths
+        const commonStudioPaths = [
+            "/Applications/DevEco-Studio.app/Contents",
+            "/Applications/DevEco Studio.app/Contents",
+            process.env.DEVECO_PATH,
+            process.env.DEVECO_HOME,
+            process.env.HOS_SDK_HOME,
+        ].filter(Boolean);
+        for (const studioPath of commonStudioPaths) {
+            // Try tools/emulator path first (primary location)
+            const toolsEmulatorPath = node_path_1.default.join(studioPath, "tools", "emulator", exeName);
+            if ((0, node_fs_1.existsSync)(toolsEmulatorPath)) {
+                return toolsEmulatorPath;
+            }
+            // Fallback to sdk/emulator path
+            const sdkEmulatorPath = node_path_1.default.join(studioPath, "sdk", "emulator", exeName);
+            if ((0, node_fs_1.existsSync)(sdkEmulatorPath)) {
+                return sdkEmulatorPath;
+            }
+        }
+        // 4. Check additional SDK paths
+        const additionalSdkPaths = [
+            process.env.HOS_SDK_HOME,
+            process.env.HARMONYOS_SDK_HOME,
+            "~/Library/Huawei/Sdk",
+            "/opt/harmonyos/sdk",
+            "/usr/local/harmonyos/sdk",
+        ].filter(Boolean);
+        for (const sdkPath of additionalSdkPaths) {
+            const expandedPath = sdkPath.startsWith("~")
+                ? node_path_1.default.join(node_os_1.default.homedir(), sdkPath.slice(1))
+                : sdkPath;
+            const toolsEmulatorPath = node_path_1.default.join(expandedPath, "tools", "emulator", exeName);
+            if ((0, node_fs_1.existsSync)(toolsEmulatorPath)) {
+                return toolsEmulatorPath;
+            }
+            const sdkEmulatorPath = node_path_1.default.join(expandedPath, "emulator", exeName);
+            if ((0, node_fs_1.existsSync)(sdkEmulatorPath)) {
+                return sdkEmulatorPath;
+            }
+        }
+        return null;
+    }
+    getConnectedDeviceIds() {
+        try {
+            const output = (0, node_child_process_1.execFileSync)(getHdcPath(), ["list", "targets"], {
+                maxBuffer: MAX_BUFFER_SIZE,
+                timeout: TIMEOUT,
+            }).toString();
+            return output
+                .split("\n")
+                .map(line => line.trim())
+                .filter(line => line !== "" && line !== "[Empty]")
+                .map(line => line.split(/\s+/)[0])
+                .filter(Boolean);
+        }
+        catch (error) {
+            return [];
+        }
+    }
+    isEmulatorDevice(deviceId) {
+        return /^\d+\.\d+\.\d+\.\d+:\d+$/.test(deviceId);
+    }
+    getDeviceName(deviceId) {
+        try {
+            if (this.isEmulatorDevice(deviceId)) {
+                const output = (0, node_child_process_1.execFileSync)(getHdcPath(), ["-t", deviceId, "shell", "param", "get", "ohos.qemu.hvd.name"], {
+                    maxBuffer: MAX_BUFFER_SIZE,
+                    timeout: TIMEOUT,
+                }).toString().trim();
+                return output || deviceId;
+            }
+            else {
+                const output = (0, node_child_process_1.execFileSync)(getHdcPath(), ["-t", deviceId, "shell", "param", "get", "const.product.name"], {
+                    maxBuffer: MAX_BUFFER_SIZE,
+                    timeout: TIMEOUT,
+                }).toString().trim();
+                return output || deviceId;
+            }
+        }
+        catch (error) {
+            return deviceId;
+        }
+    }
+    getDeviceVersion(deviceId) {
+        try {
+            const output = (0, node_child_process_1.execFileSync)(getHdcPath(), ["-t", deviceId, "shell", "getprop", "hw_sc.build.platform.version"], {
+                maxBuffer: MAX_BUFFER_SIZE,
+                timeout: TIMEOUT,
+            }).toString().trim();
+            return output || "unknown";
+        }
+        catch (error) {
+            return "unknown";
+        }
+    }
+    listInstalledEmulators() {
+        const emulatorPath = this.getEmulatorExecPath();
+        if (!emulatorPath) {
+            return [];
+        }
+        try {
+            const output = (0, node_child_process_1.execFileSync)(emulatorPath, ["-list"], {
+                maxBuffer: MAX_BUFFER_SIZE,
+                timeout: TIMEOUT,
+            }).toString();
+            return output
+                .split("\n")
+                .map(line => line.trim())
+                .filter(line => line !== "");
+        }
+        catch (error) {
+            return [];
+        }
+    }
+    getEmulatorDetails(emulatorName) {
+        const emulatorPath = this.getEmulatorExecPath();
+        if (!emulatorPath) {
+            return null;
+        }
+        try {
+            const output = (0, node_child_process_1.execFileSync)(emulatorPath, ["-list", "-details"], {
+                maxBuffer: MAX_BUFFER_SIZE,
+                timeout: TIMEOUT,
+            }).toString();
+            const details = JSON.parse(output);
+            return details.find(emu => emu.name === emulatorName) || null;
+        }
+        catch (error) {
+            return null;
+        }
+    }
+    getConnectedDevices() {
+        const connectedIds = this.getConnectedDeviceIds();
+        const devices = [];
+        for (const deviceId of connectedIds) {
+            const isEmulator = this.isEmulatorDevice(deviceId);
+            devices.push({
+                deviceId,
+                deviceType: isEmulator ? "emulator" : "real",
+                name: this.getDeviceName(deviceId),
+                version: this.getDeviceVersion(deviceId),
+            });
+        }
+        return devices;
+    }
+    getAllAvailableDevices() {
+        const devices = this.getConnectedDevices();
+        const installedEmulators = this.listInstalledEmulators();
+        for (const emulatorName of installedEmulators) {
+            if (!devices.some(d => d.name === emulatorName)) {
+                devices.push({
+                    deviceId: "",
+                    deviceType: "emulator",
+                    name: emulatorName,
+                    version: "unknown",
+                });
+            }
+        }
+        return devices;
+    }
+    async startEmulator(emulatorName) {
+        const emulatorPath = this.getEmulatorExecPath();
+        if (!emulatorPath) {
+            throw new robot_1.ActionableError("Emulator executable not found");
+        }
+        // Get emulator details from -list -details (most reliable source)
+        const details = this.getEmulatorDetails(emulatorName);
+        if (!details) {
+            throw new robot_1.ActionableError(`Emulator "${emulatorName}" not found`);
+        }
+        // Build command arguments
+        // IMPORTANT: -path should be the parent directory of instancePath
+        // -imageRoot is already the Sdk directory from -list -details
+        const args = [
+            "-hvd", emulatorName,
+            "-path", node_path_1.default.dirname(details.instancePath),
+            "-imageRoot", details.imageRoot,
+        ];
+        const child = (0, node_child_process_1.spawn)(emulatorPath, args, {
+            stdio: ["ignore", "pipe", "pipe"],
+            detached: true,
+        });
+        let stdoutData = "";
+        let stderrData = "";
+        let processExited = false;
+        let exitCode = null;
+        child.stdout?.on("data", data => {
+            stdoutData += data.toString();
+        });
+        child.stderr?.on("data", data => {
+            stderrData += data.toString();
+        });
+        child.on("exit", code => {
+            processExited = true;
+            exitCode = code;
+        });
+        // Wait for emulator to appear in connected devices (up to 60 seconds)
+        for (let i = 0; i < 30; i++) {
+            await new Promise(resolve => setTimeout(resolve, 2000));
+            // Check if process exited prematurely
+            if (processExited) {
+                const outputStr = stdoutData + stderrData;
+                if (outputStr.includes("already exists") || outputStr.includes("already running")) {
+                    continue;
+                }
+                throw new robot_1.ActionableError(`Emulator exited with code ${exitCode}. Output: ${outputStr}`);
+            }
+            const connectedIds = this.getConnectedDeviceIds();
+            for (const deviceId of connectedIds) {
+                if (this.isEmulatorDevice(deviceId)) {
+                    const name = this.getDeviceName(deviceId);
+                    if (name === emulatorName) {
+                        return deviceId;
+                    }
+                }
+            }
+        }
+        return null;
+    }
+}
+exports.HarmonyDeviceManager = HarmonyDeviceManager;