shellx-ai 1.0.0 → 1.0.2

package/dist/index.js

@@ -1,4 +1,37 @@
 "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) {
@@ -14,48 +47,145 @@ const uuid_1 = require("uuid");
 const constants_1 = require("./constants");
 const utils_1 = require("./utils");
 const cbor_x_1 = require("cbor-x");
+/**
+ * 获取适合当前环境的WebSocket构造函数
+ */
+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 {
+            // @ts-ignore - Dynamic import may not have types
+            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');
+        }
+    });
+}
 /**
  * Enhanced WebSocket Task Client with protocol-aware task methods
  */
 class WebSocketTaskClient {
     constructor(wsUrl, config = {}) {
-        this.ws = null;
-        this.connected = false;
+        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 实例
         this.wsUrl = wsUrl;
         this.config = Object.assign(Object.assign({}, constants_1.DEFAULT_CONFIG), config);
-        this.init();
+        this.initializationPromise = this.init();
     }
     init() {
-        console.log('Initializing WebSocket client...');
-        this.ws = new WebSocket(this.wsUrl);
-        this.ws.binaryType = 'arraybuffer';
-        this.ws.onopen = () => {
-            var _a, _b;
-            console.log('Connected to WebSocket server');
-            this.connected = true;
-            this.reconnectAttempts = 0;
-            (_b = (_a = this.config).onOpen) === null || _b === void 0 ? void 0 : _b.call(_a);
-            this.flushQueue();
-            this.startPing();
-        };
-        this.ws.onmessage = (event) => {
-            this.handleMessage(event);
-        };
-        this.ws.onclose = (event) => {
-            var _a, _b;
-            this.connected = false;
-            (_b = (_a = this.config).onClose) === null || _b === void 0 ? void 0 : _b.call(_a, event);
-            this.stopPing();
-            this.reconnect();
-        };
-        this.ws.onerror = (error) => {
+        return __awaiter(this, void 0, void 0, function* () {
             var _a, _b;
-            (_b = (_a = this.config).onError) === null || _b === void 0 ? void 0 : _b.call(_a, error);
-        };
+            try {
+                console.log('Initializing WebSocket client...');
+                // 获取适合当前环境的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.wsConnected = true;
+                    this.reconnectAttempts = 0;
+                    // 连接建立后立即发送认证消息
+                    this.sendAuthenticationMessage();
+                };
+                this.ws.onmessage = (event) => {
+                    this.handleMessage(event);
+                };
+                this.ws.onclose = (event) => {
+                    var _a, _b;
+                    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;
+            }
+        });
+    }
+    /**
+     * 等待WebSocket初始化完成
+     */
+    waitForInitialization() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.initializationPromise) {
+                yield this.initializationPromise;
+            }
+        });
+    }
+    /**
+     * 发送认证消息
+     */
+    sendAuthenticationMessage() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const authKey = process.env.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 });
+                if (this.ws && this.wsConnected) {
+                    this.ws.send((0, cbor_x_1.encode)(authMessage));
+                }
+                else {
+                    console.error('❌ [Auth] WebSocket未连接，无法发送认证消息');
+                }
+            }
+            catch (error) {
+                console.error('❌ [Auth] 发送认证消息失败:', error);
+            }
+        });
+    }
+    /**
+     * 从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;
@@ -96,23 +226,32 @@ class WebSocketTaskClient {
         }
     }
     processServerMessage(message) {
-        var _a, _b;
-        console.log('Received server message:', 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();
+        }
         // Call user-defined message handler
-        (_b = (_a = this.config).onMessage) === null || _b === void 0 ? void 0 : _b.call(_a, message);
+        (_d = (_c = this.config).onMessage) === null || _d === void 0 ? void 0 : _d.call(_c, 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('Server hello, user ID:', message.hello);
+            console.log('👋 [ShellX] 服务器问候，用户ID:', message.hello);
         }
         if (message.pong !== undefined) {
-            console.log('Received pong:', message.pong);
+            //console.log('🏓 [ShellX] 收到心跳响应:', message.pong);
         }
         if (message.error) {
-            console.error('Server error:', message.error);
+            console.error('❌ [ShellX] 服务器错误:', message.error);
         }
     }
     handleJsonDataResponse(jsonData) {
@@ -152,10 +291,12 @@ class WebSocketTaskClient {
                     }
                     break;
                 case 'action':
+                    /*
                     if (jsonData.action_event) {
-                        responseData = jsonData.action_event;
-                        shouldResolve = true;
-                    }
+                      responseData = jsonData.action_event;
+                      shouldResolve = true;
+                    }*/
+                    // 命令，按键，滑动，点击，等待，查找，等待，屏幕截图，屏幕信息，屏幕变化，应用列表， 需要自己处理
                     break;
             }
             if (shouldResolve) {
@@ -171,7 +312,7 @@ class WebSocketTaskClient {
             }
         }
     }
