Upload 7 files

README_HF.md

@@ -0,0 +1,74 @@
+# WebShell - Hugging Face Spaces版本
+
+这是一个基于Flask和WebSocket的Web终端和文件管理系统，专为Hugging Face Spaces部署优化。
+
+## 功能特性
+
+### 🗂️ 文件管理
+- 📁 文件/文件夹浏览、创建、删除、重命名
+- 📤 文件上传下载
+- ✏️ 在线代码编辑器（支持语法高亮）
+- 👀 文件预览功能
+
+### 💻 终端模拟器
+- 🖥️ 实时终端交互（基于WebSocket）
+- 🐧 支持Linux bash命令
+- 📜 命令历史记录（↑↓键浏览）
+- 🔄 多终端会话支持
+
+### 🛡️ 安全特性
+- 🔒 路径遍历攻击防护
+- 📁 访问权限限制在应用目录内
+- 🚫 恶意命令执行防护
+
+## 技术栈
+
+**后端：**
+- Flask + Flask-SocketIO
+- Python subprocess
+- 多线程处理
+
+**前端：**
+- Bootstrap 5 响应式设计
+- CodeMirror 代码编辑器
+- Socket.IO 实时通信
+- Font Awesome 图标
+
+## 部署说明
+
+这个版本已经针对Hugging Face Spaces进行了优化：
+
+1. **端口配置**：使用环境变量 `PORT`（默认7860）
+2. **Linux兼容**：支持Linux bash终端
+3. **Docker化**：包含完整的Dockerfile
+4. **依赖管理**：requirements.txt包含所有必需的包
+
+## 环境变量
+
+- `PORT`: 服务端口（默认7860）
+- `HOST`: 服务主机（默认0.0.0.0）
+- `DEBUG`: 调试模式（默认False）
+
+## 使用方法
+
+部署到Hugging Face Spaces后，访问以下功能：
+
+1. **主页**：`/` - 功能选择页面
+2. **文件管理**：`/files` - 文件浏览和编辑
+3. **终端**：`/terminal` - 命令行界面
+
+## 安全提醒
+
+⚠️ **重要安全提醒**：
+- 此工具仅用于开发和学习目的
+- 请勿在生产环境中暴露于公网
+- 定期检查和更新依赖包
+- 谨慎使用终端功能
+
+## 许可证
+
+MIT License
+
+---
+
+**注意**：本项目仅供学习和开发使用，请遵守相关法律法规和平台使用条款。 

app.py

@@ -19,209 +19,53 @@ app = Flask(__name__)
 app.config['SECRET_KEY'] = 'webshell-secret-key-2024'
 socketio = SocketIO(app, cors_allowed_origins="*")
 
-# 全局变量存储终端进程
-terminals = {}
+# 全局终端变量
+shell_process = None
 
-class Terminal:
-    def __init__(self, session_id):
-        self.session_id = session_id
-        self.process = None
-        self.is_windows = os.name == 'nt'
-        self.output_queue = queue.Queue()
-        self.input_queue = queue.Queue()
-        self.running = False
-        logger.info(f"创建终端实例: {session_id}, Windows: {self.is_windows}")
+def execute_command(command):
+    """执行单个命令并返回输出"""
+    try:
+        logger.info(f"执行命令: {repr(command)}")
         
-    def spawn(self):
-        """启动终端进程"""
-        try:
-            logger.info(f"启动终端进程 {self.session_id}")
-            if self.is_windows:
-                # Windows环境使用cmd，使用简化的参数
-                self.process = subprocess.Popen(
-                    ['cmd.exe', '/Q'],  # /Q 参数关闭回显
-                    stdin=subprocess.PIPE,
-                    stdout=subprocess.PIPE,
-                    stderr=subprocess.STDOUT,
-                    text=True,
-                    shell=False,
-                    bufsize=1,    # 行缓冲
-                    universal_newlines=True,
-                    cwd=os.getcwd(),
-                    env=os.environ.copy()
-                )
-                logger.info(f"CMD进程已启动，PID: {self.process.pid}")
-            else:
-                # Unix/Linux环境使用bash
-                import pty
-                self.child_pid, self.fd = pty.fork()
-                if self.child_pid == 0:
-                    # 子进程
-                    os.execvp('/bin/bash', ['/bin/bash'])
-                else:
-                    # 父进程
-                    self.set_winsize(24, 80)
-                    logger.info(f"PTY进程已启动，PID: {self.child_pid}")
-            
-            self.running = True
-            
-            # 启动输出读取线程
-            if self.is_windows:
-                self._start_output_thread()
-                self._start_input_thread()
-            else:
-                self._start_pty_thread()
+        if os.name == 'nt':
+            # Windows环境
+            result = subprocess.run(
+                command,
+                shell=True,
+                capture_output=True,
+                text=True,
+                cwd=os.getcwd(),
+                timeout=30
+            )
             
