shellx-ai 1.0.12 → 1.1.0

package/dist/index.js

@@ -1,52 +1,41 @@
-"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) {
-        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());
-    });
+import { v4 as uuidv4 } from "uuid";
+import { wait } from "./utils.js";
+import { buildDeviceApiUrl } from "./domain-manager.js";
+import { createLogger } from "./logger.js";
+// Add readable timestamp to all logs
+const formatTs = () => {
+    const now = new Date();
+    return now.toISOString();
+};
+const executionLogStore = [];
+const formatLogArgs = (args) => args
+    .map((arg) => {
+    if (typeof arg === "string")
+        return arg;
+    try {
+        return JSON.stringify(arg);
+    }
+    catch {
+        return String(arg);
+    }
+})
+    .join(" ");
+const pushExecutionLog = (ts, args) => {
+    executionLogStore.push(`[${ts}] ${formatLogArgs(args)}`);
+};
+const originalConsoleLog = console.log.bind(console);
+const originalConsoleWarn = console.warn.bind(console);
+const originalConsoleError = console.error.bind(console);
+const wrapConsole = (originalFn) => (...args) => {
+    const ts = formatTs();
+    pushExecutionLog(ts, args);
+    originalFn(`[${ts}]`, ...args);
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ShellX = exports.createShellXWithShellMonitoring = exports.ConnectionTaskClient = exports.DEFAULT_CONFIG = void 0;
-const uuid_1 = require("uuid");
-const utils_1 = require("./utils");
-// 定义默认配置
-exports.DEFAULT_CONFIG = {
+console.log = wrapConsole(originalConsoleLog);
+console.warn = wrapConsole(originalConsoleWarn);
+console.error = wrapConsole(originalConsoleError);
+// Define default configuration
+export const DEFAULT_CONFIG = {
     timeout: 5000,
     reconnect: true,
     reconnectMaxAttempts: 5,
@@ -57,230 +46,316 @@ exports.DEFAULT_CONFIG = {
     onError: () => { },
     onReconnectFailed: () => { },
 };
-const cbor_1 = require("cbor");
-// 安全地获取环境变量，兼容浏览器和Node.js环境
-let authKey = (0, utils_1.getEnvVar)('SHELLX_AUTH_KEY');
+import { initCbor, cborEncode, cborDecode } from "./cbor-compat.js";
 /**
- * 获取适合当前环境的WebSocket构造函数
+ * Get WebSocket constructor for current environment
  */
-function getWebSocket() {
-    return __awaiter(this, void 0, void 0, function* () {
-        // 检查是否已有全局WebSocket（浏览器环境或Node.js 20+）
-        if (typeof globalThis.WebSocket !== 'undefined') {
-            return globalThis.WebSocket;
-        }
-        // Node.js环境下动态导入ws模块
-        try {
-            const wsModule = yield Promise.resolve().then(() => __importStar(require('ws')));
-            return wsModule.default || wsModule;
-        }
-        catch (error) {
-            console.error('❌ [WebSocket] ws模块不可用，请安装: npm install ws');
-            throw new Error('WebSocket not available. Please install ws module: npm install ws');
-        }
-    });
+async function getWebSocket() {
+    // Check if global WebSocket exists (browser environment or Node.js 20+)
+    if (typeof globalThis.WebSocket !== "undefined") {
+        return globalThis.WebSocket;
+    }
+    // Dynamically import ws module in Node.js environment
+    try {
+        const wsModule = await import("ws");
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access
+        return (wsModule.default || wsModule);
+    }
+    catch {
+        console.error("❌ [WebSocket] ws module is not available, please install: npm install ws");
+        throw new Error("WebSocket not available. Please install ws module: npm install ws");
+    }
 }
 function isPendingTask(taskType) {
-    return taskType && taskType !== "command";
+    return taskType && taskType !== "command" && taskType !== "oneway";
 }
 /**
- * Enhanced WebSocket Task Client with protocol-aware task methods
+ * Low-level WebSocket Client for direct protocol communication
+ *
+ * @warning This is a low-level API intended for advanced use cases only.
+ * Most users should use the ShellX class instead, which provides a simpler,
+ * more intuitive interface with automatic error handling and retry logic.
+ *
+ * @example
+ * ```typescript
+ * // For most users, use ShellX instead:
+ * import { ShellX } from './shellx';
+ * const shellx = new ShellX({ deviceId: 'your-device-id' });
+ * await shellx.connect();
+ * await shellx.click({ text: 'Submit' });
+ * ```
+ *
+ * @see Use ShellX for a high-level API unless you need low-level WebSocket access
  */
-class ConnectionTaskClient {
-    constructor(deviceId, config = {}) {
-        this.ws = null; // Use any to avoid WebSocket type issues
-        this.shellxConnected = false; // ShellX.ai 连接状态
-        this.wsConnected = false; // WebSocket 连接状态
-        this.authenticated = false; // 认证状态
-        this.pendingTasks = new Map();
-        this.messageQueue = [];
-        this.reconnectAttempts = 0;
-        this.pingIntervalId = null;
-        this.initializationPromise = null;
-        this.shellx = null; // 关联的 ShellX 实例
+export class ConnectionClient {
+    wsUrl;
+    deviceId;
+    config;
+    ws = null;
+    shellxConnected = false; // ShellX.ai connection status
+    wsConnected = false; // WebSocket connection status
+    authenticated = false; // Authentication status
+    pendingTasks = new Map();
+    messageQueue = [];
+    reconnectAttempts = 0;
+    pingIntervalId = null;
+    initializationPromise = null;
+    shellx = null; // Associated ShellX instance
+    executionLogsRef = executionLogStore; // Current execution log
+    logger;
+    constructor(deviceId, config = {}, logger) {
         this.deviceId = deviceId;
-        this.config = Object.assign(Object.assign({}, exports.DEFAULT_CONFIG), config);
+        this.config = { ...DEFAULT_CONFIG, ...config };
+        // Use provided logger or create default one
+        this.logger = logger || createLogger("ConnectionClient");
         this.initializationPromise = this.init();
     }
-    init() {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b;
-            try {
-                this.wsUrl = yield this.authenticateDevice(this.deviceId);
-                if (!this.wsUrl) {
+    async init() {
+        await initCbor(); // load the right CBOR codec for this environment
+        return new Promise((resolve, reject) => {
+            this.authenticateDevice()
+                .then((wsUrl) => {
+                if (!wsUrl) {
                     this.config.onError(new Event("connection"));
+                    void this.reconnect();
+                    reject(new Error("Failed to authenticate device"));
                     return;
                 }
-                console.log('Initializing ShellX client wsUrl:' + this.wsUrl + " deviceId: " + this.deviceId);
-                // 获取适合当前环境的WebSocket构造函数
-                const WebSocketConstructor = yield getWebSocket();
-                this.ws = new WebSocketConstructor(this.wsUrl);
-                // 设置二进制类型（如果支持）
-                if (this.ws.binaryType !== undefined) {
-                    this.ws.binaryType = 'arraybuffer';
-                }
-                this.ws.onopen = () => {
-                    console.log('🔗 [ShellX] WebSocket连接已建立，发送认证消息...' + this.wsUrl);
-                    this.wsConnected = true;
-                    this.reconnectAttempts = 0;
-                    // 连接建立后立即发送认证消息
-                    this.sendAuthenticationMessage();
-                };
-                this.ws.onmessage = (event) => {
-                    this.handleMessage(event);
-                };
-                this.ws.onclose = (event) => {
-                    var _a, _b;
-                    console.log('❌ [ShellX] WebSocket连接已关闭，正在尝试重新连接...' +
-                        event.code +
-                        ' ' +
-                        this.wsUrl);
-                    this.wsConnected = false;
-                    this.shellxConnected = false;
-                    this.authenticated = false;
-                    (_b = (_a = this.config).onClose) === null || _b === void 0 ? void 0 : _b.call(_a, event);
-                    this.stopPing();
-                    this.reconnect();
-                };
-                this.ws.onerror = (error) => {
-                    var _a, _b;
-                    (_b = (_a = this.config).onError) === null || _b === void 0 ? void 0 : _b.call(_a, error);
-                };
-            }
-            catch (error) {
-                console.error('❌ [WebSocket] 初始化失败:', error);
-                (_b = (_a = this.config).onError) === null || _b === void 0 ? void 0 : _b.call(_a, error);
-                throw error;
-            }
+                // ✅ Store the WebSocket URL for later use
+                this.wsUrl = wsUrl;
+                const separator = wsUrl.includes("?") ? "&" : "?";
+                const wsUrlWithSessionId = `${wsUrl}${separator}session_id=${this.deviceId}`;
+                this.logger.info("Initializing ShellX client wsUrl:" + wsUrl + " deviceId: " + this.deviceId);
+                this.logger.info("WebSocket URL with session_id: " + wsUrlWithSessionId);
+                // Get WebSocket constructor for current environment
+                getWebSocket()
+                    .then((WebSocketConstructor) => {
+                    try {
+                        this.ws = new WebSocketConstructor(wsUrlWithSessionId);
+                        // Set binary type (if supported)
+                        if (this.ws.binaryType !== undefined) {
+                            this.ws.binaryType = "arraybuffer";
+                        }
+                        this.ws.onopen = () => {
+                            this.logger.info("🔗 [ShellX] WebSocket connection established:" + this.wsUrl);
+                            this.wsConnected = true;
+                            this.reconnectAttempts = 0;
+                            // Mark as connected after WebSocket open
+                            this.shellxConnected = true;
+                            this.config.onOpen?.(this.deviceId);
+                            void this.flushQueue();
+                            void this.startPing();
+                            // Resolve initialization promise after WebSocket is connected
+                            resolve();
+                            // Check if we're in Android sandbox environment
+                            const isAndroidSandbox = process.env["SANDBOX"] === "android";
+                            if (isAndroidSandbox) {
+                                void this.getScreenInfo();
+                            }
+                            else {
+                                void this.getAndWakeScreen();
+                            }
+                        };
+                        this.ws.onmessage = (event) => {
+                            void this.handleMessage(event);
+                        };
+                        this.ws.onclose = (event) => {
+                            this.logger.info("❌ [ShellX] WebSocket connection closed, attempting to reconnect..." +
+                                event.code +
+                                " " +
+                                this.wsUrl);
+                            this.wsConnected = false;
+                            this.shellxConnected = false;
+                            this.authenticated = false;
+                            this.config.onClose?.(event);
+                            this.stopPing();
+                            void this.reconnect();
+                        };
+                        this.ws.onerror = (error) => {
+                            this.logger.error("❌ [ShellX] WebSocket error:", error);
+                            this.config.onError?.(error);
+                            reject(new Error("WebSocket connection failed"));
+                        };
+                    }
+                    catch (error) {
+                        this.logger.error("❌ [WebSocket] Initialization failed:", error);
+                        const err = error instanceof Error ? error : new Error(String(error));
+                        this.config.onError?.(err);
+                        reject(err);
+                    }
+                })
+                    .catch((error) => {
+                    this.logger.error("❌ [WebSocket] Failed to get constructor:", error);
+                    const err = error instanceof Error ? error : new Error(String(error));
+                    reject(err);
+                });
+            })
+                .catch((error) => {
+                this.logger.error("❌ [Auth] Device authentication failed:", error);
+                const err = error instanceof Error ? error : new Error(String(error));
+                reject(err);
+            });
         });
     }
-    authenticateDevice(deviceId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let fallbackUrl = undefined;
-            // 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) && info.uuid) {
-                        if (deviceId == undefined || deviceId == info.uuid) {
-                            const localUuid = info.uuid;
-                            fallbackUrl = `ws://127.0.0.1:9091/api/s/${localUuid}`;
-                            console.log('✅ [Auth] 本地ShellX服务可用，使用本地 /info 返回的 uuid:', localUuid, '，服务地址:', fallbackUrl);
-                            return fallbackUrl;
-                        }
+    async authenticateDevice() {
+        let fallbackUrl = undefined;
+        // 1. Prioritize local service detection
+        try {
+            // fetch timeout implementation
+            const fetchWithTimeout = (url, options, timeout = 1000) => Promise.race([
+                fetch(url, options),
+                new Promise((_, reject) => setTimeout(() => reject(new Error("timeout")), timeout)),
+            ]);
+            const localResp = await fetchWithTimeout("http://127.0.0.1:9091/info", { method: "GET", headers: { Accept: "application/json" } }, 1000);
+            if (localResp.ok) {
+                const info = (await localResp.json());
+                if (info && (info.status === "ok" || info.status === 1) && info.uuid) {
+                    if (this.deviceId === undefined || this.deviceId === info.uuid) {
+                        const localUuid = info.uuid;
+                        this.deviceId = localUuid;
+                        fallbackUrl = `ws://127.0.0.1:9091/api/s/${localUuid}`;
+                        this.logger.info("✅ [Auth] Local ShellX service available, using local /info returned uuid:", localUuid, ", Service address:", fallbackUrl);
+                        return fallbackUrl;
                     }
                 }
             }
-            catch (e) {
-                // 本地不可用，继续走远程
-            }
-            if (deviceId == undefined) {
-                console.warn('❌ [Auth] 设备ID未设置，本地未连接USB，请设置环境变量 SHELLX_DEVICE_ID 或者 USB连接设备');
-                return undefined;
-            }
-            // 2. 远程认证逻辑
-            authKey = (0, utils_1.getEnvVar)('SHELLX_AUTH_KEY');
-            if (!authKey) {
-                authKey = (0, uuid_1.v4)();
-                console.log('✅ [Auth] SHELLX_AUTH_KEY 环境变量未设置, 生成新的authKey: ' + authKey);
-            }
-            try {
-                console.log('🔑 [Auth] 正在认证设备...');
-                const featGlobal = this.getFetch();
-                const jsonData = yield featGlobal(`https://shellx.ai/api/device/${deviceId}`, {
-                    method: 'GET',
-                    headers: {
-                        'Content-Type': 'application/json',
-                    },
-                });
-                console.log('ShellX.ai设备认证响应:', jsonData);
-                // 验证认证响应是否有效
-                // 如果接口返回 null 或者缺少必要字段，说明设备未注册
-                if (!jsonData || jsonData === null || !jsonData.machine || !jsonData.authenticate) {
-                    console.error('❌ [Auth] ShellX.ai设备未注册或认证信息无效');
-                    return `wss://shellx.ai/api/s/${deviceId}`;
-                }
-                // 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 {
+            // Local unavailable, proceeding with remote
+        }
+        if (this.deviceId === undefined) {
+            this.logger.warn("❌ [Auth] Device ID not set, local USB not connected, please set environment variable SHELLX_DEVICE_ID or connect USB device");
+            return undefined;
+        }
+        // 2. Remote authentication logic
+        try {
+            this.logger.info("🔑 [Auth] Authenticating device...");
+            const featGlobal = this.getFetch();
+            const deviceApiUrl = buildDeviceApiUrl(this.deviceId);
+            const jsonData = (await featGlobal(deviceApiUrl, {
+                method: "GET",
+                headers: {
+                    "Content-Type": "application/json",
+                },
+            }));
+            this.logger.info("ShellX.ai device authentication response:", jsonData);
+            // Check if device is not registered
+            if (jsonData?.status === "not_registered") {
+                this.logger.error("❌ [Auth] Device not registered");
+                this.logger.error(`📝 [Auth] Status: ${jsonData.message || "Device not registered"}`);
+                this.logger.error("💡 [Auth] Please register this device on ShellX.ai platform first");
+                throw new Error(`Device "${this.deviceId}" not registered on ShellX.ai platform. Please visit https://shellx.ai to register the device first.`);
             }
-            catch (error) {
-                const errorMessage = error instanceof Error ? error.message : String(error);
-                console.warn('⚠️ [Auth] ShellX.ai在线认证失败，使用本地服务:', JSON.stringify(errorMessage));
-                return fallbackUrl;
+            // Verify authentication response is valid
+            // If interface returns null or missing required fields, device is not registered
+            if (!jsonData || jsonData === null || !jsonData.machine || !jsonData.authenticate) {
+                this.logger.error("❌ [Auth] ShellX.ai device not registered or invalid authentication information");
+                throw new Error(`Device "${this.deviceId}" has invalid authentication information. Please check device ID or re-register on ShellX.ai platform.`);
             }
-        });
+            // const jsonData = JSON.parse(data);
+            this.logger.info("✅ [Auth] ShellX.ai device authentication successful");
+            this.logger.info(`📡 [Auth] Device ID: ${jsonData.authenticate}`);
+            this.logger.info(`📡 [Auth] ShellX.ai service address: ${jsonData.machine}`);
+            this.logger.info(`📡 [Auth] Registration time: ${jsonData.registered_at}`);
+            this.logger.info(`📡 [Auth] Last update: ${jsonData.last_updated}`);
+            this.logger.info(`📡 [Auth] Device status: ${jsonData.status || "registered"}`);
+            // UUID is the deviceId, no need to extract from URL
+            const wsUrl = `${jsonData.machine}/api/s/${this.deviceId}`;
+            this.logger.info(`🔗 [Auth] WebSocket URL: ${wsUrl}`);
+            return wsUrl;
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            this.logger.warn("⚠️ [Auth] Online authentication failed, using local service:", JSON.stringify(errorMessage));
+            return fallbackUrl;
+        }
     }
     getFetch() {
-        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}`);
+        return async (url, options) => {
+            // Try using global fetch
+            if (typeof globalThis.fetch !== "undefined") {
+                this.logger.info(`🌐 [Fetch] Request: ${options?.method || "GET"} ${url}`);
+                const response = await globalThis.fetch(url, options);
+                this.logger.info(`📡 [Fetch] Response: ${response.status} ${response.statusText}`);
                 if (!response.ok) {
                     throw new Error(`HTTP ${response.status}: ${response.statusText}`);
                 }
                 return response.json();
             }
             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}`);
+                const { default: fetch } = await import("node-fetch");
+                this.logger.info(`🌐 [Fetch] Request: ${options?.method || "GET"} ${url}`);
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-argument
+                const response = await fetch(url, options);
+                this.logger.info(`📡 [Fetch] Response: ${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}`);
+                const errorMessage = fetchError instanceof Error ? fetchError.message : String(fetchError);
+                throw new Error(`Fetch not available: ${errorMessage}`);
             }
-        });
+        };
     }
     /**
-     * 等待WebSocket初始化完成
+     * Wait for WebSocket initialization complete
      */
-    waitForInitialization() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.initializationPromise) {
-                yield this.initializationPromise;
-            }
-        });
+    async waitForInitialization() {
+        if (this.initializationPromise) {
+            await this.initializationPromise;
+        }
     }
     /**
-     * 发送认证消息
+     * Ensure connection is ready before executing device commands
+     * If not connected, wait for connection with timeout
+     *
+     * @param timeout - Timeout in milliseconds (default: 10000ms)
+     * @throws Error if connection timeout or connection failed
+     *
+     * @example
+     * ```typescript
+     * await client.ensureConnected(10000);
+     * console.log('Connection ready');
+     * ```
      */
-    sendAuthenticationMessage() {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                authKey = (0, utils_1.getEnvVar)('SHELLX_AUTH_KEY');
-                if (!authKey) {
-                    authKey = (0, uuid_1.v4)();
-                    console.log('✅ [Auth] SHELLX_AUTH_KEY 环境变量未设置, 生成新的authKey: ' + authKey);
+    async ensureConnected(timeout = 10000) {
+        // If already connected, return immediately
+        if (this.shellxConnected && this.wsConnected) {
+            return;
+        }
+        this.logger.info(`⏳ [ConnectionClient] Waiting for connection to be ready (timeout: ${timeout}ms)...`);
+        const startTime = Date.now();
+        const checkInterval = 100; // Check every 100ms
+        return new Promise((resolve, reject) => {
+            const intervalId = setInterval(() => {
+                const elapsed = Date.now() - startTime;
+                // Check if connected
+                if (this.shellxConnected && this.wsConnected) {
+                    clearInterval(intervalId);
+                    this.logger.info(`✅ [ConnectionClient] Connection ready (took ${elapsed}ms)`);
+                    resolve();
+                    return;
                 }
-                const authMessage = { authenticate: authKey };
-                console.log('📤 [Auth] 发送认证消息:', { authenticate: authKey });
-                if (this.ws && this.wsConnected) {
-                    this.ws.send((0, cbor_1.encode)(authMessage));
+                // Check timeout
+                if (elapsed >= timeout) {
+                    clearInterval(intervalId);
+                    const errorMsg = `Connection timeout after ${timeout}ms. ` +
+                        `Device "${this.deviceId}" is not connected. ` +
+                        `Please check: ` +
+                        `1. Device is online and registered on ShellX.ai ` +
+                        `2. Network connection is stable ` +
+                        `3. Device ID is correct`;
+                    this.logger.error(`❌ [ConnectionClient] ${errorMsg}`);
+                    reject(new Error(errorMsg));
+                    return;
                 }
-                else {
-                    console.error('❌ [Auth] ShellX 未连接，无法发送认证消息');
+                // Log progress every 2 seconds
+                if (elapsed > 0 && elapsed % 2000 < checkInterval) {
+                    this.logger.info(`⏳ [ConnectionClient] Still waiting for connection... (${elapsed}/${timeout}ms)`);
                 }
-            }
-            catch (error) {
-                console.error('❌ [Auth] 发送认证消息失败:', error);
-            }
+            }, checkInterval);
         });
     }
     handleMessage(event) {
@@ -300,11 +375,11 @@ class ConnectionTaskClient {
                 this.processServerMessage(serverMessage);
                 return;
             }
-            serverMessage = (0, cbor_1.decode)(binaryData);
+            serverMessage = cborDecode(binaryData);
             this.processServerMessage(serverMessage);
         }
         catch (cborError) {
-            console.log('CBOR decode failed, trying JSON fallback:', cborError);
+            this.logger.info("CBOR decode failed, trying JSON fallback:", cborError);
             try {
                 let textData;
                 if (event.data instanceof ArrayBuffer) {
@@ -317,316 +392,359 @@ class ConnectionTaskClient {
                 this.processServerMessage(serverMessage);
             }
             catch (jsonError) {
-                console.error('Failed to parse message:', { cborError, jsonError });
+                this.logger.error("Failed to parse message:", { cborError, jsonError });
             }
         }
     }
     processServerMessage(message) {
-        var _a, _b, _c, _d;
-        //console.log('📨 [ShellX] 收到服务器消息:', message);
-        this.authenticated = true;
-        // 只有在认证成功后才处理其他消息并认为连接成功
-        if (this.authenticated && !this.shellxConnected) {
-            this.shellxConnected = true;
-            console.log('✅ [ShellX] ShellX.ai服务连接成功！');
-            (_b = (_a = this.config).onOpen) === null || _b === void 0 ? void 0 : _b.call(_a);
-            this.flushQueue();
-            this.startPing();
-        }
+        //console.log('📨 [ShellX] Received server message:', message);
         // Call user-defined message handler
-        (_d = (_c = this.config).onMessage) === null || _d === void 0 ? void 0 : _d.call(_c, message);
+        this.config.onMessage?.(message);
         // Handle specific message types and resolve pending tasks
         if (message.jsonData) {
             this.handleJsonDataResponse(message.jsonData);
         }
         // Handle other server message types (hello, users, shells, etc.)
         if (message.hello !== undefined) {
-            console.log('👋 [ShellX] 服务器问候，用户ID:', message.hello);
+            this.logger.info("👋 [ShellX] Server greeting, user ID:", message.hello);
         }
         if (message.pong !== undefined) {
-            //console.log('🏓 [ShellX] 收到心跳响应:', message.pong);
+            //console.log('🏓 [ShellX] Heartbeat response:', message.pong);
         }
         if (message.error) {
-            console.error('❌ [ShellX] 服务器错误:', message.error);
+            this.logger.error("❌ [ShellX] Server error:", message.error);
+        }
+    }
+    matchResponseByType(jsonData, taskType) {
+        switch (taskType) {
+            case "findElement":
+                if (jsonData.findElement) {
+                    return jsonData.findElement;
+                }
+                break;
+            case "waitElement":
+                if (jsonData.waitElement) {
+                    return jsonData.waitElement;
+                }
+                break;
+            case "screenShot":
+                if (jsonData.screenShot) {
+                    return jsonData.screenShot;
+                }
+                break;
+            case "screenInfo":
+                if (jsonData.screenInfo) {
+                    return jsonData.screenInfo;
+                }
+                break;
+            case "appList":
+                console.log("appList");
+                console.log(jsonData);
+                if (jsonData.appList) {
+                    return jsonData.appList;
+                }
+                break;
+            case "action":
+                if (jsonData.action_event) {
+                    return jsonData.action_event;
+                }
+                break;
+            case "promptflowx":
+                if (jsonData.promptflowx) {
+                    return jsonData.promptflowx;
+                }
+                break;
+            case "clipboard":
+                if (jsonData.clipboard) {
+                    return jsonData.clipboard;
+                }
+                break;
+            case "asrControl":
+                // ASR control doesn't expect a specific response
+                return { success: true };
         }
+        return undefined;
     }
     handleJsonDataResponse(jsonData) {
-        // Match responses to pending tasks based on response type
-        for (const [taskId, task] of this.pendingTasks.entries()) {
-            let responseData = null;
-            let shouldResolve = false;
-            switch (task.type) {
-                case 'findElement':
-                    if (jsonData.findElement) {
-                        responseData = jsonData.findElement;
-                        shouldResolve = true;
-                    }
-                    break;
-                case 'waitElement':
-                    if (jsonData.waitElement) {
-                        responseData = jsonData.waitElement;
-                        shouldResolve = true;
-                    }
-                    break;
-                case 'screenShot':
-                    if (jsonData.screenShot) {
-                        responseData = jsonData.screenShot;
-                        shouldResolve = true;
+        const responseTaskId = jsonData?.taskId;
+        if (responseTaskId) {
+            const task = this.pendingTasks.get(responseTaskId);
+            if (task) {
+                const responseData = this.matchResponseByType(jsonData, task.type);
+                if (responseData !== undefined) {
+                    clearTimeout(task.timer);
+                    this.pendingTasks.delete(responseTaskId);
+                    if (task.type != "findElement") {
+                        this.logger.info("✅ [ShellX] Response processing complete:", responseTaskId, jsonData);
                     }
-                    break;
-                case 'screenInfo':
-                    if (jsonData.screenInfo) {
-                        responseData = jsonData.screenInfo;
-                        shouldResolve = true;
-                    }
-                    break;
-                case 'appList':
-                    if (jsonData.appList) {
-                        responseData = jsonData.appList;
-                        shouldResolve = true;
-                    }
-                    break;
-                case 'action':
-                    if (jsonData.action_event) {
-                        responseData = jsonData.action_event;
-                        shouldResolve = true;
-                    }
-                    break;
-                case 'actions':
-                    if (jsonData.actions) {
-                        responseData = jsonData.actions;
-                        shouldResolve = true;
-                    }
-                    break;
+                    task.resolve(responseData);
+                    return;
+                }
+                else {
+                    this.logger.warn(`⚠️ [ShellX] Task ${responseTaskId} (type: ${task.type}) found but no matching response data in:`, jsonData);
+                }
+            }
+            else {
+                this.logger.warn(`⚠️ [ShellX] Received taskId ${responseTaskId} but no pending task found`);
             }
-            if (shouldResolve) {
+        }
+        else {
+            this.logger.debug(`📨 [ShellX] Received response without taskId, trying fallback match:`, jsonData);
+        }
+        // Fallback to legacy matching when taskId is missing or not tracked
+        for (const [taskId, task] of this.pendingTasks.entries()) {
+            const responseData = this.matchResponseByType(jsonData, task.type);
+            if (responseData !== undefined) {
                 clearTimeout(task.timer);
                 this.pendingTasks.delete(taskId);
-                // 始终 resolve，保持原始响应数据结构不变
+                this.logger.info(`✅ [ShellX] Fallback match: completed task ${taskId} (type: ${task.type})`);
                 task.resolve(responseData);
-                break; // Only resolve the first matching task
+                break;
             }
         }
     }
-    sendMessage(message, taskType, timeout) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return new Promise((resolve, reject) => {
-                const taskId = (0, uuid_1.v4)();
-                if (taskType) {
-                    const timer = setTimeout(() => {
-                        this.pendingTasks.delete(taskId);
-                        // 超时时返回 undefined 而不是 reject
-                        console.log(`⏰ [ShellX] 任务超时: ${taskType}, 返回 undefined`);
-                        resolve(undefined);
-                    }, timeout ? timeout : this.config.timeout);
-                    this.pendingTasks.set(taskId, {
-                        resolve,
-                        reject,
-                        timer,
-                        type: taskType
-                    });
-                    console.log(`📋 [ShellX] 创建任务: ${taskId}, 类型: ${taskType}}`);
-                }
-                if (this.shellxConnected && this.ws) {
-                    try {
-                        console.log('📤 [ShellX] 发送消息:', JSON.stringify(message));
-                        this.ws.send((0, cbor_1.encode)(message));
-                        if (!taskType)
-                            resolve(undefined); // For fire-and-forget messages
-                    }
-                    catch (error) {
-                        if (taskType) {
-                            this.pendingTasks.delete(taskId);
-                        }
-                        // 发送失败时返回 undefined 而不是 reject
-                        console.log(`❌ [ShellX] 发送消息失败，返回 undefined:`, error);
-                        resolve(undefined);
-                    }
-                }
-                else {
-                    console.log('⏳ [ShellX] 连接未就绪，消息已加入队列');
-                    this.reconnect();
-                    this.messageQueue.push(message);
-                    if (!taskType)
-                        resolve(undefined);
-                }
-            });
-        });
+    async sendMessage(message, taskType) {
+        if (!taskType) {
+            taskType = "oneway";
+        }
+        const { promise } = await this.sendMessageWithTaskId(message, taskType);
+        return await promise;
     }
     // ===== PROTOCOL-AWARE TASK METHODS =====
     /**
      * Find UI elements on the screen
      */
-    findElement(selector, options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const findAction = {
-                type: 'find',
-                selector,
-                options,
-            };
-            return this.sendMessage({ findElement: findAction }, 'findElement');
-        });
+    async findElement(selector, options) {
+        const findAction = {
+            type: "find",
+            selector,
+            options,
+        };
+        return this.sendMessage({ findElement: findAction }, "findElement");
     }
     /**
      * Wait for UI element to appear
      */
-    waitElement(selector, options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const waitAction = {
-                type: 'wait',
-                selector,
-                options,
-            };
-            return this.sendMessage({ waitElement: waitAction }, 'waitElement');
-        });
+    async waitElement(selector, options) {
+        const waitAction = {
+            type: "wait",
+            selector,
+            options,
+        };
+        return this.sendMessage({ waitElement: waitAction }, "waitElement");
     }
     /**
      * Take a screenshot
+     * @deprecated Use takeScreenshot() instead for consistency
      */
-    screenShot(options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.sendMessage({
-                screenShot: options || {
-                    format: 'png',
-                    quality: 30,
-                    scale: 1.0,
-                    region: {
-                        left: 0,
-                        top: 0,
-                        width: 1080,
-                        height: 2340,
-                    },
+    async screenShot(options) {
+        return this.takeScreenshot(options);
+    }
+    /**
+     * Take a screenshot
+     */
+    async takeScreenshot(options) {
+        return this.sendMessage({
+            screenShot: options || {
+                format: "png",
+                quality: 30,
+                scale: 1.0,
+                region: {
+                    left: 0,
+                    top: 0,
+                    width: 1080,
+                    height: 2340,
                 },
-            }, 'screenShot');
-        });
+            },
+        }, "screenShot");
     }
     /**
      * Get screen information
      */
-    getScreenInfo() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.sendMessage({ screenInfo: {} }, 'screenInfo');
-        });
+    async getScreenInfo() {
+        return this.sendMessage({ screenInfo: { keepScreenOn: false, wakeApp: true } }, "screenInfo");
     }
     /**
-     * Get list of installed apps
+     * Get screen information
+     * @deprecated Use wakeScreenAndGetInfo() instead for clarity
      */
-    getAppList(options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.sendMessage({ appList: options || {} }, 'appList');
-        });
+    async getAndWakeScreen() {
+        return this.wakeScreenAndGetInfo();
     }
     /**
-     * Get specific app information
+     * Wake screen and get screen information
      */
-    getAppInfo(packageName) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.sendMessage({ appInfo: { packageName } }, 'appInfo');
-        });
+    async wakeScreenAndGetInfo() {
+        return this.sendMessage({ screenInfo: { keepScreenOn: true, wakeApp: true } }, "screenInfo");
     }
     /**
      * Execute an action sequence
      */
