diff --git a/linux/LinuxActivityHistory.h b/linux/LinuxActivityHistory.h new file mode 100644 index 0000000..19b5c90 --- /dev/null +++ b/linux/LinuxActivityHistory.h @@ -0,0 +1,562 @@ +#pragma once +// Linux 客户端的「历史活动」(服务端 COMMAND_QUERY_ACTIVITY → TOKEN_REPORT_ACTIVITY)。 +// +// 双后端: +// 窗口后端:有可用桌面(X11 + EWMH)时,后台每秒采样前台窗口,输出格式与 Windows +// 端 client/ActivityHistory.cpp 完全一致:[时间] [窗口标题] 时长 +// 无头后端:没有桌面时(服务器/容器/daemon 启动时 DISPLAY 不可用),查询时现算 +// 「登录记录 + shell 命令历史」,每行带 [登录] / [命令] 标签,首行标明来源 +// +// 服务端 CActivityDialog 与 MCP get_activity_history 都只按行切分纯文本,不需要改。 +// 纯解析函数放在这里(不依赖 X11),单元测试见 test/unit/linux/ActivityHistoryTest.cpp。 + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#ifndef _WIN32 +#include +#include +#include +#endif + +// 与 Windows 端 client/ActivityHistory.h 保持一致 +#ifndef ACTIVITY_MIN_DWELL_SEC +#define ACTIVITY_MIN_DWELL_SEC 5 // 一闪而过阈值(秒):驻留低于此值不记录 +#endif +#ifndef ACTIVITY_IDLE_BREAK_SEC +#define ACTIVITY_IDLE_BREAK_SEC 300 // 空闲打断阈值(秒):与 Windows 端一致 +#endif +#ifndef ACTIVITY_HISTORY_MAX +#define ACTIVITY_HISTORY_MAX 500 // 内存保留的最大记录条数 +#endif + +namespace LinuxActivity { + +// 采样线程从 X11 拿到的一条观测:id==0 表示空闲/无窗口/取不到标题 +struct ProbeResult +{ + unsigned long winId = 0; + std::string title; +}; + +inline std::tm LocalTimeOf(std::time_t t) +{ + std::tm tm{}; +#ifdef _WIN32 + localtime_s(&tm, &t); +#else + localtime_r(&t, &tm); +#endif + return tm; +} + +inline std::string FormatTimeStamp(std::time_t t) +{ + std::tm tm = LocalTimeOf(t); + char buf[80]; // 64 够放下极限值,多留一点让 -Wformat-truncation 闭嘴 + snprintf(buf, sizeof(buf), "%04d-%02d-%02d %02d:%02d:%02d", + tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, + tm.tm_hour, tm.tm_min, tm.tm_sec); + return buf; +} + +inline std::string NowStr() +{ + return FormatTimeStamp(std::time(nullptr)); +} + +// 时长格式化:Ns / Nm / NmNs / NhNm(与 Windows 端一致) +inline std::string 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"; +} + +// UTF-8 尾字节修正:按字节截断可能切在多字节字符中间,而服务端要按 UTF-8 +// 转 GBK(对话框)或塞进 JSON(MCP),半截字符会变成乱码/非法 JSON。 +// 返回可以安全截断的位置。 +inline size_t Utf8Boundary(const std::string& s) +{ + const size_t n = s.size(); + size_t i = n; + while (i > 0 && n - i < 3 && ((unsigned char)s[i - 1] & 0xC0) == 0x80) --i; + if (i == 0) return n; + const unsigned char c = (unsigned char)s[i - 1]; + size_t need = 1; + if ((c & 0x80) == 0) need = 1; + else if ((c & 0xE0) == 0xC0) need = 2; + else if ((c & 0xF0) == 0xE0) need = 3; + else if ((c & 0xF8) == 0xF0) need = 4; + return (n - (i - 1) >= need) ? n : i - 1; +} + +// 控制字符换成空格(换行会破坏「每行一条」),可选截断 +inline std::string CleanLine(const std::string& s, size_t maxLen = 512) +{ + std::string out; + out.reserve(std::min(s.size(), maxLen)); + bool cut = false; + for (char c : s) { + unsigned char uc = (unsigned char)c; + out += (uc < 0x20 || uc == 0x7f) ? ' ' : c; + if (out.size() >= maxLen) { cut = true; break; } + } + if (cut) out.resize(Utf8Boundary(out)); + return out; +} + +inline std::string FormatWindowRecord(const std::string& startTime, const std::string& title, int dwellSec) +{ + return "[" + startTime + "] [" + CleanLine(title) + "] " + FormatDuration(dwellSec); +} + +inline std::string FormatCommandRecord(std::time_t ts, const std::string& user, const std::string& cmd) +{ + std::string t = ts > 0 ? FormatTimeStamp(ts) : std::string("时间未知"); + return "[" + t + "] [命令] " + user + ": " + cmd; +} + +inline std::vector SplitWs(const std::string& s) +{ + std::vector out; + size_t i = 0; + while (i < s.size()) { + while (i < s.size() && (s[i] == ' ' || s[i] == '\t' || s[i] == '\r')) ++i; + size_t start = i; + while (i < s.size() && s[i] != ' ' && s[i] != '\t' && s[i] != '\r') ++i; + if (i > start) out.push_back(s.substr(start, i - start)); + } + return out; +} + +// bash / zsh 历史文本解析。 +// bash 设了 HISTTIMEFORMAT 时按 "#" + 命令成对写; +// zsh 开 EXTENDED_HISTORY 时写成 ": :;命令"。 +// 其余按普通行处理(时间未知)。 +inline std::vector ParseShellHistoryText(const std::string& text, + const std::string& user, + size_t maxLines) +{ + std::vector out; + std::time_t pending = 0; + size_t i = 0; + while (i < text.size()) { + size_t nl = text.find('\n', i); + std::string line = text.substr(i, nl == std::string::npos ? std::string::npos : nl - i); + i = (nl == std::string::npos) ? text.size() : nl + 1; + if (!line.empty() && line.back() == '\r') line.pop_back(); + if (line.empty()) continue; + + // "#1699560000" —— 只认纯数字,避免把真实的 "#注释" 当成时间戳 + if (line[0] == '#' && line.size() > 1 && line.size() <= 13 && + std::all_of(line.begin() + 1, line.end(), + [](unsigned char c) { return c >= '0' && c <= '9'; })) { + try { pending = (std::time_t)std::stoll(line.substr(1)); } catch (...) { pending = 0; } + continue; + } + + std::time_t ts = pending; + pending = 0; + + if (line.size() > 2 && line[0] == ':' && line[1] == ' ') { + size_t semi = line.find(';'); + if (semi != std::string::npos) { + std::string meta = line.substr(2, semi - 2); + size_t colon = meta.find(':'); + // 只认 ": :;" 这一种形状。bash 里 ": ${PATH:=/usr/bin}; ls" + // 这种命令行同样以 ": " 开头、也带 ';',不能当成 zsh 元数据截掉。 + const std::string tsPart = meta.substr(0, colon); + const bool zshMeta = colon != std::string::npos && !tsPart.empty() && + std::all_of(tsPart.begin(), tsPart.end(), + [](unsigned char c) { return c >= '0' && c <= '9'; }); + if (zshMeta) { + try { ts = (std::time_t)std::stoll(tsPart); } catch (...) { ts = 0; } + line = line.substr(semi + 1); + if (line.empty()) continue; + } + } + } + + out.push_back(FormatCommandRecord(ts, user, CleanLine(line))); + } + if (out.size() > maxLines) + out.erase(out.begin(), out.end() - (long)maxLines); + return out; +} + +inline int MonthNumber(const std::string& m) +{ + static const char* kMonths[] = { "Jan", "Feb", "Mar", "Apr", "May", "Jun", + "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" }; + for (int i = 0; i < 12; ++i) + if (m == kMonths[i]) return i + 1; + return 0; +} + +// `last -F`(LC_ALL=C)的输出解析。样例: +// root pts/0 203.0.113.7 Fri Nov 7 22:10:33 2026 - ... (00:49) +// reboot system boot 6.8.0-45 Fri Nov 7 22:10:20 2026 - ... +// root tty1 Sat Nov 8 09:00:00 2026 still logged in +// 本地登录没有 host 字段,靠「星期」在字段里的位置判断: +// [user][tty][host][Mon..Sun][Mon月][日][HH:MM:SS][年] 远程登录 +// [user][tty][Mon..Sun][月][日][HH:MM:SS][年] 本地登录 +// [reboot][system][boot][内核][Mon..Sun][月][日][...] 重启 +inline int WeekdayIndex(const std::string& s) +{ + static const char* kDays[] = { "Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun" }; + for (int i = 0; i < 7; ++i) + if (s == kDays[i]) return i; + return -1; +} + +inline std::vector ParseLastOutput(const std::string& text, size_t maxLines) +{ + std::vector out; + size_t i = 0; + while (i < text.size() && out.size() < maxLines) { + size_t nl = text.find('\n', i); + std::string line = text.substr(i, nl == std::string::npos ? std::string::npos : nl - i); + i = (nl == std::string::npos) ? text.size() : nl + 1; + if (!line.empty() && line.back() == '\r') line.pop_back(); + if (line.empty()) continue; + // 文件尾部的说明行不是记录 + if (line.compare(0, 12, "wtmp begins ") == 0) continue; + + std::vector f = SplitWs(line); + if (f.size() < 4) continue; + + // 定位「星期」,月份紧跟在它后面;找不到星期的行按未知时间原样保留 + size_t wi = 0; + for (; wi < f.size(); ++wi) { + if (WeekdayIndex(f[wi]) >= 0) break; + } + int mon = (wi + 1 < f.size()) ? MonthNumber(f[wi + 1]) : 0; + if (wi >= f.size() || !mon || wi + 4 >= f.size()) { + out.push_back("[时间未知] [登录] " + CleanLine(line)); + continue; + } + size_t mi = wi + 1; // 月份字段下标 + + const std::string& user = f[0]; + std::string tty, host; + if (user == "reboot") { + host = (wi >= 4) ? f[3] : std::string(); // 内核版本 + } else { + tty = f.size() > 1 ? f[1] : std::string(); + host = (wi >= 3) ? f[2] : std::string(); + } + + int day = atoi(f[mi + 1].c_str()); + int hour = 0, minute = 0, sec = 0; + int year = atoi(f[mi + 3].c_str()); + std::string ts; + if (sscanf(f[mi + 2].c_str(), "%d:%d:%d", &hour, &minute, &sec) == 3 && year > 1970) { + char buf[80]; + snprintf(buf, sizeof(buf), "%04d-%02d-%02d %02d:%02d:%02d", + year, mon, day, hour, minute, sec); + ts = buf; + } + + std::string rec = "[" + (ts.empty() ? std::string("时间未知") : ts) + "] [登录] " + user; + if (user == "reboot") rec += " (system boot)"; + if (!tty.empty()) rec += " " + tty; + if (!host.empty() && host != "-") rec += " from " + host; + out.push_back(rec); + } + return out; +} + +// reboot 记录里除了时间几乎没别的信息,而无头/WSL 机器的 wtmp 常常堆着几十条 +// (每次启动一条),会把真正的登录和命令全挤掉。这里只保留最近的几条。 +constexpr size_t ACTIVITY_HEADLESS_MAX_REBOOTS = 10; + +inline std::vector LimitRebootSpam(const std::vector& lines, + size_t maxReboots, size_t budget) +{ + std::vector kept; + kept.reserve(std::min(lines.size(), budget)); + size_t reboots = 0; + for (const auto& l : lines) { + if (l.find("[登录] reboot ") != std::string::npos) { + if (++reboots > maxReboots) continue; + } + if (kept.size() >= budget) break; + kept.push_back(l); + } + return kept; +} + +// 一条记录的时间戳键:"[2026-11-08 09:00:00] ..." → "2026-11-08 09:00:00", +// 认不出("[时间未知]")返回空串。 +inline std::string RecordTimestampKey(const std::string& line) +{ + if (line.size() < 21 || line[0] != '[') return std::string(); + size_t close = line.find(']'); + if (close == std::string::npos) return std::string(); + std::string ts = line.substr(1, close - 1); + if (ts.size() != 19) return std::string(); + return ts; +} + +// 登录记录和命令历史是两批数据、各自新在前;服务端和 MCP 都按「offset=0 就是最近 +// limit 条」分页,合并后必须真正按时间戳排一遍,否则最近的命令会被更早的登录挤到后面。 +inline void SortNewestFirst(std::vector& lines) +{ + std::stable_sort(lines.begin(), lines.end(), + [](const std::string& a, const std::string& b) { + const std::string ka = RecordTimestampKey(a); + const std::string kb = RecordTimestampKey(b); + if (ka.empty() != kb.empty()) return !ka.empty(); // 有时间戳的在前 + return ka > kb; // 同为空时两者等价,stable_sort 保持原顺序 + }); +} + +// 窗口后端可用但没有记录时的说明(避免对话框全空) +inline std::string WindowBackendEmptyText() +{ + return "[来源] 桌面窗口活动:暂无记录(没有停留超过 5 秒的活动窗口)\n"; +} + +#ifndef _WIN32 + +inline std::string RunCommandCapture(const std::string& cmd, size_t maxBytes = 256 * 1024) +{ + std::string out; + FILE* p = popen(cmd.c_str(), "r"); + if (!p) return out; + char buf[4096]; + size_t n; + while ((n = fread(buf, 1, sizeof(buf), p)) > 0) { + out.append(buf, n); + if (out.size() >= maxBytes) break; + } + pclose(p); + return out; +} + +// 只读文件尾部,避免把巨型历史文件整个读进来;从中间截断时丢掉半行 +inline bool ReadFileTail(const std::string& path, size_t maxBytes, std::string& out) +{ + out.clear(); + FILE* f = fopen(path.c_str(), "rb"); + if (!f) return false; + bool ok = false; + do { + if (fseek(f, 0, SEEK_END) != 0) break; + long len = ftell(f); + if (len < 0) break; + long start = ((size_t)len > maxBytes) ? len - (long)maxBytes : 0; + if (fseek(f, start, SEEK_SET) != 0) break; + char buf[8192]; + size_t n; + while ((n = fread(buf, 1, sizeof(buf), f)) > 0) out.append(buf, n); + if (start > 0) { + size_t nl = out.find('\n'); + if (nl == std::string::npos) out.clear(); + else out.erase(0, nl + 1); + } + ok = true; + } while (0); + fclose(f); + return ok; +} + +struct HistoryFile +{ + std::string user; + std::string path; + std::time_t mtime; +}; + +// 客户端通常以 root 运行,但日常操作发生在普通用户 shell 里,两边都收 +inline void CollectHistoryFiles(std::vector& files) +{ + auto add = [&](const std::string& user, const std::string& path) { + struct stat st; + if (stat(path.c_str(), &st) != 0 || !S_ISREG(st.st_mode)) return; + files.push_back(HistoryFile{ user, path, st.st_mtime }); + }; + + add("root", "/root/.bash_history"); + add("root", "/root/.zsh_history"); + + DIR* d = opendir("/home"); + if (!d) return; + while (struct dirent* e = readdir(d)) { + if (e->d_name[0] == '.') continue; + std::string base = std::string("/home/") + e->d_name; + add(e->d_name, base + "/.bash_history"); + add(e->d_name, base + "/.zsh_history"); + } + closedir(d); +} + +// 无头后端:登录记录(last)+ shell 命令历史,每行一条,首行标注来源。 +// includeCommands=false 时只返回登录记录(配置项 activity_commands=0)。 +// maxLines 是总行数上限:登录记录先占,剩下的额度给命令。 +inline std::string BuildHeadlessDump(bool includeCommands, size_t maxLines = 200) +{ + // 登录记录最多占 60%(至少 10 行),余量一定留给命令历史: + // reboot 行虽然先算进来,但下面会被 LimitRebootSpam 削掉大半,不预留额度的话 + // 无头机上很可能一条命令都看不到。 + const size_t loginBudget = includeCommands + ? std::min(maxLines, std::max(10, maxLines * 3 / 5)) + : maxLines; + std::vector logins = LimitRebootSpam( + ParseLastOutput(RunCommandCapture("LC_ALL=C last -n 100 -F 2>/dev/null"), loginBudget), + ACTIVITY_HEADLESS_MAX_REBOOTS, loginBudget); + + const size_t cmdBudget = includeCommands && maxLines > logins.size() + ? maxLines - logins.size() : 0; + std::vector cmds; + if (cmdBudget > 0) { + std::vector files; + CollectHistoryFiles(files); + // 最近改过的历史文件排在前面(大致对应当前活跃用户) + std::sort(files.begin(), files.end(), + [](const HistoryFile& a, const HistoryFile& b) { return a.mtime > b.mtime; }); + for (const auto& f : files) { + std::string text; + if (!ReadFileTail(f.path, 256 * 1024, text)) continue; + std::vector lines = ParseShellHistoryText(text, f.user, cmdBudget); + for (auto it = lines.rbegin(); it != lines.rend(); ++it) + cmds.push_back(*it); // 新在前,与 Windows 端一致 + if (cmds.size() >= cmdBudget) break; + } + if (cmds.size() > cmdBudget) cmds.resize(cmdBudget); + } + + std::vector merged; + merged.reserve(logins.size() + cmds.size()); + merged.insert(merged.end(), logins.begin(), logins.end()); + merged.insert(merged.end(), cmds.begin(), cmds.end()); + SortNewestFirst(merged); + + std::string out = std::string("[来源] 无桌面环境:") + + (includeCommands ? "登录记录 + 命令历史" : "仅登录记录") + "\n"; + if (merged.empty()) + out += "[来源] 没有可用的登录/命令记录\n"; + for (const auto& l : merged) + out += l + "\n"; + return out; +} + +#endif // !_WIN32 + +// ============== 窗口后端:后台采样线程(与 Windows 端 ActivityHistory 对齐)============== +class ActivityHistory +{ +public: + static ActivityHistory& Instance() + { + static ActivityHistory inst; + return inst; + } + + // probe 只能由采样线程调用(X11 连接不能跨线程共用,调用方要传自己的实例) + void Start(std::function probe) + { + if (m_started.exchange(true)) return; + m_probe = std::move(probe); + m_running = true; + m_thread = std::thread(&ActivityHistory::Loop, this); + } + + void Stop() + { + m_running = false; + if (m_thread.joinable()) + m_thread.join(); + } + + // 最新在前;进行中的窗口(已驻留达阈值)排在最前 + std::string Dump() const + { + std::lock_guard lock(m_mutex); + std::string out; + if (!m_curTitle.empty() && m_curDwellSec >= ACTIVITY_MIN_DWELL_SEC) + out += FormatWindowRecord(m_curStartTime, m_curTitle, m_curDwellSec) + "\n"; + for (const auto& r : m_records) + out += r + "\n"; + return out; + } + +private: + ActivityHistory() = default; + ~ActivityHistory() { Stop(); } + ActivityHistory(const ActivityHistory&) = delete; + ActivityHistory& operator=(const ActivityHistory&) = delete; + + void Loop() + { + unsigned long lastId = 0; + std::string lastTitle, startTime; + int dwellSec = 0; + + while (m_running) { + ProbeResult p = m_probe ? m_probe() : ProbeResult(); + { + std::lock_guard lock(m_mutex); + if (p.winId == 0 || p.title.empty()) { + // 空闲/锁定/无标题:结账上一个窗口 + if (lastId != 0 && dwellSec >= ACTIVITY_MIN_DWELL_SEC) + m_records.push_front(FormatWindowRecord(startTime, lastTitle, dwellSec)); + lastId = 0; + lastTitle.clear(); + dwellSec = 0; + } else if (p.winId == lastId) { + // 同一窗口:标题变了也连续累计(浏览器标签切换标题常变) + ++dwellSec; + lastTitle = p.title; + } else { + if (lastId != 0 && dwellSec >= ACTIVITY_MIN_DWELL_SEC) + m_records.push_front(FormatWindowRecord(startTime, lastTitle, dwellSec)); + lastId = p.winId; + lastTitle = p.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; + } + std::this_thread::sleep_for(std::chrono::seconds(1)); + } + } + + mutable std::mutex m_mutex; + std::deque m_records; // 已完成记录,最新在前 + std::string m_curTitle; + std::string m_curStartTime; + int m_curDwellSec = 0; + + std::atomic m_running{ false }; + std::atomic m_started{ false }; + std::function m_probe; + std::thread m_thread; +}; + +} // namespace LinuxActivity diff --git a/linux/README.md b/linux/README.md index 7d9fb67..7f75cbc 100644 --- a/linux/README.md +++ b/linux/README.md @@ -23,6 +23,7 @@ SimpleRemoter 的 Linux 客户端,支持远程桌面、远程终端、文件 | 远程终端 | `PTYHandler` (main.cpp) | `ConPTYManager.cpp` | ✅ 完整 | | 心跳/RTT | main.cpp | `KernelManager.cpp` | ✅ 完整 | | 用户活动检测 | `ActivityChecker` | `ActivityWindow` | ✅ 完整 | +| 历史活动 | `LinuxActivityHistory.h` | `ActivityHistory.cpp` | ✅ 双后端(有桌面:X11 前台窗口驻留,格式与 Windows 一致;无桌面:`last` 登录记录 + bash/zsh 命令历史,`activity_commands=0` 可关闭命令采集) | | 系统信息采集 | main.cpp | `LoginServer.cpp` | ✅ 完整 | | 守护进程 | daemonize() | Windows 服务 | ✅ 完整 | | 剪贴板同步 | `ClipboardHandler.h` | `ScreenManager.cpp` | ✅ 服务端↔Linux | @@ -265,6 +266,37 @@ macOS 可直接复用。 所以分享到一台不在当前信任锚覆盖范围内的主控时,子进程会按 fail-closed 直接 握手失败、反复重连;要么先给这台主机装好包含该主控 CA 的信任锚,要么用明文分享。 +## 历史活动 + +服务端「客户管理 → 历史活动」与 MCP `get_activity_history` 取的是同一次上报 +(`COMMAND_QUERY_ACTIVITY` → `TOKEN_REPORT_ACTIVITY`)。客户端在**启动时**按有没有 +桌面挑一个后端,之后不再切换: + +| 后端 | 触发条件 | 内容 | +|------|---------|------| +| 窗口 | `DISPLAY` 可用且能连上 X 服务器 | 后台每秒采样前台窗口,格式与 Windows 客户端一致:`[YYYY-MM-DD HH:MM:SS] [窗口标题] 时长`。驻留不足 5 秒不记录,空闲 5 分钟算打断,内存保留最近 500 条,最新在前;重启客户端后重新累计 | +| 无头 | 没有 `DISPLAY` / 连不上 X(服务器、容器、systemd 服务) | 查询时现算:登录记录来自 `last -n 100 -F`,命令历史来自 root 和 `/home/*` 下的 `.bash_history`、`.zsh_history`,每行带 `[登录]` / `[命令]` 标签,首行 `[来源]` 说明 | + +无头后端把额度按 6:4 分给登录记录和命令历史(登录至少 10 行),并且 `reboot` +记录最多保留 10 条——WSL/容器每启动一次就写一条 `reboot`,不设上限会把真正的 +登录和命令全挤掉。 + +无头后端的登录记录和命令历史合并后按时间戳统一排序(新的在前,时间未知的排最后), +所以服务端/MCP 按 offset 分页时「offset=0」真的是最近的那些。 + +窗口后端有两个已知边界: + +- **X 起来了但没有 EWMH 窗口管理器**(Xvfb、裸 X):`_NET_ACTIVE_WINDOW` 永远读不到。 + 启动时用根窗口上的 `_NET_SUPPORTING_WM_CHECK` 判一下,没有就直接按无头后端走。 +- **没装 `libXss`**(很少见):拿不到空闲时间,一直按「在用」算,同一窗口会一路累加 + 时长,锁屏也不会打断。装了 `libxss1` 就正常。 + +命令历史的时间戳取决于 shell 配置:bash 需要 `HISTTIMEFORMAT`,zsh 需要 +`EXTENDED_HISTORY`,否则只能拿到命令本身,显示为 `[时间未知]`。 + +**隐私开关**:在 `~/.config/ghost/config.conf` 里写 `activity_commands=0`,无头后端就只上报 +登录记录、不读任何 shell 历史。每次查询都重新读配置,改完不用重启。 + ## 常见问题 ### Q: 远程桌面功能不工作 @@ -369,6 +401,7 @@ loginctl show-session $(loginctl | grep $(whoami) | awk '{print $1}') -p Type | `QualityLevel` | 屏幕质量等级 | `2` (Good / H264 1080P) | | `transfer` | 主机转移记录(空 = 未转移),见「主机转移」 | `1.2.3.4:443:6:0:1790000000` | | `share_list` | 主机分享记录(空 = 未分享),竖线分隔,见「主机分享」 | `1.2.3.4:443:0:6` | +| `activity_commands` | 无头后端是否采集 shell 命令历史(1 = 采集,0 = 只报登录记录),见「历史活动」 | `1` | ### 质量等级说明 diff --git a/linux/main.cpp b/linux/main.cpp index 4627737..a4b84cd 100644 --- a/linux/main.cpp +++ b/linux/main.cpp @@ -45,6 +45,7 @@ #include "common/host_transfer.h" #include "common/host_share.h" #include "LinuxConfig.h" +#include "LinuxActivityHistory.h" #include #include #include @@ -250,6 +251,32 @@ public: return "Inactive: " + FormatMilliseconds(idle); } + // 历史活动采样用:有桌面、用户未空闲且存在活动窗口时返回 id+标题,否则 id=0。 + // 与 Check 的区别是不把「空闲」包装成 Inactive 文本 —— 采样端只关心"有没有活动"。 + LinuxActivity::ProbeResult Probe(unsigned long idle_threshold_ms = 6000) + { + LinuxActivity::ProbeResult r; + if (!m_available) return r; + if (GetIdleTime() >= idle_threshold_ms) return r; + r.winId = GetActiveWindowId(); + if (r.winId == 0) return r; + r.title = GetWindowTitle(r.winId); // 用刚取到的 id,别再读一次活动窗口(可能已换) + return r; + } + + bool Available() const { return m_available; } + + // 有桌面且真能跟踪前台窗口:X 连上了还不够,根窗口上得有 _NET_SUPPORTING_WM_CHECK + // (EWMH 窗口管理器)。Xvfb、裸 X 这类「有 DISPLAY 没有 WM」的环境里 + // _NET_ACTIVE_WINDOW 永远读不到,采样只会一直空转,应该按无头后端处理。 + bool Usable() + { + if (!m_available) return false; + Atom atom = pXInternAtom(m_display, "_NET_SUPPORTING_WM_CHECK", 0); + if (!atom) return false; + return !GetWindowProperty(m_root, atom, (Atom)0).empty(); + } + private: // X11 函数指针类型 typedef Display* (*fn_XOpenDisplay)(const char*); @@ -315,10 +342,9 @@ private: return idle; } - // 获取当前活动窗口标题(通过 EWMH _NET_ACTIVE_WINDOW + _NET_WM_NAME) - std::string GetActiveWindowTitle() + // 从根窗口读取 _NET_ACTIVE_WINDOW 得到活动窗口 ID;无窗口/WM 不支持时返回 0 + Window GetActiveWindowId() { - // 第一步:从根窗口读取 _NET_ACTIVE_WINDOW 得到活动窗口 ID Atom actualType = 0; int actualFormat = 0; unsigned long nItems = 0, bytesAfter = 0; @@ -329,20 +355,27 @@ private: &actualType, &actualFormat, &nItems, &bytesAfter, &prop); if (ret != 0 || !prop || nItems == 0) { if (prop) pXFree(prop); - return ""; + return 0; } - Window activeWin = *(Window*)prop; + Window w = *(Window*)prop; pXFree(prop); - prop = nullptr; + return w; + } - if (activeWin == 0) return ""; + // 获取当前活动窗口标题(通过 EWMH _NET_ACTIVE_WINDOW + _NET_WM_NAME) + std::string GetActiveWindowTitle() + { + return GetWindowTitle(GetActiveWindowId()); + } - // 第二步:读取 _NET_WM_NAME (UTF-8),失败则回退 WM_NAME - std::string title = GetWindowProperty(activeWin, m_atomWmName, m_atomUtf8String); + // 指定窗口的标题:_NET_WM_NAME (UTF-8),失败回退 WM_NAME + std::string GetWindowTitle(Window win) + { + if (win == 0) return ""; + std::string title = GetWindowProperty(win, m_atomWmName, m_atomUtf8String); if (title.empty()) - title = GetWindowProperty(activeWin, m_atomWmNameLegacy, (Atom)0); - + title = GetWindowProperty(win, m_atomWmNameLegacy, (Atom)0); return title; } @@ -576,6 +609,44 @@ static void CheckTransferExpiry() StopChildren(KIND_TRANSFER); } +// ============== 历史活动(COMMAND_QUERY_ACTIVITY → TOKEN_REPORT_ACTIVITY) ============== +// true=桌面窗口采样(启动时 X11 可用),false=无头后端(登录记录 + shell 命令历史) +static std::atomic g_activityWindowBackend(false); + +// 与 Windows 端一致:主连接一次性快照,不开子连接(服务端 TOKEN_REPORT_ACTIVITY 分支 +// 不 CancelIO)。无头后端要跑 last、读历史文件,所以放线程里,别堵接收线程。 +// 同时在飞的报表最多一份:连点/多个 MCP 调用会把 popen(last) 和读历史文件叠起来, +// 一次几十毫秒的活堆成几百个子进程没有任何意义。 +static std::atomic g_activityReportsInFlight(0); + +static void ActivityReportThread() +{ + const bool windowBackend = g_activityWindowBackend.load(std::memory_order_relaxed); + std::string text; + if (windowBackend) { + text = LinuxActivity::ActivityHistory::Instance().Dump(); + if (text.empty()) + text = LinuxActivity::WindowBackendEmptyText(); // 桌面空闲/刚启动,还没有够 5 秒的窗口 + } else { + LinuxConfig cfg; // 每次现读:activity_commands 改了立刻生效 + const bool includeCommands = cfg.GetInt("activity_commands", 1) != 0; + text = LinuxActivity::BuildHeadlessDump(includeCommands, 200); + } + + std::vector pkt(1 + text.size()); + pkt[0] = TOKEN_REPORT_ACTIVITY; + if (!text.empty()) + memcpy(pkt.data() + 1, text.data(), text.size()); + // 取快照可能跑上几十毫秒(last/读历史文件),期间主连接可能已经断了或是进程在退出; + // 与截屏回包一样:Send2Server 内部持锁,但先确认还连着 + bool sent = false; + if (g_pMainClient && g_pMainClient->IsConnected() && g_bExit == S_CLIENT_NORMAL) + sent = g_pMainClient->Send2Server((char*)pkt.data(), (ULONG)pkt.size()) != FALSE; + Mprintf("[Activity] report %zu bytes (%s backend)%s\n", text.size(), + windowBackend ? "window" : "headless", sent ? "" : " FAILED"); + g_activityReportsInFlight.fetch_sub(1, std::memory_order_relaxed); +} + int DataProcess(void* user, PBYTE szBuffer, ULONG ulLength) { if (szBuffer == nullptr || ulLength == 0) @@ -607,6 +678,21 @@ int DataProcess(void* user, PBYTE szBuffer, ULONG ulLength) // 子连接;若回在主连接上,被关掉的就是主连接本身。 std::thread(ClientLogThread, nullptr).detach(); Mprintf("** [%p] Received 'QUERY_LOG' command ***\n", user); + } else if (szBuffer[0] == COMMAND_QUERY_ACTIVITY) { + // 历史活动:主连接一次性快照(无子连接),有桌面走窗口采样,无桌面走登录+命令记录。 + // 已经有报表在飞就丢掉这一次(服务端每主机单飞行,连点也只是重复请求) + if (g_activityReportsInFlight.fetch_add(1) >= 1) { + g_activityReportsInFlight.fetch_sub(1); + return TRUE; + } + Mprintf("** [%p] Received 'QUERY_ACTIVITY' command ***\n", user); + try { + std::thread(ActivityReportThread).detach(); + } catch (const std::exception& e) { + // 线程起不来要把在途计数还回去,否则之后的历史活动请求全被当成「忙」丢掉 + g_activityReportsInFlight.fetch_sub(1); + Mprintf("** Activity report thread failed: %s ***\n", e.what()); + } } else if (szBuffer[0] == COMMAND_SCREEN_PREVIEW_REQ) { if (ulLength < sizeof(ScreenPreviewReq)) return TRUE; ScreenPreviewReq req; @@ -1894,6 +1980,22 @@ int main(int argc, char* argv[]) // 初始化用户活动检测器(用于心跳包中的 ActiveWnd 字段) ActivityChecker activityChecker; + // 历史活动采样器必须用独立实例:Xlib 连接不能跨线程共用,心跳线程一直在用 + // activityChecker。没有桌面 / 有 X 但没有 EWMH 窗口管理器时不启动采样线程, + // 查询时走无头后端。 + ActivityChecker historyChecker; + const bool windowBackend = historyChecker.Usable(); + g_activityWindowBackend.store(windowBackend, std::memory_order_relaxed); + if (windowBackend) { + LinuxActivity::ActivityHistory::Instance().Start([&historyChecker]() { + return historyChecker.Probe((unsigned long)ACTIVITY_IDLE_BREAK_SEC * 1000UL); + }); + } + Mprintf("[Activity] 历史活动后端: %s\n", + windowBackend ? "桌面窗口(X11)" + : (historyChecker.Available() ? "无头(登录+命令,X 上没有 EWMH 窗口管理器)" + : "无头(登录+命令)")); + std::unique_ptr ClientObject(new IOCPClient(g_bExit, false)); ClientObject->setManagerCallBack(NULL, DataProcess, NULL); // 不传 conn 的构造路径拿不到注入的 CONNECT_ADDRESS,协议只能显式喂进去:否则哪怕 @@ -2047,6 +2149,14 @@ int main(int argc, char* argv[]) StopChildren(KIND_ALL); } + // 采样线程要在 main 的局部对象(historyChecker)析构前停掉 + LinuxActivity::ActivityHistory::Instance().Stop(); + + // 历史活动的报表线程是 detached 的,可能还在跑 last / 读历史文件;它最后要写一行日志, + // 等它收尾再关日志。最多等 2 秒,等不到就算了(进程要退出,不能因此卡住)。 + for (int i = 0; i < 20 && g_activityReportsInFlight.load(std::memory_order_relaxed) > 0; ++i) + std::this_thread::sleep_for(std::chrono::milliseconds(100)); + Logger::getInstance().stop(); if (!g_bShareInstance) removePidFile(); diff --git a/server/2015Remote/McpServer.cpp b/server/2015Remote/McpServer.cpp index de9b449..5501a91 100644 --- a/server/2015Remote/McpServer.cpp +++ b/server/2015Remote/McpServer.cpp @@ -2026,7 +2026,7 @@ std::string BuildToolsListResult(const Json::Value& id) { { Json::Value tool(Json::objectValue); tool["name"] = "get_activity_history"; - tool["description"] = u8"获取指定在线主机的历史活动记录(前台窗口驻留时长,每行一条「[时间] [标题] 时长」)。主连接 RPC。结果按 limit/offset 分页(默认 100 条、上限 1000),新在前:offset=0 就是最近 limit 条,想看更早的再往后翻。total 为本机现有记录总数,hasMore 表示还有更早的记录;客户端只保留最近 500 条,所以 total 最多约 501(含进行中的当前窗口)。"; + tool["description"] = u8"获取指定在线主机的历史活动记录。Windows 与有桌面的 Linux 客户端返回前台窗口驻留记录,每行一条「[时间] [标题] 时长」;无桌面的 Linux 客户端返回登录记录与 shell 命令历史,每行带「[登录]」或「[命令]」标签(首行为「[来源]」说明)。主连接 RPC。结果按 limit/offset 分页(默认 100 条、上限 1000),新在前:offset=0 就是最近 limit 条,想看更早的再往后翻。total 为本机现有记录总数,hasMore 表示还有更早的记录;窗口后端只保留最近 500 条,所以 total 最多约 501(含进行中的当前窗口)。"; tool["inputSchema"] = BuildPagedHostListInputSchema(); // { id | ids } + limit/offset tool["outputSchema"] = BuildActivityHistoryOutputSchema(); @@ -8854,7 +8854,9 @@ const ToolPlatform kToolPlatforms[] = { // 注意别被 linux/SystemManager.h:38 和 macos/SystemManager.mm:39 的 case 骗到, // 那是给 SystemDlg 窗口管理用的,不是 MCP 这条路径。 { "list_windows", kPlatWin }, - { "get_activity_history", kPlatWin }, + // Linux 客户端已实现 COMMAND_QUERY_ACTIVITY → TOKEN_REPORT_ACTIVITY(linux/LinuxActivityHistory.h, + // 有桌面走 X11 窗口采样,无桌面走 last + shell 历史),与 Windows 同为主连接 RPC + { "get_activity_history", kPlatWin|kPlatLnx }, { "list_services", kPlatWin }, { "get_keylog", kPlatWin }, { "list_registry", kPlatWin }, diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt index 6d78968..97845a4 100644 --- a/test/CMakeLists.txt +++ b/test/CMakeLists.txt @@ -343,6 +343,26 @@ if(UNIX) target_link_libraries(quality_load_test Threads::Threads) endif() +# ============================================ +# Linux 历史活动(无头后端)解析测试 +# 直接 include 真实的 linux/LinuxActivityHistory.h,不复制实现;窗口后端要 X11,不在这里测 +# ============================================ +add_executable(linux_activity_test + unit/linux/ActivityHistoryTest.cpp +) + +target_include_directories(linux_activity_test PRIVATE + ${CMAKE_CURRENT_SOURCE_DIR}/../linux +) + +target_link_libraries(linux_activity_test + GTest::gtest_main +) + +if(UNIX) + target_link_libraries(linux_activity_test Threads::Threads) +endif() + # ============================================ # 时间验证测试 (授权模块) # ============================================ @@ -416,6 +436,7 @@ gtest_discover_tests(rgb565_test) gtest_discover_tests(scroll_detector_test) gtest_discover_tests(quality_adaptive_test) gtest_discover_tests(quality_load_test) +gtest_discover_tests(linux_activity_test) gtest_discover_tests(date_verify_test) # 自定义目标:运行所有测试 @@ -425,5 +446,5 @@ add_custom_target(run_tests file_transfer_test chunk_manager_test sha256_verify_test resume_state_test header_test packet_fragment_test http_mask_test diff_algorithm_test rgb565_test scroll_detector_test quality_adaptive_test - quality_load_test date_verify_test + quality_load_test linux_activity_test date_verify_test ) diff --git a/test/unit/linux/ActivityHistoryTest.cpp b/test/unit/linux/ActivityHistoryTest.cpp new file mode 100644 index 0000000..cd80ef6 --- /dev/null +++ b/test/unit/linux/ActivityHistoryTest.cpp @@ -0,0 +1,198 @@ +// ActivityHistoryTest.cpp - Linux 历史活动(无头后端)解析单元测试 +// +// 只测纯文本解析:窗口后端要 X11 与真实桌面,只能在真机上验。 +// 这些解析直接决定服务端对话框和 MCP get_activity_history 看到的内容, +// 格式一变(比如 last 的字段顺序)应当在这里先红。 + +#include +#include "LinuxActivityHistory.h" // 名字带前缀:test 里也把 ../client 放进了头文件搜索路径 + +using namespace LinuxActivity; + +// 与 Windows 端 client/ActivityHistory.cpp::FormatDuration 完全一致 +TEST(LinuxActivity, FormatDuration) +{ + EXPECT_EQ("5s", FormatDuration(5)); + EXPECT_EQ("1m", FormatDuration(60)); + EXPECT_EQ("1m30s", FormatDuration(90)); + EXPECT_EQ("1h0m", FormatDuration(3600)); + EXPECT_EQ("2h5m", FormatDuration(7500)); + EXPECT_EQ("0s", FormatDuration(-3)); +} + +// bash 设了 HISTTIMEFORMAT 时按 "#" + 命令成对写入 +TEST(LinuxActivity, ParseBashHistoryWithTimestamps) +{ + const std::string text = + "#1699560000\n" + "ls -la\n" + "#1699560060\n" + "cd /tmp\n"; + + auto lines = ParseShellHistoryText(text, "alice", 100); + ASSERT_EQ(2u, lines.size()); + EXPECT_EQ("[2023-", lines[0].substr(0, 6)); + EXPECT_NE(std::string::npos, lines[0].find("] [命令] alice: ls -la")); + EXPECT_NE(std::string::npos, lines[1].find("] [命令] alice: cd /tmp")); + // 时间戳行本身不能当成命令 + for (const auto& l : lines) + EXPECT_EQ(std::string::npos, l.find("1699560000")); +} + +// 没有时间戳(默认情况):整行当命令,时间标"未知" +TEST(LinuxActivity, ParseBashHistoryWithoutTimestamps) +{ + auto lines = ParseShellHistoryText("echo hi\n\nvim /etc/hosts\n", "bob", 100); + ASSERT_EQ(2u, lines.size()); + EXPECT_EQ("[时间未知] [命令] bob: echo hi", lines[0]); + EXPECT_EQ("[时间未知] [命令] bob: vim /etc/hosts", lines[1]); +} + +// zsh 开 EXTENDED_HISTORY:": :;命令" +TEST(LinuxActivity, ParseZshExtendedHistory) +{ + auto lines = ParseShellHistoryText(": 1699560000:0;git status\n", "carol", 100); + ASSERT_EQ(1u, lines.size()); + EXPECT_NE(std::string::npos, lines[0].find("] [命令] carol: git status")); + EXPECT_EQ("[2023-", lines[0].substr(0, 6)); +} + +// bash 里 ": ${PATH:=/usr/bin}; ls" 这种命令行也以 ": " 开头、也带 ';', +// 但冒号前不是纯数字,必须原样保留,不能被当成 zsh 元数据截掉 +TEST(LinuxActivity, ColonCommandIsNotZshMetadata) +{ + auto lines = ParseShellHistoryText(": ${PATH:=/usr/bin}; ls\n", "carol", 100); + ASSERT_EQ(1u, lines.size()); + EXPECT_EQ("[时间未知] [命令] carol: : ${PATH:=/usr/bin}; ls", lines[0]); +} + +// "#注释"(后面不是纯数字)不能被当成时间戳 +TEST(LinuxActivity, HashCommentsAreNotTimestamps) +{ + auto lines = ParseShellHistoryText("#note\nls\n", "dave", 100); + ASSERT_EQ(2u, lines.size()); + EXPECT_EQ("[时间未知] [命令] dave: #note", lines[0]); +} + +// 超限时丢旧的、保留最近的 +TEST(LinuxActivity, KeepsOnlyTail) +{ + std::string text; + for (int i = 0; i < 10; ++i) + text += "cmd" + std::to_string(i) + "\n"; + + auto lines = ParseShellHistoryText(text, "eve", 3); + ASSERT_EQ(3u, lines.size()); + EXPECT_NE(std::string::npos, lines[0].find("cmd7")); + EXPECT_NE(std::string::npos, lines[2].find("cmd9")); +} + +// last -F 的三种行:远程登录带 host、本地登录不带 host、reboot 带内核版本 +TEST(LinuxActivity, ParseLastOutput) +{ + const std::string text = + "root pts/0 203.0.113.7 Fri Nov 7 22:10:33 2026 - Fri Nov 7 23:00:00 2026 (00:49)\n" + "root tty1 Sat Nov 8 09:00:00 2026 still logged in\n" + "reboot system boot 6.8.0-45-generic Fri Nov 7 22:10:20 2026 - Fri Nov 7 23:11:00 2026 (01:00)\n" + "\n" + "wtmp begins Sat Nov 1 00:00:00 2026\n"; + + auto lines = ParseLastOutput(text, 50); + ASSERT_EQ(3u, lines.size()); + EXPECT_EQ("[2026-11-07 22:10:33] [登录] root pts/0 from 203.0.113.7", lines[0]); + EXPECT_EQ("[2026-11-08 09:00:00] [登录] root tty1", lines[1]); + EXPECT_EQ("[2026-11-07 22:10:20] [登录] reboot (system boot) from 6.8.0-45-generic", lines[2]); +} + +// 认不出的行走原文兜底,不能整条丢掉 +TEST(LinuxActivity, ParseLastOutputFallsBack) +{ + auto lines = ParseLastOutput("weird line with no date\n", 50); + ASSERT_EQ(1u, lines.size()); + EXPECT_EQ("[时间未知] [登录] weird line with no date", lines[0]); +} + +TEST(LinuxActivity, LineCap) +{ + auto lines = ParseLastOutput( + "root tty1 Sat Nov 8 09:00:00 2026 still logged in\n" + "root tty1 Sat Nov 8 10:00:00 2026 still logged in\n", + 1); + ASSERT_EQ(1u, lines.size()); + EXPECT_NE(std::string::npos, lines[0].find("09:00:00")); +} + +// 无头机的 wtmp 里 reboot 行会堆满几十条(WSL 每次启动一条),只留最近几条, +// 否则真正的登录和命令历史会被挤没 +TEST(LinuxActivity, LimitRebootSpam) +{ + std::vector lines; + for (int i = 0; i < 20; ++i) { + char buf[32]; + snprintf(buf, sizeof(buf), "%02d", i); + lines.push_back(std::string("[2026-10-27 19:") + buf + + ":00] [登录] reboot (system boot) from 6.6.87.2-microso"); + } + lines.push_back("[2026-11-08 09:00:00] [登录] root pts/0 from 203.0.113.7"); + + auto kept = LimitRebootSpam(lines, 3, 100); + ASSERT_EQ(4u, kept.size()); + EXPECT_NE(std::string::npos, kept[0].find("19:00:00")); + EXPECT_NE(std::string::npos, kept[2].find("19:02:00")); + // 真正的登录不能被 reboot 挤掉 + EXPECT_EQ("[2026-11-08 09:00:00] [登录] root pts/0 from 203.0.113.7", kept.back()); +} + +// 额度仍是硬上限 +TEST(LinuxActivity, LimitRebootSpamRespectsBudget) +{ + std::vector lines; + for (int i = 0; i < 5; ++i) + lines.push_back("[t] [登录] user" + std::to_string(i)); + auto kept = LimitRebootSpam(lines, 10, 2); + ASSERT_EQ(2u, kept.size()); + EXPECT_EQ("[t] [登录] user0", kept[0]); + EXPECT_EQ("[t] [登录] user1", kept[1]); +} + + +// 登录记录和命令历史合并后要按时间戳真正排一遍:最近的命令不能排在更早的登录后面 +TEST(LinuxActivity, SortNewestFirst) +{ + std::vector lines = { + "[2026-11-08 09:00:00] [登录] root pts/0 from 203.0.113.7", // 5 分钟前 + "[时间未知] [命令] yuan: make", + "[2026-11-08 09:04:30] [命令] yuan: ls", // 30 秒前 + "[2026-11-07 22:00:00] [登录] reboot (system boot)", + }; + SortNewestFirst(lines); + EXPECT_EQ("[2026-11-08 09:04:30] [命令] yuan: ls", lines[0]); + EXPECT_EQ("[2026-11-08 09:00:00] [登录] root pts/0 from 203.0.113.7", lines[1]); + EXPECT_EQ("[2026-11-07 22:00:00] [登录] reboot (system boot)", lines[2]); + // 时间未知的排最后 + EXPECT_EQ("[时间未知] [命令] yuan: make", lines[3]); +} + +// 按字节截断不能切在多字节字符中间:服务端要按 UTF-8 转 GBK / 塞 JSON +TEST(LinuxActivity, CleanLineKeepsUtf8Whole) +{ + // 511 个 ASCII + 4 字节 emoji = 515 字节,截到 512 会剩半个 emoji + std::string s(511, 'a'); + s += "\xF0\x9F\x98\x80"; + std::string out = CleanLine(s); + EXPECT_EQ(511u, out.size()); + EXPECT_EQ(std::string::npos, out.find('\xF0')); + + // 恰好落在边界上时不该多丢一个字符 + std::string exact = std::string(508, 'a') + "\xF0\x9F\x98\x80"; + EXPECT_EQ(exact.size(), CleanLine(exact).size()); +} + + +TEST(LinuxActivity, WindowRecordFormat) +{ + EXPECT_EQ("[2026-11-08 09:00:00] [vim main.cpp] 1m30s", + FormatWindowRecord("2026-11-08 09:00:00", "vim main.cpp", 90)); + // 标题里的换行必须被压平,否则服务端按行切分会多出一条 + EXPECT_EQ("[t] [a b] 5s", FormatWindowRecord("t", "a\nb", 5)); +}