-            logger.info(f"终端 {self.session_id} 启动成功")
-            return True
-        except Exception as e:
-            logger.error(f"启动终端失败: {e}")
-            return False
-    
-    def _start_output_thread(self):
-        """启动输出读取线程（Windows）"""
-        def read_output():
-            logger.info(f"输出读取线程启动 {self.session_id}")
-            while self.running and self.process and self.process.poll() is None:
-                try:
-                    # 检查进程是否还活着
-                    if self.process.poll() is not None:
-                        logger.warning(f"进程已退出: {self.process.poll()}")
-                        break
-                    
-                    # 尝试读取一行
-                    try:
-                        line = self.process.stdout.readline()
-                        if line:
-                            logger.debug(f"读取到输出: {repr(line)}")
-                            self.output_queue.put(line)
-                        else:
-                            # 没有数据时短暂等待
-                            time.sleep(0.05)
-                    except Exception as read_err:
-                        logger.error(f"读取stdout错误: {read_err}")
-                        time.sleep(0.1)
-                        
-                except Exception as e:
-                    logger.error(f"输出线程异常: {e}")
-                    break
-                    
-            logger.info(f"输出读取线程结束 {self.session_id}")
-                    
-        threading.Thread(target=read_output, daemon=True).start()
-    
-    def _start_input_thread(self):
-        """启动输入处理线程（Windows）"""
-        def process_input():
-            logger.info(f"输入处理线程启动 {self.session_id}")
-            while self.running and self.process and self.process.poll() is None:
-                try:
-                    if not self.input_queue.empty():
-                        data = self.input_queue.get(timeout=0.1)
-                        logger.debug(f"写入命令: {repr(data)}")
-                        if self.process.stdin:
-                            self.process.stdin.write(data)
-                            self.process.stdin.flush()
-                            logger.debug(f"命令已写入并刷新缓冲区")
-                            
-                            # 立即发送回显
-                            if not data.endswith('\n'):
-                                # 如果不是完整命令，发送回显
-                                self.output_queue.put(data)
-                except Exception as e:
-                    logger.error(f"处理输入错误: {e}")
-                time.sleep(0.01)
-            logger.info(f"输入处理线程结束 {self.session_id}")
-                    
-        threading.Thread(target=process_input, daemon=True).start()
-    
-    def _start_pty_thread(self):
-        """启动PTY线程（Linux）"""
-        def pty_thread():
-            logger.info(f"PTY线程启动 {self.session_id}")
-            while self.running:
-                try:
-                    import select
-                    ready, _, _ = select.select([self.fd], [], [], 0.1)
-                    if ready:
-                        data = os.read(self.fd, 1024)
-                        if data:
-                            output = data.decode('utf-8', errors='ignore')
-                            logger.debug(f"PTY输出: {repr(output)}")
-                            self.output_queue.put(output)
-                except Exception as e:
-                    logger.error(f"PTY线程错误: {e}")
-                    break
-            logger.info(f"PTY线程结束 {self.session_id}")
-                    
-        threading.Thread(target=pty_thread, daemon=True).start()
+            output = result.stdout + result.stderr
+            logger.debug(f"命令输出: {repr(output)}")
+            return output
+        else:
+            # Unix/Linux环境
+            result = subprocess.run(
+                command,
+                shell=True,
+                capture_output=True,
+                text=True,
+                cwd=os.getcwd(),
+                timeout=30
+            )
             
