shellx-ai 1.0.8 → 1.0.9

package/dist/shellx.js

@@ -1,37 +1,4 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 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) {
@@ -45,11 +12,9 @@ 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.ShellX = void 0;
 exports.createShellX = createShellX;
-exports.createHelpers = createShellX;
 exports.createShellXWithShellMonitoring = createShellXWithShellMonitoring;
-exports.createHelpersWithShellMonitoring = createShellXWithShellMonitoring;
 const uuid_1 = require("uuid");
 const utils_1 = require("./utils");
 // 导入 WebSocketTaskClient 类
@@ -258,6 +223,490 @@ class ShellX {
     generateCommandKey(command) {
         return `cmd_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
     }
+    /**
+     * 通用重试机制
+     */
+    withRetry(operation_1) {
+        return __awaiter(this, arguments, void 0, function* (operation, options = {}) {
+            const { retry = 3, delay = 1000, onRetry } = options;
+            for (let attempt = 1; attempt <= retry; attempt++) {
+                try {
+                    return yield operation();
+                }
+                catch (error) {
+                    if (attempt === retry) {
+                        throw error;
+                    }
+                    if (onRetry) {
+                        onRetry(attempt, error);
+                    }
+                    console.log(`🔄 [Retry] 第 ${attempt} 次尝试失败，${delay}ms 后重试...`);
+                    yield new Promise(resolve => setTimeout(resolve, delay));
+                }
+            }
+            throw new Error('重试次数已用完');
+        });
+    }
+    /**
+     * 转换精简选择器为原始选择器
+     */
+    convertSelector(selector) {
+        return {
+            elementId: selector.targetElementId,
+            resourceId: selector.targetResourceId,
+            className: selector.targetClass,
+            text: selector.targetText,
+            textContains: undefined,
+            visible: selector.visible,
+            clickable: selector.clickable
+        };
+    }
+    /**
+     * 转换精简元素为原始元素
+     */
+    convertElement(uiElement) {
+        return {
+            id: uiElement.elementId,
+            text: uiElement.text,
+            class: uiElement.className,
+            left: uiElement.bounds.left,
+            top: uiElement.bounds.top,
+            right: uiElement.bounds.right,
+            bottom: uiElement.bounds.bottom,
+            visible: uiElement.visible,
+            clickable: uiElement.clickable
+        };
+    }
+    // ==================== 精简 Action 封装函数 ====================
+    /**
+     * 点击操作 - 支持元素ID、坐标或选择器
+     */
+    click(clickData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const startTime = Date.now();
+            return this.withRetry(() => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    let target;
+                    if (clickData.targetElementId) {
+                        // 元素ID
+                        target = { type: "elementId", value: clickData.targetElementId };
+                    }
+                    else if (clickData.targetResourceId) {
+                        // 精简元素
+                        target = { type: "resourceId", value: clickData.targetResourceId };
+                    }
+                    else if (clickData.targetX !== undefined && clickData.targetY !== undefined) {
+                        // 坐标
+                        target = { type: "coordinate", value: { x: clickData.targetX, y: clickData.targetY } };
+                    }
+                    else if (clickData.targetText || clickData.targetClass) {
+                        // 选择器
+                        const element = yield this.findElementWithRetry(this.convertSelector(clickData), clickData.retry || 3);
+                        if (!element) {
+                            throw new Error('未找到目标元素');
+                        }
+                        target = { type: "elementId", value: element.elementId };
+                    }
+                    else {
+                        throw new Error('必须指定目标：targetElementId、targetResourceId、坐标(targetX/targetY)或选择器(targetText/targetClass)');
+                    }
+                    const action = {
+                        title: `点击操作: ${clickData.clickType || 'single'}`,
+                        actions: [{
+                                type: "click",
+                                target,
+                                options: {
+                                    clickType: clickData.clickType || 'single',
+                                    waitAfterMs: clickData.wait || 1000
+                                }
+                            }]
+                    };
+                    yield this.client.executeAction(action);
+                    return {
+                        success: true,
+                        data: {
+                            targetElementId: clickData.targetElementId,
+                            targetResourceId: clickData.targetResourceId,
+                            targetText: clickData.targetText,
+                            targetClass: clickData.targetClass,
+                            targetX: clickData.targetX,
+                            targetY: clickData.targetY,
+                            clickType: clickData.clickType
+                        },
+                        duration: Date.now() - startTime
+                    };
+                }
+                catch (error) {
+                    throw new Error(`点击操作失败: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            }), { retry: clickData.retry, delay: 500 });
+        });
+    }
+    /**
+     * 输入操作 - 支持元素ID、资源ID或选择器
+     */
+    input(inputData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const startTime = Date.now();
+            return this.withRetry(() => __awaiter(this, void 0, void 0, function* () {
+                var _a, _b;
+                try {
+                    let target;
+                    if (inputData.targetElementId) {
+                        target = { type: "elementId", value: inputData.targetElementId };
+                    }
+                    else if (inputData.targetResourceId) {
+                        target = { type: "resourceId", value: inputData.targetResourceId };
+                    }
+                    else if (inputData.targetText || inputData.targetClass) {
+                        const element = yield this.findElementWithRetry(this.convertSelector(inputData), inputData.retry || 3);
+                        if (!element) {
+                            throw new Error('未找到目标元素');
+                        }
+                        target = { type: "elementId", value: element.elementId };
+                    }
+                    else {
+                        throw new Error('必须指定目标：targetElementId、targetResourceId、targetText或targetClass');
+                    }
+                    const action = {
+                        title: `输入文本: ${inputData.text}`,
+                        actions: [{
+                                type: "input",
+                                text: inputData.text,
+                                target,
+                                options: {
+                                    replaceExisting: (_a = inputData.clear) !== null && _a !== void 0 ? _a : true,
+                                    hideKeyboardAfter: (_b = inputData.hideKeyboard) !== null && _b !== void 0 ? _b : false,
+                                    waitAfterMs: inputData.wait || 500
+                                }
+                            }]
+                    };
+                    yield this.client.executeAction(action);
+                    return {
+                        success: true,
+                        data: {
+                            text: inputData.text,
+                            targetElementId: inputData.targetElementId,
+                            targetResourceId: inputData.targetResourceId,
+                            targetText: inputData.targetText,
+                            targetClass: inputData.targetClass
+                        },
+                        duration: Date.now() - startTime
+                    };
+                }
+                catch (error) {
+                    throw new Error(`输入操作失败: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            }), { retry: inputData.retry, delay: 500 });
+        });
+    }
+    /**
+     * 滑动操作 - 支持坐标点
+     */
+    swipe(swipeData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const startTime = Date.now();
+            return this.withRetry(() => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    const from = { x: swipeData.fromX, y: swipeData.fromY };
+                    const to = { x: swipeData.toX, y: swipeData.toY };
+                    const action = {
+                        title: `滑动操作: ${from.x},${from.y} → ${to.x},${to.y}`,
+                        actions: [{
+                                type: "swipe",
+                                from,
+                                to,
+                                options: {
+                                    durationMs: swipeData.duration || 800,
+                                    waitAfterMs: swipeData.wait || 500
+                                }
+                            }]
+                    };
+                    yield this.client.executeAction(action);
+                    return {
+                        success: true,
+                        data: { from, to, duration: swipeData.duration },
+                        duration: Date.now() - startTime
+                    };
+                }
+                catch (error) {
+                    throw new Error(`滑动操作失败: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            }), { retry: swipeData.retry, delay: 500 });
+        });
+    }
+    /**
+     * 按键操作
+     */
+    pressKey(keyData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const startTime = Date.now();
+            return this.withRetry(() => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    const action = {
+                        title: `按键操作: ${keyData.key}${keyData.longPress ? ' (长按)' : ''}`,
+                        actions: [{
+                                type: "key",
+                                keyCode: keyData.key,
+                                options: {
+                                    longPress: keyData.longPress || false
+                                }
+                            }]
+                    };
+                    yield this.client.executeAction(action);
+                    if (keyData.wait) {
+                        yield new Promise(resolve => setTimeout(resolve, keyData.wait));
+                    }
+                    return {
+                        success: true,
+                        data: { key: keyData.key, longPress: keyData.longPress },
+                        duration: Date.now() - startTime
+                    };
+                }
+                catch (error) {
+                    throw new Error(`按键操作失败: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            }), { retry: keyData.retry, delay: 500 });
+        });
+    }
+    /**
+     * 等待操作 - 等待元素出现或消失
+     */
+    wait(waitData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const startTime = Date.now();
+            return this.withRetry(() => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    const selector = this.convertSelector(waitData);
+                    const timeout = waitData.timeout || 10000;
+                    const interval = 500;
+                    const maxAttempts = Math.floor(timeout / interval);
+                    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+                        try {
+                            const result = yield this.client.findElement(selector, {
+                                timeout: interval,
+                                maxResults: 1,
+                                visibleOnly: waitData.condition === 'visible',
+                                clickableOnly: waitData.condition === 'clickable'
+                            });
+                            if (result.elements.length > 0) {
+                                if (waitData.condition === 'gone') {
+                                    // 等待元素消失，继续等待
+                                    yield new Promise(resolve => setTimeout(resolve, interval));
+                                    continue;
+                                }
+                                else {
+                                    // 等待元素出现，已找到
+                                    return {
+                                        success: true,
+                                        data: { element: this.convertElement(result.elements[0]) },
+                                        duration: Date.now() - startTime
+                                    };
+                                }
+                            }
+                            else if (waitData.condition === 'gone') {
+                                // 等待元素消失，已消失
+                                return {
+                                    success: true,
+                                    data: { element: null },
+                                    duration: Date.now() - startTime
+                                };
+                            }
+                        }
+                        catch (error) {
+                            // 查找失败，继续等待
+                        }
+                        yield new Promise(resolve => setTimeout(resolve, interval));
+                    }
+                    throw new Error(`等待超时: ${waitData.condition || 'visible'}`);
+                }
+                catch (error) {
+                    throw new Error(`等待操作失败: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            }), { retry: waitData.retry, delay: 500 });
+        });
+    }
+    /**
+     * 查找操作 - 查找元素
+     */
+    find(findData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.withRetry(() => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    const selector = this.convertSelector(findData);
+                    const result = yield this.client.findElement(selector, {
+                        pressClick: findData.pressClick,
+                        waitAfterMs: findData.waitAfterMs || 5000,
+                        maxResults: findData.maxResults || 1000,
+                        visibleOnly: true,
+                        clickableOnly: false,
+                        multiple: findData.multiple || false
+                    });
+                    const elements = result.elements.map(element => this.convertElement(element));
+                    return {
+                        elements,
+                        count: elements.length,
+                        success: true,
+                        found: result.found,
+                    };
+                }
+                catch (error) {
+                    throw new Error(`查找操作失败: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            }), { retry: findData.retry, delay: 500 });
+        });
+    }
+    /**
+     * 执行命令 - 兼容现有的 shell 命令执行
+     */
+    executeCommand(commandData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.withRetry(() => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    const result = yield this.executeShellCommand(commandData.cmd, {
+                        title: `执行命令: ${commandData.cmd}`,
+                        timeout: commandData.timeout,
+                        waitAfterMs: commandData.wait
+                    });
+                    return result;
+                }
+                catch (error) {
+                    throw new Error(`命令执行失败: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            }), { retry: commandData.retry, delay: 1000 });
+        });
+    }
+    /**
+     * 获取应用信息
+     */
+    getAppInfo(appInfoData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const startTime = Date.now();
+            return this.withRetry(() => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    const action = {
+                        title: `获取应用信息: ${appInfoData.package}`,
+                        actions: [{
+                                type: "get_app_info",
+                                packageName: appInfoData.package
+                            }]
+                    };
+                    yield this.client.executeAction(action);
+                    return {
+                        success: true,
+                        data: { package: appInfoData.package },
+                        duration: Date.now() - startTime
+                    };
+                }
+                catch (error) {
+                    throw new Error(`获取应用信息失败: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            }), { retry: appInfoData.retry, delay: 500 });
+        });
+    }
+    /**
+     * 截图操作
+     */
+    takeScreenshot() {
+        return __awaiter(this, arguments, void 0, function* (screenshotData = {}) {
+            const startTime = Date.now();
+            return this.withRetry(() => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    const options = {
+                        format: screenshotData.format || 'png',
+                        quality: screenshotData.quality,
+                        scale: 0.10,
+                    };
+                    if (screenshotData.regionX !== undefined && screenshotData.regionY !== undefined &&
+                        screenshotData.regionWidth !== undefined && screenshotData.regionHeight !== undefined) {
+                        options.region = {
+                            left: screenshotData.regionX,
+                            top: screenshotData.regionY,
+                            width: screenshotData.regionWidth,
+                            height: screenshotData.regionHeight
+                        };
+                    }
+                    const screenshot = yield this.client.screenShot(options);
+                    return {
+                        success: true,
+                        data: screenshot,
+                        duration: Date.now() - startTime
+                    };
+                }
+                catch (error) {
+                    throw new Error(`截图操作失败: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            }), { retry: screenshotData.retry, delay: 500 });
+        });
+    }
+    /**
+     * 执行操作序列 - 支持多个操作连续执行
+     */
+    executeActions(actions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const results = [];
+            for (const [index, action] of actions.entries()) {
+                try {
+                    console.log(`🔨 [Actions] 执行第 ${index + 1}/${actions.length} 个操作`);
+                    let result;
+                    if ('text' in action && ('targetElementId' in action || 'targetResourceId' in action || 'targetText' in action || 'targetClass' in action)) {
+                        result = yield this.input(action);
+                    }
+                    else if ('targetElementId' in action || 'targetResourceId' in action || 'targetText' in action || 'targetClass' in action || 'targetX' in action || 'targetY' in action) {
+                        result = yield this.click(action);
+                    }
+                    else if ('fromX' in action && 'fromY' in action && 'toX' in action && 'toY' in action) {
+                        result = yield this.swipe(action);
+                    }
+                    else if ('key' in action) {
+                        result = yield this.pressKey(action);
+                    }
+                    else if ('condition' in action && ('targetElementId' in action || 'targetResourceId' in action || 'targetText' in action || 'targetClass' in action)) {
+                        result = yield this.wait(action);
+                    }
+                    else if ('multiple' in action && ('targetElementId' in action || 'targetResourceId' in action || 'targetText' in action || 'targetClass' in action)) {
+                        const findResult = yield this.find(action);
+                        result = {
+                            success: findResult.success,
+                            data: findResult,
+                            duration: 0
+                        };
+                    }
+                    else if ('cmd' in action) {
+                        const cmdResult = yield this.executeCommand(action);
+                        result = {
+                            success: cmdResult.success,
+                            data: cmdResult,
+                            duration: cmdResult.duration
+                        };
+                    }
+                    else if ('package' in action) {
+                        result = yield this.getAppInfo(action);
+                    }
+                    else {
+                        result = yield this.takeScreenshot(action);
+                    }
+                    results.push(result);
+                    // 如果操作失败且不允许继续，则抛出错误
+                    if (!result.success) {
+                        throw new Error(`操作 ${index + 1} 失败: ${result.error}`);
+                    }
+                    console.log(`✅ [Actions] 第 ${index + 1} 个操作执行成功`);
+                }
+                catch (error) {
+                    const errorResult = {
+                        success: false,
+                        error: error instanceof Error ? error.message : String(error),
+                        duration: 0
+                    };
+                    results.push(errorResult);
+                    console.error(`❌ [Actions] 第 ${index + 1} 个操作执行失败:`, error);
+                    throw error; // 停止执行后续操作
+                }
+            }
+            return results;
+        });
+    }
     /**
      * Smart element finder with retry logic
      */