-    sendMessage(message, taskType) {
+    sendMessage(message, taskType, commandType) {
         return new Promise((resolve, reject) => {
             const taskId = (0, uuid_1.v4)();
             if (taskType) {
@@ -179,11 +320,12 @@ class WebSocketTaskClient {
                     this.pendingTasks.delete(taskId);
                     reject(new Error(`Task ${taskType} timeout (${this.config.timeout}ms)`));
                 }, this.config.timeout);
-                this.pendingTasks.set(taskId, { resolve, reject, timer, type: taskType });
+                this.pendingTasks.set(taskId, { resolve, reject, timer, type: taskType, commandType });
+                console.log(`📋 [ShellX] 创建任务: ${taskId}, 类型: ${taskType}}`);
             }
-            if (this.connected && this.ws) {
+            if (this.shellxConnected && this.ws) {
                 try {
-                    console.log('Sending message:', message);
+                    console.log('📤 [ShellX] 发送消息:', message);
                     this.ws.send((0, cbor_x_1.encode)(message));
                     if (!taskType)
                         resolve(undefined); // For fire-and-forget messages
@@ -196,6 +338,7 @@ class WebSocketTaskClient {
                 }
             }
             else {
+                console.log('⏳ [ShellX] 连接未就绪，消息已加入队列');
                 this.messageQueue.push(message);
                 if (!taskType)
                     resolve(undefined);
@@ -264,9 +407,9 @@ class WebSocketTaskClient {
     /**
      * Execute an action sequence
      */
-    executeAction(actionSequence) {
+    executeAction(actionSequence, taskId) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.sendMessage({ actions: actionSequence }, 'action');
+            return this.sendMessageWithTaskId({ actions: actionSequence }, 'action', taskId);
         });
     }
     /**
@@ -327,12 +470,69 @@ class WebSocketTaskClient {
             return this.sendMessage(message);
         });
     }
+    /**
+     * 发送消息并返回 taskId，允许手动控制任务完成
+     * @param message 要发送的消息
+     * @param taskType 任务类型
+     * @returns Promise<{taskId: string, promise: Promise<any>}>
+     */
+    sendMessageWithTaskId(message, taskType, definedTaskId) {
+        return new Promise((resolve) => {
+            let taskId = definedTaskId;
+            if (taskId == null) {
+                taskId = (0, uuid_1.v4)();
+            }
+            if (taskType) {
+                const timer = setTimeout(() => {
+                    this.pendingTasks.delete(taskId);
+                    console.log(`⏰ [ShellX] 任务超时: ${taskId}, 类型: ${taskType}`);
+                }, 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] 发送消息:', message);
+                    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;
+                            }
+                        }
+                        else {
+                            promiseResolve(undefined);
+                        }
+                    });
+                    resolve({ taskId, promise });
+                }
+                catch (error) {
+                    if (taskType) {
+                        this.pendingTasks.delete(taskId);
+                    }
+                    resolve({ taskId, promise: Promise.reject(error) });
+                }
+            }
+            else {
+                console.log('⏳ [ShellX] 连接未就绪，消息已加入队列');
+                this.messageQueue.push(message);
+                resolve({ taskId, promise: Promise.resolve(undefined) });
+            }
+        });
+    }
     // ===== CONNECTION MANAGEMENT =====
     startPing() {
         this.stopPing();
-        console.log('Starting ping...');
+        console.log('🏓 [ShellX] 开始心跳检测...');
         this.pingIntervalId = setInterval(() => {
-            if (this.ws && this.connected) {
+            if (this.ws && this.shellxConnected) {
                 this.ws.send((0, cbor_x_1.encode)({ ping: BigInt(Date.now()) }));
             }
         }, this.config.pingInterval);
@@ -371,7 +571,9 @@ class WebSocketTaskClient {
     }
     close() {
         var _a;
-        this.connected = false;
+        this.shellxConnected = false;
+        this.wsConnected = false;
+        this.authenticated = false;
         (_a = this.ws) === null || _a === void 0 ? void 0 : _a.close();
         this.pendingTasks.clear();
         this.messageQueue = [];
@@ -379,7 +581,13 @@ class WebSocketTaskClient {
     }
     // Getters for debugging/monitoring
     get isConnected() {
-        return this.connected;
+        return this.shellxConnected;
+    }
+    get isWebSocketConnected() {
+        return this.wsConnected;
+    }
+    get isAuthenticated() {
+        return this.authenticated;
     }
     get pendingTaskCount() {
         return this.pendingTasks.size;
@@ -387,6 +595,83 @@ class WebSocketTaskClient {
     get queuedMessageCount() {
         return this.messageQueue.length;
     }
+    /**
+     * 设置关联的 ShellX 实例
+     */
+    setShellX(shellx) {
+        this.shellx = shellx;
+        console.log('🔗 [ShellX] 已关联 ShellX 实例');
+    }
+    /**
+     * 获取关联的 ShellX 实例
+     */
+    getShellX() {
+        return this.shellx;
+    }
+    /**
+     * 手动完成指定 taskId 的任务
+     * @param taskId 任务ID
+     * @param result 任务结果
+     * @param success 是否成功
+     */
+    completeTask(taskId, result, success = true) {
+        const task = this.pendingTasks.get(taskId);
+        if (!task) {
+            console.log(`⚠️ [ShellX] 未找到任务: ${taskId}`);
+            return false;
+        }
+        console.log(`✅ [ShellX] 手动完成任务: ${taskId}, 类型: ${task.type}, 成功: ${success}`);
+        // 清除超时定时器
+        clearTimeout(task.timer);
+        // 从待处理任务中移除
+        this.pendingTasks.delete(taskId);
+        // 根据成功状态调用相应的回调
+        if (success) {
+            task.resolve(result || { success: true, taskId });
+        }
+        else {
+            task.reject(new Error(`Task ${taskId} manually failed`));
+        }
+        return true;
+    }
+    /**
+     * 获取所有待处理任务的ID列表
+     */
+    getPendingTaskIds() {
+        return Array.from(this.pendingTasks.keys());
+    }
+    /**
+     * 获取指定任务的信息
+     */
+    getTaskInfo(taskId) {
+        const task = this.pendingTasks.get(taskId);
+        if (!task) {
+            return null;
+        }
+        return {
+            type: task.type,
+            commandType: task.commandType
+        };
+    }
+    /**
+     * 批量完成指定类型的任务
+     * @param taskType 任务类型
+     * @param result 任务结果
+     * @param success 是否成功
+     */
+    completeTasksByType(taskType, result, success = true) {
+        const taskIds = this.getPendingTaskIds();
+        let completedCount = 0;
+        for (const taskId of taskIds) {
+            const task = this.pendingTasks.get(taskId);
+            if (task && task.type === taskType) {
+                this.completeTask(taskId, result, success);
+                completedCount++;
+            }
+        }
+        console.log(`📦 [ShellX] 批量完成 ${completedCount} 个 ${taskType} 类型的任务`);
+        return completedCount;
+    }
 }
 exports.WebSocketTaskClient = WebSocketTaskClient;
 exports.default = WebSocketTaskClient;

package/dist/protocol.d.ts

@@ -159,7 +159,7 @@ export type ScreenShotOptions = {
 };
 /** Client message type, see the Rust version. */
 export type WsClient = {
-    authenticate?: Uint8Array;
+    authenticate?: string;
     setName?: string;
     setCursor?: [number, number] | null;
     setFocus?: number | null;

package/dist/shellx.d.ts

@@ -19,7 +19,7 @@ interface ShellCommandOptions {
     onError?: (error: string) => void;
     expectedOutput?: string | RegExp;
     successPattern?: string | RegExp;
-    errorPattern?: string | RegExp;
+    allowPartialResult?: boolean;
 }
 /**
  * ShellX automation utilities for common patterns
@@ -41,14 +41,18 @@ export declare class ShellX {
      * 判断输出是否属于特定命令
      */
     private isOutputForCommand;
+    /**
+     * 清理命令输出，去除输入的命令内容
+     */
+    private cleanCommandOutput;
     /**
      * 合并多个 session 的输出
      */
     private combineSessionOutputs;
     /**
-     * 检查输出是否包含提示符
+     * 转义正则表达式特殊字符
      */
-    private containsPrompt;
+    private escapeRegExp;
     /**
      * 检查命令是否完成
      */
@@ -58,7 +62,7 @@ export declare class ShellX {
      */
     private hasErrorIndicators;
     /**
-     * 判断命令是否完成（基于常见的提示符模式）
+     * 判断命令是否完成（基于时间）
      */
     private isCommandComplete;
     /**
@@ -167,7 +171,7 @@ export declare class ShellX {
 export declare function createShellX(client: WebSocketTaskClient): ShellX;
 /**
  * Create ShellX instance with automatic authentication and shell output monitoring
- * 自动处理认证和连接，无需外部提供WebSocket URL
+ * 自动处理ShellX.ai认证和连接，无需外部提供连接地址
  */
 export declare function createShellXWithShellMonitoring(config?: any): Promise<{
     client: WebSocketTaskClient;