-    def set_winsize(self, rows, cols):
-        """设置终端窗口大小"""
-        if not self.is_windows and hasattr(self, 'fd'):
-            try:
-                import termios
-                import struct
-                import fcntl
-                winsize = struct.pack("HHHH", rows, cols, 0, 0)
-                fcntl.ioctl(self.fd, termios.TIOCSWINSZ, winsize)
-                logger.debug(f"设置终端窗口大小: {rows}x{cols}")
-            except Exception as e:
-                logger.error(f"设置窗口大小失败: {e}")
-                
-    def read(self):
-        """读取终端输出"""
-        try:
-            output = ""
-            count = 0
-            while not self.output_queue.empty() and count < 10:  # 限制一次读取的数量
-                try:
-                    data = self.output_queue.get_nowait()
-                    output += data
-                    count += 1
-                except queue.Empty:
-                    break
-            if output:
-                logger.debug(f"读取到输出 {self.session_id}: {repr(output[:100])}")
+            output = result.stdout + result.stderr
+            logger.debug(f"命令输出: {repr(output)}")
             return output
-        except Exception as e:
-            logger.error(f"读取终端输出错误: {e}")
-            return ''
             
-    def write(self, data):
-        """写入终端输入"""
-        try:
-            logger.info(f"接收到输入 {self.session_id}: {repr(data)}")
-            if self.is_windows:
-                self.input_queue.put(data)
-                logger.debug(f"命令已放入输入队列，队列大小: {self.input_queue.qsize()}")
-            else:
-                # Unix/Linux
-                if hasattr(self, 'fd'):
-                    os.write(self.fd, data.encode('utf-8'))
-                    logger.debug(f"命令已写入PTY")
-        except Exception as e:
-            logger.error(f"写入终端输入错误: {e}")
-    
-    def close(self):
-        """关闭终端"""
-        try:
-            logger.info(f"关闭终端 {self.session_id}")
-            self.running = False
-            if self.is_windows:
-                if self.process:
-                    self.process.terminate()
-                    self.process = None
-            else:
-                if hasattr(self, 'fd'):
-                    os.close(self.fd)
-                if hasattr(self, 'child_pid'):
-                    try:
-                        os.kill(self.child_pid, signal.SIGTERM)
-                    except:
-                        pass
-        except Exception as e:
-            logger.error(f"关闭终端错误: {e}")
+    except subprocess.TimeoutExpired:
+        return "命令执行超时\n"
+    except Exception as e:
+        logger.error(f"执行命令错误: {e}")
+        return f"错误: {e}\n"
+
+def init_terminal():
+    """初始化全局终端"""
+    logger.info("终端初���化")
+    return True
 
 @app.route('/')
 def index():
@@ -393,91 +237,36 @@ def on_connect():
 
 @socketio.on('disconnect')
 def on_disconnect():
-    session_id = request.sid
-    logger.info(f'客户端断开: {session_id}')
-    
-    # 离开房间
-    leave_room(session_id)
-    
-    # 清理终端进程
-    if session_id in terminals:
-        terminals[session_id].close()
-        del terminals[session_id]
+    logger.info(f'客户端断开: {request.sid}')
 
 @socketio.on('start_terminal')
 def on_start_terminal():
-    session_id = request.sid
-    logger.info(f'启动终端请求: {session_id}')
-    
-    # 将客户端加入专用房间
-    join_room(session_id)
-    logger.info(f'客户端 {session_id} 加入房间')
-    
-    terminal = Terminal(session_id)
-    
-    if terminal.spawn():
-        terminals[session_id] = terminal
-        
-        # 立即发送测试消息
-        emit('terminal_output', {'data': '=== WebShell Terminal Started ===\n'})
-        emit('terminal_output', {'data': f'Session ID: {session_id}\n'})
-        emit('terminal_output', {'data': f'Working Directory: {os.getcwd()}\n'})
-        emit('terminal_output', {'data': 'Type commands below:\n'})
-        
-        if os.name == 'nt':
-            emit('terminal_output', {'data': 'C:\\> '})
-        else:
-            emit('terminal_output', {'data': '$ '})
-        
-        # 启动读取线程
-        def read_thread():
-            logger.info(f'读取线程启动: {session_id}')
-            while session_id in terminals and terminals[session_id].running:
-                try:
-                    terminal_instance = terminals[session_id]
-                    output = terminal_instance.read()
-                    if output:
-                        logger.info(f'发送输出到客户端 {session_id}: {repr(output)}')
-                        # 发送到特定房间
-                        socketio.emit('terminal_output', {'data': output}, room=session_id)
-                    time.sleep(0.05)  # 减少延迟
-                except Exception as e:
-                    logger.error(f"读取线程错误: {e}")
-                    break
-            logger.info(f'读取线程结束: {session_id}')
-        
-        threading.Thread(target=read_thread, daemon=True).start()
-        emit('terminal_ready')
-        logger.info(f'终端就绪: {session_id}')
-    else:
-        emit('terminal_error', {'error': '无法启动终端'})
-        logger.error(f'终端启动失败: {session_id}')
+    logger.info('启动终端请求')
+    emit('output', '=== WebShell Terminal Started ===\n')
+    emit('output', f'Working Directory: {os.getcwd()}\n')
+    emit('output', 'Type commands below:\n')
+    emit('terminal_ready')
 
