🖥️ WaLiSSH：当 SSH 终端遇上大模型 — 一个 AI 驱动的智能运维终端

📦 GitHub（私有仓库，持续开发中）
🔗 github.com/lechan775/walissh

为什么要再做一款 SSH 工具？

市面上的终端工具已经足够多了。从 PuTTY 到 iTerm2，从 Termius 到 Tabby，从 MobaXterm 到 WindTerm——每个都有自己的拥趸。

但这些工具的 AI 能力几乎都停留在「在你终端旁边开一个 ChatGPT 侧边栏」的水平。它们能回答你的问题，但不能直接接管你的终端。

WaLiSSH 要解决的核心命题是：

让 LLM 真正在服务器上干活，而不是只动嘴皮子。

想象一下：你输入「帮我排查一下 8080 端口为什么起不来」，Agent 自动执行 netstat、lsof、journalctl，读取日志和配置，最终给你一个结构化的诊断结果——全程不需要你手动敲一行命令。

这就是 WaLiSSH。

🏗️ 架构总览

WaLiSSH 采用 C/S 分离的 DDD 分层架构。核心设计原则只有一条：

所有 SSH 操作与 AI 控制逻辑全部收敛在服务端，客户端仅仅负责渲染与交互。

这是刻意为之的安全架构决策。在企业场景中，如果把 AI + SSH 能力放在客户端，可能导致：

服务器凭证在本地泄露
误操作执行危险命令无审计追溯
多人协作时权限管理混乱

graph TB
    subgraph Client["🖥️ WaLiSSH Client（Tauri 2 + React 19）"]
        T["Terminal<br/>xterm.js + WebGL"]
        S["SFTP Browser<br/>文件浏览 & 拖拽上传"]
        A["AI Chat Panel<br/>Agent 对话 & SSH 绑定"]
        C["Command Palette<br/>Ctrl+Shift+P"]
        E["Monaco Editor<br/>远程文件编辑"]
    end

    subgraph Server["⚙️ WaLiSSH Server（Spring Boot 3.4.3）"]
        subgraph Trigger["Trigger Layer"]
            HC["HTTP Controllers<br/>RESTful API"]
        end
        subgraph Domain["Domain Layer（DDD）"]
            SD["SSH Domain<br/>终端 · 连接 · SFTP"]
            AD["Agent Domain<br/>编排 · 意图 · 上下文"]
            BD["Business Domain<br/>业务逻辑"]
        end
        subgraph Infra["Infrastructure Layer"]
            DB["MySQL + MyBatis"]
            SSH_LIB["SSH Adapter"]
        end
        subgraph AI["AI Stack"]
            ADK["Google ADK 1.2"]
            SAI["Spring AI 1.1.5"]
            LC4J["LangChain4j 1.4"]
            MCP["MCP Client / Server"]
            INTENT["Intent Classifier"]
            CTXT["Context Reducer"]
        end
    end

    subgraph Target["🎯 Target Servers"]
        TS1["生产服务器 A"]
        TS2["测试服务器 B"]
        TS3["..."
    ]

    Client -->|"HTTP/REST"| HC
    HC --> Domain
    Domain --> Infra
    Domain --> AI
    SSH_LIB --> Target

为什么是服务端收敛？

放在客户端 ❌	放在服务端 ✅
SSH 私钥散落在每个开发者本机	凭证统一加密存储于服务器
无法审计「谁在什么时间执行了什么」	全链路操作日志可追溯
更新 Agent 能力需要所有人升级客户端	服务端热更新，客户端无感知
AI API Key 暴露在客户端代码中	Key 仅存于服务端配置

🧠 AI 核心能力矩阵

1. Agent ↔ SSH 终端双向绑定

这是 WaLiSSH 最核心的机制。每个 AI 会话可以与一个（且仅一个）SSH 终端建立双向绑定：


┌──────────────────────┐          ┌──────────────────────┐
│   AI Chat Session    │  bind    │   SSH Terminal        │
│   (chatSessionId)    │◄───────►│   (terminalSessionId)  │
└─────────┬────────────┘          └──────────┬───────────┘
          │                                  │
          │  "查一下 8080 端口"               │
          ├─────────────────────────────────►│
          │                                  │  netstat -tlnp
          │                                  │  lsof -i :8080
          │                                  │  ps aux | grep java
          │◄─────────────────────────────────┤
          │                                  │
          ▼                                  ▼
   结构化诊断报告                      原始命令输出

