shellx-ai 1.0.1 → 1.0.2

package/dist/shellx.js

@@ -51,6 +51,7 @@ exports.createHelpers = createShellX;
 exports.createShellXWithShellMonitoring = createShellXWithShellMonitoring;
 exports.createHelpersWithShellMonitoring = createShellXWithShellMonitoring;
 const index_1 = __importDefault(require("./index"));
+const uuid_1 = require("uuid");
 /**
  * ShellX automation utilities for common patterns
  */
@@ -78,7 +79,7 @@ class ShellX {
      * 处理 shell 输出数据
      */
     handleShellOutput(chunks) {
-        const [sid, sessionId, dataArrays] = chunks;
+        const [sessionId, len, dataArrays] = chunks;
         try {
             // 将 Uint8Array 数组转换为字符串
             let output = '';
@@ -99,9 +100,10 @@ class ShellX {
                     // 更新总输出
                     commandPromise.output = this.combineSessionOutputs(commandPromise.sessionOutputs);
                     console.log(`📊 [Shell] 命令 ${commandKey} 累积输出长度: ${commandPromise.output.length}`);
-                    // 调用输出回调
+                    // 调用输出回调（传递清理后的输出）
                     if (commandPromise.options.onOutput) {
-                        commandPromise.options.onOutput(output);
+                        const cleanOutput = this.cleanCommandOutput(output, commandPromise.command);
+                        commandPromise.options.onOutput(cleanOutput);
                     }
                     // 检查是否满足完成条件
                     this.checkCommandCompletion(commandKey, commandPromise, output);
@@ -120,10 +122,6 @@ class ShellX {
         if (output.includes(command)) {
             return true;
         }
-        // 如果输出包含提示符，说明是命令完成
-        if (this.containsPrompt(output)) {
-            return true;
-        }
         // 如果有多个命令在等待，按时间顺序分配
         const waitingCommands = Array.from(this.shellCommandPromises.keys());
         if (waitingCommands.length === 1) {
@@ -132,6 +130,41 @@ class ShellX {
         // 多个命令时，根据 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;
+    }
     /**
      * 合并多个 session 的输出
      */
@@ -145,20 +178,10 @@ class ShellX {
         return combined;
     }
     /**
-     * 检查输出是否包含提示符
+     * 转义正则表达式特殊字符
      */
-    containsPrompt(output) {
-        const promptPatterns = [
-            /\$ $/,
-            /# $/,
-            /> $/,
-            /\w+@\w+.*\$ $/,
-            /shell@.*:.*\$ $/,
-            /houji:\/.*\$ $/,
-            /\d+\|\w+:\/.*\$ $/, // Android pattern like "127|bluejay:/ $"
-            /\w+:\/.*\$ $/ // Android pattern like "bluejay:/ $"
-        ];
-        return promptPatterns.some(pattern => pattern.test(output));
+    escapeRegExp(string) {
+        return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
     }
     /**
      * 检查命令是否完成
@@ -166,41 +189,6 @@ class ShellX {
     checkCommandCompletion(commandKey, commandPromise, newOutput) {
         const { resolve, startTime, options, output, command } = commandPromise;
         console.log(`🔍 [Shell] 检查命令 "${command}" 完成条件，当前输出长度: ${output.length}`);
-        // 检查成功模式
-        if (options.successPattern) {
-            const pattern = options.successPattern;
-            const isMatch = typeof pattern === 'string'
-                ? output.includes(pattern)
-                : pattern.test(output);
-            if (isMatch) {
-                console.log(`✅ [Shell] 命令 "${command}" 成功完成 (匹配成功模式)`);
-                this.resolveCommand(commandKey, {
-                    success: true,
-                    output: output.trim(),
-                    duration: Date.now() - startTime
-                });
-                return;
-            }
-        }
-        // 检查错误模式
-        if (options.errorPattern) {
-            const pattern = options.errorPattern;
-            const isMatch = typeof pattern === 'string'
-                ? output.includes(pattern)
-                : pattern.test(output);
-            if (isMatch) {
-                console.log(`❌ [Shell] 命令 "${command}" 执行失败 (匹配错误模式)`);
-                this.resolveCommand(commandKey, {
-                    success: false,
-                    output: output.trim(),
-                    error: 'Command failed with error pattern',
-                    duration: Date.now() - startTime
-                });
-                return;
-            }
-        }
-        // 检查通用完成模式（如命令提示符）
-        // 这是最主要的完成检测逻辑，包括对没有输出的命令的支持
         if (this.isCommandComplete(output, command)) {
             console.log(`✅ [Shell] 命令 "${command}" 执行完成 (检测到提示符)`);
             this.resolveCommand(commandKey, {
@@ -210,26 +198,6 @@ class ShellX {
             });
             return;
         }
-        // 额外的完成检测：仅当有输出时才进行的检查
-        if (output.trim().length > 0) {
-            // 检查是否有错误指示器
-            if (this.hasErrorIndicators(output)) {
-                console.log(`❌ [Shell] 命令 "${command}" 可能执行失败 (检测到错误指示器)`);
-                // 不立即失败，继续等待完整的提示符
-                return;
-            }
-            // 检查是否包含命令和结果（备用检测方式）
-            if (output.includes(command) && this.containsPrompt(output)) {
-                console.log(`✅ [Shell] 命令 "${command}" 执行完成 (命令+提示符备用检测)`);
-                this.resolveCommand(commandKey, {
-                    success: true,
-                    output: output.trim(),
-                    duration: Date.now() - startTime
-                });
-                return;
-            }
-        }
-        // 如果没有检测到完成条件，继续等待
         console.log(`⏳ [Shell] 命令 "${command}" 继续等待完成...`);
     }
     /**
@@ -248,50 +216,12 @@ class ShellX {
         return errorPatterns.some(pattern => pattern.test(output));
     }
     /**
-     * 判断命令是否完成（基于常见的提示符模式）
+     * 判断命令是否完成（基于时间）
      */
     isCommandComplete(output, command) {
-        // 常见的命令提示符模式
-        const promptPatterns = [
-            /\$ $/, // Unix shell prompt
-            /# $/, // Root shell prompt
-            /> $/, // Windows command prompt
-            /~\$ $/, // Home directory prompt
-            /\w+@\w+.*\$ $/, // User@host prompt
-            /shell@.*:.*\$ $/, // Android shell prompt
-            /houji:\/.*\$ $/, // Specific Android shell prompt
-            /\d+\|\w+:\/.*\$ $/, // Android pattern like "127|bluejay:/ $"
-            /\w+:\/.*\$ $/, // Android pattern like "bluejay:/ $"
-            /\[.*\]\$ $/, // Bracketed prompt
-            /\w+:\w+\$ $/, // Simple path prompt
-            /\w+> $/, // Simple greater-than prompt
-            /.*:\w+\$ $/, // Path-based prompt
-            /\w+@\w+:.* $/, // User@host with path
-            /\d+\|.*\$ $/, // Numbered prompt with pipe
-            /.*#\s*$/, // Hash prompt with optional space
-            /.*\$\s*$/ // Dollar prompt with optional space
-        ];
-        // 分割输出为行，检查最后几行
-        const lines = output.split(/\r?\n/).filter(line => line.trim().length > 0);
-        const lastLine = lines[lines.length - 1] || '';
-        // 清理最后一行的控制字符
-        const cleanLastLine = lastLine.replace(/\r/g, '').trim();
-        console.log(`🔍 [Shell] 检查命令 "${command}" 最后一行提示符: "${cleanLastLine}"`);
-        const hasPrompt = promptPatterns.some(pattern => {
-            const matches = pattern.test(cleanLastLine);
-            if (matches) {
-                console.log(`✅ [Shell] 命令 "${command}" 匹配到提示符模式: ${pattern}`);
-            }
-            return matches;
-        });
-        // 如果检测到提示符，则认为命令完成
-        // 不再要求输出必须包含命令本身，因为有些命令可能没有输出
-        if (hasPrompt) {
-            return true;
-        }
-        // 如果没有检测到提示符，但输出包含命令本身，可能命令还在执行中
-        // 这种情况下返回false，继续等待
-        return false;
+        // 简化逻辑：只基于时间判断，不依赖提示符检测
+        // 命令完成由超时机制控制
+        return false; // 让超时机制处理命令完成
     }
     /**
      * 解析命令 Promise
@@ -300,7 +230,9 @@ class ShellX {
         const commandPromise = this.shellCommandPromises.get(commandKey);
         if (commandPromise) {
             console.log(`✅ [Shell] 解析命令 Promise: ${commandKey}`);
-            commandPromise.resolve(result);
+            // 清理最终输出结果
+            const cleanResult = Object.assign(Object.assign({}, result), { output: this.cleanCommandOutput(result.output, commandPromise.command) });
+            commandPromise.resolve(cleanResult);
             this.shellCommandPromises.delete(commandKey);
         }
         else {
@@ -643,7 +575,7 @@ class ShellX {
             console.log(`🔨 [Shell] ${title}`);
             console.log(`⏱️  超时时间: ${timeout}ms`);
             return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
-                const commandKey = this.generateCommandKey(command);
+                const commandKey = (0, uuid_1.v4)();
                 console.log(`🔑 [Shell] 生成命令键: ${commandKey}`);
                 // 注册命令 Promise
                 this.shellCommandPromises.set(commandKey, {
@@ -660,21 +592,21 @@ class ShellX {
                 const timeoutId = setTimeout(() => {
                     if (this.shellCommandPromises.has(commandKey)) {
                         const commandPromise = this.shellCommandPromises.get(commandKey);
-                        console.log(`⏰ [Shell] 命令超时: ${command}`);
-                        // 即使超时，如果有输出也返回输出
+                        this.shellCommandPromises.delete(commandKey);
                         if (commandPromise && commandPromise.output.trim().length > 0) {
-                            console.log(`📤 [Shell] 超时但有输出，返回部分结果`);
-                            this.shellCommandPromises.delete(commandKey);
                             resolve({
-                                success: false,
+                                success: true,
                                 output: commandPromise.output.trim(),
-                                error: `Command timeout after ${timeout}ms, but got partial output`,
                                 duration: Date.now() - startTime
                             });
                         }
                         else {
-                            this.shellCommandPromises.delete(commandKey);
-                            reject(new Error(`Command timeout after ${timeout}ms`));
+                            resolve({
+                                success: true,
+                                output: "",
+                                error: `Command timeout after ${timeout}ms, but got partial output`,
+                                duration: Date.now() - startTime
+                            });
                         }
                     }
                 }, timeout);
@@ -692,10 +624,8 @@ class ShellX {
                         }
                     };
                     // 发送命令
-                    yield this.client.executeAction(shellAction);
-                    console.log(`📤 [Shell] 命令已发送: ${command}`);
-                    // 等待命令完成（通过 chunks 数据流）
-                    // Promise 将由 handleShellOutput 解析
+                    yield this.client.executeAction(shellAction, commandKey);
+                    console.log(`📤 [Shell] 命令已发送: ${commandKey}`);
                 }
                 catch (error) {
                     clearTimeout(timeoutId);
@@ -787,7 +717,6 @@ class ShellX {
                 onError: options === null || options === void 0 ? void 0 : options.onError,
                 expectedOutput: options === null || options === void 0 ? void 0 : options.expectedOutput,
                 successPattern: options === null || options === void 0 ? void 0 : options.successPattern,
-                errorPattern: options === null || options === void 0 ? void 0 : options.errorPattern
             });
         });
     }
@@ -827,62 +756,71 @@ function createShellX(client) {
     return new ShellX(client);
 }
 /**
- * 获取适合当前环境的fetch函数
+ * 获取ofetch实例
  */
-function getFetch() {
+function getfetch() {
     return __awaiter(this, void 0, void 0, function* () {
-        // 检查是否已有全局fetch（Node.js 18+或浏览器环境）
-        if (typeof globalThis.fetch !== 'undefined') {
-            return globalThis.fetch;
-        }
-        // Node.js环境下动态导入node-fetch
         try {
-            const { default: fetch } = yield Promise.resolve().then(() => __importStar(require('node-fetch')));
-            return fetch;
+            // @ts-ignore - Dynamic import may not have types
+            const { ofetch } = yield Promise.resolve().then(() => __importStar(require('ofetch')));
+            // 创建配置好的ofetch实例
+            const fetchInstance = ofetch.create({
+                timeout: 10000,
+                retry: 1,
+                retryDelay: 1000,
+                headers: {
+                    'User-Agent': 'ShellX/1.0.1'
+                },
+                onRequest({ request, options }) {
+                    console.log(`🌐 [Fetch] 请求: ${options.method || 'GET'} ${request}`);
+                },
+                onResponse({ response }) {
+                    console.log(`📡 [Fetch] 响应: ${response.status} ${response.statusText}`);
+                },
+                onRequestError({ error }) {
+                    console.error('❌ [Fetch] 请求错误:', error.message);
+                },
+                onResponseError({ response }) {
+                    console.error(`❌ [Fetch] 响应错误: ${response.status} ${response.statusText}`);
+                }
+            });
+            return fetchInstance;
         }
         catch (error) {
-            // 如果node-fetch不可用，尝试使用内置的https模块
-            console.warn('⚠️ [Auth] node-fetch不可用，使用内置https模块');
-            return createNodeFetch();
+            console.warn('⚠️ [Auth] ofetch不可用，使用降级方案');
+            return createFallbackFetch();
         }
     });
 }
 /**
- * 使用Node.js内置模块创建fetch替代函数
+ * 降级fetch实现
  */
-function createNodeFetch() {
+function createFallbackFetch() {
     return (url, options) => __awaiter(this, void 0, void 0, function* () {
-        const https = yield Promise.resolve().then(() => __importStar(require('https')));
-        const { URL } = yield Promise.resolve().then(() => __importStar(require('url')));
-        return new Promise((resolve, reject) => {
-            const parsedUrl = new URL(url);
-            const requestOptions = {
-                hostname: parsedUrl.hostname,
-                port: parsedUrl.port || 443,
-                path: parsedUrl.pathname + parsedUrl.search,
-                method: (options === null || options === void 0 ? void 0 : options.method) || 'GET',
-                headers: (options === null || options === void 0 ? void 0 : options.headers) || {}
-            };
-            const req = https.request(requestOptions, (res) => {
-                let data = '';
-                res.on('data', (chunk) => data += chunk);
-                res.on('end', () => {
-                    const response = {
-                        ok: res.statusCode ? res.statusCode >= 200 && res.statusCode < 300 : false,
-                        status: res.statusCode || 0,
-                        statusText: res.statusMessage || '',
-                        json: () => __awaiter(this, void 0, void 0, function* () { return JSON.parse(data); }),
-                        text: () => __awaiter(this, void 0, void 0, function* () { return data; })
-                    };
-                    resolve(response);
-                });
-            });
-            req.on('error', reject);
-            if (options === null || options === void 0 ? void 0 : options.body) {
-                req.write(options.body);
+        // 尝试使用全局fetch
+        if (typeof globalThis.fetch !== 'undefined') {
+            console.log(`🌐 [Fetch] 请求: ${(options === null || options === void 0 ? void 0 : options.method) || 'GET'} ${url}`);
+            const response = yield globalThis.fetch(url, options);
+            console.log(`📡 [Fetch] 响应: ${response.status} ${response.statusText}`);
+            if (!response.ok) {
+                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
             }
-            req.end();
-        });
+            return response.json();
+        }
+        // Node.js环境降级
+        try {
+            const { default: fetch } = yield Promise.resolve().then(() => __importStar(require('node-fetch')));
+            console.log(`🌐 [Fetch] 请求: ${(options === null || options === void 0 ? void 0 : options.method) || 'GET'} ${url}`);
+            const response = yield fetch(url, options);
+            console.log(`📡 [Fetch] 响应: ${response.status} ${response.statusText}`);
+            if (!response.ok) {
+                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+            }
+            return response.json();
+        }
+        catch (fetchError) {
+            throw new Error(`Fetch not available: ${fetchError.message}`);
+        }
     });
 }
 /**
@@ -896,47 +834,45 @@ function authenticateDevice() {
         }
         try {
             console.log('🔑 [Auth] 正在认证设备...');
-            // 获取适合当前环境的fetch函数
-            const fetchFn = yield getFetch();
-            const response = yield fetchFn(`https://shellx.ai/api/device/${authKey}`, {
+            // 获取ofetch实例
+            const fetchFn = yield getfetch();
+            // ofetch自动处理JSON解析和错误处理
+            const data = yield fetchFn(`https://shellx.ai/api/device/${authKey}`, {
                 method: 'GET',
                 headers: {
                     'Content-Type': 'application/json',
                 }
             });
-            if (!response.ok) {
-                throw new Error(`Authentication failed: ${response.status} ${response.statusText}`);
-            }
-            const data = yield response.json();
-            if (data.status !== 'success') {
-                throw new Error(`Authentication failed: ${data.message}`);
-            }
-            console.log('✅ [Auth] 设备认证成功');
-            console.log(`📡 [Auth] 连接信息: ${data.machine}`);
-            return data.machine;
+            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;
         }
         catch (error) {
             const errorMessage = error instanceof Error ? error.message : String(error);
-            console.warn('⚠️ [Auth] 在线认证失败，使用本地默认连接:', errorMessage);
-            // 认证失败时使用默认的本地WebSocket URL
+            console.warn('⚠️ [Auth] ShellX.ai在线认证失败，使用本地服务:', errorMessage);
+            // 认证失败时使用默认的本地ShellX服务
             const fallbackUrl = `ws://127.0.0.1:9091/api/s/${authKey}`;
-            console.log(`🔄 [Auth] 使用默认连接: ${fallbackUrl}`);
+            console.log(`🔄 [Auth] 使用本地ShellX服务: ${fallbackUrl}`);
             return fallbackUrl;
         }
     });
 }
 /**
  * Create ShellX instance with automatic authentication and shell output monitoring
- * 自动处理认证和连接，无需外部提供WebSocket URL
+ * 自动处理ShellX.ai认证和连接，无需外部提供连接地址
  */
 function createShellXWithShellMonitoring() {
     return __awaiter(this, arguments, void 0, function* (config = {}) {
         try {
-            // 认证并获取WebSocket URL
+            // 认证并获取ShellX.ai服务地址
             const wsUrl = yield authenticateDevice();
             // 先创建 shellx 实例，但不绑定客户端
             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) {
@@ -946,10 +882,20 @@ function createShellXWithShellMonitoring() {
                     if (config.onMessage) {
                         config.onMessage(message);
                     }
+                }, onOpen: () => {
+                    // 调用原始的onOpen处理器
+                    if (config.onOpen) {
+                        config.onOpen();
+                    }
                 } }));
+            // 等待ShellX.ai服务连接完成
+            console.log('⏳ [ShellX] 等待ShellX.ai服务连接...');
+            yield client.waitForInitialization();
             // 绑定客户端到 shellx
             shellx.client = client;
-            console.log('🚀 [ShellX] 初始化完成，可以开始使用自动化功能');
+            // 将 shellx 实例关联到客户端
+            client.setShellX(shellx);
+            console.log('🚀 [ShellX] 初始化完成，等待ShellX.ai服务响应...');
             return { client, shellx };
         }
         catch (error) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shellx-ai",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "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",
@@ -24,7 +24,14 @@
     "test:shell-commands": "ts-node -r dotenv/config examples/shell-commands-demo.ts",
     "test:no-output": "ts-node -r dotenv/config examples/no-output-command-test.ts",
     "test:find-elements": "ts-node -r dotenv/config examples/find-elements-demo.ts",
-    "test:api": "ts-node test-shellx.ts"
+    "test:api": "ts-node test-shellx.ts",
+    "test:auth": "ts-node test-auth.ts",
+    "test:ofetch": "ts-node test-ofetch.ts",
+    "test:paytm-connection": "ts-node -r dotenv/config test-paytm-connection.ts",
+    "test:prompt-detection": "ts-node -r dotenv/config test-shell-prompt-integration.ts",
+    "test:simplified": "ts-node -r dotenv/config test-simplified-shell.ts",
+    "install-deps": "node install-deps.js",
+    "postinstall": "node install-deps.js"
   },
   "keywords": [
     "websocket",
@@ -44,7 +51,8 @@
     "uuid": "^11.1.0"
   },
   "optionalDependencies": {
-    "node-fetch": "^3.3.2"
+    "node-fetch": "^3.3.2",
+    "ws": "^8.14.2"
   },
   "devDependencies": {
     "@types/jest": "^30.0.0",