-@socketio.on('terminal_input')
+@socketio.on('input')  
 def on_terminal_input(data):
-    session_id = request.sid
-    command = data['data']
-    logger.info(f"收到终端输入 {session_id}: {repr(command)}")
+    command = data  # 成功案例直接发送字符串，不是对象
+    logger.info(f"收到终端输入: {repr(command)}")
     
-    if session_id in terminals:
-        terminal = terminals[session_id]
-        terminal.write(command)
-        
-        # 检查进程状态
-        if terminal.is_windows and terminal.process:
-            poll_result = terminal.process.poll()
-            logger.debug(f"进程状态 {session_id}: {poll_result}, PID: {terminal.process.pid}")
-            if poll_result is not None:
-                logger.warning(f"进程已终止 {session_id}: 退出码 {poll_result}")
-    else:
-        logger.warning(f"终端不存在: {session_id}")
+    try:
+        output = execute_command(command)
+        # 确保输出末尾有换行符，以区分命令和输出
+        if output and not output.endswith('\n'):
+            output += '\n'
+        emit('output', output)  # 改为'output'事件
+    except Exception as e:
+        logger.error(f"执行命令错误: {e}")
+        emit('output', f'错误: {e}\n')
 
 @socketio.on('terminal_resize')
 def on_terminal_resize(data):
-    session_id = request.sid
-    logger.debug(f'终端调整大小: {session_id}, {data["rows"]}x{data["cols"]}')
-    if session_id in terminals:
-        terminals[session_id].set_winsize(data['rows'], data['cols'])
+    logger.debug(f'终端调整大小: {data["rows"]}x{data["cols"]}')
+    # 对于全局终端，暂时忽略调整大小
+    pass
 
 # 错误处理
 @app.errorhandler(404)
@@ -495,4 +284,11 @@ if __name__ == '__main__':
     debug = os.environ.get('DEBUG', 'False').lower() == 'true'
     
     logger.info(f"🚀 WebShell 启动在 {host}:{port}")
+    
+    # 初始化终端
+    if init_terminal():
+        logger.info("终端初始化成功")
+    else:
+        logger.error("终端初始化失败")
+    
     socketio.run(app, host=host, port=port, debug=debug, allow_unsafe_werkzeug=True) 

templates/terminal.html

@@ -78,6 +78,22 @@
             background: #0c0c0c;
             white-space: pre-wrap;
             word-wrap: break-word;
+            /* 启用文本选择和复制 */
+            user-select: text !important;
+            -webkit-user-select: text !important;
+            -moz-user-select: text !important;
+            -ms-user-select: text !important;
+            /* 确保可以正常交互 */
+            pointer-events: auto;
+            cursor: text;
+        }
+        
+        /* 确保span元素也可以选择 */
+        .terminal-output span {
+            user-select: text !important;
+            -webkit-user-select: text !important;
+            -moz-user-select: text !important;
+            -ms-user-select: text !important;
         }
         
         .terminal-input-line {
@@ -315,15 +331,15 @@
                 updatePrompt();
             });
             