绑定由 sshAgentStore 管理，通过 HTTP API 与后端的 BindTerminalRequestDTO 通信。一个会话一次只允许绑定一个终端，防止 AI 在多台服务器间误操作。

2. 意图识别：规则 + LLM 双引擎

直接让 LLM 自由调用终端存在风险。WaLiSSH 引入了意图分类中间层：

graph LR
    U["👤 用户输入"] --> IC["IntentService"]
    IC --> RIC["RuleIntentClassifier<br/>规则引擎（关键词/正则）"]
    IC --> LIC["LLMIntentClassifier<br/>LLM 语义分类"]
    RIC --> ROUTE["意图路由"]
    LIC --> ROUTE
    ROUTE --> AGENT["对应 Agent 执行"]
    ROUTE --> TOOL["对应 Tool 调用"]

分类器	延迟	准确率	适用场景
`RuleIntentClassifier`	< 1ms	~95%（高频意图）	「查端口」「看日志」「重启服务」
`LLMIntentClassifier`	~500ms	~98%	「帮我看看最近 OOM 是哪个 Pod 导致的」

规则引擎先拦截确定性意图（零成本、零延迟），模糊或复合意图才走 LLM 通道。

3. 多智能体工作流

复杂运维任务需要多步骤编排。WaLiSSH 支持三种 Agent 工作流模式：

java
// SequentialAgentNode  —  串行：前一个 Agent 输出作为下一个输入
// ParallelAgentNode    —  并行：多 Agent 同时执行后聚合
// LoopAgentNode        —  循环：直到满足终止条件

💡 实际场景举例——「部署一个新版本并验证」：


Sequential:
  Step 1: Agent A → 拉取最新代码
  Step 2: Agent B → 编译 & 构建镜像        ← 前置条件：Step 1 成功
  Step 3: Agent C → 滚动更新 Deployment    ← 前置条件：Step 2 成功

Parallel:
  Step 4: Agent D → curl /health 端点
  Step 5: Agent E → 检查 Pod 日志          ← 同时执行
  Step 6: Agent F → 检查监控指标

4. MCP 双模：既是 Client 也是 Server

MCP（Model Context Protocol）正在成为 AI Agent 工具调用的事实标准。WaLiSSH 同时支持两种角色：

模式	角色	能力
MCP Server	向外暴露 SSH 为工具	外部 Agent 可以通过 MCP 协议远程执行 Shell 命令
MCP Client	接入外部工具	连接 Stdio/SSE 协议的 MCP Server，扩展 Agent 工具集

实现层面：

SshExecuteMcpService — 将 SSH 命令执行包装为 Spring AI @Tool 注解的方法
StdioToolMcpCreateService / SSEToolMcpCreateService — 两种 MCP Client 连接模式
DefaultMcpClientFactory — MCP Client 工厂，统一创建与管理

5. Agent 军械库（Armory）

借鉴了军事术语「军械库」，将 Agent 可用的所有能力统一管理为四个维度：


Agent Armory（军械库）
├── 🔧 MCP Tools       → 通过 MCP 协议接入的外部能力
├── ⚔️  ADK Tools        → 基于 Google ADK 的原生工具（SshExecuteAdkTool）
├── 📋 Skills           → 可复用的技能模板（battle-plan / pdf）
└── 🔌 Plugins          → 插件拦截器（日志记录 / 风险控制 / 性能监控）

6. 上下文管理

LLM 的上下文窗口是有限资源。长对话中，早期消息会「挤出」窗口。WaLiSSH 提供了三种缩减策略：

策略	类	原理	适用
滑动窗口	`SlidingWindowReducer`	保留最近 N 轮，丢弃旧消息	简单对话
优先级	`PriorityReducer`	按消息重要性排序，优先保留关键上下文	重要任务
混合	`HybridReducer`	滑动窗口 + 优先级加权	生产默认

🎨 客户端体验

界面布局


