PyPI - ssh-licco - Versions diffs - 1.3.2__tar.gz → 1.3.3__tar.gz - Mend

ssh-licco 1.3.2tar.gz → 1.3.3tar.gz

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (34) hide show

{ssh_licco-1.3.2/ssh_licco.egg-info → ssh_licco-1.3.3}/PKG-INFO RENAMED Viewed

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ssh-licco
-Version: 1.3.2
+Version: 1.3.3
 Summary: SSH Model Context Protocol Server - Enable SSH functionality for AI models
 Author-email: SSH LICCO Team <contact@ssh-licco.dev>
 License: MIT
@@ -53,7 +53,6 @@ Dynamic: license-file
 ### 核心功能
 - **[🔐 安全配置](#-安全配置)** - 多级安全策略
-- **[🐍 Anaconda 指南](ANACONDA_GUIDE.md)** - conda 环境兼容
 - **[🛠️ 可用工具](#-可用工具)** - 完整功能列表
 - **[💡 使用示例](#-使用示例)** - 实际应用场景
@@ -79,12 +78,15 @@ Dynamic: license-file
 - 🛡️ **完善的异常处理** - 统一的错误处理机制（7 层异常层次）
 - 📊 **会话管理** - 支持多个并发 SSH 会话（最大 10 个，每主机 3 个）
 - 📁 **SFTP 文件传输** - 上传、下载、目录管理
+- 🖊️ **远程文件编辑** - 直接写入/追加文件内容，无需下载再上传
 - 🔑 **密钥管理** - 生成和管理 SSH 密钥对（RSA/Ed25519）
 - 📝 **审计日志** - 完整的操作审计记录（JSON 结构化日志）
 - 🚀 **连接池** - 高性能连接复用（PooledConnection + ConnectionPool）
 - 📊 **批量执行** - 多主机并行命令执行（BatchExecutor + AsyncBatchExecutor）
 - 🐳 **Docker 支持** - Docker 构建和状态监控
-- 📋 **后台任务** - 异步任务执行和状态跟踪
+- 📋 **后台任务** - 可靠的后台进程启动（nohup + bash -c 包装，单次 SSH 调用无竞态）
+- 🖥️ **screen/tmux 会话** - 持久化远程会话，SSH 断开后进程依然存活
+- 🔍 **进程管理** - 启动/停止/查询远程进程、SSH 端口转发（tunnel）
 - 🖥️ **CLI 命令行** - exec / upload / download / list-hosts 子命令
 - 🔍 **看门狗** - 任务监控、心跳检测、全局异常处理
@@ -106,8 +108,6 @@ npx ssh-licco
 pip install ssh-licco
 ```
-> ⚠️ **Anaconda 用户注意**：如果使用 conda 环境，推荐用 `npx` 方式安装（完全隔离），或创建专用 conda 环境安装。直接在 base 环境 `pip install` 可能导致依赖冲突。详见 [Anaconda 环境指南](ANACONDA_GUIDE.md)。
 ### 方式三：从源码安装
 ```bash
@@ -277,17 +277,19 @@ npx ssh-licco
 ---
-## 🛠️ 可用工具（v1.1.0 精简至 7 个）
+## 🛠️ 可用工具（v1.3.0 扩充至 11 个）
 | 工具 | 描述 | 核心能力 |
 |------|------|---------|
 | `ssh_connect` | 连接管理 | 自动读取环境变量/配置，支持密码+密钥认证，可保存配置，登录后自动执行命令 |
-| `ssh_execute` | 命令执行 | 自动连接、智能后台检测、长任务等待、超时控制 |
+| `ssh_execute` | 命令执行 | 自动连接、智能后台检测、长任务等待、超时控制，支持 nohup/screen/tmux 三种后台模式 |
 | `ssh_disconnect` | 会话管理 | 断开指定会话 OR 列出所有活跃会话 |
-| `ssh_file_transfer` | 文件传输 | 上传 / 下载 / 列目录 |
+| `ssh_file_transfer` | 文件传输 | 上传/下载/列表/写入/追加/删除/创建目录/查看元信息（8 种操作） |
 | `ssh_host` | 主机管理 | `action=list/add/remove` 增删查主机配置 |
 | `ssh_docker` | Docker 管理 | `action=ps/images/build/logs` 全生命周期管理 |
 | `ssh_generate_key` | 密钥生成 | RSA / Ed25519 密钥对 |
+| `ssh_session` | screen/tmux 会话 | 持久化远程会话管理（create/send/capture/list/kill），SSH 断开后进程依然存活 |
+| `ssh_process` | 进程管理 | 启动/停止/查询远程进程，SSH 端口转发（tunnel_open/tunnel_close/tunnel_list） |
 ### 📖 详细文档
@@ -731,6 +733,8 @@ pytest --cov=ssh_mcp --cov-report=term-missing
 | 版本 | 日期 | 主要变更 |
 |------|------|----------|
+| v1.3.3 | 2026-06-19 | 🛠️ 后台任务可靠性修复：单次 SSH 调用 + nohup bash -c 包装消除竞态；新增 screen/tmux 会话支持（session_type 参数）；channel 引用保持防止进程被 GC 回收；docker build 不再被误判为后台任务；新增 ssh_session/ssh_process 工具 |
+| v1.3.2 | 2026-06-19 | 🔧 修复 MCP_GITHUB_TOKEN 配置，Auto Release 工作流修复 |
 | v1.2.1 | 2026-06-03 | 📝 README 文档更新，同步到 PyPI |
 | v1.1.0 | 2026-06-01 | 🔥 精简重构！MCP 工具从 15 个合并为 7 个（ssh_connect/ssh_execute/ssh_disconnect/ssh_file_transfer/ssh_host/ssh_docker/ssh_generate_key），自动连接、智能后台检测、长任务等待 |
 | v1.0.0 | 2026-05-31 | 🎉 首个主要版本！CLI 增强（exec/upload/download/docker-build/list-hosts）、完整测试套件（402 用例）、看门狗监控、审计日志、连接池、批量执行 |
@@ -786,4 +790,4 @@ MIT License - 详见 [LICENSE](LICENSE)
 **Made with ❤️ by Echoqili**
-*Last updated: 2026-06-01*
+*Last updated: 2026-06-19*

{ssh_licco-1.3.2 → ssh_licco-1.3.3}/README.md RENAMED Viewed

@@ -20,7 +20,6 @@
 ### 核心功能
 - **[🔐 安全配置](#-安全配置)** - 多级安全策略
-- **[🐍 Anaconda 指南](ANACONDA_GUIDE.md)** - conda 环境兼容
 - **[🛠️ 可用工具](#-可用工具)** - 完整功能列表
 - **[💡 使用示例](#-使用示例)** - 实际应用场景
@@ -46,12 +45,15 @@
 - 🛡️ **完善的异常处理** - 统一的错误处理机制（7 层异常层次）
 - 📊 **会话管理** - 支持多个并发 SSH 会话（最大 10 个，每主机 3 个）
 - 📁 **SFTP 文件传输** - 上传、下载、目录管理
+- 🖊️ **远程文件编辑** - 直接写入/追加文件内容，无需下载再上传
 - 🔑 **密钥管理** - 生成和管理 SSH 密钥对（RSA/Ed25519）
 - 📝 **审计日志** - 完整的操作审计记录（JSON 结构化日志）
 - 🚀 **连接池** - 高性能连接复用（PooledConnection + ConnectionPool）
 - 📊 **批量执行** - 多主机并行命令执行（BatchExecutor + AsyncBatchExecutor）
 - 🐳 **Docker 支持** - Docker 构建和状态监控
-- 📋 **后台任务** - 异步任务执行和状态跟踪
+- 📋 **后台任务** - 可靠的后台进程启动（nohup + bash -c 包装，单次 SSH 调用无竞态）
+- 🖥️ **screen/tmux 会话** - 持久化远程会话，SSH 断开后进程依然存活
+- 🔍 **进程管理** - 启动/停止/查询远程进程、SSH 端口转发（tunnel）
 - 🖥️ **CLI 命令行** - exec / upload / download / list-hosts 子命令
 - 🔍 **看门狗** - 任务监控、心跳检测、全局异常处理
@@ -73,8 +75,6 @@ npx ssh-licco
 pip install ssh-licco
 ```
-> ⚠️ **Anaconda 用户注意**：如果使用 conda 环境，推荐用 `npx` 方式安装（完全隔离），或创建专用 conda 环境安装。直接在 base 环境 `pip install` 可能导致依赖冲突。详见 [Anaconda 环境指南](ANACONDA_GUIDE.md)。
 ### 方式三：从源码安装
 ```bash
@@ -244,17 +244,19 @@ npx ssh-licco
 ---
-## 🛠️ 可用工具（v1.1.0 精简至 7 个）
+## 🛠️ 可用工具（v1.3.0 扩充至 11 个）
 | 工具 | 描述 | 核心能力 |
 |------|------|---------|
 | `ssh_connect` | 连接管理 | 自动读取环境变量/配置，支持密码+密钥认证，可保存配置，登录后自动执行命令 |
-| `ssh_execute` | 命令执行 | 自动连接、智能后台检测、长任务等待、超时控制 |
+| `ssh_execute` | 命令执行 | 自动连接、智能后台检测、长任务等待、超时控制，支持 nohup/screen/tmux 三种后台模式 |
 | `ssh_disconnect` | 会话管理 | 断开指定会话 OR 列出所有活跃会话 |
-| `ssh_file_transfer` | 文件传输 | 上传 / 下载 / 列目录 |
+| `ssh_file_transfer` | 文件传输 | 上传/下载/列表/写入/追加/删除/创建目录/查看元信息（8 种操作） |
 | `ssh_host` | 主机管理 | `action=list/add/remove` 增删查主机配置 |
 | `ssh_docker` | Docker 管理 | `action=ps/images/build/logs` 全生命周期管理 |
 | `ssh_generate_key` | 密钥生成 | RSA / Ed25519 密钥对 |
+| `ssh_session` | screen/tmux 会话 | 持久化远程会话管理（create/send/capture/list/kill），SSH 断开后进程依然存活 |
+| `ssh_process` | 进程管理 | 启动/停止/查询远程进程，SSH 端口转发（tunnel_open/tunnel_close/tunnel_list） |
 ### 📖 详细文档
@@ -698,6 +700,8 @@ pytest --cov=ssh_mcp --cov-report=term-missing
 | 版本 | 日期 | 主要变更 |
 |------|------|----------|
+| v1.3.3 | 2026-06-19 | 🛠️ 后台任务可靠性修复：单次 SSH 调用 + nohup bash -c 包装消除竞态；新增 screen/tmux 会话支持（session_type 参数）；channel 引用保持防止进程被 GC 回收；docker build 不再被误判为后台任务；新增 ssh_session/ssh_process 工具 |
+| v1.3.2 | 2026-06-19 | 🔧 修复 MCP_GITHUB_TOKEN 配置，Auto Release 工作流修复 |
 | v1.2.1 | 2026-06-03 | 📝 README 文档更新，同步到 PyPI |
 | v1.1.0 | 2026-06-01 | 🔥 精简重构！MCP 工具从 15 个合并为 7 个（ssh_connect/ssh_execute/ssh_disconnect/ssh_file_transfer/ssh_host/ssh_docker/ssh_generate_key），自动连接、智能后台检测、长任务等待 |
 | v1.0.0 | 2026-05-31 | 🎉 首个主要版本！CLI 增强（exec/upload/download/docker-build/list-hosts）、完整测试套件（402 用例）、看门狗监控、审计日志、连接池、批量执行 |
@@ -753,4 +757,4 @@ MIT License - 详见 [LICENSE](LICENSE)
 **Made with ❤️ by Echoqili**
-*Last updated: 2026-06-01*
+*Last updated: 2026-06-19*

{ssh_licco-1.3.2 → ssh_licco-1.3.3}/pyproject.toml RENAMED Viewed

@@ -1,6 +1,6 @@
 [project]
 name = "ssh-licco"
-version = "1.3.2"
+version = "1.3.3"
 description = "SSH Model Context Protocol Server - Enable SSH functionality for AI models"
 readme = "README.md"
 requires-python = ">=3.10"

{ssh_licco-1.3.2 → ssh_licco-1.3.3/ssh_licco.egg-info}/PKG-INFO RENAMED Viewed

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ssh-licco
-Version: 1.3.2
+Version: 1.3.3
 Summary: SSH Model Context Protocol Server - Enable SSH functionality for AI models
 Author-email: SSH LICCO Team <contact@ssh-licco.dev>
 License: MIT
@@ -53,7 +53,6 @@ Dynamic: license-file
 ### 核心功能
 - **[🔐 安全配置](#-安全配置)** - 多级安全策略
-- **[🐍 Anaconda 指南](ANACONDA_GUIDE.md)** - conda 环境兼容
 - **[🛠️ 可用工具](#-可用工具)** - 完整功能列表
 - **[💡 使用示例](#-使用示例)** - 实际应用场景
@@ -79,12 +78,15 @@ Dynamic: license-file
 - 🛡️ **完善的异常处理** - 统一的错误处理机制（7 层异常层次）
 - 📊 **会话管理** - 支持多个并发 SSH 会话（最大 10 个，每主机 3 个）
 - 📁 **SFTP 文件传输** - 上传、下载、目录管理
+- 🖊️ **远程文件编辑** - 直接写入/追加文件内容，无需下载再上传
 - 🔑 **密钥管理** - 生成和管理 SSH 密钥对（RSA/Ed25519）
 - 📝 **审计日志** - 完整的操作审计记录（JSON 结构化日志）
 - 🚀 **连接池** - 高性能连接复用（PooledConnection + ConnectionPool）
 - 📊 **批量执行** - 多主机并行命令执行（BatchExecutor + AsyncBatchExecutor）
 - 🐳 **Docker 支持** - Docker 构建和状态监控
-- 📋 **后台任务** - 异步任务执行和状态跟踪
+- 📋 **后台任务** - 可靠的后台进程启动（nohup + bash -c 包装，单次 SSH 调用无竞态）
+- 🖥️ **screen/tmux 会话** - 持久化远程会话，SSH 断开后进程依然存活
+- 🔍 **进程管理** - 启动/停止/查询远程进程、SSH 端口转发（tunnel）
 - 🖥️ **CLI 命令行** - exec / upload / download / list-hosts 子命令
 - 🔍 **看门狗** - 任务监控、心跳检测、全局异常处理
@@ -106,8 +108,6 @@ npx ssh-licco
 pip install ssh-licco
 ```
-> ⚠️ **Anaconda 用户注意**：如果使用 conda 环境，推荐用 `npx` 方式安装（完全隔离），或创建专用 conda 环境安装。直接在 base 环境 `pip install` 可能导致依赖冲突。详见 [Anaconda 环境指南](ANACONDA_GUIDE.md)。
 ### 方式三：从源码安装
 ```bash
@@ -277,17 +277,19 @@ npx ssh-licco
 ---
-## 🛠️ 可用工具（v1.1.0 精简至 7 个）
+## 🛠️ 可用工具（v1.3.0 扩充至 11 个）
 | 工具 | 描述 | 核心能力 |
 |------|------|---------|
 | `ssh_connect` | 连接管理 | 自动读取环境变量/配置，支持密码+密钥认证，可保存配置，登录后自动执行命令 |
-| `ssh_execute` | 命令执行 | 自动连接、智能后台检测、长任务等待、超时控制 |
+| `ssh_execute` | 命令执行 | 自动连接、智能后台检测、长任务等待、超时控制，支持 nohup/screen/tmux 三种后台模式 |
 | `ssh_disconnect` | 会话管理 | 断开指定会话 OR 列出所有活跃会话 |
-| `ssh_file_transfer` | 文件传输 | 上传 / 下载 / 列目录 |
+| `ssh_file_transfer` | 文件传输 | 上传/下载/列表/写入/追加/删除/创建目录/查看元信息（8 种操作） |
 | `ssh_host` | 主机管理 | `action=list/add/remove` 增删查主机配置 |
 | `ssh_docker` | Docker 管理 | `action=ps/images/build/logs` 全生命周期管理 |
 | `ssh_generate_key` | 密钥生成 | RSA / Ed25519 密钥对 |
+| `ssh_session` | screen/tmux 会话 | 持久化远程会话管理（create/send/capture/list/kill），SSH 断开后进程依然存活 |
+| `ssh_process` | 进程管理 | 启动/停止/查询远程进程，SSH 端口转发（tunnel_open/tunnel_close/tunnel_list） |
 ### 📖 详细文档
@@ -731,6 +733,8 @@ pytest --cov=ssh_mcp --cov-report=term-missing
 | 版本 | 日期 | 主要变更 |
 |------|------|----------|
+| v1.3.3 | 2026-06-19 | 🛠️ 后台任务可靠性修复：单次 SSH 调用 + nohup bash -c 包装消除竞态；新增 screen/tmux 会话支持（session_type 参数）；channel 引用保持防止进程被 GC 回收；docker build 不再被误判为后台任务；新增 ssh_session/ssh_process 工具 |
+| v1.3.2 | 2026-06-19 | 🔧 修复 MCP_GITHUB_TOKEN 配置，Auto Release 工作流修复 |
 | v1.2.1 | 2026-06-03 | 📝 README 文档更新，同步到 PyPI |
 | v1.1.0 | 2026-06-01 | 🔥 精简重构！MCP 工具从 15 个合并为 7 个（ssh_connect/ssh_execute/ssh_disconnect/ssh_file_transfer/ssh_host/ssh_docker/ssh_generate_key），自动连接、智能后台检测、长任务等待 |
 | v1.0.0 | 2026-05-31 | 🎉 首个主要版本！CLI 增强（exec/upload/download/docker-build/list-hosts）、完整测试套件（402 用例）、看门狗监控、审计日志、连接池、批量执行 |
@@ -786,4 +790,4 @@ MIT License - 详见 [LICENSE](LICENSE)
 **Made with ❤️ by Echoqili**
-*Last updated: 2026-06-01*
+*Last updated: 2026-06-19*

{ssh_licco-1.3.2 → ssh_licco-1.3.3}/ssh_mcp/__init__.py RENAMED Viewed

@@ -1,8 +1,8 @@
 # SSH-LICCO 版本信息
 # 所有代码中的版本信息都从这里读取
-# 版本号：1.3.2
+# 版本号：1.3.3
-__version__ = "1.3.2"
+__version__ = "1.3.3"
 __author__ = "Li Qi"
 __email__ = "1985694657@qq.com"
 __license__ = "MIT"

{ssh_licco-1.3.2 → ssh_licco-1.3.3}/ssh_mcp/server.py RENAMED Viewed

@@ -3,6 +3,7 @@ from __future__ import annotations
 import asyncio
 import logging
 import os
+import shlex
 import threading
 import uuid
 from importlib.metadata import version as get_version
@@ -217,7 +218,7 @@ class SSHMCPServer:
                 ),
                 Tool(
                     name="ssh_execute",
-                    description="Execute a command on a remote server. If session_id is omitted, auto-connects using environment variables. Supports background execution for long-running tasks (auto-detected or manual). Use background=True for web servers, Docker builds, compilations, etc.",
+                    description="Execute a command on a remote server. If session_id is omitted, auto-connects using environment variables. Supports background execution for long-running tasks (auto-detected or manual). Use session_type='screen' or 'tmux' for persistent sessions that survive SSH disconnect.",
                     inputSchema={
                         "type": "object",
                         "properties": {
@@ -228,7 +229,8 @@ class SSHMCPServer:
                             "workdir": {"type": "string", "description": "Working directory for background tasks.", "default": "/tmp"},
                             "log_file": {"type": "string", "description": "Log file path for background task output.", "default": "/tmp/background_task.log"},
                             "wait": {"type": "boolean", "description": "Wait for background task to complete.", "default": False},
-                            "wait_timeout": {"type": "integer", "description": "Max wait time in seconds when wait=True.", "default": 60}
+                            "wait_timeout": {"type": "integer", "description": "Max wait time in seconds when wait=True.", "default": 60},
+                            "session_type": {"type": "string", "enum": ["nohup", "screen", "tmux"], "default": "nohup", "description": "Background session type: nohup (default), screen, or tmux (persistent)."}
                         },
                         "required": ["command"]
                     }
@@ -571,26 +573,29 @@ Current security level: {os.getenv('SSH_SECURITY_LEVEL', 'balanced')}"""
         return [TextContent(type="text", text=output)]
     async def _execute_background(self, session_id: str, command: str, args: dict, timeout: int) -> list[TextContent]:
-        """Execute a command as a background task"""
+        """Execute a command as a background task with proper nohup + bash -c wrapping"""
         from .security import SecurityError, command_validator, path_validator
         workdir = args.get("workdir", "/tmp")
         log_file = args.get("log_file", "/tmp/background_task.log")
         wait = args.get("wait", False)
         wait_timeout = args.get("wait_timeout", 60)
+        session_type = args.get("session_type", "nohup")  # "nohup" | "screen" | "tmux"
+        # Validate the base command
         try:
             command_validator.validate_command(command.split()[0] if command.split() else "")
         except SecurityError as e:
             return [TextContent(type="text", text=f"Security error: {str(e)}")]
-        # workdir/log_file 是远程路径,不能用本地 path_validator(会把 /tmp 解析成 D:\tmp)
+        # workdir/log_file are remote paths, don't use local path_validator
         try:
             safe_workdir = self._sanitize_remote_path(workdir)
             safe_log_file = self._sanitize_remote_path(log_file)
         except SecurityError as e:
             return [TextContent(type="text", text=f"Path not allowed: {str(e)}")]
+        # Block dangerous patterns
         dangerous_patterns = ['rm -rf /', 'mkfs', 'dd if=/dev/zero', ':(){:|:&};:', 'chmod -R 777 /']
         for pattern in dangerous_patterns:
             if pattern in command:
@@ -599,78 +604,79 @@ Current security level: {os.getenv('SSH_SECURITY_LEVEL', 'balanced')}"""
         task_id = str(uuid.uuid4())[:8]
         pid_file = f"/tmp/task_{task_id}.pid"
-        # setsid: 新建会话,脱离 SSH 控制终端; nohup: 忽略 SIGHUP;
-        # < /dev/null: 不占用 channel stdin(否则 channel 无法干净关闭);
-        # &: 后台; disown: 移出 shell job 表
-        # 注意: 必须用 background=True 执行,否则 paramiko 的 chan.makefile().read()
-        # 会因后台进程 & 持有 stdout 而永远等待 EOF,导致 channel 挂起。
-        background_command = (
-            f"cd {safe_workdir} && "
-            f"setsid nohup {command} > {safe_log_file} 2>&1 < /dev/null & "
-            f"echo $! > {pid_file}; disown 2>/dev/null || true"
+        # ── screen / tmux session support ──
+        if session_type in ("screen", "tmux"):
+            return await self._execute_background_session(
+                session_id, command, safe_workdir, safe_log_file,
+                session_type, task_id, wait, wait_timeout
+            )
+        # ── nohup mode (default): single SSH call, no race condition ──
+        # Use shlex.quote() to safely escape the command and paths for bash -c.
+        # The wrapper: cd → nohup bash -c '...' → capture PID → sleep → check alive.
+        check_cmd = (
+            f"cd {shlex.quote(safe_workdir)} && "
+            f"nohup bash -c {shlex.quote(command)} "
+            f"> {shlex.quote(safe_log_file)} 2>&1 < /dev/null & "
+            f"PID=$! && "
+            f"echo $PID > {shlex.quote(pid_file)} && "
+            f"sleep 1 && "
+            f"if ps -p $PID > /dev/null 2>&1; then "
+            f"echo 'PID='$PID' STATUS=RUNNING'; "
+            f"else "
+            f"echo 'PID='$PID' STATUS=DEAD'; "
+            f"echo '--- LOG ---'; "
+            f"cat {shlex.quote(safe_log_file)} 2>/dev/null || echo '(no output)'; "
+            f"fi"
         )
         try:
-            # Step 1: 用 background=True 启动包装命令(立即返回,不挂起)
-            await self.session_manager.execute_command(
-                session_id, background_command, timeout=10, background=True
+            # Execute as a single command (background=False) — the wrapper
+            # includes sleep + status check, so it returns in ~1 second.
+            result = await self.session_manager.execute_command(
+                session_id, check_cmd, timeout=timeout + 5, background=False
             )
+        except Exception as e:
+            return [TextContent(type="text", text=f"Error starting background task: {str(e)}")]
-            # Step 2: 等待 PID 文件写入
-            await asyncio.sleep(0.5)
-            # Step 3: 单独读取 PID 文件并检查进程是否存活
-            # 如果进程已死(命令拼写错误、权限不足等),读取日志显示启动错误
-            read_cmd = (
-                f"PID=$(cat {pid_file} 2>/dev/null); "
-                f"echo \"PID=$PID\"; "
-                f"if [ -n \"$PID\" ] && ps -p $PID > /dev/null 2>&1; then "
-                f"echo 'STATUS=RUNNING'; "
-                f"else "
-                f"echo 'STATUS=DEAD'; "
-                f"echo '--- LOG ---'; "
-                f"cat {safe_log_file} 2>&1 | tail -20; "
-                f"fi"
-            )
-            start_result = await self.session_manager.execute_command(
-                session_id, read_cmd, timeout=10
+        start_stdout = (result.get("stdout") or "").strip()
+        start_stderr = (result.get("stderr") or "").strip()
+        # Parse output: PID=xxx STATUS=RUNNING|DEAD
+        pid = ""
+        status = ""
+        log_tail = ""
+        in_log = False
+        for line in start_stdout.splitlines():
+            if line.startswith("PID="):
+                parts = line.split(None, 1)
+                pid = parts[0].split("=", 1)[1].strip() if len(parts) >= 1 else ""
+                if len(parts) >= 2 and parts[1].startswith("STATUS="):
+                    status = parts[1].split("=", 1)[1].strip()
+            elif line == "--- LOG ---":
+                in_log = True
+            elif in_log:
+                log_tail += line + "\n"
+        # Startup failed
+        if status == "DEAD" or not pid:
+            return [TextContent(type="text", text=(
+                f"Background task failed to start!\n\n"
+                f"Command: {command}\n"
+                f"PID: {pid or '(none)'}\n"
+                f"Workdir: {safe_workdir}\n"
+                f"--- STDOUT ---\n{start_stdout}\n"
+                f"--- STDERR ---\n{start_stderr}\n"
+                f"--- LOG TAIL ---\n{log_tail or '(no log output)'}"
+            ))]
+        if wait:
+            output = await self._wait_for_task_completion(
+                session_id=session_id, task_id=task_id,
+                log_file=safe_log_file, timeout=wait_timeout
             )
-            start_stdout = (start_result.get("stdout") or "").strip()
-            start_stderr = (start_result.get("stderr") or "").strip()
-            # 解析远程进程真实 PID 和状态
-            pid = ""
-            status = ""
-            log_tail = ""
-            in_log = False
-            for line in start_stdout.splitlines():
-                if line.startswith("PID="):
-                    pid = line.split("=", 1)[1].strip()
-                elif line.startswith("STATUS="):
-                    status = line.split("=", 1)[1].strip()
-                elif line == "--- LOG ---":
-                    in_log = True
-                elif in_log:
-                    log_tail += line + "\n"
-            # 启动失败:进程已死或没拿到 PID
-            if status == "DEAD" or not pid:
-                return [TextContent(type="text", text=(
-                    f"Background task failed to start!\n\n"
-                    f"Command: {command}\n"
-                    f"PID: {pid or '(none)'}\n"
-                    f"--- STDOUT ---\n{start_stdout}\n"
-                    f"--- STDERR ---\n{start_stderr}\n"
-                    f"--- LOG TAIL ---\n{log_tail}"
-                ))]
-            if wait:
-                output = await self._wait_for_task_completion(
-                    session_id=session_id, task_id=task_id,
-                    log_file=safe_log_file, timeout=wait_timeout
-                )
-            else:
-                output = f"""Background Task Started!
+        else:
+            output = f"""Background Task Started!
 Task ID: {task_id}
 PID: {pid}
@@ -687,9 +693,70 @@ To check if still running:
   ssh_execute(session_id="{session_id}", command="ps -p {pid}")
 """
-            return [TextContent(type="text", text=output)]
+        return [TextContent(type="text", text=output)]
+    async def _execute_background_session(
+        self, session_id: str, command: str, workdir: str,
+        log_file: str, session_type: str, task_id: str,
+        wait: bool, wait_timeout: int
+    ) -> list[TextContent]:
+        """Execute a command inside a screen/tmux session for persistent long-running tasks"""
+        session_name = f"ssh_mcp_{task_id}"
+        escaped_cmd = command.replace("'", "'\\''")
+        if session_type == "screen":
+            # screen -dmS <name> bash -c 'cd <dir> && <cmd> > <log> 2>&1'
+            launch_cmd = (
+                f"screen -dmS {shlex.quote(session_name)} bash -c "
+                f"'cd {shlex.quote(workdir)} && {escaped_cmd} > {shlex.quote(log_file)} 2>&1'"
+            )
+        else:  # tmux
+            launch_cmd = (
+                f"tmux new-session -d -s {shlex.quote(session_name)} "
+                f"'cd {shlex.quote(workdir)} && {escaped_cmd} > {shlex.quote(log_file)} 2>&1'"
+            )
+        try:
+            result = await self.session_manager.execute_command(
+                session_id, launch_cmd, timeout=10, background=False
+            )
         except Exception as e:
-            return [TextContent(type="text", text=f"Error starting background task: {str(e)}")]
+            return [TextContent(type="text", text=f"Error starting {session_type} session: {str(e)}")]
+        stderr = (result.get("stderr") or "").strip()
+        if stderr:
+            return [TextContent(type="text", text=(
+                f"Failed to start {session_type} session!\n\n"
+                f"Session: {session_name}\n"
+                f"Command: {command}\n"
+                f"Error: {stderr}"
+            ))]
+        if wait:
+            output = await self._wait_for_task_completion(
+                session_id=session_id, task_id=task_id,
+                log_file=log_file, timeout=wait_timeout
+            )
+        else:
+            attach_cmd = f"screen -r {session_name}" if session_type == "screen" else f"tmux attach -t {session_name}"
+            output = f"""{session_type.upper()} Session Started!
+Task ID: {task_id}
+Session Name: {session_name}
+Command: {command}
+Working Directory: {workdir}
+Log File: {log_file}
+---
+To attach to session:
+  ssh_execute(session_id="{session_id}", command="{attach_cmd}")
+To view log:
+  ssh_execute(session_id="{session_id}", command="cat {log_file}")
+To kill session:
+  ssh_execute(session_id="{session_id}", command="{'screen -XS ' + session_name + ' quit' if session_type == 'screen' else 'tmux kill-session -t ' + session_name}")
+"""
+        return [TextContent(type="text", text=output)]
     async def _wait_for_task_completion(self, session_id: str, task_id: str, log_file: str, timeout: int) -> str:
         pid_file = f"/tmp/task_{task_id}.pid"
@@ -742,6 +809,8 @@ Use ssh_execute to check: cat {log_file}
             'docker pull', 'docker push', 'docker save', 'docker load',
             'docker network ls', 'docker volume ls', 'docker system',
             'docker exec', 'docker attach', 'docker cp',
+            'docker build', 'docker buildx', 'docker compose build',
+            'docker-compose build', 'docker tag', 'docker login', 'docker logout',
         ]
         for cmd in docker_instant_commands:
             if cmd in command_lower:

{ssh_licco-1.3.2 → ssh_licco-1.3.3}/ssh_mcp/session_manager.py RENAMED Viewed

@@ -54,6 +54,7 @@ class SSHSession:
         self._executor = get_executor()
         self._connect_lock = asyncio.Lock()
         self._shutdown_event = asyncio.Event()
+        self._background_channels: list = []  # 保持 background channel 引用，防止 GC 关闭 channel
     @property
     def state(self) -> SessionState:
@@ -176,6 +177,14 @@ class SSHSession:
         stdin, stdout, stderr = self.client.exec_command(command, timeout=timeout)
         if background:
+            # Keep channel references alive to prevent GC from closing the
+            # channel while the background process is still starting up.
+            # The channel will be cleaned up when the session disconnects.
+            self._background_channels.append((stdin, stdout, stderr))
+            # Limit stored channels to prevent memory leak
+            if len(self._background_channels) > 10:
+                self._background_channels = self._background_channels[-5:]
             try:
                 pid = stdout.channel.pid  # type: ignore[attr-defined]
                 pid_msg = f"PID: {pid}"
@@ -491,6 +500,13 @@ class SSHSession:
             if self._keepalive_task:
                 self._keepalive_task.cancel()
                 self._keepalive_task = None
+            # Close any lingering background channels
+            for stdin, stdout, stderr in self._background_channels:
+                try:
+                    stdout.channel.close()
+                except Exception:
+                    pass
+            self._background_channels.clear()
             if self.client:
                 await self._executor.submit(self.client.close)
                 self.client = None