@@ -411,47 +860,6 @@ class ShellX {
             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
      */
@@ -530,7 +938,35 @@ class ShellX {
             // Try scrolling to find
             for (let i = 0; i < maxScrolls; i++) {
                 console.log(`滚动查找第 ${i + 1} 次...`);
-                yield this.swipe(direction);
+                // 获取屏幕信息来计算坐标
+                const screenInfo = yield this.client.getScreenInfo();
+                const centerX = (screenInfo.width || 1080) / 2;
+                const centerY = (screenInfo.height || 1920) / 2;
+                let from, to;
+                const distance = 400;
+                if (direction === 'up') {
+                    from = { x: centerX, y: centerY + distance / 2 };
+                    to = { x: centerX, y: centerY - distance / 2 };
+                }
+                else if (direction === 'down') {
+                    from = { x: centerX, y: centerY - distance / 2 };
+                    to = { x: centerX, y: centerY + distance / 2 };
+                }
+                else if (direction === 'left') {
+                    from = { x: centerX + distance / 2, y: centerY };
+                    to = { x: centerX - distance / 2, y: centerY };
+                }
+                else {
+                    from = { x: centerX - distance / 2, y: centerY };
+                    to = { x: centerX + distance / 2, y: centerY };
+                }
+                yield this.swipe({
+                    fromX: from.x,
+                    fromY: from.y,
+                    toX: to.x,
+                    toY: to.y,
+                    duration: 800
+                });
                 element = yield this.findElementWithRetry(selector, 1, 0);
                 if (element) {
                     console.log('✅ 滚动后找到元素');
@@ -756,138 +1192,12 @@ class ShellX {
     }
 }
 exports.ShellX = ShellX;
-exports.AutomationHelpers = ShellX;
 /**
  * Create ShellX instance
  */
 function createShellX(client) {
     return new ShellX(client);
 }
-/**
- * 获取ofetch实例
- */
-function getfetch() {
-    return __awaiter(this, void 0, void 0, function* () {
-        try {
-            // @ts-ignore - Dynamic import may not have types
-            const { ofetch } = yield Promise.resolve().then(() => __importStar(require('ofetch')));
-            // 创建配置好的ofetch实例
-            const fetchInstance = ofetch.create({
-                timeout: 10000,
-                retry: 1,
-                retryDelay: 1000,
-                headers: {
-                    'User-Agent': 'ShellX/1.0.1'
-                },
-                onRequest({ request, options }) {
-                    console.log(`🌐 [Fetch] 请求: ${options.method || 'GET'} ${request}`);
-                },
-                onResponse({ response }) {
-                    console.log(`📡 [Fetch] 响应: ${response.status} ${response.statusText}`);
-                },
-                onRequestError({ error }) {
-                    console.error('❌ [Fetch] 请求错误:', error.message);
-                },
-                onResponseError({ response }) {
-                    console.error(`❌ [Fetch] 响应错误: ${response.status} ${response.statusText}`);
-                }
-            });
-            return fetchInstance;
-        }
-        catch (error) {
-            console.warn('⚠️ [Auth] ofetch不可用，使用降级方案');
-            return createFallbackFetch();
-        }
-    });
-}
-/**
- * 降级fetch实现
- */
-function createFallbackFetch() {
-    return (url, options) => __awaiter(this, void 0, void 0, function* () {
-        // 尝试使用全局fetch
-        if (typeof globalThis.fetch !== 'undefined') {
-            console.log(`🌐 [Fetch] 请求: ${(options === null || options === void 0 ? void 0 : options.method) || 'GET'} ${url}`);
-            const response = yield globalThis.fetch(url, options);
-            console.log(`📡 [Fetch] 响应: ${response.status} ${response.statusText}`);
-            if (!response.ok) {
-                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-            }
-            return response.json();
-        }
-        // Node.js环境降级
-        try {
-            const { default: fetch } = yield Promise.resolve().then(() => __importStar(require('node-fetch')));
-            console.log(`🌐 [Fetch] 请求: ${(options === null || options === void 0 ? void 0 : options.method) || 'GET'} ${url}`);
-            const response = yield fetch(url, options);
-            console.log(`📡 [Fetch] 响应: ${response.status} ${response.statusText}`);
-            if (!response.ok) {
-                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-            }
-            return response.json();
-        }
-        catch (fetchError) {
-            throw new Error(`Fetch not available: ${fetchError.message}`);
-        }
-    });
-}
-/**
- * 从ShellX.ai服务认证并获取WebSocket连接信息
- */
-function authenticateDevice(deviceId) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const fallbackUrl = `ws://127.0.0.1:9091/api/s/${deviceId}`;
-        // 1. 优先检测本地服务
-        try {
-            // fetch超时实现
-            const fetchWithTimeout = (url, options, timeout = 1000) => Promise.race([
-                fetch(url, options),
-                new Promise((_, reject) => setTimeout(() => reject(new Error('timeout')), timeout))
-            ]);
-            const localResp = yield fetchWithTimeout('http://127.0.0.1:9091/info', { method: 'GET', headers: { 'Accept': 'application/json' } }, 1000);
-            if (localResp.ok) {
-                const info = yield localResp.json();
-                if (info && (info.status === 'ok' || info.status === 1)) {
-                    console.log('✅ [Auth] 本地ShellX服务可用，直接使用本地服务:', fallbackUrl);
-                    return fallbackUrl;
-                }
-            }
-        }
-        catch (e) {
-            // 本地不可用，继续走远程
-        }
-        // 2. 远程认证逻辑
-        authKey = (0, utils_1.getEnvVar)('SHELLX_AUTH_KEY');
-        if (!authKey) {
-            throw new Error('SHELLX_AUTH_KEY environment variable is required');
-        }
-        try {
-            console.log('🔑 [Auth] 正在认证设备...');
-            // 获取ofetch实例
-            const fetchFn = yield getfetch();
-            // ofetch自动处理JSON解析和错误处理
-            const data = yield fetchFn(`https://shellx.ai/api/device/${deviceId}`, {
-                method: 'GET',
-                headers: {
-                    'Content-Type': 'application/json',
-                }
-            });
-            const jsonData = JSON.parse(data);
-            console.log('✅ [Auth] ShellX.ai设备认证成功');
-            console.log(`📡 [Auth] 设备ID: ${jsonData.authenticate}`);
-            console.log(`📡 [Auth] ShellX.ai服务地址: ${jsonData.machine}`);
-            console.log(`📡 [Auth] 注册时间: ${jsonData.registered_at}`);
-            console.log(`📡 [Auth] 最后更新: ${jsonData.last_updated}`);
-            return jsonData.machine + '/api/s/' + jsonData.authenticate;
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            console.warn('⚠️ [Auth] ShellX.ai在线认证失败，使用本地服务:', errorMessage);
-            console.log(`🔄 [Auth] 使用本地ShellX服务: ${fallbackUrl}`);
-            return fallbackUrl;
-        }
-    });
-}
 /**
  * Create ShellX instance with automatic authentication and shell output monitoring
  * 自动处理ShellX.ai认证和连接，无需外部提供连接地址
@@ -895,9 +1205,8 @@ function authenticateDevice(deviceId) {
 function createShellXWithShellMonitoring() {
     return __awaiter(this, arguments, void 0, function* (config = {}) {
         try {
-            const wsUrl = yield authenticateDevice(config.deviceId);
             const shellx = new ShellX(null);
-            const client = new index_1.default(wsUrl, Object.assign(Object.assign({}, config), { onMessage: (message) => {
+            const client = new index_1.default(config.deviceId, Object.assign(Object.assign({}, config), { onMessage: (message) => {
                     if (message.chunks) {
                         shellx.handleShellOutput(message.chunks);
                     }
@@ -918,7 +1227,7 @@ function createShellXWithShellMonitoring() {
             // 将 shellx 实例关联到客户端
             client.setShellX(shellx);
             console.log('🚀 [ShellX] 初始化完成，等待ShellX.ai服务响应...');
-            return { client, shellx };
+            return shellx;
         }
         catch (error) {
             console.error('❌ [ShellX] 初始化失败:', error);