┌──────┬────────────────────────────┬──────┐
│      │         Header              │      │
│  A   ├────────────────────────────┤  R   │
│  c   │                            │  i   │
│  t   │    Workbench Panel         │  g   │
│  i   │  ┌──────────────────────┐  │  h   │
│  v   │  │  File Tabs           │  │  t   │
│  i   │  │  (Editor / SFTP)     │  │      │
│  t   │  ├──────────────────────┤  │  S   │
│  y   │  │                      │  │  i   │
│      │  │  Terminal Panel      │  │  d   │
│  B   │  │  (xterm.js)          │  │  e   │
│  a   │  │                      │  │  b   │
│  r   │  └──────────────────────┘  │  a   │
│      │                            │  r   │
└──────┴────────────────────────────┴──────┘

核心交互组件：

组件	技术	功能
`TerminalPanel`	xterm.js + WebGL addon + Fit addon	GPU 加速终端渲染，窗口自适应
`WorkbenchPanel`	三模式布局（Tab / 水平分屏 / 垂直分屏）	多文件 + 终端同屏协作
`SFTPWorkspace`	双面板 + 拖拽上传	本地↔远程文件传输
`CodeEditor`	Monaco Editor（VS Code 同款内核）	远程文件在线编辑，语法高亮
`CommandPalette`	Ctrl+Shift+P 热键	VS Code 风格命令面板
`SSHConnectionModal`	三标签页（基础 / 认证 / 高级）	密码 + 私钥双模式连接

状态管理

基于 Zustand 的轻量级状态管理，五个 Store 各司其职：

Store	职责	关键状态
`connectionStore`	SSH 连接生命周期	连接 CRUD、心跳检测、断线重连
`sshAgentStore`	Agent ↔ SSH 绑定	绑定/解绑、输入框标签、连接选择器
`fileExplorerStore`	文件浏览与编辑	目录树、文件标签页、选中状态
`agentStore`	AI 对话	会话管理、消息流、ReAct 事件
`themeStore`	主题	暗色/亮色切换、配色方案

📊 技术栈速览

yaml
Client:
  Shell:     Tauri 2 (Rust)               # 桌面壳，替代 Electron，包体积 ~5MB
  UI:        React 19 + TypeScript 5.8    # 前端框架
  Terminal:  xterm.js 6.0 + WebGL Addon   # GPU 加速终端渲染
  Editor:    Monaco Editor 4.7             # VS Code 内核
  State:     Zustand 5                     # 轻量状态管理
  Style:     Tailwind CSS 4.2              # 原子化 CSS
  Build:     Vite 7                        # 构建工具

Server:
  Framework: Spring Boot 3.4.3           # Java 微服务框架
  Language:  Java 17                      # LTS 版本
  ORM:       MyBatis 3.0.4 + MySQL 8.0   # 持久层
  AI Core:   Google ADK 1.2.0             # Agent 开发框架
  AI Ext:    Spring AI 1.1.5              # Spring 生态 AI 集成
  AI Ext:    LangChain4j 1.4.0            # Java 版 LangChain
  Protocol:  MCP (Client + Server)        # 模型上下文协议

🚀 快速上手

环境准备

依赖	版本要求
☕ JDK	17+
📦 Maven	3.8+
🟩 Node.js	18+
🦀 Rust	stable（Tauri 编译需要）
🗄️ MySQL	8.0+
🔑 LLM API Key	OpenAI 兼容接口（如 DeepSeek / Qwen / GPT-4o）

三步启动

Step 1 — 初始化数据库

sql
-- 执行 walissh-server/docs/dev-ops/mysql/sql/walissh.sql

Step 2 — 启动服务端

bash
cd walissh-server
# 配置 LLM API Key（两处）：
#   walissh-server-app/src/main/resources/application-dev.yml
#   walissh-server-app/src/main/resources/agent/ssh-agent.yml

mvn clean install -DskipTests
cd walissh-server-app
mvn spring-boot:run -Dspring.profiles.active=dev
# → 服务端启动在 http://localhost:8080

💡 ssh-agent.yml 配置示例：

yaml
ai:
  agent:
    llm:
      api-key: sk-your-key-here
      base-url: https://api.deepseek.com/v1
      model: deepseek-chat