-            socket.on('terminal_output', function(data) {
-                console.log('收到terminal_output事件:', data);
-                if (data && data.data) {
-                    // 确保文本正确显示
-                    console.log('输出内容:', JSON.stringify(data.data));
-                    addOutput(data.data, '#cccccc', false);
+            socket.on('output', function(data) {
+                console.log('收到output事件:', data);
+                if (data) {
+                    // 直接显示输出，与成功案例一致
+                    console.log('输出内容:', JSON.stringify(data));
+                    addOutput(data, '#cccccc', false);
                     updatePrompt();
                 } else {
-                    console.error('terminal_output数据格式错误:', data);
+                    console.error('output数据为空:', data);
                 }
             });
             
@@ -377,6 +393,28 @@
                 }
             });
             
+            // 添加全局快捷键支持
+            document.addEventListener('keydown', function(e) {
+                // Ctrl+A 全选终端输出
+                if (e.ctrlKey && e.key === 'a') {
+                    const output = document.getElementById('terminalOutput');
+                    if (window.getSelection().toString() === '') {
+                        const range = document.createRange();
+                        range.selectNodeContents(output);
+                        const selection = window.getSelection();
+                        selection.removeAllRanges();
+                        selection.addRange(range);
+                        e.preventDefault();
+                    }
+                }
+                
+                // Ctrl+L 清空终端
+                if (e.ctrlKey && e.key === 'l') {
+                    clearTerminal();
+                    e.preventDefault();
+                }
+            });
+            
             // 输入内容变化时
             input.addEventListener('input', function() {
                 currentCommand = this.value;
@@ -389,13 +427,18 @@
             
             // 点击其他地方时隐藏历史
             document.addEventListener('click', function(e) {
+                // 如果点击的是终端输出区域，不要隐藏历史，允许文本选择
+                if (e.target.closest('.terminal-output')) {
+                    return;
+                }
+                
                 if (!e.target.closest('.history-dropdown') && !e.target.closest('.terminal-input')) {
                     hideHistoryDropdown();
                 }
             });
             
-            // 阻止右键菜单
-            document.addEventListener('contextmenu', function(e) {
+            // 只在输入区域阻止右键菜单，输出区域允许右键复制
+            document.getElementById('terminalInput').addEventListener('contextmenu', function(e) {
                 e.preventDefault();
             });
             
@@ -427,11 +470,11 @@
             hideHistoryDropdown();
             
             // 显示命令
-            addOutput(document.getElementById('terminalPrompt').textContent + ' ' + command, '#569cd6');
+            addOutput(document.getElementById('terminalPrompt').textContent + ' ' + command + '\n', '#569cd6');
             
             // 发送命令到服务器
             if (socket && isConnected) {
-                socket.emit('terminal_input', {data: command + '\n'});
+                socket.emit('input', command + '\n');  // 直接发送字符串
             }
             
             // 清空输入
@@ -449,16 +492,17 @@
                 return;
             }
             
-            // 创建文本节点而不是div，保持原始格式
-            const textNode = document.createTextNode(text);
-            const span = document.createElement('span');
-            
-            if (color) {
-                span.style.color = color;
-            }
+            // 转义HTML特殊字符但保留换行
+            const escapedText = text
+                .replace(/&/g, '&')
+                .replace(/</g, '&lt;')
+                .replace(/>/g, '&gt;')
+                .replace(/"/g, '&quot;')
+                .replace(/'/g, '&#39;');
             
-            span.appendChild(textNode);
-            output.appendChild(span);
+            // 直接使用innerHTML添加，这样文本更容易选择
+            const colorStyle = color ? `color: ${color};` : '';
+            output.innerHTML += `<span style="${colorStyle}">${escapedText}</span>`;
             
             // 自动滚动到底部
             output.scrollTop = output.scrollHeight;
@@ -585,10 +629,18 @@
             }
         });
         
-        // 保持输入框焦点
+        // 保持输入框焦点，但不要在用户选择文本时干扰
         setInterval(function() {
             const input = document.getElementById('terminalInput');
-            if (document.activeElement !== input) {
+            const selection = window.getSelection();
+            
+            // 如果用户正在选择文本，不要强制聚焦
+            if (selection.toString().length > 0) {
+                return;
+            }
+            
+            // 如果当前焦点不在输入框且没有其他元素获得焦点
+            if (document.activeElement !== input && document.activeElement === document.body) {
                 input.focus();
             }
         }, 100);