-    executeAction(actionSequence, taskId, timeeout) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.sendMessageWithTaskId({ actions: actionSequence }, 'action', taskId, timeeout);
-        });
+    async executeAction(actionSequence, taskId, timeout) {
+        const { promise } = await this.sendMessageWithTaskId({ actions: actionSequence }, "action", { taskId, timeout });
+        return await promise;
     }
     /**
      * Execute promptflow actions
      */
-    executePromptFlow(actionSequence) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.sendMessage({ promptflowx: actionSequence });
-        });
+    async executePromptFlow(actionSequence) {
+        return this.sendMessage({ promptflowx: actionSequence });
     }
     /**
      * Listen for display changes
      */
-    screenChange(options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.sendMessage({
-                screenChange: options || { enable: true },
-            });
+    async screenChange(options) {
+        return this.sendMessage({
+            screenChange: options || { enable: true },
         });
     }
     /**
      * Switch to a different node
      */
-    switchNode(nodeId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.sendMessage({ switchNode: nodeId });
-        });
+    async switchNode(nodeId) {
+        return this.sendMessage({ switchNode: nodeId });
     }
     /**
      * Send authentication data
      */
-    authenticate(authData) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.sendMessage({ authenticate: authData });
-        });
+    async authenticate(authData) {
+        return this.sendMessage({ authenticate: authData });
     }
     /**
      * Set user name
      */
