shellx-ai 1.0.0

package/dist/shellx.js

@@ -0,0 +1,866 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ShellX = exports.AutomationHelpers = void 0;
+exports.createShellX = createShellX;
+exports.createHelpers = createShellX;
+exports.createShellXWithShellMonitoring = createShellXWithShellMonitoring;
+exports.createHelpersWithShellMonitoring = createShellXWithShellMonitoring;
+const index_1 = __importDefault(require("./index"));
+/**
+ * ShellX automation utilities for common patterns
+ */
+class ShellX {
+    constructor(client) {
+        this.client = client;
+        this.shellOutputBuffers = new Map();
+        this.shellCommandPromises = new Map();
+        // 注意：由于 WebSocketTaskClient 的 config 是私有的，
+        // 监听 shell 输出需要在创建 WebSocketTaskClient 时设置 onMessage 回调
+        console.log('⚠️ [Shell] 注意：要监听 shell 输出，请在创建 WebSocketTaskClient 时设置 onMessage 回调');
+    }
+    /**
+     * 设置 shell 输出监听器（需要在创建 WebSocketTaskClient 时调用）
+     */
+    static createShellOutputHandler(helpers) {
+        return (message) => {
+            // 处理 chunks 数据（pty 终端输出）
+            if (message.chunks) {
+                helpers.handleShellOutput(message.chunks);
+            }
+        };
+    }
+    /**
+     * 处理 shell 输出数据
+     */
+    handleShellOutput(chunks) {
+        const [sid, sessionId, dataArrays] = chunks;
+        try {
+            // 将 Uint8Array 数组转换为字符串
+            let output = '';
+            for (const data of dataArrays) {
+                output += new TextDecoder().decode(data);
+            }
+            console.log(`📟 [Shell] 收到输出 (Session ${sessionId}): ${output.trim()}`);
+            // 为每个等待的命令累积输出
+            for (const [commandKey, commandPromise] of this.shellCommandPromises.entries()) {
+                // 检查是否该命令相关的输出
+                if (this.isOutputForCommand(output, commandPromise.command, sessionId)) {
+                    // 存储该 session 的输出
+                    if (!commandPromise.sessionOutputs.has(sessionId)) {
+                        commandPromise.sessionOutputs.set(sessionId, '');
+                    }
+                    const currentSessionOutput = commandPromise.sessionOutputs.get(sessionId) || '';
+                    commandPromise.sessionOutputs.set(sessionId, currentSessionOutput + output);
+                    // 更新总输出
+                    commandPromise.output = this.combineSessionOutputs(commandPromise.sessionOutputs);
+                    console.log(`📊 [Shell] 命令 ${commandKey} 累积输出长度: ${commandPromise.output.length}`);
+                    // 调用输出回调
+                    if (commandPromise.options.onOutput) {
+                        commandPromise.options.onOutput(output);
+                    }
+                    // 检查是否满足完成条件
+                    this.checkCommandCompletion(commandKey, commandPromise, output);
+                }
+            }
+        }
+        catch (error) {
+            console.error(`❌ [Shell] 处理输出数据失败:`, error);
+        }
+    }
+    /**
+     * 判断输出是否属于特定命令
+     */
+    isOutputForCommand(output, command, sessionId) {
+        // 如果输出包含命令本身，说明是命令回显
+        if (output.includes(command)) {
+            return true;
+        }
+        // 如果输出包含提示符，说明是命令完成
+        if (this.containsPrompt(output)) {
+            return true;
+        }
+        // 如果有多个命令在等待，按时间顺序分配
+        const waitingCommands = Array.from(this.shellCommandPromises.keys());
+        if (waitingCommands.length === 1) {
+            return true; // 只有一个命令在等待，所有输出都属于它
+        }
+        // 多个命令时，根据 sessionId 和命令创建时间进行启发式匹配
+        return true; // 暂时返回 true，让所有命令都接收输出
+    }
+    /**
+     * 合并多个 session 的输出
+     */
+    combineSessionOutputs(sessionOutputs) {
+        const sessions = Array.from(sessionOutputs.keys()).sort();
+        let combined = '';
+        for (const sessionId of sessions) {
+            const sessionOutput = sessionOutputs.get(sessionId) || '';
+            combined += sessionOutput;
+        }
+        return combined;
+    }
+    /**
+     * 检查输出是否包含提示符
+     */
+    containsPrompt(output) {
+        const promptPatterns = [
+            /\$ $/,
+            /# $/,
+            /> $/,
+            /\w+@\w+.*\$ $/,
+            /shell@.*:.*\$ $/,
+            /houji:\/.*\$ $/,
+            /\d+\|\w+:\/.*\$ $/, // Android pattern like "127|bluejay:/ $"
+            /\w+:\/.*\$ $/ // Android pattern like "bluejay:/ $"
+        ];
+        return promptPatterns.some(pattern => pattern.test(output));
+    }
+    /**
+     * 检查命令是否完成
+     */
+    checkCommandCompletion(commandKey, commandPromise, newOutput) {
+        const { resolve, startTime, options, output, command } = commandPromise;
+        console.log(`🔍 [Shell] 检查命令 "${command}" 完成条件，当前输出长度: ${output.length}`);
+        // 检查成功模式
+        if (options.successPattern) {
+            const pattern = options.successPattern;
+            const isMatch = typeof pattern === 'string'
+                ? output.includes(pattern)
+                : pattern.test(output);
+            if (isMatch) {
+                console.log(`✅ [Shell] 命令 "${command}" 成功完成 (匹配成功模式)`);
+                this.resolveCommand(commandKey, {
+                    success: true,
+                    output: output.trim(),
+                    duration: Date.now() - startTime
+                });
+                return;
+            }
+        }
+        // 检查错误模式
+        if (options.errorPattern) {
+            const pattern = options.errorPattern;
+            const isMatch = typeof pattern === 'string'
+                ? output.includes(pattern)
+                : pattern.test(output);
+            if (isMatch) {
+                console.log(`❌ [Shell] 命令 "${command}" 执行失败 (匹配错误模式)`);
+                this.resolveCommand(commandKey, {
+                    success: false,
+                    output: output.trim(),
+                    error: 'Command failed with error pattern',
+                    duration: Date.now() - startTime
+                });
+                return;
+            }
+        }
+        // 检查通用完成模式（如命令提示符）
+        // 这是最主要的完成检测逻辑，包括对没有输出的命令的支持
+        if (this.isCommandComplete(output, command)) {
+            console.log(`✅ [Shell] 命令 "${command}" 执行完成 (检测到提示符)`);
+            this.resolveCommand(commandKey, {
+                success: true,
+                output: output.trim(),
+                duration: Date.now() - startTime
+            });
+            return;
+        }
+        // 额外的完成检测：仅当有输出时才进行的检查
+        if (output.trim().length > 0) {
+            // 检查是否有错误指示器
+            if (this.hasErrorIndicators(output)) {
+                console.log(`❌ [Shell] 命令 "${command}" 可能执行失败 (检测到错误指示器)`);
+                // 不立即失败，继续等待完整的提示符
+                return;
+            }
+            // 检查是否包含命令和结果（备用检测方式）
+            if (output.includes(command) && this.containsPrompt(output)) {
+                console.log(`✅ [Shell] 命令 "${command}" 执行完成 (命令+提示符备用检测)`);
+                this.resolveCommand(commandKey, {
+                    success: true,
+                    output: output.trim(),
+                    duration: Date.now() - startTime
+                });
+                return;
+            }
+        }
+        // 如果没有检测到完成条件，继续等待
+        console.log(`⏳ [Shell] 命令 "${command}" 继续等待完成...`);
+    }
+    /**
+     * 检查输出是否包含错误指示器
+     */
+    hasErrorIndicators(output) {
+        const errorPatterns = [
+            /error/i,
+            /failed/i,
+            /not found/i,
+            /permission denied/i,
+            /command not found/i,
+            /no such file/i,
+            /syntax error/i
+        ];
+        return errorPatterns.some(pattern => pattern.test(output));
+    }
+    /**
+     * 判断命令是否完成（基于常见的提示符模式）
+     */
+    isCommandComplete(output, command) {
+        // 常见的命令提示符模式
+        const promptPatterns = [
+            /\$ $/, // Unix shell prompt
+            /# $/, // Root shell prompt
+            /> $/, // Windows command prompt
+            /~\$ $/, // Home directory prompt
+            /\w+@\w+.*\$ $/, // User@host prompt
+            /shell@.*:.*\$ $/, // Android shell prompt
+            /houji:\/.*\$ $/, // Specific Android shell prompt
+            /\d+\|\w+:\/.*\$ $/, // Android pattern like "127|bluejay:/ $"
+            /\w+:\/.*\$ $/, // Android pattern like "bluejay:/ $"
+            /\[.*\]\$ $/, // Bracketed prompt
+            /\w+:\w+\$ $/, // Simple path prompt
+            /\w+> $/, // Simple greater-than prompt
+            /.*:\w+\$ $/, // Path-based prompt
+            /\w+@\w+:.* $/, // User@host with path
+            /\d+\|.*\$ $/, // Numbered prompt with pipe
+            /.*#\s*$/, // Hash prompt with optional space
+            /.*\$\s*$/ // Dollar prompt with optional space
+        ];
+        // 分割输出为行，检查最后几行
+        const lines = output.split(/\r?\n/).filter(line => line.trim().length > 0);
+        const lastLine = lines[lines.length - 1] || '';
+        // 清理最后一行的控制字符
+        const cleanLastLine = lastLine.replace(/\r/g, '').trim();
+        console.log(`🔍 [Shell] 检查命令 "${command}" 最后一行提示符: "${cleanLastLine}"`);
+        const hasPrompt = promptPatterns.some(pattern => {
+            const matches = pattern.test(cleanLastLine);
+            if (matches) {
+                console.log(`✅ [Shell] 命令 "${command}" 匹配到提示符模式: ${pattern}`);
+            }
+            return matches;
+        });
+        // 如果检测到提示符，则认为命令完成
+        // 不再要求输出必须包含命令本身，因为有些命令可能没有输出
+        if (hasPrompt) {
+            return true;
+        }
+        // 如果没有检测到提示符，但输出包含命令本身，可能命令还在执行中
+        // 这种情况下返回false，继续等待
+        return false;
+    }
+    /**
+     * 解析命令 Promise
+     */
+    resolveCommand(commandKey, result) {
+        const commandPromise = this.shellCommandPromises.get(commandKey);
+        if (commandPromise) {
+            console.log(`✅ [Shell] 解析命令 Promise: ${commandKey}`);
+            commandPromise.resolve(result);
+            this.shellCommandPromises.delete(commandKey);
+        }
+        else {
+            console.log(`⚠️ [Shell] 未找到命令 Promise: ${commandKey}`);
+        }
+    }
+    /**
+     * 生成命令唯一标识
+     */
+    generateCommandKey(command) {
+        return `cmd_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    }
+    /**
+     * Smart element finder with retry logic
+     */
+    findElementWithRetry(selector_1) {
+        return __awaiter(this, arguments, void 0, function* (selector, maxRetries = 3, retryDelay = 1000) {
+            for (let i = 0; i < maxRetries; i++) {
+                try {
+                    const result = yield this.client.findElement(selector, {
+                        timeout: 3000,
+                        visibleOnly: true,
+                        maxResults: 1
+                    });
+                    if (result.elements.length > 0) {
+                        return result.elements[0];
+                    }
+                }
+                catch (error) {
+                    console.log(`查找尝试 ${i + 1}/${maxRetries} 失败:`, error);
+                }
+                if (i < maxRetries - 1) {
+                    yield new Promise(resolve => setTimeout(resolve, retryDelay));
+                }
+            }
+            return null;
+        });
+    }
+    /**
+     * Smart multiple elements finder with retry logic
+     */
+    findElementsWithRetry(selector_1) {
+        return __awaiter(this, arguments, void 0, function* (selector, maxRetries = 3, retryDelay = 1000, options) {
+            var _a, _b, _c;
+            for (let i = 0; i < maxRetries; i++) {
+                try {
+                    const result = yield this.client.findElement(selector, {
+                        timeout: 3000,
+                        visibleOnly: (_a = options === null || options === void 0 ? void 0 : options.visibleOnly) !== null && _a !== void 0 ? _a : true,
+                        clickableOnly: (_b = options === null || options === void 0 ? void 0 : options.clickableOnly) !== null && _b !== void 0 ? _b : false,
+                        multiple: true,
+                        maxResults: (_c = options === null || options === void 0 ? void 0 : options.maxResults) !== null && _c !== void 0 ? _c : 10
+                    });
+                    if (result.elements.length > 0) {
+                        console.log(`🔍 [FindElements] 找到 ${result.elements.length} 个元素`);
+                        return result.elements;
+                    }
+                }
+                catch (error) {
+                    console.log(`查找尝试 ${i + 1}/${maxRetries} 失败:`, error);
+                }
+                if (i < maxRetries - 1) {
+                    yield new Promise(resolve => setTimeout(resolve, retryDelay));
+                }
+            }
+            console.log(`❌ [FindElements] 未找到任何元素`);
+            return [];
+        });
+    }
+    /**
+     * 打印元素信息的工具方法
+     */
+    printElementInfo(element, index) {
+        const prefix = index !== undefined ? `📋 元素 ${index + 1}:` : `📋 元素信息:`;
+        console.log(`\n${prefix}`);
+        console.log(`  - Element ID: ${element.elementId}`);
+        console.log(`  - Class Name: ${element.className}`);
+        console.log(`  - Resource ID: ${element.resourceId}`);
+        console.log(`  - Text: "${element.text}"`);
+        console.log(`  - Describe: "${element.describe}"`);
+        console.log(`  - Visible: ${element.visible}`);
+        console.log(`  - Clickable: ${element.clickable}`);
+        console.log(`  - Bounds: {left: ${element.bounds.left}, top: ${element.bounds.top}, right: ${element.bounds.right}, bottom: ${element.bounds.bottom}}`);
+        console.log(`  - Size: ${element.bounds.right - element.bounds.left} x ${element.bounds.bottom - element.bounds.top}`);
+    }
+    /**
+     * 打印多个元素信息的工具方法
+     */
+    printElementsInfo(elements, title) {
+        if (elements.length === 0) {
+            console.log('❌ 没有元素可以打印');
+            return;
+        }
+        console.log(`\n${title || `✅ 找到 ${elements.length} 个元素`}:`);
+        elements.forEach((element, index) => {
+            this.printElementInfo(element, index);
+        });
+        // 统计信息
+        const visibleCount = elements.filter(e => e.visible).length;
+        const clickableCount = elements.filter(e => e.clickable).length;
+        const withTextCount = elements.filter(e => e.text && e.text.trim().length > 0).length;
+        console.log(`\n📊 统计信息:`);
+        console.log(`  - 总共元素: ${elements.length}`);
+        console.log(`  - 可见元素: ${visibleCount}`);
+        console.log(`  - 可点击元素: ${clickableCount}`);
+        console.log(`  - 有文本内容元素: ${withTextCount}`);
+        // 展示不同的文本内容
+        const uniqueTexts = [...new Set(elements.map(e => e.text).filter(text => text && text.trim().length > 0))];
+        if (uniqueTexts.length > 0) {
+            console.log(`\n📝 不同的文本内容:`);
+            uniqueTexts.forEach((text, index) => {
+                console.log(`  ${index + 1}. "${text}"`);
+            });
+        }
+    }
+    /**
+     * Click element by text content
+     */
+    clickByText(text_1) {
+        return __awaiter(this, arguments, void 0, function* (text, exact = false) {
+            const selector = exact
+                ? { text, clickable: false, visible: true }
+                : { textContains: text, clickable: false, visible: true };
+            const element = yield this.findElementWithRetry(selector);
+            if (!element) {
+                throw new Error(`未找到包含文本 "${text}" 的可点击元素`);
+            }
+            const clickAction = {
+                title: `点击文本: ${text}`,
+                actions: [{
+                        type: "click",
+                        target: { type: "elementId", value: element.elementId },
+                        options: { waitAfterMs: 2000 }
+                    }]
+            };
+            yield this.client.executeAction(clickAction);
+            return true;
+        });
+    }
+    /**
+     * Input text into field
+     */
+    inputText(selector, text, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const element = yield this.findElementWithRetry(selector);
+            if (!element) {
+                throw new Error('未找到输入框元素');
+            }
+            const inputAction = {
+                title: `输入文本: ${text}`,
+                actions: [{
+                        type: "input",
+                        text,
+                        target: { type: "elementId", value: element.elementId },
+                        options: {
+                            replaceExisting: (_a = options === null || options === void 0 ? void 0 : options.clear) !== null && _a !== void 0 ? _a : true,
+                            hideKeyboardAfter: (_b = options === null || options === void 0 ? void 0 : options.hideKeyboard) !== null && _b !== void 0 ? _b : false
+                        }
+                    }]
+            };
+            yield this.client.executeAction(inputAction);
+            return true;
+        });
+    }
+    /**
+     * Swipe in a direction
+     */
+    swipe(direction_1) {
+        return __awaiter(this, arguments, void 0, function* (direction, distance = 400, duration = 800) {
+            // Get screen info to calculate coordinates
+            const screenInfo = yield this.client.getScreenInfo();
+            const centerX = (screenInfo.width || 1080) / 2;
+            const centerY = (screenInfo.height || 1920) / 2;
+            let from;
+            let to;
+            switch (direction) {
+                case 'up':
+                    from = { x: centerX, y: centerY + distance / 2 };
+                    to = { x: centerX, y: centerY - distance / 2 };
+                    break;
+                case 'down':
+                    from = { x: centerX, y: centerY - distance / 2 };
+                    to = { x: centerX, y: centerY + distance / 2 };
+                    break;
+                case 'left':
+                    from = { x: centerX + distance / 2, y: centerY };
+                    to = { x: centerX - distance / 2, y: centerY };
+                    break;
+                case 'right':
+                    from = { x: centerX - distance / 2, y: centerY };
+                    to = { x: centerX + distance / 2, y: centerY };
+                    break;
+            }
+            const swipeAction = {
+                title: `向${direction}滑动`,
+                actions: [{
+                        type: "swipe",
+                        from,
+                        to,
+                        options: { durationMs: duration, waitAfterMs: 500 }
+                    }]
+            };
+            yield this.client.executeAction(swipeAction);
+        });
+    }
+    /**
+     * Take screenshot and save info
+     */
+    captureScreen(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const screenshot = yield this.client.screenShot(options);
+            if (options === null || options === void 0 ? void 0 : options.saveInfo) {
+                console.log('截图信息:', {
+                    格式: screenshot.format,
+                    尺寸: screenshot.dimensions,
+                    大小: `${Math.round(screenshot.imageData.length / 1024)}KB`,
+                    时间: new Date(Number(screenshot.timestamp)).toLocaleString()
+                });
+            }
+            return screenshot;
+        });
+    }
+    /**
+     * Wait for any of multiple elements to appear
+     */
+    waitForAnyElement(selectors_1) {
+        return __awaiter(this, arguments, void 0, function* (selectors, timeout = 10000) {
+            const startTime = Date.now();
+            while (Date.now() - startTime < timeout) {
+                for (let i = 0; i < selectors.length; i++) {
+                    try {
+                        const result = yield this.client.findElement(selectors[i], {
+                            timeout: 1000,
+                            maxResults: 1,
+                            visibleOnly: true
+                        });
+                        if (result.elements.length > 0) {
+                            return { element: result.elements[0], selectorIndex: i };
+                        }
+                    }
+                    catch (error) {
+                        // Continue to next selector
+                    }
+                }
+                yield new Promise(resolve => setTimeout(resolve, 500));
+            }
+            return null;
+        });
+    }
+    /**
+     * Login helper for common login flows
+     */
+    performLogin(usernameSelector, passwordSelector, loginButtonSelector, username, password) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                console.log('开始登录流程...');
+                // Input username
+                yield this.inputText(usernameSelector, username, { clear: true });
+                console.log('✅ 用户名已输入');
+                // Input password
+                yield this.inputText(passwordSelector, password, { clear: true });
+                console.log('✅ 密码已输入');
+                // Click login button
+                const loginElement = yield this.findElementWithRetry(loginButtonSelector);
+                if (!loginElement) {
+                    throw new Error('未找到登录按钮');
+                }
+                const loginAction = {
+                    title: "执行登录",
+                    actions: [{
+                            type: "click",
+                            target: { type: "elementId", value: loginElement.elementId },
+                            options: { waitAfterMs: 2000 }
+                        }]
+                };
+                yield this.client.executeAction(loginAction);
+                console.log('✅ 登录按钮已点击');
+                return true;
+            }
+            catch (error) {
+                console.error('❌ 登录失败:', error);
+                return false;
+            }
+        });
+    }
+    /**
+     * Navigate through app using a series of clicks
+     */
+    navigateByPath(textPath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                console.log('开始导航路径:', textPath.join(' → '));
+                for (const [index, text] of textPath.entries()) {
+                    console.log(`导航步骤 ${index + 1}/${textPath.length}: 点击 "${text}"`);
+                    yield this.clickByText(text);
+                    // Wait a bit between clicks
+                    yield new Promise(resolve => setTimeout(resolve, 1000));
+                }
+                console.log('✅ 导航完成');
+                return true;
+            }
+            catch (error) {
+                console.error('❌ 导航失败:', error);
+                return false;
+            }
+        });
+    }
+    /**
+     * Scroll to find element
+     */
+    scrollToFindElement(selector_1) {
+        return __awaiter(this, arguments, void 0, function* (selector, maxScrolls = 5, direction = 'down') {
+            // First try to find without scrolling
+            let element = yield this.findElementWithRetry(selector, 1, 0);
+            if (element)
+                return element;
+            // Try scrolling to find
+            for (let i = 0; i < maxScrolls; i++) {
+                console.log(`滚动查找第 ${i + 1} 次...`);
+                yield this.swipe(direction);
+                element = yield this.findElementWithRetry(selector, 1, 0);
+                if (element) {
+                    console.log('✅ 滚动后找到元素');
+                    return element;
+                }
+            }
+            console.log('❌ 滚动后仍未找到元素');
+            return null;
+        });
+    }
+    /**
+     * Execute shell command action with output monitoring
+     */
+    executeShellCommand(command_1) {
+        return __awaiter(this, arguments, void 0, function* (command, options = {}) {
+            const startTime = Date.now();
+            const title = options.title || `执行命令: ${command}`;
+            const timeout = options.timeout || 20000; // 增加默认超时时间到20秒
+            console.log(`🔨 [Shell] ${title}`);
+            console.log(`⏱️  超时时间: ${timeout}ms`);
+            return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+                const commandKey = this.generateCommandKey(command);
+                console.log(`🔑 [Shell] 生成命令键: ${commandKey}`);
+                // 注册命令 Promise
+                this.shellCommandPromises.set(commandKey, {
+                    resolve,
+                    reject,
+                    startTime,
+                    options,
+                    output: '',
+                    sessionOutputs: new Map(),
+                    command
+                });
+                console.log(`📋 [Shell] 当前待处理命令数: ${this.shellCommandPromises.size}`);
+                // 设置超时
+                const timeoutId = setTimeout(() => {
+                    if (this.shellCommandPromises.has(commandKey)) {
+                        const commandPromise = this.shellCommandPromises.get(commandKey);
+                        console.log(`⏰ [Shell] 命令超时: ${command}`);
+                        // 即使超时，如果有输出也返回输出
+                        if (commandPromise && commandPromise.output.trim().length > 0) {
+                            console.log(`📤 [Shell] 超时但有输出，返回部分结果`);
+                            this.shellCommandPromises.delete(commandKey);
+                            resolve({
+                                success: false,
+                                output: commandPromise.output.trim(),
+                                error: `Command timeout after ${timeout}ms, but got partial output`,
+                                duration: Date.now() - startTime
+                            });
+                        }
+                        else {
+                            this.shellCommandPromises.delete(commandKey);
+                            reject(new Error(`Command timeout after ${timeout}ms`));
+                        }
+                    }
+                }, timeout);
+                try {
+                    // 构建 shell 命令操作
+                    const shellAction = {
+                        title,
+                        actions: [{
+                                type: "command",
+                                command,
+                                title: options.title
+                            }],
+                        options: {
+                            timeoutMs: timeout
+                        }
+                    };
+                    // 发送命令
+                    yield this.client.executeAction(shellAction);
+                    console.log(`📤 [Shell] 命令已发送: ${command}`);
+                    // 等待命令完成（通过 chunks 数据流）
+                    // Promise 将由 handleShellOutput 解析
+                }
+                catch (error) {
+                    clearTimeout(timeoutId);
+                    this.shellCommandPromises.delete(commandKey);
+                    console.error(`❌ [Shell] 命令发送失败: ${command}`, error);
+                    reject(error);
+                }
+            }));
+        });
+    }
+    /**
+     * Execute shell command with simple output (for backward compatibility)
+     */
+    executeSimpleShellCommand(command, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const result = yield this.executeShellCommand(command, {
+                    title: options === null || options === void 0 ? void 0 : options.title,
+                    timeout: options === null || options === void 0 ? void 0 : options.timeout
+                });
+                // 如果设置了等待时间，则等待
+                if (options === null || options === void 0 ? void 0 : options.waitAfterMs) {
+                    yield new Promise(resolve => setTimeout(resolve, options.waitAfterMs));
+                }
+                console.log(`✅ [Shell] 命令执行完成: ${command}`);
+                return result;
+            }
+            catch (error) {
+                console.error(`❌ [Shell] 命令执行失败: ${command}`, error);
+                throw error;
+            }
+        });
+    }
+    /**
+     * Execute multiple shell commands in sequence
+     */
+    executeShellCommands(commands, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const results = [];
+            try {
+                console.log(`🔨 [Shell] 开始执行 ${commands.length} 个命令`);
+                for (const [index, cmd] of commands.entries()) {
+                    try {
+                        const title = cmd.title || `命令 ${index + 1}/${commands.length}: ${cmd.command}`;
+                        console.log(`🔨 [Shell] ${title}`);
+                        const result = yield this.executeShellCommand(cmd.command, {
+                            title,
+                            timeout: options === null || options === void 0 ? void 0 : options.timeout,
+                            waitAfterMs: cmd.waitAfterMs
+                        });
+                        results.push(result);
+                    }
+                    catch (error) {
+                        console.error(`❌ [Shell] 命令 ${index + 1} 执行失败:`, error);
+                        if (options === null || options === void 0 ? void 0 : options.continueOnError) {
+                            results.push({
+                                success: false,
+                                output: '',
+                                error: error instanceof Error ? error.message : String(error),
+                                duration: Date.now() - Date.now() // 简单的时间戳
+                            });
+                            continue;
+                        }
+                        else {
+                            throw error;
+                        }
+                    }
+                }
+                console.log(`✅ [Shell] 所有命令执行完成`);
+                return results;
+            }
+            catch (error) {
+                console.error(`❌ [Shell] 批量命令执行失败:`, error);
+                throw error;
+            }
+        });
+    }
+    /**
+     * Common ADB commands helper
+     */
+    adbCommand(command, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const adbCmd = command;
+            return this.executeShellCommand(adbCmd, {
+                title: (options === null || options === void 0 ? void 0 : options.title) || `ADB命令: ${command}`,
+                timeout: options === null || options === void 0 ? void 0 : options.timeout,
+                waitAfterMs: options === null || options === void 0 ? void 0 : options.waitAfterMs,
+                onOutput: options === null || options === void 0 ? void 0 : options.onOutput,
+                onError: options === null || options === void 0 ? void 0 : options.onError,
+                expectedOutput: options === null || options === void 0 ? void 0 : options.expectedOutput,
+                successPattern: options === null || options === void 0 ? void 0 : options.successPattern,
+                errorPattern: options === null || options === void 0 ? void 0 : options.errorPattern
+            });
+        });
+    }
+    /**
+     * Device info commands
+     */
+    getDeviceInfo() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const commands = [
+                { command: 'getprop ro.product.model', title: '获取设备型号' },
+                { command: 'getprop ro.build.version.release', title: '获取Android版本' },
+                { command: 'wm size', title: '获取屏幕尺寸' },
+                { command: 'dumpsys battery', title: '获取电池信息' }
+            ];
+            console.log('📱 [Device] 开始获取设备信息...');
+            try {
+                const results = yield this.executeShellCommands(commands, {
+                    continueOnError: true,
+                    timeout: 5000
+                });
+                console.log('📱 [Device] 设备信息获取完成');
+                return results;
+            }
+            catch (error) {
+                console.error('❌ [Device] 获取设备信息失败:', error);
+                throw error;
+            }
+        });
+    }
+}
+exports.ShellX = ShellX;
+exports.AutomationHelpers = ShellX;
+/**
+ * Create ShellX instance
+ */
+function createShellX(client) {
+    return new ShellX(client);
+}
+/**
+ * 从ShellX.ai服务认证并获取WebSocket连接信息
+ */
+function authenticateDevice() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const authKey = process.env.SHELLX_AUTH_KEY;
+        if (!authKey) {
+            throw new Error('SHELLX_AUTH_KEY environment variable is required');
+        }
+        try {
+            console.log('🔑 [Auth] 正在认证设备...');
+            const response = yield fetch(`https://shellx.ai/api/device/${authKey}`, {
+                method: 'GET',
+                headers: {
+                    'Content-Type': 'application/json',
+                }
+            });
+            if (!response.ok) {
+                throw new Error(`Authentication failed: ${response.status} ${response.statusText}`);
+            }
+            const data = yield response.json();
+            if (data.status !== 'success') {
+                throw new Error(`Authentication failed: ${data.message}`);
+            }
+            console.log('✅ [Auth] 设备认证成功');
+            console.log(`📡 [Auth] 连接信息: ${data.machine}`);
+            return data.machine;
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            console.warn('⚠️ [Auth] 在线认证失败，使用本地默认连接:', errorMessage);
+            // 认证失败时使用默认的本地WebSocket URL
+            const fallbackUrl = `ws://127.0.0.1:9091/api/s/${authKey}`;
+            console.log(`🔄 [Auth] 使用默认连接: ${fallbackUrl}`);
+            return fallbackUrl;
+        }
+    });
+}
+/**
+ * Create ShellX instance with automatic authentication and shell output monitoring
+ * 自动处理认证和连接，无需外部提供WebSocket URL
+ */
+function createShellXWithShellMonitoring() {
+    return __awaiter(this, arguments, void 0, function* (config = {}) {
+        try {
+            // 认证并获取WebSocket URL
+            const wsUrl = yield authenticateDevice();
+            // 先创建 shellx 实例，但不绑定客户端
+            const shellx = new ShellX(null);
+            // 创建客户端时设置消息监听器
+            const client = new index_1.default(wsUrl, Object.assign(Object.assign({}, config), { onMessage: (message) => {
+                    // 处理 chunks 数据（pty 终端输出）
+                    if (message.chunks) {
+                        shellx.handleShellOutput(message.chunks);
+                    }
+                    // 调用原始的消息处理器
+                    if (config.onMessage) {
+                        config.onMessage(message);
+                    }
+                } }));
+            // 绑定客户端到 shellx
+            shellx.client = client;
+            console.log('🚀 [ShellX] 初始化完成，可以开始使用自动化功能');
+            return { client, shellx };
+        }
+        catch (error) {
+            console.error('❌ [ShellX] 初始化失败:', error);
+            throw error;
+        }
+    });
+}