shellx-ai 1.0.3 → 1.0.5

package/dist/index.d.ts

@@ -1,4 +1,16 @@
-import { TaskClientConfig } from './constants';
+export interface TaskClientConfig {
+    timeout: number;
+    reconnect: boolean;
+    reconnectMaxAttempts: number;
+    reconnectInterval: number;
+    pingInterval: number;
+    onOpen: () => void;
+    onClose: (event?: CloseEvent) => void;
+    onError: (error?: Event) => void;
+    onReconnectFailed: () => void;
+    onMessage?: (data: any) => void;
+}
+export declare const DEFAULT_CONFIG: TaskClientConfig;
 import type { WsClient, ActionSequence, ScreenShotOptions, ElementSelector, FindOptions, WaitOptions, UIHierarchy, WAITElement, ScreenShotResponse, ScreenInfoResponse, AppListResponse } from './protocol';
 export interface TaskResponse<T = any> {
     taskId?: string;
@@ -11,7 +23,7 @@ export interface TaskResponse<T = any> {
 export interface PendingTask {
     resolve: (data: any) => void;
     reject: (err: Error) => void;
-    timer: NodeJS.Timeout;
+    timer: number;
     type: string;
     commandType?: string;
 }
@@ -41,10 +53,6 @@ export declare class WebSocketTaskClient {
      * 发送认证消息
      */
     private sendAuthenticationMessage;
-    /**
-     * 从WebSocket URL中提取认证密钥
-     */
-    private extractAuthKeyFromUrl;
     private handleMessage;
     private processServerMessage;
     private handleJsonDataResponse;
@@ -168,5 +176,5 @@ export declare class WebSocketTaskClient {
     completeTasksByType(taskType: string, result?: any, success?: boolean): number;
 }
 export default WebSocketTaskClient;
-export { ShellX, createShellX, createShellXWithShellMonitoring } from './shellx';
-export type { UIElement, ElementSelector, ActionSequence } from './shellx';
+export type { UIElement, ElementSelector, ActionSequence, WsClient, WsServer, ScreenShotOptions, FindOptions, WaitOptions, UIHierarchy, WAITElement, ScreenShotResponse, ScreenInfoResponse, AppListResponse } from './protocol';
+export { createShellXWithShellMonitoring, ShellX } from './shellx';

package/dist/index.js

@@ -42,11 +42,24 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createShellXWithShellMonitoring = exports.createShellX = exports.ShellX = exports.WebSocketTaskClient = void 0;
+exports.ShellX = exports.createShellXWithShellMonitoring = exports.WebSocketTaskClient = exports.DEFAULT_CONFIG = void 0;
 const uuid_1 = require("uuid");
-const constants_1 = require("./constants");
 const utils_1 = require("./utils");
+// 定义默认配置
+exports.DEFAULT_CONFIG = {
+    timeout: 5000,
+    reconnect: true,
+    reconnectMaxAttempts: 5,
+    reconnectInterval: 1000,
+    pingInterval: 2000,
+    onOpen: () => { },
+    onClose: () => { },
+    onError: () => { },
+    onReconnectFailed: () => { },
+};
 const cbor_x_1 = require("cbor-x");
+// 安全地获取环境变量，兼容浏览器和Node.js环境
+let authKey = (0, utils_1.getEnvVar)('SHELLX_AUTH_KEY');
 /**
  * 获取适合当前环境的WebSocket构造函数
  */
@@ -84,14 +97,14 @@ class WebSocketTaskClient {
         this.initializationPromise = null;
         this.shellx = null; // 关联的 ShellX 实例
         this.wsUrl = wsUrl;
-        this.config = Object.assign(Object.assign({}, constants_1.DEFAULT_CONFIG), config);
+        this.config = Object.assign(Object.assign({}, exports.DEFAULT_CONFIG), config);
         this.initializationPromise = this.init();
     }
     init() {
         return __awaiter(this, void 0, void 0, function* () {
             var _a, _b;
             try {
-                console.log('Initializing WebSocket client...');
+                console.log('Initializing WebSocket client...' + this.wsUrl);
                 // 获取适合当前环境的WebSocket构造函数
                 const WebSocketConstructor = yield getWebSocket();
                 this.ws = new WebSocketConstructor(this.wsUrl);
@@ -100,7 +113,7 @@ class WebSocketTaskClient {
                     this.ws.binaryType = 'arraybuffer';
                 }
                 this.ws.onopen = () => {
-                    console.log('🔗 [ShellX] WebSocket连接已建立，发送认证消息...');
+                    console.log('🔗 [ShellX] WebSocket连接已建立，发送认证消息...' + this.wsUrl);
                     this.wsConnected = true;
                     this.reconnectAttempts = 0;
                     // 连接建立后立即发送认证消息
@@ -111,6 +124,7 @@ class WebSocketTaskClient {
                 };
                 this.ws.onclose = (event) => {
                     var _a, _b;
+                    console.log('❌ [ShellX] WebSocket连接已关闭，正在尝试重新连接...' + event.code + ' ' + this.wsUrl);
                     this.wsConnected = false;
                     this.shellxConnected = false;
                     this.authenticated = false;
@@ -146,20 +160,16 @@ class WebSocketTaskClient {
     sendAuthenticationMessage() {
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                const authKey = process.env.SHELLX_AUTH_KEY;
+                authKey = (0, utils_1.getEnvVar)('SHELLX_AUTH_KEY');
                 if (!authKey) {
                     console.error('❌ [Auth] SHELLX_AUTH_KEY 环境变量未设置');
                     return;
                 }
                 console.log('🔑 [Auth] 发送认证消息...');
                 // 从URL中提取认证密钥（如果URL包含认证信息）
-                const urlAuthKey = this.extractAuthKeyFromUrl();
-                const finalAuthKey = urlAuthKey || authKey;
-                // 创建认证数据（这里使用简单的字符串，实际可能需要更复杂的格式）
-                const authData = new TextEncoder().encode(finalAuthKey);
                 // 发送认证消息
-                const authMessage = { authenticate: authData };
-                console.log('📤 [Auth] 发送认证消息:', { authenticate: finalAuthKey });
+                const authMessage = { authenticate: authKey };
+                console.log('📤 [Auth] 发送认证消息:', { authenticate: authKey });
                 if (this.ws && this.wsConnected) {
                     this.ws.send((0, cbor_x_1.encode)(authMessage));
                 }
@@ -172,21 +182,6 @@ class WebSocketTaskClient {
             }
         });
     }
-    /**
-     * 从WebSocket URL中提取认证密钥
-     */
-    extractAuthKeyFromUrl() {
-        try {
-            const url = new URL(this.wsUrl);
-            // 尝试从路径中提取认证密钥
-            const pathParts = url.pathname.split('/');
-            const authKey = pathParts[pathParts.length - 1];
-            return authKey && authKey !== 's' ? authKey : null;
-        }
-        catch (error) {
-            return null;
-        }
-    }
     handleMessage(event) {
         let serverMessage;
         try {
@@ -377,7 +372,18 @@ class WebSocketTaskClient {
      */
     screenShot(options) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.sendMessage({ screenShot: options || { format: 'png' } }, 'screenShot');
+            return this.sendMessage({ screenShot: options || {
+                    "format": "png",
+                    "quality": 30,
+                    "scale": 1.0,
+                    "region": {
+                        "left": 0,
+                        "top": 0,
+                        "width": 1080,
+                        "height": 2340
+                    }
+                }
+            }, 'screenShot');
         });
     }
     /**
@@ -484,7 +490,9 @@ class WebSocketTaskClient {
             }
             if (taskType) {
                 const timer = setTimeout(() => {
-                    this.pendingTasks.delete(taskId);
+                    if (taskId != null) {
+                        this.pendingTasks.delete(taskId);
+                    }
                     console.log(`⏰ [ShellX] 任务超时: ${taskId}, 类型: ${taskType}`);
                 }, this.config.timeout);
                 this.pendingTasks.set(taskId, {
@@ -501,10 +509,12 @@ class WebSocketTaskClient {
                     this.ws.send((0, cbor_x_1.encode)(message));
                     const promise = new Promise((promiseResolve, promiseReject) => {
                         if (taskType) {
-                            const task = this.pendingTasks.get(taskId);
-                            if (task) {
-                                task.resolve = promiseResolve;
-                                task.reject = promiseReject;
+                            if (taskId != null) {
+                                const task = this.pendingTasks.get(taskId);
+                                if (task) {
+                                    task.resolve = promiseResolve;
+                                    task.reject = promiseReject;
+                                }
                             }
                         }
                         else {
@@ -546,6 +556,8 @@ class WebSocketTaskClient {
     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) {
                 (_b = (_a = this.config).onReconnectFailed) === null || _b === void 0 ? void 0 : _b.call(_a);
                 return;
@@ -675,9 +687,7 @@ class WebSocketTaskClient {
 }
 exports.WebSocketTaskClient = WebSocketTaskClient;
 exports.default = WebSocketTaskClient;
-// Export ShellX automation utilities
+// PromptFlow 模块已移至 examples/ 目录作为示例实现
 var shellx_1 = require("./shellx");
-Object.defineProperty(exports, "ShellX", { enumerable: true, get: function () { return shellx_1.ShellX; } });
-Object.defineProperty(exports, "createShellX", { enumerable: true, get: function () { return shellx_1.createShellX; } });
 Object.defineProperty(exports, "createShellXWithShellMonitoring", { enumerable: true, get: function () { return shellx_1.createShellXWithShellMonitoring; } });
-// PromptFlow 模块已移至 examples/ 目录作为示例实现 
+Object.defineProperty(exports, "ShellX", { enumerable: true, get: function () { return shellx_1.ShellX; } });

package/dist/protocol.d.ts

@@ -14,6 +14,7 @@ export type UIElement = {
     resourceId: string;
     text: string;
     describe: string;
+    hintText: string;
     bounds: UIBounds;
     visible: boolean;
     clickable: boolean;
@@ -59,6 +60,7 @@ export type ScreenInfoResponse = {
     timestamp: bigint;
     success?: boolean;
     errorMessage?: string;
+    bashStatus?: number;
 };
 export type App = {
     packageName: string;
@@ -163,7 +165,7 @@ export type WsClient = {
     setName?: string;
     setCursor?: [number, number] | null;
     setFocus?: number | null;
-    create?: [number, number];
+    create?: [number, number, number, number];
     close?: Sid;
     move?: [Sid, WsWinsize | null];
     data?: [Sid, Uint8Array, bigint];
@@ -197,19 +199,22 @@ export type ShellXActions = {
     thought?: string;
     action: ShellCommandAction | ClickAction | InputAction | SwipeAction | KeyAction | WaitAction | findAction | getAppInfoAction | completeAction;
 };
-interface ShellCommandAction {
+export interface ShellCommandAction {
     title?: string;
     type: "command";
+    activity?: string;
     command: string;
 }
-interface getAppInfoAction {
+export interface getAppInfoAction {
     title?: string;
     type: "get_app_info";
+    activity?: string;
     packageName: string;
 }
-interface ClickAction {
+export interface ClickAction {
     title?: string;
     type: 'click';
+    activity?: string;
     target: {
         type: "elementId";
         value: string;
@@ -223,15 +228,16 @@ interface ClickAction {
             "y": number;
         };
     };
-    options?: {
+    options: {
         timeoutMs?: number;
         durationMs?: number;
         waitAfterMs?: number;
-        clickType?: 'normal' | 'long' | 'double';
+        clickType?: 'single' | 'normal' | 'long' | 'double';
     };
 }
-interface InputAction {
+export interface InputAction {
     title?: string;
+    activity?: string;
     type: "input";
     text: string;
     target: {
@@ -247,8 +253,9 @@ interface InputAction {
         hideKeyboardAfter?: boolean;
     };
 }
-interface SwipeAction {
+export interface SwipeAction {
     title?: string;
+    activity?: string;
     type: 'swipe';
     "from": {
         "x": number;
@@ -267,8 +274,9 @@ interface SwipeAction {
         hideKeyboardAfter?: boolean;
     };
 }
-interface KeyAction {
+export interface KeyAction {
     title?: string;
+    activity?: string;
     type: "key";
     keyCode?: string;
     options?: {
@@ -277,6 +285,7 @@ interface KeyAction {
 }
 export interface WaitAction {
     title?: string;
+    activity?: string;
     type?: "wait";
     selector: ElementSelector;
     options?: WaitOptions;
@@ -284,14 +293,17 @@ export interface WaitAction {
 }
 export interface findAction {
     title?: string;
+    activity?: string;
     type?: "find";
     selector: ElementSelector;
     options?: FindOptions;
 }
 export type completeAction = {
     title?: string;
+    activity?: string;
     type: "complete";
     result?: string;
+    script?: string;
 };
 export type ElementSelector = {
     elementId?: string;
@@ -309,6 +321,8 @@ export type WaitOptions = {
     failOnTimeout?: boolean;
 };
 export type FindOptions = {
+    pressClick?: boolean;
+    waitAfterMs?: number;
     timeout?: number;
     visibleOnly?: boolean;
     clickableOnly?: boolean;

package/dist/shellx.d.ts

@@ -29,6 +29,10 @@ export declare class ShellX {
     private shellOutputBuffers;
     private shellCommandPromises;
     constructor(client: WebSocketTaskClient);
+    /**
+     * Get the WebSocket client instance
+     */
+    getClient(): WebSocketTaskClient;
     /**
      * 设置 shell 输出监听器（需要在创建 WebSocketTaskClient 时调用）
      */
@@ -121,10 +125,6 @@ export declare class ShellX {
         element: UIElement;
         selectorIndex: number;
     } | null>;
-    /**
-     * Login helper for common login flows
-     */
-    performLogin(usernameSelector: ElementSelector, passwordSelector: ElementSelector, loginButtonSelector: ElementSelector, username: string, password: string): Promise<boolean>;
     /**
      * Navigate through app using a series of clicks
      */
@@ -164,6 +164,13 @@ export declare class ShellX {
      * Device info commands
      */
     getDeviceInfo(): Promise<ShellCommandResult[]>;
+    /**
+     * Execute key action (press a key)
+     */
+    executeKeyAction(keyCode: string, options?: {
+        longPress?: boolean;
+        waitAfterMs?: number;
+    }): Promise<boolean>;
 }
 /**
  * Create ShellX instance

package/dist/shellx.js

@@ -50,8 +50,12 @@ exports.createShellX = createShellX;
 exports.createHelpers = createShellX;
 exports.createShellXWithShellMonitoring = createShellXWithShellMonitoring;
 exports.createHelpersWithShellMonitoring = createShellXWithShellMonitoring;
-const index_1 = __importDefault(require("./index"));
 const uuid_1 = require("uuid");
+const utils_1 = require("./utils");
+// 导入 WebSocketTaskClient 类
+const index_1 = __importDefault(require("./index"));
+// 安全地获取环境变量，兼容浏览器和Node.js环境
+let authKey = (0, utils_1.getEnvVar)('SHELLX_AUTH_KEY');
 /**
  * ShellX automation utilities for common patterns
  */
@@ -64,6 +68,12 @@ class ShellX {
         // 监听 shell 输出需要在创建 WebSocketTaskClient 时设置 onMessage 回调
         console.log('⚠️ [Shell] 注意：要监听 shell 输出，请在创建 WebSocketTaskClient 时设置 onMessage 回调');
     }
+    /**
+     * Get the WebSocket client instance
+     */
+    getClient() {
+        return this.client;
+    }
     /**
      * 设置 shell 输出监听器（需要在创建 WebSocketTaskClient 时调用）
      */
@@ -483,42 +493,6 @@ class ShellX {
             return null;
         });
     }
-    /**
-     * Login helper for common login flows
-     */
-    performLogin(usernameSelector, passwordSelector, loginButtonSelector, username, password) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                console.log('开始登录流程...');
-                // Input username
-                yield this.inputText(usernameSelector, username, { clear: true });
-                console.log('✅ 用户名已输入');
-                // Input password
-                yield this.inputText(passwordSelector, password, { clear: true });
-                console.log('✅ 密码已输入');
-                // Click login button
-                const loginElement = yield this.findElementWithRetry(loginButtonSelector);
-                if (!loginElement) {
-                    throw new Error('未找到登录按钮');
-                }
-                const loginAction = {
-                    title: "执行登录",
-                    actions: [{
-                            type: "click",
-                            target: { type: "elementId", value: loginElement.elementId },
-                            options: { waitAfterMs: 2000 }
-                        }]
-                };
-                yield this.client.executeAction(loginAction);
-                console.log('✅ 登录按钮已点击');
-                return true;
-            }
-            catch (error) {
-                console.error('❌ 登录失败:', error);
-                return false;
-            }
-        });
-    }
     /**
      * Navigate through app using a series of clicks
      */
@@ -746,6 +720,37 @@ class ShellX {
             }
         });
     }
