ssh-licco 2.2.1__tar.gz → 2.3.0__tar.gz

{ssh_licco-2.2.1/ssh_licco.egg-info → ssh_licco-2.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ssh-licco
-Version: 2.2.1
+Version: 2.3.0
 Summary: SSH Model Context Protocol Server - Enable SSH functionality for AI models
 Author-email: SSH LICCO Team <contact@ssh-licco.dev>
 License: MIT
@@ -267,7 +267,7 @@ SSH 跳板模式部署的生产必做加固，补齐跳板机单点风险：
 | 3. 双层命令拦截 | `SSH_REMOTE_GUARD=true` + 远端 ForceCommand | 跳板机侧禁元字符 + 远端二次白名单校验 |
 | 4. 灾难性命令硬拦截（v2.2.0 新增） | 默认开启，不可关闭 | rm -rf 绝对路径、mkfs、raw-disk dd、fork-bomb、chmod -R 777/000 /、`> /dev/sd*` 等在 MCP 网关层被**无条件**拒绝；任何安全级别、`confirm_dangerous=true` 等均无法绕过 |
 
-> **关于 v2.1.0 引入的"高危操作审批"项**：v2.1.0 曾提供 `SSH_APPROVAL_GATE=true` + 3 个审批工具作为第 4 项加固。v2.2.0 起该项被**硬拦截取代**——审批流程依赖 AI 自报命令，存在闭环风险；硬拦截更直接，灾难性命令在 MCP 网关层就被拒绝，运维侧不需要再走"先申请再审批"流程。`SSH_APPROVAL_GATE` 环境变量与 `ssh_mcp/approval.py` 代码仍保留作为参考，但不建议在生产启用。
+> **关于 v2.1.0 引入的"高危操作审批"项**：v2.1.0 曾提供 `SSH_APPROVAL_GATE=true` + 3 个审批工具作为第 4 项加固。v2.2.0 起该项被**硬拦截取代**——审批流程依赖 AI 自报命令，存在闭环风险；硬拦截更直接，灾难性命令在 MCP 网关层就被拒绝，运维侧不需要再走"先申请再审批"流程。`SSH_APPROVAL_GATE` 环境变量与 `ssh_mcp/approval.py` / `ssh_mcp/handlers/approval.py` 代码已在 v2.2.0 删除。
 
 完整方案见 [docs/SECURITY_HARDENING.md](docs/SECURITY_HARDENING.md)。
 
@@ -287,7 +287,7 @@ SSH 跳板模式部署的生产必做加固，补齐跳板机单点风险：
 | `ssh_session` | screen/tmux 会话 | 持久化远程会话管理（create/send/capture/list/kill），SSH 断开后进程依然存活 |
 | `ssh_process` | 进程管理 | 启动/停止/查询远程进程，SSH 端口转发（tunnel_open/tunnel_close/tunnel_list） |
 
-> **关于 v2.1.0 引入的 3 个审批工具**（`ssh_request_approval` / `ssh_approve_command` / `ssh_list_approvals`）：已从 MCP `list_tools()` 移除。审批流程依赖 AI 自报命令、运维侧背书，存在闭环风险；v2.2.0 的硬拦截更直接——灾难性命令在 MCP 网关层就被拒绝，运维侧不需要再走"先申请再审批"流程。相关代码（`ssh_mcp/approval.py`、`ssh_mcp/handlers/approval.py`）保留作为参考，但不暴露给 MCP。
+> **关于 v2.1.0 引入的 3 个审批工具**（`ssh_request_approval` / `ssh_approve_command` / `ssh_list_approvals`）：已从 MCP `list_tools()` 移除，**代码已在 v2.2.0 删除**（`ssh_mcp/approval.py`、`ssh_mcp/handlers/approval.py`）。审批流程依赖 AI 自报命令、运维侧背书，存在闭环风险；v2.2.0 的硬拦截更直接——灾难性命令在 MCP 网关层就被拒绝，运维侧不需要再走"先申请再审批"流程。
 
 ### 📖 详细文档
 

{ssh_licco-2.2.1 → ssh_licco-2.3.0}/README.md

@@ -234,7 +234,7 @@ SSH 跳板模式部署的生产必做加固，补齐跳板机单点风险：
 | 3. 双层命令拦截 | `SSH_REMOTE_GUARD=true` + 远端 ForceCommand | 跳板机侧禁元字符 + 远端二次白名单校验 |
 | 4. 灾难性命令硬拦截（v2.2.0 新增） | 默认开启，不可关闭 | rm -rf 绝对路径、mkfs、raw-disk dd、fork-bomb、chmod -R 777/000 /、`> /dev/sd*` 等在 MCP 网关层被**无条件**拒绝；任何安全级别、`confirm_dangerous=true` 等均无法绕过 |
 
-> **关于 v2.1.0 引入的"高危操作审批"项**：v2.1.0 曾提供 `SSH_APPROVAL_GATE=true` + 3 个审批工具作为第 4 项加固。v2.2.0 起该项被**硬拦截取代**——审批流程依赖 AI 自报命令，存在闭环风险；硬拦截更直接，灾难性命令在 MCP 网关层就被拒绝，运维侧不需要再走"先申请再审批"流程。`SSH_APPROVAL_GATE` 环境变量与 `ssh_mcp/approval.py` 代码仍保留作为参考，但不建议在生产启用。
+> **关于 v2.1.0 引入的"高危操作审批"项**：v2.1.0 曾提供 `SSH_APPROVAL_GATE=true` + 3 个审批工具作为第 4 项加固。v2.2.0 起该项被**硬拦截取代**——审批流程依赖 AI 自报命令，存在闭环风险；硬拦截更直接，灾难性命令在 MCP 网关层就被拒绝，运维侧不需要再走"先申请再审批"流程。`SSH_APPROVAL_GATE` 环境变量与 `ssh_mcp/approval.py` / `ssh_mcp/handlers/approval.py` 代码已在 v2.2.0 删除。
 
 完整方案见 [docs/SECURITY_HARDENING.md](docs/SECURITY_HARDENING.md)。
 
@@ -254,7 +254,7 @@ SSH 跳板模式部署的生产必做加固，补齐跳板机单点风险：
 | `ssh_session` | screen/tmux 会话 | 持久化远程会话管理（create/send/capture/list/kill），SSH 断开后进程依然存活 |
 | `ssh_process` | 进程管理 | 启动/停止/查询远程进程，SSH 端口转发（tunnel_open/tunnel_close/tunnel_list） |
 
-> **关于 v2.1.0 引入的 3 个审批工具**（`ssh_request_approval` / `ssh_approve_command` / `ssh_list_approvals`）：已从 MCP `list_tools()` 移除。审批流程依赖 AI 自报命令、运维侧背书，存在闭环风险；v2.2.0 的硬拦截更直接——灾难性命令在 MCP 网关层就被拒绝，运维侧不需要再走"先申请再审批"流程。相关代码（`ssh_mcp/approval.py`、`ssh_mcp/handlers/approval.py`）保留作为参考，但不暴露给 MCP。
+> **关于 v2.1.0 引入的 3 个审批工具**（`ssh_request_approval` / `ssh_approve_command` / `ssh_list_approvals`）：已从 MCP `list_tools()` 移除，**代码已在 v2.2.0 删除**（`ssh_mcp/approval.py`、`ssh_mcp/handlers/approval.py`）。审批流程依赖 AI 自报命令、运维侧背书，存在闭环风险；v2.2.0 的硬拦截更直接——灾难性命令在 MCP 网关层就被拒绝，运维侧不需要再走"先申请再审批"流程。
 
 ### 📖 详细文档
 

{ssh_licco-2.2.1 → ssh_licco-2.3.0}/pyproject.toml

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

{ssh_licco-2.2.1 → ssh_licco-2.3.0/ssh_licco.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ssh-licco
-Version: 2.2.1
+Version: 2.3.0
 Summary: SSH Model Context Protocol Server - Enable SSH functionality for AI models
 Author-email: SSH LICCO Team <contact@ssh-licco.dev>
 License: MIT
@@ -267,7 +267,7 @@ SSH 跳板模式部署的生产必做加固，补齐跳板机单点风险：
 | 3. 双层命令拦截 | `SSH_REMOTE_GUARD=true` + 远端 ForceCommand | 跳板机侧禁元字符 + 远端二次白名单校验 |
 | 4. 灾难性命令硬拦截（v2.2.0 新增） | 默认开启，不可关闭 | rm -rf 绝对路径、mkfs、raw-disk dd、fork-bomb、chmod -R 777/000 /、`> /dev/sd*` 等在 MCP 网关层被**无条件**拒绝；任何安全级别、`confirm_dangerous=true` 等均无法绕过 |
 
-> **关于 v2.1.0 引入的"高危操作审批"项**：v2.1.0 曾提供 `SSH_APPROVAL_GATE=true` + 3 个审批工具作为第 4 项加固。v2.2.0 起该项被**硬拦截取代**——审批流程依赖 AI 自报命令，存在闭环风险；硬拦截更直接，灾难性命令在 MCP 网关层就被拒绝，运维侧不需要再走"先申请再审批"流程。`SSH_APPROVAL_GATE` 环境变量与 `ssh_mcp/approval.py` 代码仍保留作为参考，但不建议在生产启用。
+> **关于 v2.1.0 引入的"高危操作审批"项**：v2.1.0 曾提供 `SSH_APPROVAL_GATE=true` + 3 个审批工具作为第 4 项加固。v2.2.0 起该项被**硬拦截取代**——审批流程依赖 AI 自报命令，存在闭环风险；硬拦截更直接，灾难性命令在 MCP 网关层就被拒绝，运维侧不需要再走"先申请再审批"流程。`SSH_APPROVAL_GATE` 环境变量与 `ssh_mcp/approval.py` / `ssh_mcp/handlers/approval.py` 代码已在 v2.2.0 删除。
 
 完整方案见 [docs/SECURITY_HARDENING.md](docs/SECURITY_HARDENING.md)。
 
@@ -287,7 +287,7 @@ SSH 跳板模式部署的生产必做加固，补齐跳板机单点风险：
 | `ssh_session` | screen/tmux 会话 | 持久化远程会话管理（create/send/capture/list/kill），SSH 断开后进程依然存活 |
 | `ssh_process` | 进程管理 | 启动/停止/查询远程进程，SSH 端口转发（tunnel_open/tunnel_close/tunnel_list） |
 
-> **关于 v2.1.0 引入的 3 个审批工具**（`ssh_request_approval` / `ssh_approve_command` / `ssh_list_approvals`）：已从 MCP `list_tools()` 移除。审批流程依赖 AI 自报命令、运维侧背书，存在闭环风险；v2.2.0 的硬拦截更直接——灾难性命令在 MCP 网关层就被拒绝，运维侧不需要再走"先申请再审批"流程。相关代码（`ssh_mcp/approval.py`、`ssh_mcp/handlers/approval.py`）保留作为参考，但不暴露给 MCP。
+> **关于 v2.1.0 引入的 3 个审批工具**（`ssh_request_approval` / `ssh_approve_command` / `ssh_list_approvals`）：已从 MCP `list_tools()` 移除，**代码已在 v2.2.0 删除**（`ssh_mcp/approval.py`、`ssh_mcp/handlers/approval.py`）。审批流程依赖 AI 自报命令、运维侧背书，存在闭环风险；v2.2.0 的硬拦截更直接——灾难性命令在 MCP 网关层就被拒绝，运维侧不需要再走"先申请再审批"流程。
 
 ### 📖 详细文档
 

{ssh_licco-2.2.1 → ssh_licco-2.3.0}/ssh_licco.egg-info/SOURCES.txt

@@ -9,7 +9,6 @@ ssh_licco.egg-info/requires.txt
 ssh_licco.egg-info/top_level.txt
 ssh_mcp/__init__.py
 ssh_mcp/__main__.py
-ssh_mcp/approval.py
 ssh_mcp/audit_logger.py
 ssh_mcp/batch_executor.py
 ssh_mcp/cli.py
@@ -34,7 +33,6 @@ ssh_mcp/clients/factory.py
 ssh_mcp/clients/interface.py
 ssh_mcp/clients/paramiko_client.py
 ssh_mcp/handlers/__init__.py
-ssh_mcp/handlers/approval.py
 ssh_mcp/handlers/connect.py
 ssh_mcp/handlers/context.py
 ssh_mcp/handlers/docker.py

{ssh_licco-2.2.1 → ssh_licco-2.3.0}/ssh_mcp/__init__.py

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

{ssh_licco-2.2.1 → ssh_licco-2.3.0}/ssh_mcp/handlers/__init__.py

@@ -7,7 +7,6 @@ from collections.abc import Awaitable, Callable
 from mcp.types import TextContent
 
 from . import schemas
-from .approval import handle_approve_command, handle_list_approvals, handle_request_approval
 from .connect import handle_connect, handle_disconnect
 from .context import HandlerContext
 from .docker import handle_docker
@@ -30,9 +29,6 @@ HANDLERS: dict[str, Handler] = {
     "ssh_generate_key": handle_generate_key,
     "ssh_session": handle_session,
     "ssh_process": handle_process,
-    "ssh_request_approval": handle_request_approval,
-    "ssh_approve_command": handle_approve_command,
-    "ssh_list_approvals": handle_list_approvals,
 }
 
 __all__ = ["HANDLERS", "schemas"]

{ssh_licco-2.2.1 → ssh_licco-2.3.0}/ssh_mcp/handlers/execute.py

@@ -13,7 +13,6 @@ from ..security import SecurityError, command_validator
 from .connect import handle_connect
 from .context import HandlerContext
 from .utils import (
-    check_approval_gate,
     diagnose_exit_code,
     diagnose_startup_failure,
     ensure_session,
@@ -55,14 +54,6 @@ async def handle_execute(ctx: HandlerContext, args: dict) -> list[TextContent]:
             ]
         command = normalized
 
-    # 加固点 4：高危操作审批门禁
-    # 当 SSH_APPROVAL_GATE=true 且命令被判定为高危时，必须携带有效 approval_id 才能执行。
-    approval_id = args.get("approval_id")
-    approval_err = check_approval_gate(command, approval_id)
-    if approval_err:
-        ctx.logger.warning(f"Command blocked by approval gate: {command}")
-        return [TextContent(type="text", text=approval_err)]
-
     # Resolve session via session_id / name / host / env fallback
     session_id = await ensure_session(ctx, args, handle_connect)
     if not session_id:

{ssh_licco-2.2.1 → ssh_licco-2.3.0}/ssh_mcp/handlers/schemas.py

@@ -137,10 +137,6 @@ TOOLS: dict[str, Tool] = {
                     "default": False,
                     "description": "Bypass security validation for known-dangerous commands (e.g. rm -rf /path). Use with caution — only for operations you explicitly intend to perform.",
                 },
-                "approval_id": {
-                    "type": "string",
-                    "description": "加固点 4：高危操作审批 ID。当 SSH_APPROVAL_GATE=true 且命令被判定为高危时，必须先调用 ssh_request_approval 获取 approval_id，再带上此参数执行。否则高危命令会被拒绝。",
-                },
                 "remote_guard": {
                     "type": "boolean",
                     "default": False,
@@ -496,61 +492,4 @@ TOOLS: dict[str, Tool] = {
             "required": ["session_id", "action"],
         },
     ),
-    "ssh_request_approval": Tool(
-        name="ssh_request_approval",
-        description="加固点 4：高危操作审批 — AI 提交审批申请。当 SSH_APPROVAL_GATE=true 时，rm -rf、reboot、iptables 等高危命令必须先调用本工具申请审批，获得 approval_id 后再调用 ssh_execute 携带 approval_id 执行。AI 不能直接下发高危命令。",
-        inputSchema={
-            "type": "object",
-            "properties": {
-                "command": {
-                    "type": "string",
-                    "description": "需要审批的高危命令（必须与后续 ssh_execute 的 command 完全一致，否则校验失败）。",
-                },
-                "reason": {
-                    "type": "string",
-                    "description": "申请理由：为什么需要执行此高危命令、预期影响、回滚方案。",
-                },
-            },
-            "required": ["command", "reason"],
-        },
-    ),
-    "ssh_approve_command": Tool(
-        name="ssh_approve_command",
-        description="加固点 4：高危操作审批 — 运维人员人工审批 AI 提交的申请。返回审批结果。审批通过后 AI 可用获得的 approval_id 执行命令（一次性，用后即焚）。",
-        inputSchema={
-            "type": "object",
-            "properties": {
-                "approval_id": {
-                    "type": "string",
-                    "description": "待审批的 approval_id（由 ssh_request_approval 返回）。",
-                },
-                "decision": {
-                    "type": "string",
-                    "enum": ["approved", "rejected"],
-                    "description": "审批决定：approved=同意执行，rejected=拒绝。",
-                },
-                "reviewer": {
-                    "type": "string",
-                    "description": "审批人标识（运维人员姓名/账号），用于审计。",
-                },
-                "comment": {"type": "string", "description": "审批意见（可选）。"},
-            },
-            "required": ["approval_id", "decision", "reviewer"],
-        },
-    ),
-    "ssh_list_approvals": Tool(
-        name="ssh_list_approvals",
-        description="加固点 4：高危操作审批 — 列出审批记录。运维人员查看待处理队列或历史记录。action=pending 只看待审批，action=all 查看全部（最近 100 条）。",
-        inputSchema={
-            "type": "object",
-            "properties": {
-                "action": {
-                    "type": "string",
-                    "enum": ["pending", "all"],
-                    "default": "pending",
-                    "description": "pending=仅待审批，all=全部记录（最近 100 条）。",
-                }
-            },
-        },
-    ),
 }

{ssh_licco-2.2.1 → ssh_licco-2.3.0}/ssh_mcp/handlers/utils.py

@@ -2,7 +2,6 @@
 
 from __future__ import annotations
 
-import os
 import re
 import shlex
 from collections.abc import Awaitable, Callable
@@ -116,53 +115,6 @@ def normalize_command_for_remote_guard(command: str) -> tuple[str, str | None]:
     return command, None
 
 
-def check_approval_gate(command: str, approval_id: str | None) -> str | None:
-    """加固点 4：高危操作审批门禁。
-
-    当 SSH_APPROVAL_GATE=true 时，高危命令（CRITICAL/HIGH 风险）必须携带有效
-    approval_id（由 ssh_request_approval 工具申请、人工 approve 后获得）才能执行。
-
-    返回 None 表示放行；返回字符串表示拒绝原因（作为 MCP 返回文本）。
-    """
-    if os.getenv("SSH_APPROVAL_GATE", "false").lower() != "true":
-        return None  # 审批门禁未启用
-
-    from ..security import RiskLevel, command_validator
-
-    risk = command_validator.assess_risk_level(command)
-
-    # 仅 CRITICAL / HIGH 风险需要审批；MEDIUM/LOW/SAFE 直接放行
-    if risk not in (RiskLevel.CRITICAL, RiskLevel.HIGH):
-        return None
-
-    if not approval_id:
-        return (
-            f"❌ 高危操作审批门禁拦截\n\n"
-            f"Command: {command}\n"
-            f"Risk: {risk.value}\n\n"
-            f"此命令被判定为「{risk.value}」风险，启用了人工审批门禁（SSH_APPROVAL_GATE=true）。\n"
-            f"AI 不能直接下发此类高危运维命令，必须先申请审批：\n\n"
-            f"  1. 调用 ssh_request_approval 工具，提交 command 与 reason；\n"
-            f"  2. 等待人工审批通过，获得 approval_id；\n"
-            f"  3. 用 ssh_execute 携带 approval_id 重新执行。\n\n"
-            f"高危命令类别：rm -rf、reboot/shutdown、iptables/防火墙修改、mkfs、dd 覆盘等。"
-        )
-
-    # 校验 approval_id 有效性
-    from ..approval import ApprovalGate
-
-    gate = ApprovalGate.instance()
-    ok, reason = gate.verify(approval_id, command)
-    if not ok:
-        return (
-            f"❌ 审批校验失败\n\n"
-            f"approval_id: {approval_id}\n"
-            f"Reason: {reason}\n\n"
-            f"请重新申请审批（ssh_request_approval）或确认 approval_id 是否匹配当前命令。"
-        )
-    return None
-
-
 def diagnose_exit_code(exit_code: int, log_tail: str, stderr: str) -> str:
     """根据退出码和日志输出诊断命令失败原因"""
     combined = (log_tail + " " + stderr).lower()

ssh_licco-2.2.1/ssh_mcp/approval.py

@@ -1,220 +0,0 @@
-"""SSH-LICCO 高危操作审批门禁 — 加固点 4
-
-生产跳板机场景下，AI 不能直接一键下发高危运维命令（rm、重启服务、修改防火墙等）。
-本模块实现审批工作流：
-
-    AI 调用 ssh_execute(高危命令)
-        │
-        │  被审批门禁拦截（_check_approval_gate）
-        ▼
-    AI 调用 ssh_request_approval(command, reason)
-        │  → 生成 approval_id，写入待审批队列（持久化 JSON）
-        │  → 返回 approval_id 与提示「等待人工审批」
-        ▼
-    运维人员人工审批
-        │  调用 ssh_approve_command(approval_id, decision, reviewer)
-        │  → approval 状态变更为 approved / rejected
-        ▼
-    AI 再次调用 ssh_execute(command, approval_id)
-        │  → 审批门禁校验 approval_id 有效且 approved、命令匹配
-        ▼
-    执行命令（一次性，用后即焚）
-
-设计要点：
-  - 审批记录持久化到 JSON 文件（SSH_APPROVAL_STORE，默认 ~/.ssh_licco/approvals.json），
-    进程重启后审批状态不丢失。
-  - approval_id 是 UUID，不可猜测。
-  - 一次性消费：approved 的 approval_id 校验通过后立即标记为 consumed，防止复用。
-  - 命令必须严格匹配（shlex 规范化后比对），防止「申请 rm -rf /tmp/a，执行 rm -rf /」。
-  - 审批有 TTL（默认 1 小时），超时自动失效。
-  - 文件读写加锁，支持并发请求。
-
-启用方式：
-    SSH_APPROVAL_GATE=true                  # 开启审批门禁
-    SSH_APPROVAL_STORE=/path/to/approvals.json  # 审批记录存储路径
-    SSH_APPROVAL_TTL=3600                    # 审批有效期（秒），默认 3600
-"""
-
-from __future__ import annotations
-
-import json
-import os
-import shlex
-import threading
-import time
-import uuid
-from dataclasses import asdict, dataclass
-from pathlib import Path
-
-
-@dataclass
-class ApprovalRecord:
-    approval_id: str
-    command: str  # 原始命令
-    command_norm: str  # shlex 规范化后的命令（用于比对）
-    reason: str  # 申请理由
-    status: str  # pending | approved | rejected | consumed | expired
-    requested_at: float  # 申请时间戳
-    decided_at: float | None = None  # 审批决定时间
-    reviewer: str | None = None  # 审批人
-    consumed_at: float | None = None  # 消费（执行）时间
-    ttl: int = 3600  # 有效期（秒）
-
-
-class ApprovalGate:
-    """审批门禁单例。"""
-
-    _instance: ApprovalGate | None = None
-    _lock = threading.Lock()
-
-    def __init__(self):
-        store_path = os.getenv(
-            "SSH_APPROVAL_STORE",
-            str(Path.home() / ".ssh_licco" / "approvals.json"),
-        )
-        self._store_path = Path(store_path)
-        self._store_path.parent.mkdir(parents=True, exist_ok=True)
-        self._ttl = int(os.getenv("SSH_APPROVAL_TTL", "3600"))
-        self._file_lock = threading.Lock()
-        self._records: dict[str, ApprovalRecord] = {}
-        self._load()
-
-    @classmethod
-    def instance(cls) -> ApprovalGate:
-        with cls._lock:
-            if cls._instance is None:
-                cls._instance = cls()
-            return cls._instance
-
-    # ── 持久化 ──
-    def _load(self) -> None:
-        if not self._store_path.exists():
-            self._records = {}
-            return
-        try:
-            with open(self._store_path, encoding="utf-8") as f:
-                data = json.load(f)
-            self._records = {k: ApprovalRecord(**v) for k, v in data.items()}
-        except Exception:
-            self._records = {}
-
-    def _save(self) -> None:
-        data = {k: asdict(v) for k, v in self._records.items()}
-        tmp = self._store_path.with_suffix(".tmp")
-        with open(tmp, "w", encoding="utf-8") as f:
-            json.dump(data, f, ensure_ascii=False, indent=2)
-        tmp.replace(self._store_path)  # 原子替换
-
-    @staticmethod
-    def _normalize(command: str) -> str:
-        """shlex 规范化命令，用于申请与执行时的命令比对。"""
-        try:
-            parts = shlex.split(command)
-            return " ".join(parts)
-        except ValueError:
-            return command.strip()
-
-    # ── 公开 API ──
-    def request(self, command: str, reason: str = "") -> ApprovalRecord:
-        """AI 提交审批申请。返回 ApprovalRecord（status=pending）。"""
-        with self._file_lock:
-            self._purge_expired_locked()
-            rec = ApprovalRecord(
-                approval_id=uuid.uuid4().hex,
-                command=command,
-                command_norm=self._normalize(command),
-                reason=reason,
-                status="pending",
-                requested_at=time.time(),
-                ttl=self._ttl,
-            )
-            self._records[rec.approval_id] = rec
-            self._save()
-            return rec
-
-    def approve(
-        self, approval_id: str, reviewer: str, decision: str = "approved"
-    ) -> ApprovalRecord:
-        """运维人员审批。decision = approved | rejected。"""
-        with self._file_lock:
-            self._purge_expired_locked()
-            rec = self._records.get(approval_id)
-            if rec is None:
-                raise KeyError(f"approval_id 不存在：{approval_id}")
-            if rec.status == "expired":
-                raise ValueError("审批已过期，请重新申请")
-            if rec.status in ("approved", "rejected", "consumed"):
-                raise ValueError(f"审批已处理（status={rec.status}），不可重复操作")
-            if decision not in ("approved", "rejected"):
-                raise ValueError("decision 必须是 approved 或 rejected")
-            rec.status = decision
-            rec.decided_at = time.time()
-            rec.reviewer = reviewer
-            self._save()
-            return rec
-
-    def verify(self, approval_id: str, command: str) -> tuple[bool, str]:
-        """执行前校验 approval_id。返回 (是否通过, 原因)。"""
-        with self._file_lock:
-            self._purge_expired_locked()
-            rec = self._records.get(approval_id)
-            if rec is None:
-                return False, f"approval_id 不存在：{approval_id}"
-            if rec.status == "expired":
-                return False, "审批已过期，请重新申请"
-            if rec.status == "pending":
-                return False, "审批仍在 pending，尚未被人工审批"
-            if rec.status == "rejected":
-                return False, f"审批已被拒绝（reviewer={rec.reviewer}）"
-            if rec.status == "consumed":
-                return False, "此 approval_id 已被使用过（一次性消费），请重新申请"
-            if rec.status != "approved":
-                return False, f"审批状态异常：{rec.status}"
-
-            # 命令必须严格匹配（规范化后比对）
-            cmd_norm = self._normalize(command)
-            if cmd_norm != rec.command_norm:
-                return False, (
-                    f"命令与审批申请不匹配。\n"
-                    f"  申请命令：{rec.command}\n"
-                    f"  执行命令：{command}\n"
-                    f"拒绝执行，防止「申请 A 命令、执行 B 命令」绕过审批。"
-                )
-
-            # 校验通过，标记为已消费（一次性）
-            rec.status = "consumed"
-            rec.consumed_at = time.time()
-            self._save()
-            return True, f"审批校验通过（reviewer={rec.reviewer}），已消费。"
-
-    def list_pending(self) -> list[ApprovalRecord]:
-        """列出所有 pending 审批（供运维人员查看待处理队列）。"""
-        with self._file_lock:
-            self._purge_expired_locked()
-            return [r for r in self._records.values() if r.status == "pending"]
-
-    def list_all(self, limit: int = 100) -> list[ApprovalRecord]:
-        """列出所有审批记录（最近的在前）。"""
-        with self._file_lock:
-            self._purge_expired_locked()
-            recs = sorted(
-                self._records.values(),
-                key=lambda r: r.requested_at,
-                reverse=True,
-            )
-            return recs[:limit]
-
-    def _purge_expired_locked(self) -> None:
-        """清理过期审批（pending 超过 TTL 标记为 expired）。"""
-        now = time.time()
-        changed = False
-        for rec in self._records.values():
-            if rec.status == "pending" and (now - rec.requested_at) > rec.ttl:
-                rec.status = "expired"
-                changed = True
-            # approved 但未消费的也按 TTL 失效（从 decided_at 起算）
-            if rec.status == "approved" and rec.decided_at and (now - rec.decided_at) > rec.ttl:
-                rec.status = "expired"
-                changed = True
-        if changed:
-            self._save()

ssh_licco-2.2.1/ssh_mcp/handlers/approval.py

@@ -1,131 +0,0 @@
-"""Handlers for approval workflow tools."""
-
-from __future__ import annotations
-
-import time
-
-from mcp.types import TextContent
-
-from .context import HandlerContext
-
-
-def _fmt_ts(ts: float | None) -> str:
-    """Format a Unix timestamp to a human-readable string."""
-    if ts is None:
-        return "N/A"
-    return time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(ts))
-
-
-async def handle_request_approval(ctx: HandlerContext, args: dict) -> list[TextContent]:
-    """加固点 4：AI 提交高危命令审批申请。"""
-    from ..approval import ApprovalGate
-    from ..security import command_validator
-
-    command = args.get("command", "").strip()
-    reason = args.get("reason", "").strip()
-    if not command:
-        return [TextContent(type="text", text="command 不能为空")]
-    if not reason:
-        return [TextContent(type="text", text="reason 不能为空：必须说明为什么需要执行此高危命令")]
-
-    risk = command_validator.assess_risk_level(command)
-    gate = ApprovalGate.instance()
-    rec = gate.request(command, reason)
-
-    return [
-        TextContent(
-            type="text",
-            text=(
-                f"✅ 审批申请已提交\n\n"
-                f"approval_id: {rec.approval_id}\n"
-                f"command: {command}\n"
-                f"risk: {risk.value}\n"
-                f"reason: {reason}\n"
-                f"requested_at: {_fmt_ts(rec.requested_at)}\n"
-                f"TTL: {rec.ttl}s（超时自动失效）\n\n"
-                f"⏳ 等待运维人员审批。\n"
-                "   审批人请调用 ssh_approve_command("
-                f"approval_id='{rec.approval_id}', "
-                "decision='approved'|'rejected', reviewer='...')\n"
-                "   审批通过后，调用 ssh_execute("
-                f"command=..., approval_id='{rec.approval_id}') 执行。\n"
-                "   注意：approval_id 一次性消费，命令必须与此申请完全一致。"
-            ),
-        )
-    ]
-
-
-async def handle_approve_command(ctx: HandlerContext, args: dict) -> list[TextContent]:
-    """加固点 4：运维人员审批 AI 提交的申请。"""
-    from ..approval import ApprovalGate
-
-    approval_id = args.get("approval_id", "").strip()
-    decision = args.get("decision", "").strip()
-    reviewer = args.get("reviewer", "").strip()
-    comment = args.get("comment", "")
-
-    if not approval_id:
-        return [TextContent(type="text", text="approval_id 不能为空")]
-    if decision not in ("approved", "rejected"):
-        return [TextContent(type="text", text="decision 必须是 approved 或 rejected")]
-    if not reviewer:
-        return [TextContent(type="text", text="reviewer 不能为空：必须填写审批人标识")]
-
-    gate = ApprovalGate.instance()
-    try:
-        rec = gate.approve(approval_id, reviewer, decision)
-    except (KeyError, ValueError) as e:
-        return [TextContent(type="text", text=f"审批失败：{e}")]
-
-    status_emoji = "✅" if rec.status == "approved" else "❌"
-    return [
-        TextContent(
-            type="text",
-            text=(
-                f"{status_emoji} 审批已完成\n\n"
-                f"approval_id: {rec.approval_id}\n"
-                f"command: {rec.command}\n"
-                f"status: {rec.status}\n"
-                f"reviewer: {rec.reviewer}\n"
-                f"decided_at: {_fmt_ts(rec.decided_at)}\n"
-            )
-            + (f"comment: {comment}\n" if comment else "")
-            + (
-                "\n👉 审批通过，AI 可执行：ssh_execute("
-                f"command='{rec.command}', approval_id='{rec.approval_id}')"
-                if rec.status == "approved"
-                else "\n🚫 审批拒绝，AI 不可执行此命令。"
-            ),
-        )
-    ]
-
-
-async def handle_list_approvals(ctx: HandlerContext, args: dict) -> list[TextContent]:
-    """加固点 4：列出审批记录。"""
-    from ..approval import ApprovalGate
-
-    action = args.get("action", "pending")
-    gate = ApprovalGate.instance()
-    recs = gate.list_pending() if action == "pending" else gate.list_all()
-
-    if not recs:
-        return [
-            TextContent(type="text", text=f"没有{('待审批' if action == 'pending' else '')}记录。")
-        ]
-
-    lines = [f"📋 审批记录（{action}，共 {len(recs)} 条）\n" + "=" * 60]
-    for r in recs:
-        lines.append(
-            f"\napproval_id: {r.approval_id}\n"
-            f"  command: {r.command}\n"
-            f"  status: {r.status}\n"
-            f"  risk_reason: {r.reason}\n"
-            f"  requested_at: {_fmt_ts(r.requested_at)}\n"
-            + (
-                f"  reviewer: {r.reviewer}\n  decided_at: {_fmt_ts(r.decided_at)}\n"
-                if r.decided_at
-                else ""
-            )
-            + (f"  consumed_at: {_fmt_ts(r.consumed_at)}\n" if r.consumed_at else "")
-        )
-    return [TextContent(type="text", text="\n".join(lines))]