-    setName(name) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.sendMessage({ setName: name });
-        });
+    async setName(name) {
+        return this.sendMessage({ setName: name });
     }
     /**
      * Send chat message
      */
-    sendChat(message) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.sendMessage({ chat: message });
-        });
+    async sendChat(message) {
+        return this.sendMessage({ chat: message });
+    }
+    /**
+     * Start ASR (Automatic Speech Recognition)
+     */
+    async startAsr() {
+        return this.sendMessage({ asrControl: { action: "start_asr" } }, "oneway");
+    }
+    /**
+     * Stop ASR (Automatic Speech Recognition)
+     */
+    async stopAsr() {
+        return this.sendMessage({ asrControl: { action: "stop_asr" } }, "oneway");
+    }
+    /**
+     * Speak text using TTS (Text-to-Speech)
+     */
+    async speak(text) {
+        return this.sendMessage({ ttsControl: { action: "tts_speak", text } }, "oneway");
+    }
+    /**
+     * Stop TTS (Text-to-Speech)
+     */
+    async stopTts() {
+        return this.sendMessage({ ttsControl: { action: "tts_stop" } }, "oneway");
     }
     /**
      * Send raw message (for custom integrations)
      */
-    sendRawMessage(message) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.sendMessage(message);
-        });
+    async sendRawMessage(message) {
+        // Auto-detect task type from message content
+        const taskType = this.detectTaskType(message);
+        return this.sendMessage(message, taskType);
     }
     /**
-     * 发送消息并返回 taskId，允许手动控制任务完成
-     * @param message 要发送的消息
-     * @param taskType 任务类型
-     * @returns Promise<{taskId: string, promise: Promise<any>}>
+     * Detect task type from message content
      */