Step 3 — 启动客户端

bash
cd walissh-client
npm install
npm run tauri dev
# → 桌面应用启动，连接 localhost:8080

🔐 安全设计

WaLiSSH 从架构层面做了一系列安全控制：


┌─────────────────────────────────────────────────────┐
│                    安全层次                           │
├─────────────────────────────────────────────────────┤
│  传输层    │ 客户端 ↔ 服务端：JWT Token 认证          │
│           │ 服务端 ↔ 目标机：SSH 加密隧道             │
├───────────┼─────────────────────────────────────────┤
│  凭证层    │ SSH 私钥/密码仅存于服务端，客户端无感知    │
│           │ AI API Key 仅存于服务端配置               │
├───────────┼─────────────────────────────────────────┤
│  操作层    │ 终端会话隔离：每个 session 独立 PTY       │
│           │ Agent 执行命令全量日志审计                │
│           │ Armory Plugin 层可拦截危险命令             │
├───────────┼─────────────────────────────────────────┤
│  应用层    │ CORS + CSP 双重防护                     │
│           │ 密码传输：BCrypt 哈希存储                 │
└─────────────────────────────────────────────────────┘

🗺️ 路线图

状态	功能	说明
✅	SSH 基础连接与终端	密码/私钥双认证，xterm.js 渲染
✅	AI 对话与终端绑定	Agent ↔ SSH 一对一绑定
✅	SFTP 文件浏览器	双面板拖拽上传/下载
✅	Monaco 代码编辑器	VS Code 内核，远程文件直接编辑
✅	MCP Client/Server	双模 MCP 协议支持
✅	多智能体工作流	Sequential / Parallel / Loop
✅	意图识别引擎	规则 + LLM 双路径分类
✅	动态 Prompt & 上下文缩减	三种缩减策略 + 里程碑追踪
🚧	AI 命令补全	输入时实时预测下一步操作
🚧	终端输出智能解读	实时流式分析异常日志
🚧	Runbook 自动化	预定义运维剧本，一键执行
🚧	Web 版客户端	浏览器直接使用，无需安装
📋	多语言国际化	i18n 支持

📁 项目结构速查


waliCode/
├── walissh-client/                 # Tauri 2 桌面客户端（React + TypeScript + Rust）
│   ├── src/api/                    # HTTP API 封装（terminal / ssh / agent / sftp）
│   ├── src/components/             # UI 组件（TerminalPanel / SFTPWorkspace / Monaco...）
│   ├── src/stores/                 # Zustand 状态管理（5 个独立 Store）
│   ├── src-tauri/                  # Rust 后端（系统调用 / 原生能力）
│   └── docs/                       # 开发部署文档
│
└── walissh-server/                 # Spring Boot 服务端（DDD 7 模块分层）
    ├── walissh-server-api/         # DTO 与 Feign 接口
    ├── walissh-server-app/         # Spring Boot 启动入口 + 配置
    ├── walissh-server-case/        # 用例编排层
    ├── walissh-server-domain/      # 🧠 核心领域层
    │   ├── agent/                  #   Agent 编排 / 意图 / 上下文 / MCP / Armory
    │   ├── ssh/                    #   SSH 终端 / 连接 / SFTP
    │   └── business/               #   业务领域
    ├── walissh-server-infrastructure/  # 持久化 / SSH 适配器 / DAO
    ├── walissh-server-trigger/     # HTTP Controller
    └── walissh-server-types/       # 公共常量 / 枚举 / 异常

💡 域名结构遵循 cn.bugstack.ai，基于 fuzhengwei/ai-agent-scaffold-lite 脚手架架构深度定制。

💬 最后

WaLiSSH 不是要替代你手中的终端工具，而是想探索一个问题：

当 LLM 不再只是聊天窗口里的「问答机器」，而是真正能接管终端、执行命令、编排工作流时，工程师与服务器的交互范式会发生什么变化？

如果你对这个方向感兴趣，欢迎 ⭐ Star / 🍴 Fork，或者直接提 Issue 讨论。

_{Built with ❤️ by @lechan775 · Apache 2.0 License}

目录