+    /**
+     * Execute key action (press a key)
+     */
+    executeKeyAction(keyCode_1) {
+        return __awaiter(this, arguments, void 0, function* (keyCode, options = {}) {
+            try {
+                console.log(`🔑 [Key] 执行按键操作: ${keyCode}${options.longPress ? ' (长按)' : ''}`);
+                const keyAction = {
+                    title: `按键: ${keyCode}${options.longPress ? ' (长按)' : ''}`,
+                    actions: [{
+                            type: "key",
+                            keyCode,
+                            options: {
+                                longPress: options.longPress
+                            }
+                        }]
+                };
+                yield this.client.executeAction(keyAction);
+                // 如果设置了等待时间，则等待
+                if (options.waitAfterMs) {
+                    yield new Promise(resolve => setTimeout(resolve, options.waitAfterMs));
+                }
+                console.log(`✅ [Key] 按键操作完成: ${keyCode}`);
+                return true;
+            }
+            catch (error) {
+                console.error(`❌ [Key] 按键操作失败: ${keyCode}`, error);
+                return false;
+            }
+        });
+    }
 }
 exports.ShellX = ShellX;
 exports.AutomationHelpers = ShellX;
@@ -826,9 +831,30 @@ function createFallbackFetch() {
 /**
  * 从ShellX.ai服务认证并获取WebSocket连接信息
  */
-function authenticateDevice() {
+function authenticateDevice(deviceId) {
     return __awaiter(this, void 0, void 0, function* () {
-        const authKey = process.env.SHELLX_AUTH_KEY;
+        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');
         }
@@ -837,7 +863,7 @@ function authenticateDevice() {
             // 获取ofetch实例
             const fetchFn = yield getfetch();
             // ofetch自动处理JSON解析和错误处理
-            const data = yield fetchFn(`https://shellx.ai/api/device/${authKey}`, {
+            const data = yield fetchFn(`https://shellx.ai/api/device/${deviceId}`, {
                 method: 'GET',
                 headers: {
                     'Content-Type': 'application/json',
@@ -849,13 +875,11 @@ function authenticateDevice() {
             console.log(`📡 [Auth] ShellX.ai服务地址: ${jsonData.machine}`);
             console.log(`📡 [Auth] 注册时间: ${jsonData.registered_at}`);
             console.log(`📡 [Auth] 最后更新: ${jsonData.last_updated}`);
-            return jsonData.machine;
+            return jsonData.machine + '/api/s/' + jsonData.authenticate;
         }
         catch (error) {
             const errorMessage = error instanceof Error ? error.message : String(error);
             console.warn('⚠️ [Auth] ShellX.ai在线认证失败，使用本地服务:', errorMessage);
-            // 认证失败时使用默认的本地ShellX服务
-            const fallbackUrl = `ws://127.0.0.1:9091/api/s/${authKey}`;
             console.log(`🔄 [Auth] 使用本地ShellX服务: ${fallbackUrl}`);
             return fallbackUrl;
         }
@@ -868,17 +892,12 @@ function authenticateDevice() {
 function createShellXWithShellMonitoring() {
     return __awaiter(this, arguments, void 0, function* (config = {}) {
         try {
-            // 认证并获取ShellX.ai服务地址
-            const wsUrl = yield authenticateDevice();
-            // 先创建 shellx 实例，但不绑定客户端
+            const wsUrl = yield authenticateDevice(config.deviceId);
             const shellx = new ShellX(null);
-            // 创建ShellX客户端并设置消息监听器
             const client = new index_1.default(wsUrl, Object.assign(Object.assign({}, config), { onMessage: (message) => {
-                    // 处理 chunks 数据（pty 终端输出）
                     if (message.chunks) {
                         shellx.handleShellOutput(message.chunks);
                     }
-                    // 调用原始的消息处理器
                     if (config.onMessage) {
                         config.onMessage(message);
                     }

package/dist/utils.d.ts

@@ -1,6 +1,18 @@
 export declare const wait: (ms: number) => Promise<void>;
+/**
+ * 安全地获取环境变量，兼容浏览器和Node.js环境
+ */
+export declare function getEnvVar(key: string): string | undefined;
+/**
+ * 安全地设置环境变量，兼容浏览器和Node.js环境
+ */
+export declare function setEnvVar(key: string, value: string): void;
+/**
+ * 安全地删除环境变量，兼容浏览器和Node.js环境
+ */
+export declare function deleteEnvVar(key: string): void;
 /**
  * 检查并获取 WebSocket URL 环境变量
- * 如果未设置则显示错误并退出程序
+ * 如果未设置则显示错误并抛出异常
  */
 export declare function getWebSocketUrl(): string;

package/dist/utils.js

@@ -1,37 +1,81 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.wait = void 0;
+exports.getEnvVar = getEnvVar;
+exports.setEnvVar = setEnvVar;
+exports.deleteEnvVar = deleteEnvVar;
 exports.getWebSocketUrl = getWebSocketUrl;
 const wait = (ms) => new Promise(resolve => setTimeout(resolve, ms));
 exports.wait = wait;
+/**
+ * 安全地获取环境变量，兼容浏览器和Node.js环境
+ */
+function getEnvVar(key) {
+    if (typeof process !== 'undefined' && process.env) {
+        return process.env[key];
+    }
+    else if (typeof window !== 'undefined' && window.localStorage) {
+        const item = window.localStorage.getItem(key);
+        if (item) {
+            console.log("已从 localStorage 中获取环境变量:", key);
+            return item;
+        }
+    }
+    return undefined;
+}
+/**
+ * 安全地设置环境变量，兼容浏览器和Node.js环境
+ */
+function setEnvVar(key, value) {
+    if (typeof process !== 'undefined' && process.env) {
+        process.env[key] = value;
+    }
+    else if (typeof window !== 'undefined' && window.localStorage) {
+        window.localStorage.setItem(key, value);
+        console.log("已保存环境变量:", key, value);
+    }
+}
+/**
+ * 安全地删除环境变量，兼容浏览器和Node.js环境
+ */
+function deleteEnvVar(key) {
+    if (typeof process !== 'undefined' && process.env) {
+        delete process.env[key];
+    }
+    else if (typeof window !== 'undefined' && window.localStorage) {
+        window.localStorage.removeItem(key);
+        console.log("已删除环境变量:", key);
+    }
+}
 /**
  * 检查并获取 WebSocket URL 环境变量
- * 如果未设置则显示错误并退出程序
+ * 如果未设置则显示错误并抛出异常
  */
 function getWebSocketUrl() {
-    const wsUrl = process.env.WEBSOCKET_URL;
+    // 安全地获取环境变量，兼容浏览器和Node.js环境
+    const wsUrl = getEnvVar('WEBSOCKET_URL');
     if (!wsUrl || wsUrl.trim() === '') {
-        console.error('❌ 错误: 未设置 WEBSOCKET_URL 环境变量！');
-        console.error('');
-        console.error('📋 解决方案：');
-        console.error('1. 在项目根目录创建 .env 文件');
-        console.error('2. 在 .env 文件中添加以下内容：');
-        console.error('   WEBSOCKET_URL=ws://127.0.0.1:9091/api/s/your-session-id');
-        console.error('');
-        console.error('💡 提示：');
-        console.error('- 请将 your-session-id 替换为实际的会话ID');
-        console.error('- 确保 ShellX 服务器正在运行');
-        console.error('- 检查端口号是否正确（默认9091）');
-        console.error('');
-        process.exit(1);
+        const errorMessage = '❌ 错误: 未设置 WEBSOCKET_URL 环境变量！\n\n📋 解决方案：\n1. 在项目根目录创建 .env 文件\n2. 在 .env 文件中添加以下内容：\n   WEBSOCKET_URL=ws://127.0.0.1:9091/api/s/your-session-id\n\n💡 提示：\n- 请将 your-session-id 替换为实际的会话ID\n- 确保 ShellX 服务器正在运行\n- 检查端口号是否正确（默认9091）';
+        console.error(errorMessage);
+        // 在Node.js环境中退出，在浏览器环境中抛出异常
+        if (typeof process !== 'undefined' && process.exit) {
+            process.exit(1);
+        }
+        else {
+            throw new Error(errorMessage);
+        }
     }
     // 简单的 URL 格式验证
     if (!wsUrl.startsWith('ws://') && !wsUrl.startsWith('wss://')) {
-        console.error('❌ 错误: WEBSOCKET_URL 格式不正确！');
-        console.error(`当前值: ${wsUrl}`);
-        console.error('应该以 ws:// 或 wss:// 开头');
-        console.error('例如: ws://127.0.0.1:9091/api/s/your-session-id');
-        process.exit(1);
+        const errorMessage = `❌ 错误: WEBSOCKET_URL 格式不正确！\n当前值: ${wsUrl}\n应该以 ws:// 或 wss:// 开头\n例如: ws://127.0.0.1:9091/api/s/your-session-id`;
+        console.error(errorMessage);
+        // 在Node.js环境中退出，在浏览器环境中抛出异常
+        if (typeof process !== 'undefined' && process.exit) {
+            process.exit(1);
+        }
+        else {
+            throw new Error(errorMessage);
+        }
     }
     return wsUrl;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shellx-ai",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "description": "shellx is a powerful WebSocket-based client for controlling shell commands and UI automation on remote devices.",
   "repository": {
     "url": "git+https://github.com/10cl/shellx.git",
@@ -32,6 +32,7 @@
   "dependencies": {
     "cbor-x": "^1.6.0",
     "dotenv": "^16.4.5",
+    "ofetch": "^1.4.1",
     "uuid": "^11.1.0"
   },
   "optionalDependencies": {
@@ -41,14 +42,15 @@
   "devDependencies": {
     "@types/jest": "^30.0.0",
     "@types/node": "^24.0.13",
+    "@types/ws": "^8.18.1",
     "jest": "^30.0.4",
-    "ts-jest": "^29.4.0",
-    "ts-node": "^10.9.2",
-    "typescript": "^5.8.3",
     "langchain": "^0.1.34",
     "promptflow-eval": "1.0.0",
     "promptflow-template": "1.0.0",
-    "promptflowx": "^0.1.7"
+    "promptflowx": "^0.1.9",
+    "ts-jest": "^29.4.0",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.8.3"
   },
   "bugs": {
     "url": "https://github.com/10cl/shellx/issues"