-    sendMessageWithTaskId(message, taskType, definedTaskId, timeout) {
+    detectTaskType(message) {
+        if (message.findElement)
+            return "findElement";
+        if (message.waitElement)
+            return "waitElement";
+        if (message.screenShot)
+            return "screenShot";
+        if (message.screenInfo)
+            return "screenInfo";
+        if (message.appList)
+            return "appList";
+        if (message.action)
+            return "action";
+        if (message.actions)
+            return "action";
+        if (message.promptflowx)
+            return "promptflowx";
+        if (message.asrControl)
+            return "asrControl";
+        // Oneway messages (fire-and-forget, no response expected)
+        if (message.ttsControl)
+            return "oneway";
+        if (message.screenChange)
+            return "oneway";
+        if (message.switchNode)
+            return "oneway";
+        if (message.authenticate)
+            return "oneway";
+        if (message.setName)
+            return "oneway";
+        if (message.chat)
+            return "oneway";
+        if (message.ping)
+            return "oneway";
+        // Default to oneway for unknown message types
+        return "oneway";
+    }
+    /**
+     * Send message and return taskId
+     * @param message Message to send
+     * @param taskType Task type
+     * @param options Optional parameters { timeout, taskId }
+     * @returns Promise<{taskId: string, promise: Promise<T>>}
+     */
+    async sendMessageWithTaskId(message, taskType, options) {
         return new Promise((resolve) => {
+            const { timeout, taskId: definedTaskId } = options || {};
             let taskId = definedTaskId;
             if (taskId == null) {
-                taskId = (0, uuid_1.v4)();
+                taskId = uuidv4();
             }
+            this.logger.info(`📋 [ShellX] Created task: ${taskId}, Task type: ${taskType}`);
+            this.logger.info(message);
+            const outgoingMessage = taskId ? { ...message, taskId } : message;
             if (isPendingTask(taskType)) {
                 const timer = setTimeout(() => {
                     if (taskId != null) {
+                        const task = this.pendingTasks.get(taskId);
+                        if (task) {
+                            // Create a timeout result based on task type
+                            const timeoutResult = this.createTimeoutResult(taskType, timeout ?? this.config.timeout);
+                            // Resolve with timeout result instead of rejecting
+                            task.resolve(timeoutResult);
+                        }
                         this.pendingTasks.delete(taskId);
                     }
-                    console.log(`⏰ [ShellX] 任务超时: ${taskId}, 类型: ${taskType}`);
-                }, timeout ? timeout : this.config.timeout);
+                    this.logger.info(`⏰ [ShellX] Task timeout: ${taskId}, Task type: ${taskType}`);
+                }, timeout ?? this.config.timeout);
                 this.pendingTasks.set(taskId, {
                     resolve: () => { },
                     reject: () => { },
                     timer,
                     type: taskType,
                 });
-                console.log(`📋 [ShellX] 创建可手动控制的任务: ${taskId}, 类型: ${taskType}}`);
+                this.logger.info(`📋 [ShellX] Created manually controllable task: ${taskId}, Task type: ${taskType}}`);
             }
             if (this.shellxConnected && this.ws) {
                 try {
-                    console.log(Date.now() + ' 📤 [ShellX] 发送消息:', JSON.stringify(message));
-                    this.ws.send((0, cbor_1.encode)(message));
+                    this.logger.info(" 📤 [ShellX] Sending message:", JSON.stringify(outgoingMessage));
+                    this.ws.send(cborEncode(outgoingMessage));
                     const promise = new Promise((promiseResolve, promiseReject) => {
                         if (isPendingTask(taskType)) {
                             if (taskId != null) {
                                 const task = this.pendingTasks.get(taskId);
                                 if (task) {
+                                    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-explicit-any
                                     task.resolve = promiseResolve;
+                                    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-explicit-any
                                     task.reject = promiseReject;
                                 }
                             }
@@ -641,12 +759,14 @@ class ConnectionTaskClient {
                     if (isPendingTask(taskType)) {
                         this.pendingTasks.delete(taskId);
                     }
-                    resolve({ taskId, promise: Promise.reject(error) });
+                    const err = error instanceof Error ? error : new Error(String(error));
+                    resolve({ taskId, promise: Promise.reject(err) });
                 }
             }
             else {
-                console.log('⏳ [ShellX] 连接未就绪，消息已加入队列');
-                this.messageQueue.push(message);
+                this.logger.info("⏳ [ShellX] Connection not ready, message queued");
+                this.messageQueue.push(outgoingMessage);
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-assignment
                 resolve({ taskId, promise: Promise.resolve(undefined) });
             }
         });
@@ -654,10 +774,10 @@ class ConnectionTaskClient {
     // ===== CONNECTION MANAGEMENT =====
     startPing() {
         this.stopPing();
-        console.log('🏓 [ShellX] 开始心跳检测...');
+        this.logger.info("🏓 [ShellX] Starting heartbeat detection...");
         this.pingIntervalId = setInterval(() => {
             if (this.ws && this.shellxConnected) {
-                this.ws.send((0, cbor_1.encode)({ ping: Date.now() }));
+                this.ws.send(cborEncode({ ping: Date.now() }));
             }
         }, this.config.pingInterval);
     }
@@ -667,32 +787,37 @@ class ConnectionTaskClient {
             this.pingIntervalId = null;
         }
     }
-    reconnect() {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b;
-            // TODO: 本地的需要重连
-            console.log(`🔄 [ShellX] 重连中... (${this.reconnectAttempts}/${this.config.reconnectMaxAttempts})` +
-                this.wsUrl);
-            if (this.reconnectAttempts >= this.config.reconnectMaxAttempts) {
-                console.error('❌ [ShellX] 重连失败，达到最大重连次数');
-                (_b = (_a = this.config).onReconnectFailed) === null || _b === void 0 ? void 0 : _b.call(_a);
-                return;
-            }
-            this.reconnectAttempts++;
-            yield (0, utils_1.wait)(this.config.reconnectInterval * this.reconnectAttempts);
-            this.init();
-        });
+    async reconnect() {
+        // TODO: Local needs reconnection
+        this.logger.info(`🔄 [ShellX] Reconnecting... (${this.reconnectAttempts}/${this.config.reconnectMaxAttempts})` +
+            this.wsUrl);
+        if (this.reconnectAttempts >= this.config.reconnectMaxAttempts) {
+            this.logger.error("❌ [ShellX] Reconnection failed, max attempts reached");
+            this.config.onReconnectFailed?.();
+            return;
+        }
+        this.reconnectAttempts++;
+        // Exponential backoff strategy: baseInterval * 2^(attempts-1), with maximum delay cap and random jitter
+        const baseInterval = this.config.reconnectInterval || 1000;
+        const maxDelay = 30000; // Maximum delay 30 seconds
+        const exponentialDelay = baseInterval * Math.pow(2, this.reconnectAttempts - 1);
+        const delay = Math.min(exponentialDelay, maxDelay);
+        // Add random jitter (±20%) to avoid multiple clients reconnecting simultaneously
+        const jitter = delay * 0.2 * (Math.random() * 2 - 1);
+        const finalDelay = Math.max(0, delay + jitter);
+        await wait(Math.floor(finalDelay));
+        void this.init();
     }
     flushQueue() {
         while (this.messageQueue.length > 0 && this.ws && this.shellxConnected) {
             const message = this.messageQueue.shift();
             if (message) {
                 try {
-                    console.log('flushQueue Sending message:', message);
-                    this.ws.send((0, cbor_1.encode)(message));
+                    this.logger.info("flushQueue Sending message:", message);
+                    this.ws.send(cborEncode(message));
                 }
                 catch (error) {
-                    console.error('Failed to send queued message:', error);
+                    this.logger.error("Failed to send queued message:", error);
                     // Re-queue the message if sending fails
                     this.messageQueue.unshift(message);
                     break;
@@ -701,11 +826,10 @@ class ConnectionTaskClient {
         }
     }
     close() {
-        var _a;
         this.shellxConnected = false;
         this.wsConnected = false;
         this.authenticated = false;
-        (_a = this.ws) === null || _a === void 0 ? void 0 : _a.close();
+        this.ws?.close();
         this.pendingTasks.clear();
         this.messageQueue = [];
         this.stopPing();
@@ -720,6 +844,12 @@ class ConnectionTaskClient {
     get isAuthenticated() {
         return this.authenticated;
     }
+    /**
+     * Get the authenticated device ID (UUID)
+     */
+    getDeviceId() {
+        return this.deviceId;
+    }
     get pendingTaskCount() {
         return this.pendingTasks.size;
     }
@@ -727,36 +857,128 @@ class ConnectionTaskClient {
         return this.messageQueue.length;
     }
     /**
-     * 设置关联的 ShellX 实例
+     * Get current execution log
+     */
+    getExecutionLogs() {
+        return [...this.executionLogsRef];
+    }
+    /**
+     * Clear current execution log
+     */
+    clearExecutionLogs() {
+        this.executionLogsRef.length = 0;
+    }
+    /**
+     * Manually append an execution log
+     */
+    appendExecutionLog(log) {
+        this.logger.info("Append log:", log);
+        this.executionLogsRef.push(log);
+    }
+    /**
+     * Set associated ShellX instance
      */
     setShellX(shellx) {
         this.shellx = shellx;
-        console.log('🔗 [ShellX] 已关联 ShellX 实例');
+        this.logger.info("🔗 [ShellX] ShellX instance associated");
+    }
+    /**
+     * Create a timeout result object based on task type
+     * @param taskType Type of the task that timed out
+     * @param timeoutMs Timeout duration in milliseconds
+     * @returns A result object with success: false
+     */
+    createTimeoutResult(taskType, timeoutMs) {
+        const baseResult = {
+            success: false,
+            error: `Task timed out after ${timeoutMs}ms`,
+            duration: timeoutMs,
+            timestamp: Date.now(),
+        };
+        // Return type-specific result based on task type
+        switch (taskType) {
+            case "action":
+                // For action tasks, return a basic result
+                return baseResult;
+            case "screenShot":
+                return {
+                    ...baseResult,
+                    imageData: "",
+                    imagePath: "",
+                    format: "png",
+                };
+            case "screenInfo":
+                return {
+                    ...baseResult,
+                    width: 0,
+                    height: 0,
+                    density: 0,
+                    screenOn: false,
+                    screenUnlocked: false,
+                };
+            case "findElement":
+            case "waitElement":
+                return {
+                    ...baseResult,
+                    elements: [],
+                };
+            case "appList":
+                return {
+                    ...baseResult,
+                    apps: [],
+                    totalCount: 0,
+                    systemAppCount: 0,
+                    userAppCount: 0,
+                };
+            case "input":
+                return baseResult;
+            case "swipe":
+                return {
+                    ...baseResult,
+                    fromX: 0,
+                    fromY: 0,
+                    toX: 0,
+                    toY: 0,
+                };
+            case "press":
+                return {
+                    ...baseResult,
+                    key: "",
+                };
+            case "clipboard":
+                return {
+                    ...baseResult,
+                    text: "",
+                };
+            default:
+                // Default fallback result
+                return baseResult;
+        }
     }
     /**
-     * 获取关联的 ShellX 实例
+     * Get associated ShellX instance
      */
     getShellX() {
         return this.shellx;
     }
     /**
-     * 手动完成指定 taskId 的任务
-     * @param taskId 任务ID
-     * @param result 任务结果
-     * @param success 是否成功
+     * Manually complete task by taskId
+     * @param taskId Task ID
+     * @param result Task result
+     * @param success Success status
      */
     completeTask(taskId, result, success = true) {
         const task = this.pendingTasks.get(taskId);
         if (!task) {
-            console.log(`⚠️ [ShellX] 未找到任务: ${taskId}`);
+            this.logger.info(`⚠️ [ShellX] Task not found: ${taskId}`);
             return false;
         }
-        console.log(`✅ [ShellX] 手动完成任务: ${taskId}, 类型: ${task.type}, 成功: ${success}`);
-        // 清除超时定时器
+        this.logger.info(`✅ [ShellX] Manually completed task: ${taskId}, Task type: ${task.type}, Success: ${success}`);
+        // Clear timeout timer
         clearTimeout(task.timer);
-        // 从待处理任务中移除
+        // Remove from pending tasks
         this.pendingTasks.delete(taskId);
-        // 根据成功状态调用相应的回调
+        // Call appropriate callback based on success status
         if (success) {
             task.resolve(result || { success: true, taskId });
         }
@@ -766,13 +988,13 @@ class ConnectionTaskClient {
         return true;
     }
     /**
-     * 获取所有待处理任务的ID列表
+     * Get all pending task IDs
      */
     getPendingTaskIds() {
         return Array.from(this.pendingTasks.keys());
     }
     /**
-     * 获取指定任务的信息
+     * Get task info by taskId
      */
     getTaskInfo(taskId) {
         const task = this.pendingTasks.get(taskId);
@@ -780,14 +1002,14 @@ class ConnectionTaskClient {
             return null;
         }
         return {
-            type: task.type
+            type: task.type,
         };
     }
     /**
-     * 批量完成指定类型的任务
-     * @param taskType 任务类型
-     * @param result 任务结果
-     * @param success 是否成功
+     * Batch complete tasks by type
+     * @param taskType Task type
+     * @param result Task result
+     * @param success Success status
      */
     completeTasksByType(taskType, result, success = true) {
         const taskIds = this.getPendingTaskIds();
@@ -799,12 +1021,16 @@ class ConnectionTaskClient {
                 completedCount++;
             }
         }
-        console.log(`📦 [ShellX] 批量完成 ${completedCount} 个 ${taskType} 类型的任务`);
+        this.logger.info(`📦 [ShellX] Batch completed ${completedCount} tasks of type ${taskType}`);
         return completedCount;
     }
 }
-exports.ConnectionTaskClient = ConnectionTaskClient;
-exports.default = ConnectionTaskClient;
-var shellx_1 = require("./shellx");
-Object.defineProperty(exports, "createShellXWithShellMonitoring", { enumerable: true, get: function () { return shellx_1.createShellXWithShellMonitoring; } });
-Object.defineProperty(exports, "ShellX", { enumerable: true, get: function () { return shellx_1.ShellX; } });
+export default ConnectionClient;
+export { ShellX } from "./shellx.js";
+// Error handling exports
+export { createErrorResponse, createOperationResult, ErrorCode, ShellXError, ConnectionError, OperationError, ElementError, ValidationError, } from "./errors.js";
+// Error handler utilities
+export { extractErrorMessage, createErrorResult, createSuccessResult, handleOperation, handleOperationWithRetry, validateRequired, validateOneOfRequired, wrapErrorWithContext, } from "./error-handler.js";
+// Domain management exports
+export { buildDeviceApiUrl, buildDeviceConfigUrl, buildDeviceRegisterUrl, buildTokenVerifyUrl, buildTokenRefreshUrl, getApiBaseUrl, getWsServerUrl, getCurrentDomainInfo, createDomainConfig, isChineseUser, } from "./domain-manager.js";
+//# sourceMappingURL=index.js.map