@midscene/harmony 1.4.7-beta-20260226072540.0

package/dist/es/index.mjs

@@ -0,0 +1,821 @@
+import * as __rspack_external_node_fs_5ea92f0c from "node:fs";
+import node_assert from "node:assert";
+import { getMidsceneLocationSchema, z } from "@midscene/core";
+import { defineAction, defineActionClearInput, defineActionCursorMove, defineActionDoubleClick, defineActionDragAndDrop, defineActionKeyboardPress, defineActionScroll, defineActionSwipe, defineActionTap, normalizeMobileSwipeParam } from "@midscene/core/device";
+import { getTmpFile, sleep } from "@midscene/core/utils";
+import { createImgBase64ByFormat } from "@midscene/shared/img";
+import { getDebug } from "@midscene/shared/logger";
+import { mergeAndNormalizeAppNameMapping, normalizeForComparison, repeat } from "@midscene/shared/utils";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { Agent } from "@midscene/core/agent";
+import { overrideAIConfig } from "@midscene/shared/env";
+var __webpack_modules__ = {
+    "node:fs" (module) {
+        module.exports = __rspack_external_node_fs_5ea92f0c;
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+var external_node_fs_ = __webpack_require__("node:fs");
+function _define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+const execFileAsync = promisify(execFile);
+const debugHdc = getDebug('harmony:hdc');
+function resolveHdcPath(hdcPath) {
+    if (hdcPath) return hdcPath;
+    if (process.env.HDC_HOME) {
+        const envPath = `${process.env.HDC_HOME}/hdc`;
+        debugHdc(`Using HDC from HDC_HOME: ${envPath}`);
+        return envPath;
+    }
+    const homeDir = process.env.HOME || process.env.USERPROFILE || '';
+    const commonPaths = [
+        `${homeDir}/Library/HarmonyOS/next/command-line-tools/sdk/default/openharmony/toolchains/hdc`,
+        `${homeDir}/Library/HarmonyOS/sdk/hmscore/3.1.0/toolchains/hdc`
+    ];
+    for (const p of commonPaths)try {
+        __webpack_require__("node:fs").accessSync(p, __webpack_require__("node:fs").constants.X_OK);
+        debugHdc(`Found HDC at: ${p}`);
+        return p;
+    } catch  {}
+    return 'hdc';
+}
+class HdcClient {
+    buildArgs(args) {
+        if (this.deviceId) return [
+            '-t',
+            this.deviceId,
+            ...args
+        ];
+        return args;
+    }
+    async exec(...args) {
+        const fullArgs = this.buildArgs(args);
+        debugHdc(`hdc ${fullArgs.join(' ')}`);
+        try {
+            const { stdout, stderr } = await execFileAsync(this.hdcPath, fullArgs, {
+                timeout: this.timeout,
+                maxBuffer: 52428800
+            });
+            if (stderr?.trim()) debugHdc(`hdc stderr: ${stderr.trim()}`);
+            debugHdc(`hdc ${fullArgs.join(' ')} end`);
+            return stdout;
+        } catch (error) {
+            debugHdc(`hdc error: ${error.message}`);
+            throw new Error(`HDC command failed: hdc ${fullArgs.join(' ')}: ${error.message}`, {
+                cause: error
+            });
+        }
+    }
+    async shell(command) {
+        return this.exec('shell', command);
+    }
+    async fileSend(localPath, remotePath) {
+        await this.exec('file', 'send', localPath, remotePath);
+    }
+    async fileRecv(remotePath, localPath) {
+        await this.exec('file', 'recv', remotePath, localPath);
+    }
+    async screenshot(remotePath) {
+        await this.shell(`snapshot_display -f ${remotePath}`);
+    }
+    async click(x, y) {
+        await this.shell(`uitest uiInput click ${Math.round(x)} ${Math.round(y)}`);
+    }
+    async doubleClick(x, y) {
+        await this.shell(`uitest uiInput doubleClick ${Math.round(x)} ${Math.round(y)}`);
+    }
+    async longClick(x, y) {
+        await this.shell(`uitest uiInput longClick ${Math.round(x)} ${Math.round(y)}`);
+    }
+    async swipe(fromX, fromY, toX, toY, speed) {
+        const args = [
+            Math.round(fromX),
+            Math.round(fromY),
+            Math.round(toX),
+            Math.round(toY)
+        ];
+        if (void 0 !== speed) args.push(Math.round(speed));
+        await this.shell(`uitest uiInput swipe ${args.join(' ')}`);
+    }
+    async fling(fromX, fromY, toX, toY, speed) {
+        const args = [
+            Math.round(fromX),
+            Math.round(fromY),
+            Math.round(toX),
+            Math.round(toY)
+        ];
+        if (void 0 !== speed) args.push(Math.round(speed));
+        await this.shell(`uitest uiInput fling ${args.join(' ')}`);
+    }
+    async drag(fromX, fromY, toX, toY, speed) {
+        const args = [
+            Math.round(fromX),
+            Math.round(fromY),
+            Math.round(toX),
+            Math.round(toY)
+        ];
+        if (void 0 !== speed) args.push(Math.round(speed));
+        await this.shell(`uitest uiInput drag ${args.join(' ')}`);
+    }
+    async inputText(x, y, text) {
+        const escapedText = text.replace(/'/g, "'\\''");
+        await this.shell(`uitest uiInput inputText ${Math.round(x)} ${Math.round(y)} '${escapedText}'`);
+    }
+    async keyEvent(...keys) {
+        await this.shell(`uitest uiInput keyEvent ${keys.join(' ')}`);
+    }
+    async startAbility(bundleName, abilityName) {
+        await this.shell(`aa start -a ${abilityName} -b ${bundleName}`);
+    }
+    async forceStop(bundleName) {
+        await this.shell(`aa force-stop ${bundleName}`);
+    }
+    async getScreenInfo() {
+        const stdout = await this.shell('hidumper -s RenderService -a screen');
+        const renderSizeMatch = stdout.match(/(\d{3,5})\s*x\s*(\d{3,5})/);
+        if (renderSizeMatch) return {
+            width: Number.parseInt(renderSizeMatch[1], 10),
+            height: Number.parseInt(renderSizeMatch[2], 10)
+        };
+        const displayStdout = await this.shell('hidumper -s DisplayManagerService -a -a');
+        const displayMatch = displayStdout.match(/activeModes.*?(\d{3,5}),\s*(\d{3,5})/);
+        if (displayMatch) return {
+            width: Number.parseInt(displayMatch[1], 10),
+            height: Number.parseInt(displayMatch[2], 10)
+        };
+        throw new Error(`Failed to get screen size from HDC. RenderService output: ${stdout}`);
+    }
+    async listTargets() {
+        const stdout = await this.exec('list', 'targets');
+        return stdout.trim().split('\n').map((line)=>line.trim()).filter((line)=>line.length > 0 && !line.startsWith('['));
+    }
+    constructor(options){
+        _define_property(this, "hdcPath", void 0);
+        _define_property(this, "deviceId", void 0);
+        _define_property(this, "timeout", void 0);
+        this.hdcPath = resolveHdcPath(options.hdcPath);
+        this.deviceId = options.deviceId || '';
+        this.timeout = options.timeout || 60000;
+    }
+}
+function device_define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+const defaultScrollUntilTimes = 10;
+const defaultSwipeSpeed = 600;
+const defaultFastSwipeSpeed = 2000;
+const debugDevice = getDebug('harmony:device');
+class HarmonyDevice {
+    actionSpace() {
+        const defaultActions = [
+            defineActionTap(async (param)=>{
+                const element = param.locate;
+                node_assert(element, 'Element not found, cannot tap');
+                await this.tap(element.center[0], element.center[1]);
+            }),
+            defineActionDoubleClick(async (param)=>{
+                const element = param.locate;
+                node_assert(element, 'Element not found, cannot double click');
+                await this.doubleTap(element.center[0], element.center[1]);
+            }),
+            defineAction({
+                name: 'Input',
+                description: 'Input text into the input field',
+                interfaceAlias: 'aiInput',
+                paramSchema: z.object({
+                    value: z.string().describe('The text to input. Provide the final content for replace/append modes, or an empty string when using clear mode to remove existing text.'),
+                    mode: z.preprocess((val)=>'append' === val ? 'typeOnly' : val, z["enum"]([
+                        'replace',
+                        'clear',
+                        'typeOnly'
+                    ]).default('replace').optional().describe('Input mode: "replace" (default) - clear the field and input the value; "typeOnly" - type the value directly without clearing the field first; "clear" - clear the field without inputting new text.')),
+                    locate: getMidsceneLocationSchema().describe('The input field to be filled').optional()
+                }),
+                call: async (param)=>{
+                    const element = param.locate;
+                    if ('clear' === param.mode) return void await this.clearInput(element);
+                    if (!param || !param.value) return;
+                    const shouldReplace = 'typeOnly' !== param.mode;
+                    await this.inputText(param.value, element, shouldReplace);
+                }
+            }),
+            defineActionScroll(async (param)=>{
+                const element = param.locate;
+                const startingPoint = element ? {
+                    left: element.center[0],
+                    top: element.center[1]
+                } : void 0;
+                const scrollToEventName = param?.scrollType;
+                if ('scrollToTop' === scrollToEventName) await this.scrollUntilTop(startingPoint);
+                else if ('scrollToBottom' === scrollToEventName) await this.scrollUntilBottom(startingPoint);
+                else if ('scrollToRight' === scrollToEventName) await this.scrollUntilRight(startingPoint);
+                else if ('scrollToLeft' === scrollToEventName) await this.scrollUntilLeft(startingPoint);
+                else if ('singleAction' !== scrollToEventName && scrollToEventName) throw new Error(`Unknown scroll event type: ${scrollToEventName}, param: ${JSON.stringify(param)}`);
+                else {
+                    if (param?.direction !== 'down' && param && param.direction) if ('up' === param.direction) await this.scrollUp(param.distance || void 0, startingPoint);
+                    else if ('left' === param.direction) await this.scrollLeft(param.distance || void 0, startingPoint);
+                    else if ('right' === param.direction) await this.scrollRight(param.distance || void 0, startingPoint);
+                    else throw new Error(`Unknown scroll direction: ${param.direction}`);
+                    else await this.scrollDown(param?.distance || void 0, startingPoint);
+                    await sleep(500);
+                }
+            }),
+            defineActionDragAndDrop(async (param)=>{
+                const from = param.from;
+                const to = param.to;
+                node_assert(from, 'missing "from" param for drag and drop');
+                node_assert(to, 'missing "to" param for drag and drop');
+                const hdc = await this.getHdc();
+                await hdc.drag(from.center[0], from.center[1], to.center[0], to.center[1]);
+            }),
+            defineActionSwipe(async (param)=>{
+                const { startPoint, endPoint, duration, repeatCount } = normalizeMobileSwipeParam(param, await this.size());
+                const hdc = await this.getHdc();
+                for(let i = 0; i < repeatCount; i++)await hdc.swipe(startPoint.x, startPoint.y, endPoint.x, endPoint.y, duration ? Math.round(duration) : void 0);
+            }),
+            defineActionKeyboardPress(async (param)=>{
+                await this.keyboardPress(param.keyName);
+            }),
+            defineActionCursorMove(async (param)=>{
+                const arrowKey = 'left' === param.direction ? 'ArrowLeft' : 'ArrowRight';
+                const times = param.times ?? 1;
+                for(let i = 0; i < times; i++){
+                    await this.keyboardPress(arrowKey);
+                    await sleep(100);
+                }
+            }),
+            defineAction({
+                name: 'LongPress',
+                description: 'Trigger a long press on the screen at specified element',
+                paramSchema: z.object({
+                    duration: z.number().optional().describe('The duration of the long press in milliseconds'),
+                    locate: getMidsceneLocationSchema().describe('The element to be long pressed')
+                }),
+                call: async (param)=>{
+                    const element = param.locate;
+                    if (!element) throw new Error('LongPress requires an element to be located');
+                    await this.longPress(element.center[0], element.center[1]);
+                }
+            }),
+            defineActionClearInput(async (param)=>{
+                await this.clearInput(param.locate);
+            })
+        ];
+        const platformSpecificActions = Object.values(createPlatformActions(this));
+        const customActions = this.customActions || [];
+        return [
+            ...defaultActions,
+            ...platformSpecificActions,
+            ...customActions
+        ];
+    }
+    describe() {
+        return this.descriptionText || `DeviceId: ${this.deviceId}`;
+    }
+    async connect() {
+        const hdc = await this.getHdc();
+        return hdc;
+    }
+    async getHdc() {
+        if (this.destroyed) throw new Error(`HarmonyDevice ${this.deviceId} has been destroyed and cannot execute HDC commands`);
+        if (this.hdc) return this.hdc;
+        if (this.connecting) return this.connecting;
+        this.connecting = (async ()=>{
+            let error = null;
+            debugDevice(`Initializing HDC with device ID: ${this.deviceId}`);
+            try {
+                this.hdc = new HdcClient({
+                    hdcPath: this.options?.hdcPath,
+                    deviceId: this.deviceId
+                });
+                const screenInfo = await this.hdc.getScreenInfo();
+                this.cachedScreenSize = screenInfo;
+                this.descriptionText = `DeviceId: ${this.deviceId}\nScreenSize: ${screenInfo.width}x${screenInfo.height}`;
+                debugDevice('HDC initialized successfully', this.descriptionText);
+                return this.hdc;
+            } catch (e) {
+                debugDevice(`Failed to initialize HDC: ${e}`);
+                error = new Error(`Unable to connect to device ${this.deviceId}: ${e}`);
+            } finally{
+                this.connecting = null;
+            }
+            if (error) throw error;
+            throw new Error('HDC initialization failed unexpectedly');
+        })();
+        return this.connecting;
+    }
+    setAppNameMapping(mapping) {
+        this.appNameMapping = mapping;
+    }
+    resolvePackageName(appName) {
+        const normalizedAppName = normalizeForComparison(appName);
+        return this.appNameMapping[normalizedAppName];
+    }
+    async launch(uri) {
+        const hdc = await this.getHdc();
+        this.uri = uri;
+        try {
+            debugDevice(`Launching app: ${uri}`);
+            if (uri.startsWith('http://') || uri.startsWith('https://') || uri.includes('://')) await hdc.shell(`aa start -U ${uri}`);
+            else if (uri.includes('/')) {
+                const [bundleName, abilityName] = uri.split('/');
+                await hdc.startAbility(bundleName, abilityName);
+            } else {
+                const resolvedUri = this.resolvePackageName(uri) ?? uri;
+                await hdc.startAbility(resolvedUri, 'EntryAbility');
+            }
+            debugDevice(`Successfully launched: ${uri}`);
+        } catch (error) {
+            debugDevice(`Error launching ${uri}: ${error}`);
+            throw new Error(`Failed to launch ${uri}: ${error.message}`, {
+                cause: error
+            });
+        }
+        return this;
+    }
+    async getScreenSize() {
+        if (this.cachedScreenSize) return this.cachedScreenSize;
+        const hdc = await this.getHdc();
+        const screenInfo = await hdc.getScreenInfo();
+        this.cachedScreenSize = screenInfo;
+        return screenInfo;
+    }
+    async size() {
+        const screenInfo = await this.getScreenSize();
+        const scale = this.options?.screenshotResizeScale ?? 1;
+        const logicalWidth = Math.round(screenInfo.width * scale);
+        const logicalHeight = Math.round(screenInfo.height * scale);
+        return {
+            width: logicalWidth,
+            height: logicalHeight
+        };
+    }
+    async screenshotBase64() {
+        debugDevice('screenshotBase64 begin');
+        const hdc = await this.getHdc();
+        const screenshotId = Date.now().toString(36);
+        const remoteScreenshotPath = `/data/local/tmp/ms_${screenshotId}.jpeg`;
+        const localScreenshotPath = getTmpFile('jpeg');
+        try {
+            await hdc.screenshot(remoteScreenshotPath);
+            await hdc.fileRecv(remoteScreenshotPath, localScreenshotPath);
+            const screenshotBuffer = await external_node_fs_["default"].promises.readFile(localScreenshotPath);
+            if (!screenshotBuffer || 0 === screenshotBuffer.length) throw new Error('Screenshot buffer is empty');
+            debugDevice(`Screenshot captured: ${screenshotBuffer.length} bytes`);
+            const result = createImgBase64ByFormat('jpeg', screenshotBuffer.toString('base64'));
+            debugDevice('screenshotBase64 end');
+            return result;
+        } finally{
+            Promise.resolve().then(()=>hdc.shell(`rm ${remoteScreenshotPath}`)).catch((error)=>{
+                debugDevice(`Failed to delete remote screenshot: ${error}`);
+            });
+            (0, external_node_fs_.unlink)(localScreenshotPath, (unlinkError)=>{
+                if (unlinkError) debugDevice(`Failed to delete local screenshot: ${unlinkError}`);
+            });
+        }
+    }
+    async tap(x, y) {
+        this.lastTapPosition = {
+            x,
+            y
+        };
+        const hdc = await this.getHdc();
+        await hdc.click(x, y);
+    }
+    async doubleTap(x, y) {
+        const hdc = await this.getHdc();
+        await hdc.doubleClick(x, y);
+    }
+    async longPress(x, y) {
+        const hdc = await this.getHdc();
+        await hdc.longClick(x, y);
+    }
+    async inputText(text, element, shouldReplace) {
+        if (!text) return;
+        const hdc = await this.getHdc();
+        let x;
+        let y;
+        if (element) [x, y] = element.center;
+        else if (this.lastTapPosition) {
+            x = this.lastTapPosition.x;
+            y = this.lastTapPosition.y;
+        } else {
+            const { width, height } = await this.size();
+            x = Math.round(width / 2);
+            y = Math.round(height / 2);
+        }
+        if (shouldReplace) {
+            await hdc.inputText(x, y, '.');
+            await hdc.keyEvent('2072', '2017');
+        }
+        await hdc.inputText(x, y, text);
+        if (this.options?.autoDismissKeyboard) await this.hideKeyboard();
+    }
+    async clearInput(_element) {}
+    async keyboardPress(key) {
+        const keyMap = {
+            Enter: '2054',
+            Backspace: '2055',
+            Tab: '2049',
+            Escape: '2070',
+            Home: 'Home',
+            ArrowUp: '2012',
+            ArrowDown: '2013',
+            ArrowLeft: '2014',
+            ArrowRight: '2015',
+            Space: '2050',
+            Delete: '2071'
+        };
+        const normalizedKey = this.normalizeKeyName(key);
+        const harmonyKey = keyMap[normalizedKey] || key;
+        const hdc = await this.getHdc();
+        await hdc.keyEvent(harmonyKey);
+    }
+    normalizeKeyName(key) {
+        const keyMap = {
+            enter: 'Enter',
+            backspace: 'Backspace',
+            tab: 'Tab',
+            escape: 'Escape',
+            esc: 'Escape',
+            home: 'Home',
+            space: 'Space',
+            delete: 'Delete',
+            arrowup: 'ArrowUp',
+            arrowdown: 'ArrowDown',
+            arrowleft: 'ArrowLeft',
+            arrowright: 'ArrowRight',
+            up: 'ArrowUp',
+            down: 'ArrowDown',
+            left: 'ArrowLeft',
+            right: 'ArrowRight'
+        };
+        const lowerKey = key.toLowerCase();
+        return keyMap[lowerKey] || key;
+    }
+    async scroll(deltaX, deltaY, speed) {
+        if (0 === deltaX && 0 === deltaY) throw new Error('Scroll distance cannot be zero in both directions');
+        const { width, height } = await this.size();
+        const n = 4;
+        const startX = Math.round(deltaX < 0 ? width / n * (n - 1) : width / n);
+        const startY = Math.round(deltaY < 0 ? height / n * (n - 1) : height / n);
+        const maxPositiveDeltaX = startX;
+        const maxNegativeDeltaX = width - startX;
+        const maxPositiveDeltaY = startY;
+        const maxNegativeDeltaY = height - startY;
+        deltaX = Math.max(-maxNegativeDeltaX, Math.min(deltaX, maxPositiveDeltaX));
+        deltaY = Math.max(-maxNegativeDeltaY, Math.min(deltaY, maxPositiveDeltaY));
+        const endX = Math.round(startX - deltaX);
+        const endY = Math.round(startY - deltaY);
+        const hdc = await this.getHdc();
+        await hdc.swipe(startX, startY, endX, endY, speed ?? defaultSwipeSpeed);
+    }
+    async scrollDown(distance, startPoint) {
+        const { height } = await this.size();
+        const scrollDistance = Math.round(distance || height);
+        if (startPoint) {
+            const hdc = await this.getHdc();
+            const startX = Math.round(startPoint.left);
+            const startY = Math.round(startPoint.top);
+            const endY = Math.max(0, startY - scrollDistance);
+            await hdc.swipe(startX, startY, startX, endY);
+            return;
+        }
+        await this.scroll(0, scrollDistance);
+    }
+    async scrollUp(distance, startPoint) {
+        const { height } = await this.size();
+        const scrollDistance = Math.round(distance || height);
+        if (startPoint) {
+            const hdc = await this.getHdc();
+            const startX = Math.round(startPoint.left);
+            const startY = Math.round(startPoint.top);
+            const endY = Math.min(height, startY + scrollDistance);
+            await hdc.swipe(startX, startY, startX, endY);
+            return;
+        }
+        await this.scroll(0, -scrollDistance);
+    }
+    async scrollLeft(distance, startPoint) {
+        const { width } = await this.size();
+        const scrollDistance = Math.round(distance || width);
+        if (startPoint) {
+            const hdc = await this.getHdc();
+            const startX = Math.round(startPoint.left);
+            const startY = Math.round(startPoint.top);
+            const endX = Math.min(width, startX + scrollDistance);
+            await hdc.swipe(startX, startY, endX, startY);
+            return;
+        }
+        await this.scroll(-scrollDistance, 0);
+    }
+    async scrollRight(distance, startPoint) {
+        const { width } = await this.size();
+        const scrollDistance = Math.round(distance || width);
+        if (startPoint) {
+            const hdc = await this.getHdc();
+            const startX = Math.round(startPoint.left);
+            const startY = Math.round(startPoint.top);
+            const endX = Math.max(0, startX - scrollDistance);
+            await hdc.swipe(startX, startY, endX, startY);
+            return;
+        }
+        await this.scroll(scrollDistance, 0);
+    }
+    async scrollUntilTop(startPoint) {
+        if (startPoint) {
+            const { height } = await this.size();
+            const hdc = await this.getHdc();
+            const startX = Math.round(startPoint.left);
+            const startY = Math.round(startPoint.top);
+            await repeat(defaultScrollUntilTimes, ()=>hdc.fling(startX, startY, startX, Math.round(height), defaultFastSwipeSpeed));
+            await sleep(1000);
+            return;
+        }
+        await repeat(defaultScrollUntilTimes, ()=>this.scroll(0, -9999999, defaultFastSwipeSpeed));
+        await sleep(1000);
+    }
+    async scrollUntilBottom(startPoint) {
+        if (startPoint) {
+            const hdc = await this.getHdc();
+            const startX = Math.round(startPoint.left);
+            const startY = Math.round(startPoint.top);
+            await repeat(defaultScrollUntilTimes, ()=>hdc.fling(startX, startY, startX, 0, defaultFastSwipeSpeed));
+            await sleep(1000);
+            return;
+        }
+        await repeat(defaultScrollUntilTimes, ()=>this.scroll(0, 9999999, defaultFastSwipeSpeed));
+        await sleep(1000);
+    }
+    async scrollUntilLeft(startPoint) {
+        if (startPoint) {
+            const { width } = await this.size();
+            const hdc = await this.getHdc();
+            const startX = Math.round(startPoint.left);
+            const startY = Math.round(startPoint.top);
+            await repeat(defaultScrollUntilTimes, ()=>hdc.fling(startX, startY, Math.round(width), startY, defaultFastSwipeSpeed));
+            await sleep(1000);
+            return;
+        }
+        await repeat(defaultScrollUntilTimes, ()=>this.scroll(-9999999, 0, defaultFastSwipeSpeed));
+        await sleep(1000);
+    }
+    async scrollUntilRight(startPoint) {
+        if (startPoint) {
+            const hdc = await this.getHdc();
+            const startX = Math.round(startPoint.left);
+            const startY = Math.round(startPoint.top);
+            await repeat(defaultScrollUntilTimes, ()=>hdc.fling(startX, startY, 0, startY, defaultFastSwipeSpeed));
+            await sleep(1000);
+            return;
+        }
+        await repeat(defaultScrollUntilTimes, ()=>this.scroll(9999999, 0, defaultFastSwipeSpeed));
+        await sleep(1000);
+    }
+    async back() {
+        const hdc = await this.getHdc();
+        await hdc.keyEvent('Back');
+    }
+    async home() {
+        const hdc = await this.getHdc();
+        await hdc.keyEvent('Home');
+    }
+    async recentApps() {
+        const hdc = await this.getHdc();
+        await hdc.keyEvent('RecentApps');
+    }
+    async hideKeyboard() {
+        const hdc = await this.getHdc();
+        await hdc.keyEvent('Back');
+    }
+    async getTimestamp() {
+        const hdc = await this.getHdc();
+        try {
+            const stdout = await hdc.shell('date +%s%3N');
+            const timestamp = Number.parseInt(stdout.trim(), 10);
+            if (Number.isNaN(timestamp)) throw new Error(`Invalid timestamp format: ${stdout}`);
+            debugDevice(`Got device time: ${timestamp}`);
+            return timestamp;
+        } catch (error) {
+            debugDevice(`Failed to get device time: ${error}`);
+            throw new Error(`Failed to get device time: ${error}`);
+        }
+    }
+    async destroy() {
+        if (this.destroyed) return;
+        this.destroyed = true;
+        this.cachedScreenSize = null;
+        this.hdc = null;
+        this.connecting = null;
+    }
+    constructor(deviceId, options){
+        device_define_property(this, "deviceId", void 0);
+        device_define_property(this, "hdc", null);
+        device_define_property(this, "connecting", null);
+        device_define_property(this, "destroyed", false);
+        device_define_property(this, "descriptionText", void 0);
+        device_define_property(this, "customActions", void 0);
+        device_define_property(this, "cachedScreenSize", null);
+        device_define_property(this, "appNameMapping", {});
+        device_define_property(this, "lastTapPosition", null);
+        device_define_property(this, "interfaceType", 'harmony');
+        device_define_property(this, "uri", void 0);
+        device_define_property(this, "options", void 0);
+        node_assert(deviceId, 'deviceId is required for HarmonyDevice');
+        this.deviceId = deviceId;
+        this.options = options;
+        this.customActions = options?.customActions;
+    }
+}
+const runHdcShellParamSchema = z.object({
+    command: z.string().describe('HDC shell command to execute')
+});
+const launchParamSchema = z.object({
+    uri: z.string().describe('App name, bundle name, or URL to launch. Prioritize using the exact bundle name or URL the user has provided. If none provided, use the accurate app name.')
+});
+const createPlatformActions = (device)=>({
+        RunHdcShell: defineAction({
+            name: 'RunHdcShell',
+            description: 'Execute HDC shell command on HarmonyOS device',
+            interfaceAlias: 'runHdcShell',
+            paramSchema: runHdcShellParamSchema,
+            call: async (param)=>{
+                if (!param.command || '' === param.command.trim()) throw new Error('RunHdcShell requires a non-empty command parameter');
+                const hdc = await device.getHdc();
+                return await hdc.shell(param.command);
+            }
+        }),
+        Launch: defineAction({
+            name: 'Launch',
+            description: 'Launch a HarmonyOS app or URL',
+            interfaceAlias: 'launch',
+            paramSchema: launchParamSchema,
+            call: async (param)=>{
+                if (!param.uri || '' === param.uri.trim()) throw new Error('Launch requires a non-empty uri parameter');
+                await device.launch(param.uri);
+            }
+        }),
+        HarmonyBackButton: defineAction({
+            name: 'HarmonyBackButton',
+            description: 'Trigger the system "back" operation on HarmonyOS devices',
+            call: async ()=>{
+                await device.back();
+            }
+        }),
+        HarmonyHomeButton: defineAction({
+            name: 'HarmonyHomeButton',
+            description: 'Trigger the system "home" operation on HarmonyOS devices',
+            call: async ()=>{
+                await device.home();
+            }
+        }),
+        HarmonyRecentAppsButton: defineAction({
+            name: 'HarmonyRecentAppsButton',
+            description: 'Trigger the system "recent apps" operation on HarmonyOS devices',
+            call: async ()=>{
+                await device.recentApps();
+            }
+        })
+    });
+const defaultAppNameMapping = {
+    设置: 'com.huawei.hmos.settings',
+    Settings: 'com.huawei.hmos.settings',
+    相机: 'com.huawei.hmos.camera',
+    Camera: 'com.huawei.hmos.camera',
+    图库: 'com.huawei.hmos.photos',
+    Gallery: 'com.huawei.hmos.photos',
+    日历: 'com.huawei.hmos.calendar',
+    Calendar: 'com.huawei.hmos.calendar',
+    时钟: 'com.huawei.hmos.clock',
+    Clock: 'com.huawei.hmos.clock',
+    计算器: 'com.huawei.hmos.calculator',
+    Calculator: 'com.huawei.hmos.calculator',
+    文件管理: 'com.huawei.hmos.filemanager',
+    备忘录: 'com.huawei.hmos.notepad',
+    联系人: 'com.huawei.hmos.contacts',
+    电话: 'com.huawei.hmos.phone',
+    信息: 'com.huawei.hmos.message',
+    邮件: 'com.huawei.hmos.email',
+    浏览器: 'com.huawei.hmos.browser',
+    Browser: 'com.huawei.hmos.browser',
+    应用市场: 'com.huawei.appmarket',
+    AppGallery: 'com.huawei.appmarket',
+    华为音乐: 'com.huawei.hmos.music',
+    华为视频: 'com.huawei.hmos.video',
+    天气: 'com.huawei.hmos.weather',
+    Weather: 'com.huawei.hmos.weather',
+    微信: 'com.tencent.mm',
+    WeChat: 'com.tencent.mm',
+    支付宝: 'com.eg.android.AlipayGphone',
+    淘宝: 'com.taobao.taobao',
+    京东: 'com.jingdong.app.mall',
+    抖音: 'com.ss.hm.ugc.aweme',
+    小红书: 'com.xingin.xhs',
+    bilibili: 'tv.danmaku.bili',
+    QQ: 'com.tencent.mobileqq',
+    微博: 'com.sina.weibo',
+    高德地图: 'com.autonavi.minimap',
+    百度地图: 'com.baidu.BaiduMap',
+    美团: 'com.sankuai.meituan',
+    饿了么: 'me.ele',
+    飞书: 'com.ss.android.lark',
+    豆包: 'com.larus.nova',
+    网易云音乐: 'com.netease.cloudmusic',
+    QQ音乐: 'com.tencent.qqmusic',
+    知乎: 'com.zhihu.android',
+    今日头条: 'com.ss.android.article.news',
+    Keep: 'com.gotokeep.keep'
+};
+const debugUtils = getDebug('harmony:utils');
+async function getConnectedDevices(hdcPath) {
+    try {
+        const hdc = new HdcClient({
+            hdcPath
+        });
+        const targets = await hdc.listTargets();
+        const devices = targets.map((deviceId)=>({
+                deviceId
+            }));
+        debugUtils(`Found ${devices.length} connected devices: `, devices);
+        return devices;
+    } catch (error) {
+        console.error('Failed to get device list:', error);
+        throw new Error(`Unable to get connected HarmonyOS device list, please ensure HDC is properly configured: ${error.message}`, {
+            cause: error
+        });
+    }
+}
+function agent_define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+const debugAgent = getDebug('harmony:agent');
+class HarmonyAgent extends Agent {
+    async launch(uri) {
+        const action = this.wrapActionInActionSpace('Launch');
+        return action({
+            uri
+        });
+    }
+    async runHdcShell(command) {
+        const action = this.wrapActionInActionSpace('RunHdcShell');
+        return action({
+            command
+        });
+    }
+    createActionWrapper(name) {
+        const action = this.wrapActionInActionSpace(name);
+        return (...args)=>action(args[0]);
+    }
+    constructor(device, opts){
+        super(device, opts), agent_define_property(this, "back", void 0), agent_define_property(this, "home", void 0), agent_define_property(this, "recentApps", void 0), agent_define_property(this, "appNameMapping", void 0);
+        this.appNameMapping = mergeAndNormalizeAppNameMapping(defaultAppNameMapping, opts?.appNameMapping);
+        device.setAppNameMapping(this.appNameMapping);
+        this.back = this.createActionWrapper('HarmonyBackButton');
+        this.home = this.createActionWrapper('HarmonyHomeButton');
+        this.recentApps = this.createActionWrapper('HarmonyRecentAppsButton');
+    }
+}
+async function agentFromHdcDevice(deviceId, opts) {
+    if (!deviceId) {
+        const devices = await getConnectedDevices(opts?.hdcPath);
+        if (0 === devices.length) throw new Error('No HarmonyOS devices found. Please connect a HarmonyOS device and ensure HDC is properly configured. Run `hdc list targets` to verify device connection.');
+        deviceId = devices[0].deviceId;
+        debugAgent('deviceId not specified, will use the first device (id = %s)', deviceId);
+    }
+    const device = new HarmonyDevice(deviceId, opts || {});
+    await device.connect();
+    return new HarmonyAgent(device, opts);
+}
+export { HarmonyAgent, HarmonyDevice, agentFromHdcDevice, getConnectedDevices, overrideAIConfig };