shellx-ai 1.0.9 → 1.0.11

package/dist/index.d.ts

@@ -25,7 +25,6 @@ export interface PendingTask {
     reject: (err: Error) => void;
     timer: number;
     type: string;
-    commandType?: string;
 }
 /**
  * Enhanced WebSocket Task Client with protocol-aware task methods
@@ -59,7 +58,7 @@ export declare class ConnectionTaskClient {
     private handleMessage;
     private processServerMessage;
     private handleJsonDataResponse;
-    sendMessage(message: WsClient, taskType?: string, commandType?: string): Promise<any>;
+    sendMessage(message: WsClient, taskType?: string, timeout?: number): Promise<any>;
     /**
      * Find UI elements on the screen
      */
@@ -90,7 +89,7 @@ export declare class ConnectionTaskClient {
     /**
      * Execute an action sequence
      */
-    executeAction(actionSequence: ActionSequence, taskId?: string): Promise<any>;
+    executeAction(actionSequence: ActionSequence, taskId?: string, timeeout?: number): Promise<any>;
     /**
      * Execute promptflow actions
      */
@@ -130,7 +129,7 @@ export declare class ConnectionTaskClient {
      * @param taskType 任务类型
      * @returns Promise<{taskId: string, promise: Promise<any>}>
      */
-    sendMessageWithTaskId(message: WsClient, taskType?: string, definedTaskId?: string): Promise<{
+    sendMessageWithTaskId(message: WsClient, taskType: string, definedTaskId?: string, timeout?: number): Promise<{
         taskId: string;
         promise: Promise<any>;
     }>;
@@ -168,7 +167,6 @@ export declare class ConnectionTaskClient {
      */
     getTaskInfo(taskId: string): {
         type: string;
-        commandType?: string;
     } | null;
     /**
      * 批量完成指定类型的任务

package/dist/index.js

@@ -81,6 +81,9 @@ function getWebSocket() {
         }
     });
 }
+function isPendingTask(taskType) {
+    return taskType && taskType !== "command";
+}
 /**
  * Enhanced WebSocket Task Client with protocol-aware task methods
  */
@@ -161,10 +164,12 @@ class ConnectionTaskClient {
                 if (localResp.ok) {
                     const info = yield localResp.json();
                     if (info && (info.status === 'ok' || info.status === 1) && info.uuid) {
-                        const localUuid = info.uuid;
-                        const fallbackUrl = `ws://127.0.0.1:9091/api/s/${localUuid}`;
-                        console.log('✅ [Auth] 本地ShellX服务可用，使用本地 /info 返回的 uuid:', localUuid, '，服务地址:', fallbackUrl);
-                        return fallbackUrl;
+                        if (deviceId == info.uuid) {
+                            const localUuid = info.uuid;
+                            const fallbackUrl = `ws://127.0.0.1:9091/api/s/${localUuid}`;
+                            console.log('✅ [Auth] 本地ShellX服务可用，使用本地 /info 返回的 uuid:', localUuid, '，服务地址:', fallbackUrl);
+                            return fallbackUrl;
+                        }
                     }
                 }
             }
@@ -180,13 +185,14 @@ class ConnectionTaskClient {
             try {
                 console.log('🔑 [Auth] 正在认证设备...');
                 const featGlobal = this.getFetch();
-                const data = yield featGlobal(`https://shellx.ai/api/device/${deviceId}`, {
+                const jsonData = yield featGlobal(`https://shellx.ai/api/device/${deviceId}`, {
                     method: 'GET',
                     headers: {
                         'Content-Type': 'application/json',
                     },
                 });
-                const jsonData = JSON.parse(data);
+                console.log('ShellX.ai设备认证响应:', jsonData);
+                // const jsonData = JSON.parse(data);
                 console.log('✅ [Auth] ShellX.ai设备认证成功');
                 console.log(`📡 [Auth] 设备ID: ${jsonData.authenticate}`);
                 console.log(`📡 [Auth] ShellX.ai服务地址: ${jsonData.machine}`);
@@ -370,12 +376,16 @@ class ConnectionTaskClient {
                     }
                     break;
                 case 'action':
-                    /*
                     if (jsonData.action_event) {
-                      responseData = jsonData.action_event;
-                      shouldResolve = true;
-                    }*/
-                    // 命令，按键，滑动，点击，等待，查找，等待，屏幕截图，屏幕信息，屏幕变化，应用列表， 需要自己处理
+                        responseData = jsonData.action_event;
+                        shouldResolve = true;
+                    }
+                    break;
+                case 'actions':
+                    if (jsonData.actions) {
+                        responseData = jsonData.actions;
+                        shouldResolve = true;
+                    }
                     break;
             }
             if (shouldResolve) {
@@ -391,21 +401,20 @@ class ConnectionTaskClient {
             }
         }
     }
-    sendMessage(message, taskType, commandType) {
+    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);
-                        reject(new Error(`Task ${taskType} timeout (${this.config.timeout}ms)`));
-                    }, this.config.timeout);
+                        reject(new Error(`Task ${taskType} timeout (${timeout ? timeout : this.config.timeout}ms)`));
+                    }, timeout ? timeout : this.config.timeout);
                     this.pendingTasks.set(taskId, {
                         resolve,
                         reject,
                         timer,
-                        type: taskType,
-                        commandType,
+                        type: taskType
                     });
                     console.log(`📋 [ShellX] 创建任务: ${taskId}, 类型: ${taskType}}`);
                 }
@@ -507,9 +516,9 @@ class ConnectionTaskClient {
     /**
      * Execute an action sequence
      */
-    executeAction(actionSequence, taskId) {
+    executeAction(actionSequence, taskId, timeeout) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.sendMessageWithTaskId({ actions: actionSequence }, 'action', taskId);
+            return this.sendMessageWithTaskId({ actions: actionSequence }, 'action', taskId, timeeout);
         });
     }
     /**
@@ -576,19 +585,19 @@ class ConnectionTaskClient {
      * @param taskType 任务类型
      * @returns Promise<{taskId: string, promise: Promise<any>}>
      */
-    sendMessageWithTaskId(message, taskType, definedTaskId) {
+    sendMessageWithTaskId(message, taskType, definedTaskId, timeout) {
         return new Promise((resolve) => {
             let taskId = definedTaskId;
             if (taskId == null) {
                 taskId = (0, uuid_1.v4)();
             }
-            if (taskType) {
+            if (isPendingTask(taskType)) {
                 const timer = setTimeout(() => {
                     if (taskId != null) {
                         this.pendingTasks.delete(taskId);
                     }
                     console.log(`⏰ [ShellX] 任务超时: ${taskId}, 类型: ${taskType}`);
-                }, this.config.timeout);
+                }, timeout ? timeout : this.config.timeout);
                 this.pendingTasks.set(taskId, {
                     resolve: () => { },
                     reject: () => { },
@@ -602,7 +611,7 @@ class ConnectionTaskClient {
                     console.log(Date.now() + ' 📤 [ShellX] 发送消息:', JSON.stringify(message));
                     this.ws.send((0, cbor_1.encode)(message));
                     const promise = new Promise((promiseResolve, promiseReject) => {
-                        if (taskType) {
+                        if (isPendingTask(taskType)) {
                             if (taskId != null) {
                                 const task = this.pendingTasks.get(taskId);
                                 if (task) {
@@ -618,7 +627,7 @@ class ConnectionTaskClient {
                     resolve({ taskId, promise });
                 }
                 catch (error) {
-                    if (taskType) {
+                    if (isPendingTask(taskType)) {
                         this.pendingTasks.delete(taskId);
                     }
                     resolve({ taskId, promise: Promise.reject(error) });
@@ -757,8 +766,7 @@ class ConnectionTaskClient {
             return null;
         }
         return {
-            type: task.type,
-            commandType: task.commandType,
+            type: task.type
         };
     }
     /**

package/dist/protocol.d.ts

@@ -43,6 +43,8 @@ export type ScreenShotResponse = {
     dimensions: ScreenDimensions;
     success?: boolean;
     errorMessage?: string;
+    isVideo?: boolean;
+    videoPath?: string;
 };
 export type ScreenInfoResponse = {
     displayId?: number;
@@ -159,6 +161,9 @@ export type ScreenShotOptions = {
     quality?: number;
     scale?: number;
     region?: ScreenRegion;
+    isRecording?: boolean;
+    saveToFile?: boolean;
+    duration?: number;
 };
 /** Client message type, see the Rust version. */
 export type WsClient = {
@@ -206,6 +211,17 @@ export interface ShellCommandAction {
     activity?: string;
     command: string;
 }
+export interface ScreenShotAction {
+    title?: string;
+    type: "screenShot";
+    activity?: string;
+    format: 'png' | 'jpeg';
+    quality?: number;
+    scale?: number;
+    region?: ScreenRegion;
+    isRecording?: boolean;
+    duration?: number;
+}
 export interface getAppInfoAction {
     title?: string;
     type: "get_app_info";

package/dist/shellx.d.ts

@@ -40,10 +40,6 @@ export declare class ShellX {
      * 处理 shell 输出数据
      */
     handleShellOutput(chunks: [any, number, Uint8Array[]]): void;
-    /**
-     * 判断输出是否属于特定命令
-     */
-    private isOutputForCommand;
     /**
      * 清理命令输出，去除输入的命令内容
      */
@@ -52,30 +48,6 @@ export declare class ShellX {
      * 合并多个 session 的输出
      */
     private combineSessionOutputs;
-    /**
-     * 转义正则表达式特殊字符
-     */
-    private escapeRegExp;
-    /**
-     * 检查命令是否完成
-     */
-    private checkCommandCompletion;
-    /**
-     * 检查输出是否包含错误指示器
-     */
-    private hasErrorIndicators;
-    /**
-     * 判断命令是否完成（基于时间）
-     */
-    private isCommandComplete;
-    /**
-     * 解析命令 Promise
-     */
-    private resolveCommand;
-    /**
-     * 生成命令唯一标识
-     */
-    private generateCommandKey;
     /**
      * 通用重试机制
      */

package/dist/shellx.js

@@ -16,11 +16,8 @@ exports.ShellX = void 0;
 exports.createShellX = createShellX;
 exports.createShellXWithShellMonitoring = createShellXWithShellMonitoring;
 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');
 const COMMAND_PTY_SID = 999;
 /**
  * ShellX automation utilities for common patterns
@@ -63,27 +60,24 @@ class ShellX {
                 for (const data of dataArrays) {
                     output += new TextDecoder().decode(data);
                 }
-                console.log(`📟 [Shell] 收到输出 (Session ${sessionId}): ${output.trim()}`);
+                /*console.log(
+                  `📟 [Shell] 收到输出 (Session ${sessionId}): ${output.trim()}`,
+                );*/
                 // 为每个等待的命令累积输出
-                for (const [commandKey, commandPromise] of this.shellCommandPromises.entries()) {
-                    // 检查是否该命令相关的输出
-                    if (this.isOutputForCommand(output, commandPromise.command, sessionId)) {
-                        // 存储该 session 的输出
-                        if (!commandPromise.sessionOutputs.has(sessionId)) {
-                            commandPromise.sessionOutputs.set(sessionId, '');
-                        }
-                        const currentSessionOutput = commandPromise.sessionOutputs.get(sessionId) || '';
-                        commandPromise.sessionOutputs.set(sessionId, currentSessionOutput + output);
-                        // 更新总输出
-                        commandPromise.output = this.combineSessionOutputs(commandPromise.sessionOutputs);
-                        console.log(`📊 [Shell] 命令 ${commandKey} 累积输出长度: ${commandPromise.output.length}`);
-                        // 调用输出回调（传递清理后的输出）
-                        if (commandPromise.options.onOutput) {
-                            const cleanOutput = this.cleanCommandOutput(output, commandPromise.command);
-                            commandPromise.options.onOutput(cleanOutput);
-                        }
-                        // 检查是否满足完成条件
-                        this.checkCommandCompletion(commandKey, commandPromise, output);
+                for (const [commandKey, commandPromise,] of this.shellCommandPromises.entries()) {
+                    if (!commandPromise.sessionOutputs.has(sessionId)) {
+                        commandPromise.sessionOutputs.set(sessionId, '');
+                    }
+                    const currentSessionOutput = commandPromise.sessionOutputs.get(sessionId) || '';
+                    commandPromise.sessionOutputs.set(sessionId, currentSessionOutput + output);
+                    commandPromise.output = this.combineSessionOutputs(commandPromise.sessionOutputs);
+                    /*console.log(
+                      `📊 [Shell] 命令 ${commandKey} 累积输出长度: ${commandPromise.output.length}`,
+                    );*/
+                    // 调用输出回调（传递清理后的输出）
+                    if (commandPromise.options.onOutput) {
+                        const cleanOutput = this.cleanCommandOutput(output, commandPromise.command);
+                        commandPromise.options.onOutput(cleanOutput);
                     }
                 }
             }
@@ -92,56 +86,11 @@ class ShellX {
             }
         }
     }
-    /**
-     * 判断输出是否属于特定命令
-     */
-    isOutputForCommand(output, command, sessionId) {
-        // 如果输出包含命令本身，说明是命令回显
-        if (output.includes(command)) {
-            return true;
-        }
-        // 如果有多个命令在等待，按时间顺序分配
-        const waitingCommands = Array.from(this.shellCommandPromises.keys());
-        if (waitingCommands.length === 1) {
-            return true; // 只有一个命令在等待，所有输出都属于它
-        }
-        // 多个命令时，根据 sessionId 和命令创建时间进行启发式匹配
-        return true; // 暂时返回 true，让所有命令都接收输出
-    }
     /**
      * 清理命令输出，去除输入的命令内容
      */
     cleanCommandOutput(output, command) {
-        if (!output || !command) {
-            return output;
-        }
-        let cleanOutput = output;
-        // 去除命令回显（命令本身）
-        cleanOutput = cleanOutput.replace(new RegExp(this.escapeRegExp(command), 'g'), '');
-        // 去除可能的命令提示符前缀和后缀
-        const promptPatterns = [
-            /^\s*[^$#>\s]*[#$>]\s*/, // 匹配提示符前缀
-            /^\s*[^$#>\s]*@[^$#>\s]*[#$>]\s*/, // 匹配 user@host 格式
-            /^\s*[^$#>\s]*:\s*[^$#>\s]*[#$>]\s*/, // 匹配 path: 格式
-            /\s*[^$#>\s]*[#$>]\s*$/, // 匹配提示符后缀
-            /\s*[^$#>\s]*@[^$#>\s]*[#$>]\s*$/, // 匹配 user@host 后缀
-            /\s*[^$#>\s]*:\s*[^$#>\s]*[#$>]\s*$/, // 匹配 path: 后缀
-            /\s*\d+\|[^$#>\s]*[#$>]\s*$/, // 匹配 Android 格式后缀
-        ];
-        for (const pattern of promptPatterns) {
-            cleanOutput = cleanOutput.replace(pattern, '');
-        }
-        // 去除多余的空行和空格
-        cleanOutput = cleanOutput.replace(/^\s+|\s+$/g, ''); // 去除首尾空白
-        cleanOutput = cleanOutput.replace(/\n\s*\n/g, '\n'); // 去除多余空行
-        // 如果清理后为空，返回空字符串
-        if (cleanOutput.trim().length === 0) {
-            return '';
-        }
-        console.log(`🧹 [Shell] 清理命令输出:`);
-        console.log(`   原始: "${output.trim()}"`);
-        console.log(`   清理后: "${cleanOutput.trim()}"`);
-        return cleanOutput;
+        return output.replace(command, '');
     }
     /**
      * 合并多个 session 的输出
@@ -155,74 +104,6 @@ class ShellX {
         }
         return combined;
     }
-    /**
-     * 转义正则表达式特殊字符
-     */
-    escapeRegExp(string) {
-        return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-    }
-    /**
-     * 检查命令是否完成
-     */
-    checkCommandCompletion(commandKey, commandPromise, newOutput) {
-        const { resolve, startTime, options, output, command } = commandPromise;
-        console.log(`🔍 [Shell] 检查命令 "${command}" 完成条件，当前输出长度: ${output.length}`);
-        if (this.isCommandComplete(output, command)) {
-            console.log(`✅ [Shell] 命令 "${command}" 执行完成 (检测到提示符)`);
-            this.resolveCommand(commandKey, {
-                success: true,
-                output: output.trim(),
-                duration: Date.now() - startTime
-            });
-            return;
-        }
-        console.log(`⏳ [Shell] 命令 "${command}" 继续等待完成...`);
-    }
-    /**
-     * 检查输出是否包含错误指示器
-     */
-    hasErrorIndicators(output) {
-        const errorPatterns = [
-            /error/i,
-            /failed/i,
-            /not found/i,
-            /permission denied/i,
-            /command not found/i,
-            /no such file/i,
-            /syntax error/i
-        ];
-        return errorPatterns.some(pattern => pattern.test(output));
-    }
-    /**
-     * 判断命令是否完成（基于时间）
-     */
-    isCommandComplete(output, command) {
-        // 简化逻辑：只基于时间判断，不依赖提示符检测
-        // 命令完成由超时机制控制
-        return false; // 让超时机制处理命令完成
-    }
-    /**
-     * 解析命令 Promise
-     */
-    resolveCommand(commandKey, result) {
-        const commandPromise = this.shellCommandPromises.get(commandKey);
-        if (commandPromise) {
-            console.log(`✅ [Shell] 解析命令 Promise: ${commandKey}`);
-            // 清理最终输出结果
-            const cleanResult = Object.assign(Object.assign({}, result), { output: this.cleanCommandOutput(result.output, commandPromise.command) });
-            commandPromise.resolve(cleanResult);
-            this.shellCommandPromises.delete(commandKey);
-        }
-        else {
-            console.log(`⚠️ [Shell] 未找到命令 Promise: ${commandKey}`);
-        }
-    }
-    /**
-     * 生成命令唯一标识
-     */
-    generateCommandKey(command) {
-        return `cmd_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-    }
     /**
      * 通用重试机制
      */
@@ -789,9 +670,10 @@ class ShellX {
             return;
         }
         console.log(`\n${title || `✅ 找到 ${elements.length} 个元素`}:`);
-        elements.forEach((element, index) => {
-            this.printElementInfo(element, index);
-        });
+        /*
+            elements.forEach((element, index) => {
+              this.printElementInfo(element, index);
+            });*/
         // 统计信息
         const visibleCount = elements.filter(e => e.visible).length;
         const clickableCount = elements.filter(e => e.clickable).length;
@@ -1004,27 +886,17 @@ class ShellX {
                 // 设置超时
                 const timeoutId = setTimeout(() => {
                     if (this.shellCommandPromises.has(commandKey)) {
+                        console.log(`✅ [Shell] 命令  ${command} 执行完成`);
                         const commandPromise = this.shellCommandPromises.get(commandKey);
                         this.shellCommandPromises.delete(commandKey);
-                        if (commandPromise && commandPromise.output.trim().length > 0) {
-                            resolve({
-                                success: true,
-                                output: commandPromise.output.trim(),
-                                duration: Date.now() - startTime
-                            });
-                        }
-                        else {
-                            resolve({
-                                success: true,
-                                output: "",
-                                error: `Command timeout after ${timeout}ms, but got partial output`,
-                                duration: Date.now() - startTime
-                            });
-                        }
+                        resolve({
+                            success: true,
+                            output: commandPromise ? commandPromise.output.trim() : "",
+                            duration: Date.now() - startTime
+                        });
                     }
                 }, timeout);
                 try {
-                    // 构建 shell 命令操作
                     const shellAction = {
                         title,
                         actions: [{
@@ -1037,7 +909,7 @@ class ShellX {
                         }
                     };
                     // 发送命令
-                    yield this.client.executeAction(shellAction, commandKey);
+                    yield this.client.sendMessageWithTaskId({ actions: shellAction }, 'command', commandKey, timeout);
                     console.log(`📤 [Shell] 命令已发送: ${commandKey}`);
                 }
                 catch (error) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shellx-ai",
-  "version": "1.0.9",
+  "version": "1.0.11",
   "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",
@@ -33,7 +33,6 @@
     "cbor": "^9.0.0",
     "dotenv": "^16.4.5",
     "ofetch": "^1.4.1",
-    "shellx-ai": "file:",
     "uuid": "^11.1.0"
   },
   "optionalDependencies": {