Feature(Go): four local MCP read tools and a shared audit query package

Implement milestone M2 of the minimal MCP plan: the tools that answer from
the server's own state instead of opening a device channel.

- Extract the audit-log scanner from web into package auditquery so the
  admin page and get_audit_log share one implementation. The web handler
  keeps its 500-row cap, the MCP tool uses the protocol's 1000-row cap.
  Query gains json tags for the web snake_case wire format (device_id,
  warn_only) and reports TotalAll before filters.
- Add package buildinfo and inject Version/Commit with -X from build.ps1
  and the Makefile; go-winres refreshes Windows resources from the git tag
  when available. An unversioned build reports "", and only initialize
  substitutes "dev".
- list_hosts: online/offline pools, include_offline merge, every
  documented filter, limit/offset paging with total/totalAll/hasMore, and
  schema-named host fields (authStatus/tls/remark are never fabricated).
- get_host_detail: single id or a batch of up to 50, online lookup then
  the last history record, capabilities from protocol.SupportsCap plus the
  Windows/registry/virtual-desktop rules; v2 is not listed.
- get_server_status: version, uptime, online/offline counts, port and
  bind. sessions stays absent until the MCP session table lands in M3.
- get_audit_log: case-insensitive event substring, keyword, paging;
  hasMore turns false at the MaxOffset clamp so paging cannot loop.

Wire hub, history, audit path and listen address through mcp.Config from
cmd/main.go. Tests cover pools/filters/paging, capability bits, batch
failures, audit paging and the unversioned build.

Co-Authored-By: deepseek-flash
This commit is contained in:
yuanyuanxianganddeepseek-flash committed 2026-11-12 20:55:18 +01:00
1 parent 3f1957a9c9
commit 774c0d2545
16 files changed
+1952 -449

No files matched your search

+1
View File
@@ -95,6 +95,7 @@ server/go/web/assets/index.html
server/go/users.json
server/go/devices.json
server/go/build/
server/go/cmd/*.syso
server/go/.claude/settings.json
android/app/.cxx/
+36 -1
View File
@@ -74,8 +74,28 @@ function Build-GoServer {
} else {
Join-Path $binDir "YamaGo_x64.exe"
}
# Version/commit metadata injected into serverInfo and get_server_status.
# Empty when git is unavailable (source tarball, IDE build) — the server
# then reports no version rather than a fabricated one.
$gitVersion = ""
$gitCommit = ""
if (Get-Command git -ErrorAction SilentlyContinue) {
$gitVersion = (& git -C $rootDir describe --tags --always --dirty 2>$null | Select-Object -First 1)
if ($LASTEXITCODE -ne 0 -or -not $gitVersion) { $gitVersion = "" } else { $gitVersion = "$gitVersion".Trim() }
$gitCommit = (& git -C $rootDir rev-parse --short HEAD 2>$null | Select-Object -First 1)
if ($LASTEXITCODE -ne 0 -or -not $gitCommit) { $gitCommit = "" } else { $gitCommit = "$gitCommit".Trim() }
}
$buildinfoPkg = "github.com/yuanyuanxiang/SimpleRemoter/server/go/buildinfo"
$ldflagParts = @()
# Release strips debug info for smaller binary; Debug keeps symbols.
$ldflags = if ($Configuration -eq "Debug") { "" } else { "-s -w" }
if ($Configuration -ne "Debug") { $ldflagParts += @("-s", "-w") }
if ($gitVersion) { $ldflagParts += @("-X", "$buildinfoPkg.Version=$gitVersion") }
if ($gitCommit) { $ldflagParts += @("-X", "$buildinfoPkg.Commit=$gitCommit") }
$ldflags = $ldflagParts -join " "
if ($gitVersion) {
Write-Host "Version: $gitVersion ($gitCommit)" -ForegroundColor DarkGray
}
# Save the caller's Go env so a direct .\build.ps1 invocation does not
# leave GOOS=linux behind for later builds in the same shell.
@@ -90,6 +110,21 @@ function Build-GoServer {
# Cross-compiling for Linux requires a pure-Go build; the server has
# no cgo dependencies, so this is the normal configuration.
if ($TargetOS -eq "linux") { $env:CGO_ENABLED = "0" }
# Refresh the Windows resources before linking: go-winres rewrites the
# manifest identity, FileVersion and ProductVersion from the git tag so
# Explorer's file properties match the tag while the runtime version
# string stays the full `git describe` output. Missing go-winres or a
# non-git tree keeps the checked-in .syso files unchanged.
if ($TargetOS -eq "windows" -and $gitVersion) {
if (Get-Command go-winres -ErrorAction SilentlyContinue) {
& go-winres make --in cmd/winres/winres.json --out cmd/rsrc --product-version git-tag --file-version git-tag
if ($LASTEXITCODE -ne 0) {
Write-Host "WARNING: go-winres failed; keeping existing cmd/rsrc_*.syso" -ForegroundColor Yellow
}
} else {
Write-Host "WARNING: go-winres not found; version resources not refreshed (go install github.com/tc-hib/go-winres@latest)" -ForegroundColor Yellow
}
}
if ($ldflags) {
& go build -ldflags $ldflags -o $outFile ./cmd
} else {
+2 -1
View File
@@ -145,7 +145,8 @@
`totalAll` 是过滤前总数,`hasMore` 表示同一条件下还有下一页。
`hosts[]` 的字段按 `outputSchema`:`id/name/group/version/clientType/os/ip/rtt/activeWindow/
screen/online/last_seen`;hub 没有 `authStatus/tls/location/install_time/remark`,不出现。
screen/online/last_seen`,以及 hub 或历史记录里确有的 `location/install_time`;两个服务端都
没有 `authStatus/tls/remark`,不输出。离线历史条目不存 `clientType`,也没有 `rtt/activeWindow`。
#### `get_host_detail`
+2 -1
View File
@@ -196,7 +196,8 @@ curl -s -X POST localhost:18090/mcp -H "Authorization: Bearer $YAMA_MCP_TOKEN" \
- `list_hosts`:`hub.ListDevices()` + `history.Offline(onlineSet)` 合并;`include_offline`
决定是否并入历史;`online/ip/os/group/name/client_type/query` 全为过滤(`name`/`query`
大小写不敏感子串);按 `outputSchema` 返回 `{hosts,total,totalAll,limit,offset,hasMore}`,
host 字段按 schema 命名组装,hub 没有的(`authStatus/tls/location/install_time/remark`)不伪造。
host 字段按 schema 命名组装,hub/历史里确有的 `location/install_time/screen/version` 照填,
两边都没有的 `authStatus/tls/remark` 不伪造。
- `get_host_detail`:`id` 或 `ids`(≤50,批量走 `{tool,total,succeeded,failed,skipped,results[]}`);
`capabilities{screenPreview,screenRegion,windowInfo,fileTransferV2,c2cPaths,registry,remoteControl,platform}`
(`protocol.SupportsCap` 逐位)——**不含 `v2`**(恒真,列出来误导)。
+9 -2
View File
@@ -10,8 +10,15 @@ BUILD_DIR=build
# Main package path
MAIN_PACKAGE=./cmd
# Go build flags (strip debug info for smaller binary)
LDFLAGS=-ldflags "-s -w"
# Version metadata injected at link time (see buildinfo package). Both are
# empty outside a git checkout; the server then reports no version rather than
# a fabricated one.
VERSION := $(shell git describe --tags --always --dirty 2>nul)
COMMIT := $(shell git rev-parse --short HEAD 2>nul)
BUILDINFO_PKG = github.com/yuanyuanxiang/SimpleRemoter/server/go/buildinfo
# Go build flags (strip debug info for smaller binary; version always injected)
LDFLAGS=-ldflags "-s -w -X $(BUILDINFO_PKG).Version=$(VERSION) -X $(BUILDINFO_PKG).Commit=$(COMMIT)"
# Windows commands
MKDIR=if not exist $(BUILD_DIR) mkdir $(BUILD_DIR)
+287
View File
@@ -0,0 +1,287 @@
// Package auditquery scans the server's JSON-lines audit file.
//
// The server writes its own audit records to logs/audit.log (see
// logger.AuditAt); records are already redacted at write time, so returning
// raw fields to an authenticated viewer is safe as long as we never widen what
// is written.
//
// Only the CURRENT audit file is searched. Rotated files (audit-*.log[.gz])
// are deliberately out of scope: they need gzip support and a separate index,
// and both the web UI and the MCP tool exist for recent-window triage ("what
// happened just now").
//
// The package is shared by web/audit_query.go (admin audit page) and the MCP
// get_audit_log tool, which is why it has no dependency on either.
package auditquery
import (
"bufio"
"encoding/json"
"os"
"strings"
"time"
)
const (
// DefaultLimit is used when the caller asks for no limit (0 or negative).
DefaultLimit = 100
// MaxLimit caps how many records one query may return.
MaxLimit = 1000
// MaxOffset caps how far a query may page into the result set.
MaxOffset = 10000
// scanBudget bounds how much of the audit file a single query reads. The
// tail is read when the file is larger, so the newest records (what
// operators actually triage) are always covered and a multi-GB log cannot
// stall the query goroutine.
scanBudget = 32 << 20 // 32 MB
)
// Query is one audit-log search. All filters are optional and combined with
// AND. Limit/Offset are clamped by Scan; callers that report the effective
// values back should clamp first with ClampLimit/ClampOffset.
type Query struct {
From string `json:"from"` // RFC3339 ("2026-10-18T10:00:00Z"), optional
To string `json:"to"` // RFC3339, optional
Event string `json:"event"` // exact ("web.login.failure"), prefix ("web." / "web.*"), or ""
Actor string `json:"actor"` // exact, case-insensitive
IP string `json:"ip"` // exact
DeviceID string `json:"device_id"`
Keyword string `json:"keyword"` // case-insensitive substring of the raw record
WarnOnly bool `json:"warn_only"` // only level=warn records
// EventContains is a case-insensitive substring match on the event column.
// The web UI uses Event's exact/prefix forms; the MCP get_audit_log tool
// exposes a "type contains" filter, which maps here.
EventContains string `json:"event_contains"`
Limit int `json:"limit"`
Offset int `json:"offset"` // skip the newest N matching records
}
// Result is the outcome of scanning the audit file.
type Result struct {
Events []map[string]any // newest-first
Total int // matching records in the scanned window
TotalAll int // audit records in the scanned window before filters
FileExists bool
FileSize int64
ScannedBytes int64
Truncated bool // the file was larger than the scan budget
}
// ClampLimit bounds n to [1, max]. A non-positive n means DefaultLimit; a
// non-positive max means MaxLimit. Callers with a tighter UI cap (the web
// audit page uses 500) pass it as max.
func ClampLimit(n, max int) int {
if max <= 0 {
max = MaxLimit
}
if n <= 0 {
return DefaultLimit
}
if n > max {
return max
}
return n
}
// ClampOffset bounds n to [0, MaxOffset].
func ClampOffset(n int) int {
if n < 0 {
return 0
}
if n > MaxOffset {
return MaxOffset
}
return n
}
// Scan scans path for audit records matching q. The returned events are the
// newest Limit records after skipping Offset, in newest-first order. A missing
// file is not an error: no audit record has been written yet (the logger
// creates the file lazily), so the result is empty with FileExists=false.
func Scan(path string, q Query) (Result, error) {
q.Limit = ClampLimit(q.Limit, MaxLimit)
q.Offset = ClampOffset(q.Offset)
res := Result{Events: []map[string]any{}}
f, err := os.Open(path)
if err != nil {
if os.IsNotExist(err) {
return res, nil
}
return res, err
}
defer f.Close()
info, err := f.Stat()
if err != nil {
return res, err
}
res.FileExists = true
res.FileSize = info.Size()
// For very large files, scan only the tail; the newest matches live there.
start := int64(0)
if info.Size() > scanBudget {
start = info.Size() - scanBudget
if _, err := f.Seek(start, 0); err != nil {
return res, err
}
res.Truncated = true
}
from, hasFrom := parseTime(q.From)
to, hasTo := parseTime(q.To)
keep := q.Offset + q.Limit
ring := make([]map[string]any, keep)
filled := 0
sc := bufio.NewScanner(f)
// Sanitized values are capped at 4096 bytes each; a record with many
// fields stays well under 1 MB. Allow headroom rather than aborting the
// whole query on one long line.
sc.Buffer(make([]byte, 64*1024), 4*1024*1024)
first := true
for sc.Scan() {
line := sc.Text()
if start > 0 && first {
// Seeking into the middle of the file lands mid-line. Drop that
// partial record.
first = false
continue
}
first = false
res.ScannedBytes += int64(len(line)) + 1
line = strings.TrimSpace(line)
if line == "" {
continue
}
var rec map[string]any
if err := json.Unmarshal([]byte(line), &rec); err != nil {
continue // tolerate a torn line instead of failing the page
}
if _, ok := rec["event"].(string); !ok {
continue
}
// Only audit records belong in the result. The dedicated file contains
// nothing else, but a hand-edited or mixed file must not surface
// ordinary operational lines here.
if rec["audit"] != true {
continue
}
res.TotalAll++
if !recordMatches(rec, line, q, from, hasFrom, to, hasTo) {
continue
}
// Ring buffer of the last `keep` matches (file order is chronological).
ring[res.Total%keep] = rec
if filled < keep {
filled++
}
res.Total++
}
if err := sc.Err(); err != nil {
return res, err
}
// Newest first, skipping Offset. The match with 0-based index i lives at
// ring[i%keep] as long as i >= Total-filled.
for i := res.Total - 1 - q.Offset; i >= 0 && i >= res.Total-filled; i-- {
res.Events = append(res.Events, ring[i%keep])
if len(res.Events) >= q.Limit {
break
}
}
return res, nil
}
// recordMatches applies the non-time and time filters to one record. line is
// the raw JSON line, used for the keyword substring search.
func recordMatches(rec map[string]any, line string, q Query, from time.Time, hasFrom bool, to time.Time, hasTo bool) bool {
if q.Event != "" && !eventFilterMatches(q.Event, StringField(rec, "event")) {
return false
}
if q.EventContains != "" && !strings.Contains(strings.ToLower(StringField(rec, "event")), strings.ToLower(q.EventContains)) {
return false
}
if q.Actor != "" && !strings.EqualFold(StringField(rec, "actor"), q.Actor) {
return false
}
if q.IP != "" && StringField(rec, "ip") != q.IP {
return false
}
if q.DeviceID != "" && StringField(rec, "device_id") != q.DeviceID {
return false
}
if q.WarnOnly && StringField(rec, "level") != "warn" {
return false
}
if q.Keyword != "" && !strings.Contains(strings.ToLower(line), strings.ToLower(q.Keyword)) {
return false
}
if hasFrom || hasTo {
t, ok := parseTime(StringField(rec, "time"))
if !ok {
return false // cannot prove it is in range
}
if hasFrom && t.Before(from) {
return false
}
if hasTo && t.After(to) {
return false
}
}
return true
}
// eventFilterMatches supports three forms so the UI stays simple:
//
// "web.login.failure" exact
// "web.*" prefix (trailing "*")
// "web." prefix (trailing ".")
func eventFilterMatches(filter, event string) bool {
switch {
case strings.HasSuffix(filter, "*"):
return strings.HasPrefix(event, strings.TrimSuffix(filter, "*"))
case strings.HasSuffix(filter, "."):
return strings.HasPrefix(event, filter)
default:
return event == filter
}
}
// StringField returns rec[key] when it is a string, else "".
func StringField(rec map[string]any, key string) string {
s, _ := rec[key].(string)
return s
}
// parseTime accepts the formats operators and browsers realistically send.
// Layouts without an explicit zone are parsed as UTC; the frontend always sends
// Date.toISOString(), so the RFC3339 path is what production uses.
func parseTime(s string) (time.Time, bool) {
s = strings.TrimSpace(s)
if s == "" {
return time.Time{}, false
}
layouts := []string{
time.RFC3339Nano,
time.RFC3339,
"2006-01-02T15:04:05",
"2006-01-02T15:04",
"2006-01-02 15:04:05",
"2006-01-02",
}
for _, layout := range layouts {
if t, err := time.Parse(layout, s); err == nil {
return t, true
}
}
return time.Time{}, false
}
+248
View File
@@ -0,0 +1,248 @@
package auditquery
import (
"encoding/json"
"os"
"path/filepath"
"strings"
"testing"
"time"
)
// writeAuditFixture writes JSON-lines audit records (oldest first) and returns
// the file path. Times are UTC RFC3339 so the tests are timezone-independent.
func writeAuditFixture(t *testing.T, records []map[string]any) string {
t.Helper()
path := filepath.Join(t.TempDir(), "audit.log")
var b strings.Builder
for _, rec := range records {
line, err := json.Marshal(rec)
if err != nil {
t.Fatalf("marshal fixture: %v", err)
}
b.Write(line)
b.WriteByte('\n')
}
if err := os.WriteFile(path, []byte(b.String()), 0o644); err != nil {
t.Fatalf("write fixture: %v", err)
}
return path
}
func auditFixtureRecords() []map[string]any {
at := func(hhmm string) string {
tm, err := time.Parse("2006-01-02T15:04", "2026-10-18T"+hhmm)
if err != nil {
panic(err)
}
return tm.Format(time.RFC3339)
}
return []map[string]any{
{"level": "info", "time": at("10:00"), "audit": true, "event": "web.login.success", "actor": "admin", "ip": "203.0.113.1"},
{"level": "warn", "time": at("10:01"), "audit": true, "event": "web.login.failure", "actor": "alice", "ip": "203.0.113.2", "reason": "invalid_credentials"},
{"level": "info", "time": at("10:02"), "audit": true, "event": "remote.screen.start", "actor": "admin", "role": "admin", "ip": "203.0.113.1", "device_id": "dev1"},
{"level": "info", "time": at("10:03"), "audit": true, "event": "admin.user.delete", "actor": "admin", "ip": "203.0.113.1", "target": "bob"},
}
}
func runAuditQuery(t *testing.T, path string, q Query) Result {
t.Helper()
q.Limit = ClampLimit(q.Limit, MaxLimit)
q.Offset = ClampOffset(q.Offset)
res, err := Scan(path, q)
if err != nil {
t.Fatalf("Scan: %v", err)
}
return res
}
func eventNames(res Result) []string {
out := make([]string, 0, len(res.Events))
for _, e := range res.Events {
out = append(out, StringField(e, "event"))
}
return out
}
func TestNoFilterNewestFirst(t *testing.T) {
path := writeAuditFixture(t, auditFixtureRecords())
res := runAuditQuery(t, path, Query{Limit: 100})
if res.Total != 4 || len(res.Events) != 4 {
t.Fatalf("total=%d events=%d, want 4/4", res.Total, len(res.Events))
}
if res.TotalAll != 4 {
t.Fatalf("totalAll=%d, want 4", res.TotalAll)
}
got := eventNames(res)
want := []string{"admin.user.delete", "remote.screen.start", "web.login.failure", "web.login.success"}
if strings.Join(got, ",") != strings.Join(want, ",") {
t.Fatalf("events = %v, want %v", got, want)
}
}
func TestEventFilters(t *testing.T) {
path := writeAuditFixture(t, auditFixtureRecords())
cases := []struct {
filter string
want []string
}{
{"web.", []string{"web.login.failure", "web.login.success"}},
{"web.*", []string{"web.login.failure", "web.login.success"}},
{"web.login.failure", []string{"web.login.failure"}},
{"remote.*", []string{"remote.screen.start"}},
}
for _, tc := range cases {
res := runAuditQuery(t, path, Query{Event: tc.filter, Limit: 100})
got := eventNames(res)
if strings.Join(got, ",") != strings.Join(tc.want, ",") {
t.Errorf("filter %q → %v, want %v", tc.filter, got, tc.want)
}
}
}
func TestEventContainsFilter(t *testing.T) {
path := writeAuditFixture(t, auditFixtureRecords())
res := runAuditQuery(t, path, Query{EventContains: "LOGIN", Limit: 100})
got := eventNames(res)
want := []string{"web.login.failure", "web.login.success"}
if strings.Join(got, ",") != strings.Join(want, ",") {
t.Fatalf("events = %v, want %v", got, want)
}
// Filters run before paging: total reflects matches, totalAll the window.
if res.Total != 2 || res.TotalAll != 4 {
t.Fatalf("total=%d totalAll=%d, want 2/4", res.Total, res.TotalAll)
}
}
func TestFieldFilters(t *testing.T) {
path := writeAuditFixture(t, auditFixtureRecords())
from, _ := time.Parse(time.RFC3339, "2026-10-18T10:01:00Z")
to, _ := time.Parse(time.RFC3339, "2026-10-18T10:02:00Z")
cases := []struct {
name string
q Query
want []string
}{
{"actor case-insensitive", Query{Actor: "ALICE", Limit: 100}, []string{"web.login.failure"}},
{"ip", Query{IP: "203.0.113.2", Limit: 100}, []string{"web.login.failure"}},
{"device", Query{DeviceID: "dev1", Limit: 100}, []string{"remote.screen.start"}},
{"warn only", Query{WarnOnly: true, Limit: 100}, []string{"web.login.failure"}},
{"keyword target", Query{Keyword: "BOB", Limit: 100}, []string{"admin.user.delete"}},
{"time range", Query{
From: from.Format(time.RFC3339), To: to.Format(time.RFC3339), Limit: 100,
}, []string{"remote.screen.start", "web.login.failure"}},
}
for _, tc := range cases {
res := runAuditQuery(t, path, tc.q)
got := eventNames(res)
if strings.Join(got, ",") != strings.Join(tc.want, ",") {
t.Errorf("%s → %v, want %v", tc.name, got, tc.want)
}
}
}
func TestOffsetAndLimit(t *testing.T) {
path := writeAuditFixture(t, auditFixtureRecords())
res := runAuditQuery(t, path, Query{Limit: 2, Offset: 1})
if res.Total != 4 {
t.Fatalf("total = %d, want 4", res.Total)
}
got := eventNames(res)
want := []string{"remote.screen.start", "web.login.failure"}
if strings.Join(got, ",") != strings.Join(want, ",") {
t.Fatalf("events = %v, want %v", got, want)
}
// Offsetting past the end yields no events but keeps the total.
res = runAuditQuery(t, path, Query{Limit: 2, Offset: 4})
if res.Total != 4 || len(res.Events) != 0 {
t.Fatalf("offset past end: total=%d events=%v", res.Total, eventNames(res))
}
}
func TestSkipsNonAuditAndTornLines(t *testing.T) {
path := filepath.Join(t.TempDir(), "audit.log")
content := `{"event":"device.online","actor":"x"}
not json at all
{"level":"info","time":"2026-10-18T10:00:00Z","audit":true,"event":"web.login.success","actor":"admin"}`
if err := os.WriteFile(path, []byte(content), 0o644); err != nil {
t.Fatal(err)
}
res := runAuditQuery(t, path, Query{Limit: 100})
if res.Total != 1 || len(res.Events) != 1 {
t.Fatalf("total=%d events=%v, want the single valid record", res.Total, eventNames(res))
}
// Non-audit and torn lines do not count toward totalAll either.
if res.TotalAll != 1 {
t.Fatalf("totalAll=%d, want 1", res.TotalAll)
}
}
func TestMissingFile(t *testing.T) {
res := runAuditQuery(t, filepath.Join(t.TempDir(), "does-not-exist.log"), Query{Limit: 10})
if res.FileExists {
t.Error("FileExists = true for a missing file")
}
if res.Total != 0 || len(res.Events) != 0 {
t.Errorf("total=%d events=%v, want empty", res.Total, eventNames(res))
}
if res.Events == nil {
t.Error("Events is nil; JSON would encode null instead of []")
}
}
func TestClampsPaging(t *testing.T) {
if got := ClampLimit(0, MaxLimit); got != DefaultLimit {
t.Errorf("limit(0) = %d, want default %d", got, DefaultLimit)
}
if got := ClampLimit(-3, MaxLimit); got != DefaultLimit {
t.Errorf("limit(-3) = %d, want default %d", got, DefaultLimit)
}
if got := ClampLimit(9999, MaxLimit); got != MaxLimit {
t.Errorf("limit(9999) = %d, want max %d", got, MaxLimit)
}
if got := ClampLimit(9999, 500); got != 500 {
t.Errorf("limit(9999, max 500) = %d, want 500", got)
}
if got := ClampLimit(50, MaxLimit); got != 50 {
t.Errorf("limit(50) = %d, want 50", got)
}
if got := ClampLimit(0, 0); got != DefaultLimit {
t.Errorf("limit(0, max 0) = %d, want default %d", got, DefaultLimit)
}
if got := ClampOffset(-5); got != 0 {
t.Errorf("offset(-5) = %d, want 0", got)
}
if got := ClampOffset(1 << 30); got != MaxOffset {
t.Errorf("offset(huge) = %d, want max %d", got, MaxOffset)
}
}
// The web audit page sends snake_case keys. Query is decoded from that wire
// format in web/audit_query.go, so the tags must keep those names — otherwise
// device_id / warn_only silently stop filtering.
func TestQueryDecodesWebWireFormat(t *testing.T) {
body := `{"from":"2026-11-01T00:00:00Z","to":"2026-11-12T00:00:00Z",` +
`"event":"web.","actor":"admin","ip":"1.2.3.4","device_id":"1001",` +
`"keyword":"k","warn_only":true,"limit":5,"offset":2}`
var q Query
if err := json.Unmarshal([]byte(body), &q); err != nil {
t.Fatalf("unmarshal: %v", err)
}
if q.From != "2026-11-01T00:00:00Z" || q.To != "2026-11-12T00:00:00Z" {
t.Fatalf("time range = %q..%q", q.From, q.To)
}
if q.Event != "web." || q.Actor != "admin" || q.IP != "1.2.3.4" {
t.Fatalf("filters = %+v", q)
}
if q.DeviceID != "1001" {
t.Fatalf("device_id = %q, want 1001", q.DeviceID)
}
if q.Keyword != "k" || !q.WarnOnly {
t.Fatalf("keyword/warn_only = %q/%v", q.Keyword, q.WarnOnly)
}
if q.Limit != 5 || q.Offset != 2 {
t.Fatalf("limit/offset = %d/%d", q.Limit, q.Offset)
}
}
+31
View File
@@ -0,0 +1,31 @@
// Package buildinfo exposes the version metadata injected at link time.
//
// Version and Commit are set by the build scripts with
//
// go build -ldflags "-X github.com/yuanyuanxiang/SimpleRemoter/server/go/buildinfo.Version=... \
// -X github.com/yuanyuanxiang/SimpleRemoter/server/go/buildinfo.Commit=..."
//
// They stay empty when the binary is built without git (source tarball, IDE
// run). Callers must report the empty string rather than inventing a value;
// only the MCP initialize response substitutes a literal "dev" marker.
package buildinfo
var (
// Version is the full `git describe --tags --always --dirty` string, e.g.
// "v1.4.2-72-g425d737-dirty".
Version = ""
// Commit is the short commit hash, e.g. "425d737".
Commit = ""
)
// Info is a JSON-friendly snapshot of the injected metadata.
type Info struct {
Version string `json:"version"`
Commit string `json:"commit"`
}
// Snapshot returns the current build metadata. It is safe to call before the
// values are injected (both fields are empty).
func Snapshot() Info {
return Info{Version: Version, Commit: Commit}
}
+14 -3
View File
@@ -17,6 +17,7 @@ import (
"time"
"github.com/yuanyuanxiang/SimpleRemoter/server/go/auth"
"github.com/yuanyuanxiang/SimpleRemoter/server/go/buildinfo"
"github.com/yuanyuanxiang/SimpleRemoter/server/go/connection"
"github.com/yuanyuanxiang/SimpleRemoter/server/go/devicehistory"
"github.com/yuanyuanxiang/SimpleRemoter/server/go/hub"
@@ -1302,20 +1303,30 @@ func main() {
// MCP endpoint: a static bearer token independent of the web login. An
// empty YAMA_MCP_TOKEN leaves /mcp unregistered (404) — there is no
// auto-generated token, because a secret that only appears in a log is not
// a secret. Version wiring arrives with the buildinfo package; until then
// initialize reports "dev".
// a secret. Version/commit come from the link-time buildinfo injection.
mcpReadonly := envBool("YAMA_MCP_READONLY")
bindAddr := ""
if *httpPort != 0 {
bindAddr = "0.0.0.0" // web server listens on :port (all interfaces)
}
mcpSrv := mcp.New(mcp.Config{
Token: strings.TrimSpace(os.Getenv("YAMA_MCP_TOKEN")),
Readonly: mcpReadonly,
TermIdle: time.Duration(envInt("YAMA_MCP_TERM_IDLE", 180)) * time.Second,
MaxConcurrency: envInt("YAMA_MCP_MAX_CONCURRENCY", 16),
ReadMax: int64(envInt("YAMA_MCP_READ_MAX", 2<<20)),
Version: buildinfo.Version,
StartedAt: time.Now(),
Log: log.WithPrefix("MCP"),
Hub: deviceHub,
History: deviceHistory,
AuditPath: auditFile,
Port: *httpPort,
Bind: bindAddr,
})
if mcpSrv.Enabled() {
log.Info("MCP endpoint enabled on /mcp (readonly=%v)", mcpReadonly)
log.Info("MCP endpoint enabled on /mcp (readonly=%v, commit=%s)",
mcpReadonly, buildinfo.Commit)
}
// Start HTTP server for web UI. Hub gives it read-only access to the
+25 -5
View File
@@ -11,6 +11,8 @@ import (
"strings"
"time"
"github.com/yuanyuanxiang/SimpleRemoter/server/go/devicehistory"
"github.com/yuanyuanxiang/SimpleRemoter/server/go/hub"
"github.com/yuanyuanxiang/SimpleRemoter/server/go/logger"
)
@@ -39,6 +41,15 @@ type Config struct {
Version string // serverInfo.version
StartedAt time.Time // reported by get_server_status
Log *logger.Logger
// Server-side state the local read tools answer from. A nil Hub means the
// endpoint was built without a device registry: the host tools then fail
// with -32000 instead of reporting an empty (and misleading) list.
Hub *hub.Hub
History *devicehistory.Store // nil: no offline history to merge
AuditPath string // "" = audit file disabled (YAMA_AUDIT_LOG=off)
Port int // web/MCP listening port, for get_server_status
Bind string // listening address, for get_server_status
}
// toolFunc implements one tools/call. It returns either a result value or a
@@ -69,18 +80,21 @@ func New(cfg Config) *Server {
if cfg.StartedAt.IsZero() {
cfg.StartedAt = time.Now()
}
if cfg.Version == "" {
cfg.Version = "dev"
}
// Version is left exactly as injected: it may be empty in a build without
// git/ldflags. The initialize response substitutes "dev" for such builds;
// get_server_status reports the empty string rather than inventing a
// version (design §3.2).
if cfg.Log == nil {
cfg.Log = logger.New(logger.Config{Level: logger.LevelError})
}
return &Server{
s := &Server{
cfg: cfg,
log: cfg.Log,
tools: buildToolSet(toolsJSON),
handlers: make(map[string]toolFunc),
}
s.registerLocalTools()
return s
}
// Enabled reports whether /mcp should be registered. An empty token disables
@@ -203,10 +217,16 @@ type initializeResult struct {
// serverInfo.name ("yama") so clients do not special-case the Go backend.
// Differences are stated in instructions, which models read.
func (s *Server) initializeResult() initializeResult {
// "dev" is a serverInfo-only marker for an unversioned build; the status
// tool keeps the raw (empty) value.
version := s.cfg.Version
if version == "" {
version = "dev"
}
return initializeResult{
ProtocolVersion: protocolVersion,
Capabilities: serverCapabilities{Tools: toolsCapability{ListChanged: false}},
ServerInfo: serverInfo{Name: "yama", Version: s.cfg.Version},
ServerInfo: serverInfo{Name: "yama", Version: version},
Instructions: serverInstructions,
}
}
+3 -1
View File
@@ -370,7 +370,9 @@ func TestToolsCallGates(t *testing.T) {
code: CodeInvalidParams,
},
{
name: "known but not implemented in M1",
// testServer has no hub: the handler exists (M2) and must fail
// loudly rather than report an empty device list.
name: "local tool without device registry",
srv: s,
body: `{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"list_hosts"}}`,
code: CodeInternal,
+590
View File
@@ -0,0 +1,590 @@
package mcp
import (
"context"
"encoding/json"
"fmt"
"strconv"
"strings"
"time"
"github.com/yuanyuanxiang/SimpleRemoter/server/go/auditquery"
"github.com/yuanyuanxiang/SimpleRemoter/server/go/hub"
"github.com/yuanyuanxiang/SimpleRemoter/server/go/protocol"
)
// Local read tools: they answer from the server's own state (device hub,
// device history, audit file) and never open a channel to a client. The
// remote tools (screenshot, files, terminal) live in later milestones.
const (
// Page size bounds shared by list_hosts and get_audit_log, matching the
// tool descriptions in mcp/tools.json.
listDefaultLimit = 100
listMaxLimit = 1000
// batchMaxIDs is the per-call cap for get_host_detail.ids, matching the
// Win32 server.
batchMaxIDs = 50
)
// toolResult is the MCP tools/call success envelope, byte-compatible with the
// Win32 server: one text item plus structuredContent. Failures are JSON-RPC
// error objects at the top level, not isError results.
type toolResult struct {
Content []contentItem `json:"content"`
StructuredContent any `json:"structuredContent"`
IsError bool `json:"isError"`
}
type contentItem struct {
Type string `json:"type"`
Text string `json:"text"`
}
func newToolResult(text string, structured any) toolResult {
return toolResult{
Content: []contentItem{{Type: "text", Text: text}},
StructuredContent: structured,
IsError: false,
}
}
func (s *Server) registerLocalTools() {
s.handlers["list_hosts"] = s.callListHosts
s.handlers["get_host_detail"] = s.callGetHostDetail
s.handlers["get_server_status"] = s.callGetServerStatus
s.handlers["get_audit_log"] = s.callGetAuditLog
}
// decodeArgs unmarshals tools/call arguments into v. An absent/null arguments
// object leaves v at its zero value, which is valid for the all-optional tools.
func decodeArgs(raw json.RawMessage, v any) *rpcError {
if len(raw) == 0 || string(raw) == "null" {
return nil
}
if err := json.Unmarshal(raw, v); err != nil {
return errf(CodeInvalidParams, "invalid arguments: %v", err)
}
return nil
}
// ----- list_hosts -----------------------------------------------------------
type listHostsArgs struct {
ClientType string `json:"client_type"`
Group string `json:"group"`
IncludeOffline *bool `json:"include_offline"`
IP string `json:"ip"`
Limit int `json:"limit"`
Name string `json:"name"`
Offset int `json:"offset"`
Online *bool `json:"online"`
OS string `json:"os"`
Query string `json:"query"`
}
func (s *Server) callListHosts(_ context.Context, raw json.RawMessage) (any, *rpcError) {
if s.cfg.Hub == nil {
return nil, errf(CodeInternal, "server device registry is not configured")
}
var args listHostsArgs
if rerr := decodeArgs(raw, &args); rerr != nil {
return nil, rerr
}
// online defaults to true (only online hosts). online=false means "only
// offline"; include_offline=true merges history behind the online hosts.
online := true
if args.Online != nil {
online = *args.Online
}
includeOffline := args.IncludeOffline != nil && *args.IncludeOffline
onlineDevices := s.cfg.Hub.ListDevices()
onlineSet := make(map[string]struct{}, len(onlineDevices))
for _, d := range onlineDevices {
onlineSet[d.ID] = struct{}{}
}
offlineDevices := s.offlineDevices(onlineSet)
var pool []hub.DeviceInfo
switch {
case !online:
pool = offlineDevices
case includeOffline:
pool = make([]hub.DeviceInfo, 0, len(onlineDevices)+len(offlineDevices))
pool = append(pool, onlineDevices...)
pool = append(pool, offlineDevices...)
default:
pool = onlineDevices
}
totalAll := len(pool)
// All filters are optional, ANDed, and substring matches. ASCII case
// folding is what the tool description promises; strings.ToLower is a
// superset and cannot change an ASCII-only match.
q := strings.ToLower(args.Query)
nameF := strings.ToLower(args.Name)
ipF := strings.ToLower(args.IP)
groupF := strings.ToLower(args.Group)
osF := strings.ToLower(args.OS)
ctF := strings.ToLower(args.ClientType)
matched := make([]hub.DeviceInfo, 0, len(pool))
for _, d := range pool {
group := d.Group
if group == "" {
group = "default"
}
ip := d.IP
if ip == "" {
ip = d.PeerIP
}
clientType := ""
if d.Online {
clientType = s.clientType(d.ID)
}
// query matches computer name, remark and IP. The two servers keep no
// remark column, so name+IP is the full set here.
if q != "" && !strings.Contains(strings.ToLower(d.Name), q) && !strings.Contains(strings.ToLower(ip), q) {
continue
}
if nameF != "" && !strings.Contains(strings.ToLower(d.Name), nameF) {
continue
}
if ipF != "" && !strings.Contains(strings.ToLower(ip), ipF) {
continue
}
if groupF != "" && !strings.Contains(strings.ToLower(group), groupF) {
continue
}
if osF != "" && !strings.Contains(strings.ToLower(d.OS), osF) {
continue
}
if ctF != "" && !strings.Contains(strings.ToLower(clientType), ctF) {
continue
}
matched = append(matched, d)
}
limit := clampPageLimit(args.Limit)
offset := max(args.Offset, 0)
total := len(matched)
begin := min(offset, total)
end := min(begin+limit, total)
hosts := make([]map[string]any, 0, end-begin)
for _, d := range matched[begin:end] {
hosts = append(hosts, s.hostJSON(d))
}
structured := map[string]any{
"hosts": hosts,
"total": total,
"totalAll": totalAll,
"limit": limit,
"offset": offset,
"hasMore": end < total,
}
text := pageSummary(total, limit, offset, "台主机")
if total != totalAll {
text += fmt.Sprintf("过滤前共 %d 台。", totalAll)
}
return newToolResult(text, structured), nil
}
// hostJSON projects a hub device onto the list_hosts/get_host_detail schema.
// Fields the Go server does not know (authStatus, tls, remark, clientType of
// an offline entry) are omitted rather than fabricated.
func (s *Server) hostJSON(d hub.DeviceInfo) map[string]any {
group := d.Group
if group == "" {
group = "default"
}
h := map[string]any{
"id": d.ID,
"name": d.Name,
"group": group,
"online": d.Online,
}
if d.Version != "" {
h["version"] = d.Version
}
if d.OS != "" {
h["os"] = d.OS
}
ip := d.IP
if ip == "" {
ip = d.PeerIP
}
if ip != "" {
h["ip"] = ip
}
if d.Location != "" {
h["location"] = d.Location
}
if d.InstallTime != "" {
h["install_time"] = d.InstallTime
}
if d.Screen != "" {
h["screen"] = d.Screen
}
if d.Online {
// RTT 0 means "no heartbeat yet", not "zero latency".
if d.RTT > 0 {
h["rtt"] = strconv.Itoa(d.RTT)
}
if d.ActiveWindow != "" {
h["activeWindow"] = d.ActiveWindow
}
if ct := s.clientType(d.ID); ct != "" {
h["clientType"] = ct
}
} else if d.LastSeen > 0 {
h["last_seen"] = time.Unix(d.LastSeen, 0).Format("2006-01-02 15:04:05")
}
return h
}
// clientType reads the RES_CLIENT_TYPE the client reported at login. It lives
// on the main connection's ClientInfo, not on the hub's Device projection.
func (s *Server) clientType(deviceID string) string {
if s.cfg.Hub == nil {
return ""
}
if ctx := s.cfg.Hub.MainConn(deviceID); ctx != nil {
return ctx.GetInfo().ClientType
}
return ""
}
// offlineDevices returns history entries that are not currently online. A nil
// history store (server started without persistence) yields no entries.
func (s *Server) offlineDevices(online map[string]struct{}) []hub.DeviceInfo {
if s.cfg.History == nil {
return nil
}
return s.cfg.History.Offline(online)
}
// ----- get_host_detail ------------------------------------------------------
type getHostDetailArgs struct {
ID string `json:"id"`
IDs []string `json:"ids"`
}
func (s *Server) callGetHostDetail(_ context.Context, raw json.RawMessage) (any, *rpcError) {
if s.cfg.Hub == nil {
return nil, errf(CodeInternal, "server device registry is not configured")
}
var args getHostDetailArgs
if rerr := decodeArgs(raw, &args); rerr != nil {
return nil, rerr
}
if len(args.IDs) > 0 {
return s.hostDetailBatch(args.IDs)
}
if args.ID == "" {
return nil, errf(CodeInvalidParams, "Missing required parameter: id or ids")
}
online, offline := s.hostMaps()
host, rerr := s.lookupHost(args.ID, online, offline)
if rerr != nil {
return nil, rerr
}
return newToolResult(hostSummary(host), map[string]any{"host": host}), nil
}
func (s *Server) hostDetailBatch(ids []string) (any, *rpcError) {
if len(ids) > batchMaxIDs {
return nil, errf(CodeInvalidParams,
"Too many ids: %d (max %d per batch)", len(ids), batchMaxIDs)
}
online, offline := s.hostMaps()
results := make([]map[string]any, 0, len(ids))
succeeded, failed := 0, 0
for _, id := range ids {
host, rerr := s.lookupHost(id, online, offline)
if rerr != nil {
results = append(results, map[string]any{
"id": id,
"ok": false,
"text": rerr.Message,
"error": map[string]any{"code": rerr.Code, "message": rerr.Message},
})
failed++
continue
}
results = append(results, map[string]any{
"id": id,
"ok": true,
"text": hostSummary(host),
"data": map[string]any{"host": host},
})
succeeded++
}
structured := map[string]any{
"tool": "get_host_detail",
"total": len(ids),
"succeeded": succeeded,
"failed": failed,
"skipped": 0, // no batch deadline: every id is answered locally
"results": results,
}
text := fmt.Sprintf("批量调用 get_host_detail:共 %d 台,成功 %d 台,失败 %d 台。",
len(ids), succeeded, failed)
return newToolResult(text, structured), nil
}
// hostMaps indexes the online devices and offline history by ID. Building both
// once per call keeps a 50-id batch at one hub snapshot instead of 50.
func (s *Server) hostMaps() (online, offline map[string]hub.DeviceInfo) {
onlineDevices := s.cfg.Hub.ListDevices()
online = make(map[string]hub.DeviceInfo, len(onlineDevices))
onlineSet := make(map[string]struct{}, len(onlineDevices))
for _, d := range onlineDevices {
online[d.ID] = d
onlineSet[d.ID] = struct{}{}
}
offlineDevices := s.offlineDevices(onlineSet)
offline = make(map[string]hub.DeviceInfo, len(offlineDevices))
for _, d := range offlineDevices {
offline[d.ID] = d
}
return online, offline
}
// lookupHost resolves one host: online first, then the last-known history
// record. It mirrors the Win32 server, which answers offline hosts with their
// final snapshot instead of an error.
func (s *Server) lookupHost(id string, online, offline map[string]hub.DeviceInfo) (map[string]any, *rpcError) {
if !isDecimalID(id) {
return nil, errf(CodeInvalidParams, "Invalid id: expected a decimal host id string")
}
if d, ok := online[id]; ok {
h := s.hostJSON(d)
h["capabilities"] = s.capabilities(d)
return h, nil
}
if d, ok := offline[id]; ok {
return s.hostJSON(d), nil
}
return nil, errf(CodeOffline, "Host not found or offline: %s", id)
}
// capabilities answers "what can this host do" from the capability hex string
// the client reported at login. v2 is deliberately absent: CLIENT_CAP_V2 is
// set by every platform, so listing it would only mislead.
func (s *Server) capabilities(d hub.DeviceInfo) map[string]any {
platform := s.clientType(d.ID)
windows := platform != "LNX" && platform != "MAC" && platform != "APK"
monitors := monitorCount(d.Screen)
// Multi-monitor Windows needs whole-virtual-desktop capture for the
// observed and injected coordinate spaces to line up; monitorCount 0
// means the client did not report the "N:W*H" form (legacy) and passes,
// matching the Win32 server's remote_open gate.
virtualDesktopOK := monitors <= 1 || !windows ||
protocol.SupportsCap(d.Capability, protocol.ClientCapVirtualDesktop)
caps := map[string]any{
"screenPreview": protocol.SupportsCap(d.Capability, protocol.ClientCapScreenPreview),
"screenRegion": protocol.SupportsCap(d.Capability, protocol.ClientCapScreenRegion),
"windowInfo": protocol.SupportsCap(d.Capability, protocol.ClientCapWindowInfo),
"fileTransferV2": protocol.SupportsCap(d.Capability, protocol.ClientCapV2),
"c2cPaths": protocol.SupportsCap(d.Capability, protocol.ClientCapC2CPaths),
"registry": windows,
"remoteControl": (windows || platform == "LNX" || platform == "APK") && virtualDesktopOK,
}
if platform != "" {
caps["platform"] = platform
}
return caps
}
// hostSummary is the human-readable text item for one host.
func hostSummary(h map[string]any) string {
name, _ := h["name"].(string)
ip, _ := h["ip"].(string)
if online, _ := h["online"].(bool); !online {
return fmt.Sprintf("主机 %s (%s) 当前离线,以下为其最后一次登录时的记录。", name, ip)
}
return fmt.Sprintf("主机 %s (%s) 的详情。", name, ip)
}
// ----- get_server_status ----------------------------------------------------
func (s *Server) callGetServerStatus(_ context.Context, _ json.RawMessage) (any, *rpcError) {
uptime := max(int64(time.Since(s.cfg.StartedAt).Seconds()), 0)
status := map[string]any{
"version": s.cfg.Version,
"uptime_sec": uptime,
}
text := fmt.Sprintf("YAMA Go 服务端已运行 %d 秒", uptime)
if s.cfg.Version != "" {
text = fmt.Sprintf("YAMA Go 服务端 %s 已运行 %d 秒", s.cfg.Version, uptime)
}
if s.cfg.Hub != nil {
onlineDevices := s.cfg.Hub.ListDevices()
onlineSet := make(map[string]struct{}, len(onlineDevices))
for _, d := range onlineDevices {
onlineSet[d.ID] = struct{}{}
}
offline := len(s.offlineDevices(onlineSet))
status["hosts"] = map[string]any{"online": len(onlineDevices), "offline": offline}
text += fmt.Sprintf(";在线 %d 台,离线 %d 台", len(onlineDevices), offline)
}
// MCP is mounted on the web server, so its listening address is the web
// server's. Port/bind stay absent when the caller did not provide them.
if s.cfg.Port > 0 {
status["port"] = s.cfg.Port
}
if s.cfg.Bind != "" {
status["bind"] = s.cfg.Bind
text += ",监听 " + s.cfg.Bind
}
// The status fields are flat in structuredContent (the outputSchema has no
// "status" wrapper object).
return newToolResult(text+"。", status), nil
}
// ----- get_audit_log --------------------------------------------------------
type getAuditLogArgs struct {
Keyword string `json:"keyword"`
Limit int `json:"limit"`
Offset int `json:"offset"`
Type string `json:"type"`
}
func (s *Server) callGetAuditLog(_ context.Context, raw json.RawMessage) (any, *rpcError) {
if s.cfg.AuditPath == "" {
return nil, errf(CodeInternal,
"audit log file is disabled on this server (YAMA_AUDIT_LOG=off)")
}
var args getAuditLogArgs
if rerr := decodeArgs(raw, &args); rerr != nil {
return nil, rerr
}
q := auditquery.Query{
Keyword: args.Keyword,
// The tool's "type" column is a case-insensitive substring of the
// event name; the web UI's exact/prefix Event filter does not fit.
EventContains: args.Type,
}
q.Limit = auditquery.ClampLimit(args.Limit, auditquery.MaxLimit)
q.Offset = auditquery.ClampOffset(args.Offset)
res, err := auditquery.Scan(s.cfg.AuditPath, q)
if err != nil {
return nil, errf(CodeInternal, "failed to read audit log: %v", err)
}
entries := make([]map[string]any, 0, len(res.Events))
for _, rec := range res.Events {
entries = append(entries, map[string]any{
"type": auditquery.StringField(rec, "event"),
"time": auditquery.StringField(rec, "time"),
"msg": auditMessage(rec),
})
}
// Scan caps Offset at auditquery.MaxOffset, so a page that reaches that
// point must not advertise a next page: the follow-up offset would be
// clamped back and return the same records forever.
reached := q.Offset + len(entries)
structured := map[string]any{
"entries": entries,
"total": res.Total,
"totalAll": res.TotalAll,
"limit": q.Limit,
"offset": q.Offset,
"hasMore": reached < res.Total && reached < auditquery.MaxOffset,
}
text := pageSummary(res.Total, q.Limit, q.Offset, "条日志")
if res.Total != res.TotalAll {
text += fmt.Sprintf("过滤前共 %d 条。", res.TotalAll)
}
if res.Truncated {
text += "(审计文件较大,仅扫描最近 32 MB。)"
}
return newToolResult(text, structured), nil
}
// auditMessage renders the non-envelope fields as compact JSON. The web audit
// page shows the raw record; the MCP entry has dedicated type/time columns, so
// repeating them inside msg would only add noise.
func auditMessage(rec map[string]any) string {
rest := make(map[string]any, len(rec))
for k, v := range rec {
switch k {
case "audit", "level", "time", "event":
continue
}
rest[k] = v
}
if len(rest) == 0 {
return ""
}
b, err := json.Marshal(rest)
if err != nil {
return ""
}
return string(b)
}
// ----- shared helpers -------------------------------------------------------
func clampPageLimit(n int) int {
if n <= 0 {
return listDefaultLimit
}
if n > listMaxLimit {
return listMaxLimit
}
return n
}
// pageSummary mirrors the Win32 server's summary line:
// 「共 N 台主机,本次返回第 1-100 条(还有更多,可用 offset 继续取)。」
func pageSummary(total, limit, offset int, unit string) string {
out := fmt.Sprintf("共 %d %s", total, unit)
if total == 0 {
return out + "。"
}
begin := min(offset, total)
if begin >= total {
return out + ",offset 超出范围,本次返回 0 条。"
}
end := min(begin+limit, total)
out += fmt.Sprintf(",本次返回第 %d-%d 条", begin+1, end)
if end < total {
out += "(还有更多,可用 offset 继续取)"
}
return out + "。"
}
// isDecimalID reports whether id is a non-empty decimal string. Host IDs are
// uint64 rendered in decimal; anything else is a caller mistake.
func isDecimalID(id string) bool {
if id == "" {
return false
}
for _, r := range id {
if r < '0' || r > '9' {
return false
}
}
return true
}
// monitorCount parses the "N:W*H" screen string the client reports. 0 means
// "not reported / not in that form".
func monitorCount(screen string) int {
i := strings.IndexByte(screen, ':')
if i <= 0 {
return 0
}
n, err := strconv.Atoi(strings.TrimSpace(screen[:i]))
if err != nil || n < 0 {
return 0
}
return n
}
+679
View File
@@ -0,0 +1,679 @@
package mcp
import (
"context"
"encoding/json"
"fmt"
"os"
"path/filepath"
"strings"
"testing"
"time"
"github.com/yuanyuanxiang/SimpleRemoter/server/go/auditquery"
"github.com/yuanyuanxiang/SimpleRemoter/server/go/connection"
"github.com/yuanyuanxiang/SimpleRemoter/server/go/devicehistory"
"github.com/yuanyuanxiang/SimpleRemoter/server/go/hub"
)
// localFixture is the shared setup for the four local read tools: three online
// hosts (two Windows in one group, one Linux), two offline history entries, and
// a history store that is subscribed to the hub.
type localFixture struct {
srv *Server
hub *hub.Hub
hist *devicehistory.Store
}
func newLocalFixture(t *testing.T) *localFixture {
t.Helper()
h := hub.New()
hist, err := devicehistory.Open(filepath.Join(t.TempDir(), "devices.json"), 100, nil)
if err != nil {
t.Fatalf("open history: %v", err)
}
t.Cleanup(func() { _ = hist.Close() })
h.Subscribe(hist)
now := time.Now()
register := func(d hub.Device, clientType string) {
h.Register(&d, &connection.Context{
RemoteAddr: d.PeerIP + ":40000",
Info: connection.ClientInfo{ClientType: clientType},
})
}
register(hub.Device{
ID: "1001", Name: "ALPHA", Version: "1.2.3", Capability: "0005",
OS: "Windows 10", PublicIP: "10.0.0.1", PeerIP: "192.168.1.1",
Resolution: "1:1920*1080", ConnectedAt: now.Add(-3 * time.Minute),
}, "EXE")
register(hub.Device{
ID: "1002", Name: "BETA", Group: "Office", Version: "1.2.3", Capability: "0005",
OS: "Windows 11", PeerIP: "192.168.1.2",
Resolution: "2:3840*2160", ConnectedAt: now.Add(-2 * time.Minute),
}, "EXE")
register(hub.Device{
ID: "1003", Name: "GAMMA", Group: "Office", Version: "1.1.0",
OS: "Ubuntu 24.04", PublicIP: "10.1.0.3", PeerIP: "192.168.1.3",
Resolution: "1:2560*1440", ConnectedAt: now.Add(-time.Minute),
}, "LNX")
h.UpdateLive("1001", 42, "Notepad")
h.UpdateLive("1003", 120, "")
// Two devices that logged in and then left, so the history store has
// offline entries to merge into listings.
register(hub.Device{
ID: "2001", Name: "OLDWIN", Group: "Legacy", Version: "0.9.0", Capability: "0002",
OS: "Windows 7", PublicIP: "10.9.0.1", PeerIP: "192.168.9.1",
Resolution: "1:1280*1024", ConnectedAt: now.Add(-10 * time.Minute),
}, "EXE")
register(hub.Device{
ID: "2002", Name: "OLDMAC", Version: "0.8.0",
OS: "macOS 14", PublicIP: "10.9.0.2", PeerIP: "192.168.9.2",
Resolution: "1:1440*900", ConnectedAt: now.Add(-9 * time.Minute),
}, "MAC")
h.Unregister("2001")
h.Unregister("2002")
srv := New(Config{
Token: "test-token",
Hub: h,
History: hist,
Version: "v9.9.9",
StartedAt: time.Now().Add(-90 * time.Second),
Port: 6544,
Bind: "0.0.0.0",
})
return &localFixture{srv: srv, hub: h, hist: hist}
}
// callLocal drives one tools/call through the same gate the HTTP path uses and
// returns the decoded structuredContent plus the text item.
func callLocal(t *testing.T, s *Server, name, args string) (string, map[string]any, *rpcError) {
t.Helper()
params := fmt.Sprintf(`{"name":%q,"arguments":%s}`, name, args)
res, rerr := s.callTool(context.Background(), json.RawMessage(params))
if rerr != nil {
return "", nil, rerr
}
raw, err := json.Marshal(res)
if err != nil {
t.Fatalf("marshal tool result: %v", err)
}
var env struct {
Content []struct {
Type string `json:"type"`
Text string `json:"text"`
} `json:"content"`
StructuredContent map[string]any `json:"structuredContent"`
IsError bool `json:"isError"`
}
if err := json.Unmarshal(raw, &env); err != nil {
t.Fatalf("decode tool result: %v", err)
}
if env.IsError {
t.Fatalf("isError = true on success path: %s", raw)
}
if len(env.Content) != 1 || env.Content[0].Type != "text" {
t.Fatalf("content = %+v, want one text item", env.Content)
}
return env.Content[0].Text, env.StructuredContent, nil
}
func mustCallLocal(t *testing.T, s *Server, name, args string) (string, map[string]any) {
t.Helper()
text, sc, rerr := callLocal(t, s, name, args)
if rerr != nil {
t.Fatalf("%s returned error %d: %s", name, rerr.Code, rerr.Message)
}
return text, sc
}
func intField(t *testing.T, m map[string]any, key string) int {
t.Helper()
v, ok := m[key]
if !ok {
t.Fatalf("missing %q in %v", key, m)
}
f, ok := v.(float64)
if !ok {
t.Fatalf("%q = %v (%T), want number", key, v, v)
}
return int(f)
}
func boolField(t *testing.T, m map[string]any, key string) bool {
t.Helper()
v, ok := m[key]
if !ok {
t.Fatalf("missing %q in %v", key, m)
}
b, ok := v.(bool)
if !ok {
t.Fatalf("%q = %v (%T), want bool", key, v, v)
}
return b
}
func strField(t *testing.T, m map[string]any, key string) string {
t.Helper()
v, ok := m[key]
if !ok {
t.Fatalf("missing %q in %v", key, m)
}
s, ok := v.(string)
if !ok {
t.Fatalf("%q = %v (%T), want string", key, v, v)
}
return s
}
func hostList(t *testing.T, sc map[string]any) []map[string]any {
t.Helper()
raw, ok := sc["hosts"].([]any)
if !ok {
t.Fatalf("hosts = %v (%T), want array", sc["hosts"], sc["hosts"])
}
out := make([]map[string]any, 0, len(raw))
for _, item := range raw {
m, ok := item.(map[string]any)
if !ok {
t.Fatalf("host entry = %v (%T), want object", item, item)
}
out = append(out, m)
}
return out
}
func hostIDs(hosts []map[string]any) []string {
ids := make([]string, 0, len(hosts))
for _, h := range hosts {
ids = append(ids, h["id"].(string))
}
return ids
}
func wantIDs(t *testing.T, hosts []map[string]any, want ...string) {
t.Helper()
got := hostIDs(hosts)
if strings.Join(got, ",") != strings.Join(want, ",") {
t.Fatalf("ids = %v, want %v", got, want)
}
}
func TestListHostsPoolsAndProjection(t *testing.T) {
f := newLocalFixture(t)
text, sc := mustCallLocal(t, f.srv, "list_hosts", `{}`)
hosts := hostList(t, sc)
wantIDs(t, hosts, "1001", "1002", "1003")
if got := intField(t, sc, "total"); got != 3 {
t.Fatalf("total = %d, want 3", got)
}
if got := intField(t, sc, "totalAll"); got != 3 {
t.Fatalf("totalAll = %d, want 3", got)
}
if got := intField(t, sc, "limit"); got != 100 {
t.Fatalf("limit = %d, want default 100", got)
}
if boolField(t, sc, "hasMore") {
t.Fatal("hasMore = true for a full 3-host page")
}
if !strings.Contains(text, "共 3 台主机") {
t.Fatalf("text = %q, want host count", text)
}
alpha := hosts[0]
if got := strField(t, alpha, "name"); got != "ALPHA" {
t.Fatalf("name = %q", got)
}
if got := strField(t, alpha, "group"); got != "default" {
t.Fatalf("group = %q, want normalized default", got)
}
if got := strField(t, alpha, "clientType"); got != "EXE" {
t.Fatalf("clientType = %q", got)
}
if got := strField(t, alpha, "rtt"); got != "42" {
t.Fatalf("rtt = %q, want decimal string", got)
}
if got := strField(t, alpha, "activeWindow"); got != "Notepad" {
t.Fatalf("activeWindow = %q", got)
}
if got := strField(t, alpha, "ip"); got != "10.0.0.1" {
t.Fatalf("ip = %q, want client-reported public IP", got)
}
if got := strField(t, alpha, "screen"); got != "1:1920*1080" {
t.Fatalf("screen = %q", got)
}
if _, ok := alpha["last_seen"]; ok {
t.Fatal("online host carries last_seen")
}
for _, absent := range []string{"remark", "authStatus", "tls"} {
if _, ok := alpha[absent]; ok {
t.Fatalf("%s present but the Go server has no such data", absent)
}
}
// include_offline merges history behind the online hosts.
_, sc = mustCallLocal(t, f.srv, "list_hosts", `{"include_offline":true}`)
hosts = hostList(t, sc)
wantIDs(t, hosts, "1001", "1002", "1003", "2001", "2002")
if got := intField(t, sc, "totalAll"); got != 5 {
t.Fatalf("totalAll = %d, want 5", got)
}
for _, h := range hosts[:3] {
if !boolField(t, h, "online") {
t.Fatalf("%s should be online", h["id"])
}
}
for _, h := range hosts[3:] {
if boolField(t, h, "online") {
t.Fatalf("%s should be offline", h["id"])
}
if h["last_seen"] == "" || h["last_seen"] == nil {
t.Fatalf("%s missing last_seen", h["id"])
}
}
// online=false lists offline only.
_, sc = mustCallLocal(t, f.srv, "list_hosts", `{"online":false}`)
hosts = hostList(t, sc)
wantIDs(t, hosts, "2001", "2002")
if got := intField(t, sc, "totalAll"); got != 2 {
t.Fatalf("totalAll = %d, want 2 offline hosts", got)
}
}
func TestListHostsFilters(t *testing.T) {
f := newLocalFixture(t)
cases := []struct {
name string
args string
want []string
}{
{"name substring", `{"name":"beta"}`, []string{"1002"}},
{"group substring", `{"group":"office"}`, []string{"1002", "1003"}},
{"os substring case-insensitive", `{"os":"windows"}`, []string{"1001", "1002"}},
{"client type", `{"client_type":"lnx"}`, []string{"1003"}},
{"public ip substring", `{"ip":"10.1.0"}`, []string{"1003"}},
{"peer ip fallback", `{"ip":"192.168.1.2"}`, []string{"1002"}},
{"query matches name", `{"query":"gamma"}`, []string{"1003"}},
{"query matches ip", `{"query":"10.0.0.1"}`, []string{"1001"}},
{"filters are ANDed", `{"group":"office","os":"ubuntu"}`, []string{"1003"}},
{"no match", `{"name":"zzz"}`, nil},
}
for _, tc := range cases {
t.Run(tc.name, func(t *testing.T) {
text, sc := mustCallLocal(t, f.srv, "list_hosts", tc.args)
hosts := hostList(t, sc)
wantIDs(t, hosts, tc.want...)
if got := intField(t, sc, "total"); got != len(tc.want) {
t.Fatalf("total = %d, want %d (text %q)", got, len(tc.want), text)
}
// totalAll stays the unfiltered pool size.
if got := intField(t, sc, "totalAll"); got != 3 {
t.Fatalf("totalAll = %d, want 3", got)
}
})
}
// An empty result must be a JSON array, never null.
_, sc := mustCallLocal(t, f.srv, "list_hosts", `{"name":"zzz"}`)
raw, err := json.Marshal(sc)
if err != nil {
t.Fatalf("marshal: %v", err)
}
if !strings.Contains(string(raw), `"hosts":[]`) {
t.Fatalf("hosts not an empty array: %s", raw)
}
// client_type cannot match an offline record: history keeps no client type.
_, sc = mustCallLocal(t, f.srv, "list_hosts", `{"online":false,"client_type":"EXE"}`)
if hosts := hostList(t, sc); len(hosts) != 0 {
t.Fatalf("offline client_type filter matched %v, want none", hostIDs(hosts))
}
}
func TestListHostsPaging(t *testing.T) {
f := newLocalFixture(t)
_, sc := mustCallLocal(t, f.srv, "list_hosts", `{"limit":2}`)
hosts := hostList(t, sc)
wantIDs(t, hosts, "1001", "1002")
if got := intField(t, sc, "total"); got != 3 {
t.Fatalf("total = %d, want 3", got)
}
if !boolField(t, sc, "hasMore") {
t.Fatal("hasMore = false, want true")
}
_, sc = mustCallLocal(t, f.srv, "list_hosts", `{"limit":2,"offset":2}`)
hosts = hostList(t, sc)
wantIDs(t, hosts, "1003")
if boolField(t, sc, "hasMore") {
t.Fatal("hasMore = true on the last page")
}
if got := intField(t, sc, "offset"); got != 2 {
t.Fatalf("offset = %d, want 2", got)
}
text, sc := mustCallLocal(t, f.srv, "list_hosts", `{"offset":99}`)
if hosts := hostList(t, sc); len(hosts) != 0 {
t.Fatalf("offset past end returned %v", hostIDs(hosts))
}
if !strings.Contains(text, "offset 超出范围") {
t.Fatalf("text = %q, want out-of-range note", text)
}
_, sc = mustCallLocal(t, f.srv, "list_hosts", `{"limit":5000}`)
if got := intField(t, sc, "limit"); got != listMaxLimit {
t.Fatalf("limit = %d, want clamped to %d", got, listMaxLimit)
}
_, sc = mustCallLocal(t, f.srv, "list_hosts", `{"limit":-5}`)
if got := intField(t, sc, "limit"); got != listDefaultLimit {
t.Fatalf("limit = %d, want default %d", got, listDefaultLimit)
}
// Malformed arguments are a caller error, not an empty list.
if _, _, rerr := callLocal(t, f.srv, "list_hosts", `{"limit":"many"}`); rerr == nil || rerr.Code != CodeInvalidParams {
t.Fatalf("malformed limit error = %+v, want -32602", rerr)
}
}
func TestGetHostDetailOnlineAndOffline(t *testing.T) {
f := newLocalFixture(t)
_, sc := mustCallLocal(t, f.srv, "get_host_detail", `{"id":"1001"}`)
host, ok := sc["host"].(map[string]any)
if !ok {
t.Fatalf("host = %v", sc["host"])
}
if !boolField(t, host, "online") {
t.Fatal("1001 should be online")
}
caps, ok := host["capabilities"].(map[string]any)
if !ok {
t.Fatalf("capabilities = %v", host["capabilities"])
}
if !boolField(t, caps, "screenPreview") || !boolField(t, caps, "fileTransferV2") {
t.Fatalf("caps = %v, want preview+V2 from 0x0005", caps)
}
if boolField(t, caps, "screenRegion") {
t.Fatalf("caps = %v, screenRegion set without 0x0200", caps)
}
if !boolField(t, caps, "registry") {
t.Fatalf("caps = %v, Windows client must have registry", caps)
}
if !boolField(t, caps, "remoteControl") {
t.Fatalf("caps = %v, single-monitor Windows must allow remote control", caps)
}
if got := strField(t, caps, "platform"); got != "EXE" {
t.Fatalf("platform = %q", got)
}
if _, ok := caps["v2"]; ok {
t.Fatal("v2 must not be reported: every platform sets it")
}
// A multi-monitor Windows client without whole-desktop capture is not
// remotely controllable (coordinate spaces would not line up).
f.hub.Register(&hub.Device{
ID: "1004", Name: "DUAL", Capability: "0005",
OS: "Windows 11", PublicIP: "10.0.0.4", PeerIP: "192.168.1.4",
Resolution: "2:3840*2160", ConnectedAt: time.Now(),
}, &connection.Context{RemoteAddr: "192.168.1.4:40000",
Info: connection.ClientInfo{ClientType: "EXE"}})
_, sc = mustCallLocal(t, f.srv, "get_host_detail", `{"id":"1004"}`)
caps = sc["host"].(map[string]any)["capabilities"].(map[string]any)
if boolField(t, caps, "remoteControl") {
t.Fatalf("caps = %v, dual-monitor without VIRTUAL_DESKTOP must not allow remote control", caps)
}
// Offline detail comes from history: no capabilities (the device is gone),
// but the last-known fields are intact.
_, sc = mustCallLocal(t, f.srv, "get_host_detail", `{"id":"2001"}`)
host = sc["host"].(map[string]any)
if boolField(t, host, "online") {
t.Fatal("2001 should be offline")
}
if got := strField(t, host, "version"); got != "0.9.0" {
t.Fatalf("version = %q", got)
}
if _, ok := host["capabilities"]; ok {
t.Fatal("offline host must not report capabilities")
}
if _, _, rerr := callLocal(t, f.srv, "get_host_detail", `{"id":"9999"}`); rerr == nil || rerr.Code != CodeOffline {
t.Fatalf("unknown host error = %+v, want -32002", rerr)
}
if _, _, rerr := callLocal(t, f.srv, "get_host_detail", `{"id":"12ab"}`); rerr == nil || rerr.Code != CodeInvalidParams {
t.Fatalf("non-decimal id error = %+v, want -32602", rerr)
}
if _, _, rerr := callLocal(t, f.srv, "get_host_detail", `{}`); rerr == nil || rerr.Code != CodeInvalidParams {
t.Fatalf("missing id error = %+v, want -32602", rerr)
}
}
func TestGetHostDetailBatch(t *testing.T) {
f := newLocalFixture(t)
_, sc := mustCallLocal(t, f.srv, "get_host_detail", `{"ids":["1001","9999","2001"]}`)
if got := strField(t, sc, "tool"); got != "get_host_detail" {
t.Fatalf("tool = %q", got)
}
if got := intField(t, sc, "total"); got != 3 {
t.Fatalf("total = %d, want 3", got)
}
if got := intField(t, sc, "succeeded"); got != 2 {
t.Fatalf("succeeded = %d, want 2", got)
}
if got := intField(t, sc, "failed"); got != 1 {
t.Fatalf("failed = %d, want 1", got)
}
if got := intField(t, sc, "skipped"); got != 0 {
t.Fatalf("skipped = %d, want 0", got)
}
results, ok := sc["results"].([]any)
if !ok || len(results) != 3 {
t.Fatalf("results = %v", sc["results"])
}
first := results[0].(map[string]any)
if !boolField(t, first, "ok") {
t.Fatal("first result should be ok")
}
data := first["data"].(map[string]any)
if id := strField(t, data["host"].(map[string]any), "id"); id != "1001" {
t.Fatalf("first host id = %q", id)
}
second := results[1].(map[string]any)
if boolField(t, second, "ok") {
t.Fatal("second result should fail")
}
errObj := second["error"].(map[string]any)
if got := intField(t, errObj, "code"); got != CodeOffline {
t.Fatalf("per-entry code = %d, want %d", got, CodeOffline)
}
third := results[2].(map[string]any)
if !boolField(t, third, "ok") {
t.Fatal("offline history entry should succeed in a batch")
}
ids := make([]string, batchMaxIDs+1)
for i := range ids {
ids[i] = "1001"
}
payload, _ := json.Marshal(map[string]any{"ids": ids})
if _, _, rerr := callLocal(t, f.srv, "get_host_detail", string(payload)); rerr == nil || rerr.Code != CodeInvalidParams {
t.Fatalf("oversized batch error = %+v, want -32602", rerr)
}
}
func TestGetServerStatus(t *testing.T) {
f := newLocalFixture(t)
_, sc := mustCallLocal(t, f.srv, "get_server_status", `{}`)
if got := strField(t, sc, "version"); got != "v9.9.9" {
t.Fatalf("version = %q", got)
}
// StartedAt is 90s in the past; the exact value depends on test runtime.
if got := intField(t, sc, "uptime_sec"); got < 90 {
t.Fatalf("uptime_sec = %d, want >= 90", got)
}
hosts, ok := sc["hosts"].(map[string]any)
if !ok {
t.Fatalf("hosts = %v", sc["hosts"])
}
if got := intField(t, hosts, "online"); got != 3 {
t.Fatalf("online = %d, want 3", got)
}
if got := intField(t, hosts, "offline"); got != 2 {
t.Fatalf("offline = %d, want 2", got)
}
if got := intField(t, sc, "port"); got != 6544 {
t.Fatalf("port = %d", got)
}
if got := strField(t, sc, "bind"); got != "0.0.0.0" {
t.Fatalf("bind = %q", got)
}
if _, ok := sc["sessions"]; ok {
t.Fatal("sessions reported before the MCP session table exists")
}
}
// A build without link-time version injection must not invent one: the status
// tool reports the empty string, and only initialize substitutes "dev".
func TestUnversionedBuild(t *testing.T) {
s := New(Config{Token: "test-token"})
_, sc := mustCallLocal(t, s, "get_server_status", `{}`)
if got, ok := sc["version"]; !ok || got != "" {
t.Fatalf("status version = %#v, want empty string", got)
}
if got := s.initializeResult().ServerInfo.Version; got != "dev" {
t.Fatalf("initialize version = %q, want dev", got)
}
}
func writeAuditFile(t *testing.T, lines ...string) string {
t.Helper()
path := filepath.Join(t.TempDir(), "audit.log")
body := strings.Join(lines, "\n") + "\n"
if err := os.WriteFile(path, []byte(body), 0o600); err != nil {
t.Fatalf("write audit file: %v", err)
}
return path
}
func TestGetAuditLog(t *testing.T) {
path := writeAuditFile(t,
`{"audit":true,"time":"2026-11-12T10:00:00Z","level":"info","event":"web.login.success","actor":"admin","ip":"1.2.3.4"}`,
`{"audit":true,"time":"2026-11-12T10:01:00Z","level":"info","event":"web.login.failure","actor":"bob","ip":"5.6.7.8"}`,
`{"audit":true,"time":"2026-11-12T10:02:00Z","level":"warn","event":"authz.denied","actor":"admin","ip":"1.2.3.4","detail":"readonly"}`,
`{"audit":true,"time":"2026-11-12T10:03:00Z","level":"info","event":"device.online","device_id":"1001"}`,
)
s := New(Config{Token: "test-token", AuditPath: path})
_, sc := mustCallLocal(t, s, "get_audit_log", `{}`)
entries, ok := sc["entries"].([]any)
if !ok || len(entries) != 4 {
t.Fatalf("entries = %v, want 4", sc["entries"])
}
if got := intField(t, sc, "total"); got != 4 {
t.Fatalf("total = %d, want 4", got)
}
if got := intField(t, sc, "totalAll"); got != 4 {
t.Fatalf("totalAll = %d, want 4", got)
}
if boolField(t, sc, "hasMore") {
t.Fatal("hasMore = true for a complete page")
}
newest := entries[0].(map[string]any)
if got := strField(t, newest, "type"); got != "device.online" {
t.Fatalf("newest type = %q, want newest first", got)
}
if got := strField(t, newest, "time"); got != "2026-11-12T10:03:00Z" {
t.Fatalf("newest time = %q", got)
}
msg := strField(t, newest, "msg")
if !strings.Contains(msg, `"device_id":"1001"`) {
t.Fatalf("msg = %q, want remaining fields", msg)
}
for _, envelope := range []string{`"audit"`, `"event"`, `"level"`, `"time"`} {
if strings.Contains(msg, envelope) {
t.Fatalf("msg repeats envelope key %s: %s", envelope, msg)
}
}
// type is a case-insensitive substring of the event name.
_, sc = mustCallLocal(t, s, "get_audit_log", `{"type":"LOGIN"}`)
if got := intField(t, sc, "total"); got != 2 {
t.Fatalf("login total = %d, want 2", got)
}
if got := intField(t, sc, "totalAll"); got != 4 {
t.Fatalf("login totalAll = %d, want unfiltered 4", got)
}
_, sc = mustCallLocal(t, s, "get_audit_log", `{"type":"login","keyword":"1.2.3.4"}`)
if got := intField(t, sc, "total"); got != 1 {
t.Fatalf("type+keyword total = %d, want 1", got)
}
// Paging: limit 2 → hasMore; the tail page stops there.
_, sc = mustCallLocal(t, s, "get_audit_log", `{"limit":2}`)
if got := len(sc["entries"].([]any)); got != 2 {
t.Fatalf("entries = %d, want 2", got)
}
if !boolField(t, sc, "hasMore") {
t.Fatal("hasMore = false with 2 of 4")
}
_, sc = mustCallLocal(t, s, "get_audit_log", `{"limit":2,"offset":3}`)
if got := len(sc["entries"].([]any)); got != 1 {
t.Fatalf("tail entries = %d, want 1", got)
}
if boolField(t, sc, "hasMore") {
t.Fatal("hasMore = true on the tail page")
}
// Empty result is an array, and the file is scanned only up to its size.
_, sc = mustCallLocal(t, s, "get_audit_log", `{"keyword":"no-such-thing"}`)
raw, _ := json.Marshal(sc)
if !strings.Contains(string(raw), `"entries":[]`) {
t.Fatalf("entries not an empty array: %s", raw)
}
// Missing file: an empty log, not an error.
f := newLocalFixture(t)
f.srv.cfg.AuditPath = filepath.Join(t.TempDir(), "missing.log")
if _, sc = mustCallLocal(t, f.srv, "get_audit_log", `{}`); intField(t, sc, "total") != 0 {
t.Fatalf("missing file total = %d, want 0", intField(t, sc, "total"))
}
// Disabled audit file (YAMA_AUDIT_LOG=off) is a configuration error.
off := New(Config{Token: "test-token"})
if _, _, rerr := callLocal(t, off, "get_audit_log", `{}`); rerr == nil || rerr.Code != CodeInternal {
t.Fatalf("disabled audit error = %+v, want -32000", rerr)
}
// Offset is clamped at auditquery.MaxOffset. A page that ends exactly
// there must not advertise a next page: the follow-up offset would be
// clamped back and return the same records forever.
var big strings.Builder
for i := range auditquery.MaxOffset + 2000 {
fmt.Fprintf(&big, `{"audit":true,"time":"2026-11-12T10:00:00Z","level":"info","event":"device.online","n":%d}`+"\n", i)
}
bigPath := filepath.Join(t.TempDir(), "audit.log")
if err := os.WriteFile(bigPath, []byte(big.String()), 0o600); err != nil {
t.Fatalf("write big audit file: %v", err)
}
bigSrv := New(Config{Token: "test-token", AuditPath: bigPath})
_, sc = mustCallLocal(t, bigSrv, "get_audit_log", `{"limit":500}`)
if !boolField(t, sc, "hasMore") {
t.Fatal("hasMore = false on the first page of a large log")
}
_, sc = mustCallLocal(t, bigSrv, "get_audit_log", `{"limit":500,"offset":9500}`)
if got := len(sc["entries"].([]any)); got != 500 {
t.Fatalf("entries at cap = %d, want 500", got)
}
if boolField(t, sc, "hasMore") {
t.Fatal("hasMore = true at the MaxOffset cap, paging would loop")
}
}
+7
View File
@@ -69,6 +69,13 @@ const (
ClientCapV2 uint32 = 0x0001 // CLIENT_CAP_V2 — V2 file transfer
ClientCapUTF8 uint32 = 0x0002 // CLIENT_CAP_UTF8 — UTF-8 protocol strings (activeWindow, key-log titles, ...)
ClientCapScreenPreview uint32 = 0x0004 // CLIENT_CAP_SCREEN_PREVIEW
ClientCapC2CPaths uint32 = 0x0008 // CLIENT_CAP_C2C_PATHS — path-list driven host-to-host transfer
// Bits 0x0010 (C2C recv ack), 0x0020 (protocol switch) and 0x0040
// (embedded anchor) are not consumed by the Go server yet. They are simply
// skipped by the constants below.
ClientCapVirtualDesktop uint32 = 0x0080 // CLIENT_CAP_VIRTUAL_DESKTOP — whole virtual desktop capture
ClientCapWindowInfo uint32 = 0x0100 // CLIENT_CAP_WINDOW_INFO — window enumeration / rects
ClientCapScreenRegion uint32 = 0x0200 // CLIENT_CAP_SCREEN_REGION — region/window/monitor capture
)
// SupportsCap returns true when the client's reported capability hex string
+13 -250
View File
@@ -1,57 +1,21 @@
package web
import (
"bufio"
"encoding/json"
"os"
"strings"
"time"
"github.com/yuanyuanxiang/SimpleRemoter/server/go/auditquery"
)
// Audit-log query support for the admin-only "Audit Log" page.
//
// The server reads its own JSON-lines audit file (logs/audit.log) back to the
// browser. Records are already redacted at write time (see logger.AuditAt), so
// returning raw lines is safe as long as we never widen what is written.
//
// Only the CURRENT audit file is searched. Rotated files (audit-*.log[.gz])
// are deliberately out of scope: they need gzip support and a separate index,
// and the UI is meant for recent-window triage ("what happened just now").
const (
auditQueryDefaultLimit = 100
auditQueryMaxLimit = 500
auditQueryMaxOffset = 10000
// The scanner itself (file tail, filters, paging) lives in package
// auditquery so the MCP get_audit_log tool can share it; this file keeps only
// the WebSocket command handler and the reply shaping specific to the UI.
// auditQueryScanBudget bounds how much of the audit file a single query
// reads. The tail is read when the file is larger, so the newest records
// (what operators actually triage) are always covered and a multi-GB log
// cannot stall the WS goroutine.
auditQueryScanBudget = 32 << 20 // 32 MB
)
// auditQueryRequest is the JSON body of the `query_audit` command.
type auditQueryRequest struct {
From string `json:"from"` // RFC3339 ("2026-10-18T10:00:00Z"), optional
To string `json:"to"` // RFC3339, optional
Event string `json:"event"` // exact ("web.login.failure"), prefix ("web." / "web.*"), or ""
Actor string `json:"actor"` // exact, case-insensitive
IP string `json:"ip"` // exact
DeviceID string `json:"device_id"`
Keyword string `json:"keyword"` // case-insensitive substring of the raw record
WarnOnly bool `json:"warn_only"` // only level=warn records
Limit int `json:"limit"`
Offset int `json:"offset"` // skip the newest N matching records
}
// auditQueryResult is the internal result of scanning the audit file.
type auditQueryResult struct {
Events []map[string]any
Total int // matching records in the scanned window
FileExists bool
FileSize int64
ScannedBytes int64
Truncated bool // the file was larger than auditQueryScanBudget
}
// auditQueryMaxLimit caps the page size of the audit page. It is tighter than
// auditquery.MaxLimit (the protocol-wide cap the MCP tool uses) because the
// admin table is meant to be paged, not downloaded.
const auditQueryMaxLimit = 500
// handleQueryAudit implements the admin-only audit query command. The reply is
// `{cmd:"audit_result", ok, events, total, ...}`; events are newest-first.
@@ -60,13 +24,13 @@ func (h *wsHub) handleQueryAudit(c *wsClient, raw []byte) {
if !h.requireAdmin(c, raw, replyCmd) {
return
}
var in auditQueryRequest
var in auditquery.Query
if err := json.Unmarshal(raw, &in); err != nil {
c.queue(mustJSON(map[string]any{"cmd": replyCmd, "ok": false, "msg": "Invalid request"}))
return
}
in.Limit = clampAuditLimit(in.Limit)
in.Offset = clampAuditOffset(in.Offset)
in.Limit = auditquery.ClampLimit(in.Limit, auditQueryMaxLimit)
in.Offset = auditquery.ClampOffset(in.Offset)
path := h.log.AuditPath()
if path == "" {
@@ -81,7 +45,7 @@ func (h *wsHub) handleQueryAudit(c *wsClient, raw []byte) {
return
}
res, err := queryAuditLog(path, in)
res, err := auditquery.Scan(path, in)
if err != nil {
h.audit(c, true, auditQuery, map[string]any{
"ok": false,
@@ -125,204 +89,3 @@ func (h *wsHub) handleQueryAudit(c *wsClient, raw []byte) {
"truncated": res.Truncated,
}))
}
func clampAuditLimit(n int) int {
if n <= 0 {
return auditQueryDefaultLimit
}
if n > auditQueryMaxLimit {
return auditQueryMaxLimit
}
return n
}
func clampAuditOffset(n int) int {
if n < 0 {
return 0
}
if n > auditQueryMaxOffset {
return auditQueryMaxOffset
}
return n
}
// queryAuditLog scans path for audit records matching q. The returned events
// are the newest limit records after skipping offset, in newest-first order.
func queryAuditLog(path string, q auditQueryRequest) (auditQueryResult, error) {
res := auditQueryResult{Events: []map[string]any{}}
f, err := os.Open(path)
if err != nil {
if os.IsNotExist(err) {
// No audit record has been written yet (lumberjack creates the file
// lazily). An empty result is correct, not an error.
return res, nil
}
return res, err
}
defer f.Close()
info, err := f.Stat()
if err != nil {
return res, err
}
res.FileExists = true
res.FileSize = info.Size()
// For very large files, scan only the tail; the newest matches live there.
start := int64(0)
if info.Size() > auditQueryScanBudget {
start = info.Size() - auditQueryScanBudget
if _, err := f.Seek(start, 0); err != nil {
return res, err
}
res.Truncated = true
}
from, hasFrom := parseAuditTime(q.From)
to, hasTo := parseAuditTime(q.To)
keep := q.Offset + q.Limit
ring := make([]map[string]any, keep)
filled := 0
sc := bufio.NewScanner(f)
// Sanitized values are capped at 4096 bytes each; a record with many
// fields stays well under 1 MB. Allow headroom rather than aborting the
// whole query on one long line.
sc.Buffer(make([]byte, 64*1024), 4*1024*1024)
first := true
for sc.Scan() {
line := sc.Text()
if start > 0 && first {
// Seeking into the middle of the file lands mid-line. Drop that
// partial record.
first = false
continue
}
first = false
res.ScannedBytes += int64(len(line)) + 1
line = strings.TrimSpace(line)
if line == "" {
continue
}
var rec map[string]any
if err := json.Unmarshal([]byte(line), &rec); err != nil {
continue // tolerate a torn line instead of failing the page
}
if _, ok := rec["event"].(string); !ok {
continue
}
// Only audit records belong on the page. The dedicated file contains
// nothing else, but a hand-edited or mixed file must not surface
// ordinary operational lines here.
if rec["audit"] != true {
continue
}
if !auditRecordMatches(rec, line, q, from, hasFrom, to, hasTo) {
continue
}
// Ring buffer of the last `keep` matches (file order is chronological).
ring[res.Total%keep] = rec
if filled < keep {
filled++
}
res.Total++
}
if err := sc.Err(); err != nil {
return res, err
}
// Newest first, skipping Offset. The match with 0-based index i lives at
// ring[i%keep] as long as i >= Total-filled.
for i := res.Total - 1 - q.Offset; i >= 0 && i >= res.Total-filled; i-- {
res.Events = append(res.Events, ring[i%keep])
if len(res.Events) >= q.Limit {
break
}
}
return res, nil
}
// auditRecordMatches applies the non-time and time filters to one record.
// line is the raw JSON line, used for the keyword substring search.
func auditRecordMatches(rec map[string]any, line string, q auditQueryRequest, from time.Time, hasFrom bool, to time.Time, hasTo bool) bool {
if q.Event != "" && !auditEventFilterMatches(q.Event, auditStringField(rec, "event")) {
return false
}
if q.Actor != "" && !strings.EqualFold(auditStringField(rec, "actor"), q.Actor) {
return false
}
if q.IP != "" && auditStringField(rec, "ip") != q.IP {
return false
}
if q.DeviceID != "" && auditStringField(rec, "device_id") != q.DeviceID {
return false
}
if q.WarnOnly && auditStringField(rec, "level") != "warn" {
return false
}
if q.Keyword != "" && !strings.Contains(strings.ToLower(line), strings.ToLower(q.Keyword)) {
return false
}
if hasFrom || hasTo {
t, ok := parseAuditTime(auditStringField(rec, "time"))
if !ok {
return false // cannot prove it is in range
}
if hasFrom && t.Before(from) {
return false
}
if hasTo && t.After(to) {
return false
}
}
return true
}
// auditEventFilterMatches supports three forms so the UI stays simple:
//
// "web.login.failure" exact
// "web.*" prefix (trailing "*")
// "web." prefix (trailing ".")
func auditEventFilterMatches(filter, event string) bool {
switch {
case strings.HasSuffix(filter, "*"):
return strings.HasPrefix(event, strings.TrimSuffix(filter, "*"))
case strings.HasSuffix(filter, "."):
return strings.HasPrefix(event, filter)
default:
return event == filter
}
}
func auditStringField(rec map[string]any, key string) string {
s, _ := rec[key].(string)
return s
}
// parseAuditTime accepts the formats operators and browsers realistically send.
// Layouts without an explicit zone are parsed as UTC; the frontend always sends
// Date.toISOString(), so the RFC3339 path is what production uses.
func parseAuditTime(s string) (time.Time, bool) {
s = strings.TrimSpace(s)
if s == "" {
return time.Time{}, false
}
layouts := []string{
time.RFC3339Nano,
time.RFC3339,
"2006-01-02T15:04:05",
"2006-01-02T15:04",
"2006-01-02 15:04:05",
"2006-01-02",
}
for _, layout := range layouts {
if t, err := time.Parse(layout, s); err == nil {
return t, true
}
}
return time.Time{}, false
}
+5 -185
View File
@@ -2,17 +2,20 @@ package web
import (
"encoding/json"
"os"
"path/filepath"
"strings"
"testing"
"time"
"github.com/yuanyuanxiang/SimpleRemoter/server/go/auditquery"
"github.com/yuanyuanxiang/SimpleRemoter/server/go/hub"
"github.com/yuanyuanxiang/SimpleRemoter/server/go/logger"
"github.com/yuanyuanxiang/SimpleRemoter/server/go/wsauth"
)
// The scanner has its own tests in package auditquery; this file covers the
// WebSocket command handler and its reply shape.
// newAuditTestHubWithoutAuditFile builds a hub whose logger has no dedicated
// audit file, mirroring a server started with YAMA_AUDIT_LOG=off.
func newAuditTestHubWithoutAuditFile(t *testing.T, dir string) (*wsHub, string) {
@@ -43,189 +46,6 @@ func readQueuedJSON(t *testing.T, c *wsClient) map[string]any {
}
}
// writeAuditFixture writes JSON-lines audit records (oldest first) and returns
// the file path. Times are UTC RFC3339 so the tests are timezone-independent.
func writeAuditFixture(t *testing.T, records []map[string]any) string {
t.Helper()
path := filepath.Join(t.TempDir(), "audit.log")
var b strings.Builder
for _, rec := range records {
line, err := json.Marshal(rec)
if err != nil {
t.Fatalf("marshal fixture: %v", err)
}
b.Write(line)
b.WriteByte('\n')
}
if err := os.WriteFile(path, []byte(b.String()), 0o644); err != nil {
t.Fatalf("write fixture: %v", err)
}
return path
}
func auditFixtureRecords() []map[string]any {
at := func(hhmm string) string {
tm, err := time.Parse("2006-01-02T15:04", "2026-10-18T"+hhmm)
if err != nil {
panic(err)
}
return tm.Format(time.RFC3339)
}
return []map[string]any{
{"level": "info", "time": at("10:00"), "audit": true, "event": "web.login.success", "actor": "admin", "ip": "203.0.113.1"},
{"level": "warn", "time": at("10:01"), "audit": true, "event": "web.login.failure", "actor": "alice", "ip": "203.0.113.2", "reason": "invalid_credentials"},
{"level": "info", "time": at("10:02"), "audit": true, "event": "remote.screen.start", "actor": "admin", "role": "admin", "ip": "203.0.113.1", "device_id": "dev1"},
{"level": "info", "time": at("10:03"), "audit": true, "event": "admin.user.delete", "actor": "admin", "ip": "203.0.113.1", "target": "bob"},
}
}
func runAuditQuery(t *testing.T, path string, q auditQueryRequest) auditQueryResult {
t.Helper()
q.Limit = clampAuditLimit(q.Limit)
q.Offset = clampAuditOffset(q.Offset)
res, err := queryAuditLog(path, q)
if err != nil {
t.Fatalf("queryAuditLog: %v", err)
}
return res
}
func eventNames(res auditQueryResult) []string {
out := make([]string, 0, len(res.Events))
for _, e := range res.Events {
out = append(out, auditStringField(e, "event"))
}
return out
}
func TestAuditQueryNoFilterNewestFirst(t *testing.T) {
path := writeAuditFixture(t, auditFixtureRecords())
res := runAuditQuery(t, path, auditQueryRequest{Limit: 100})
if res.Total != 4 || len(res.Events) != 4 {
t.Fatalf("total=%d events=%d, want 4/4", res.Total, len(res.Events))
}
got := eventNames(res)
want := []string{"admin.user.delete", "remote.screen.start", "web.login.failure", "web.login.success"}
if strings.Join(got, ",") != strings.Join(want, ",") {
t.Fatalf("events = %v, want %v", got, want)
}
}
func TestAuditQueryEventFilters(t *testing.T) {
path := writeAuditFixture(t, auditFixtureRecords())
cases := []struct {
filter string
want []string
}{
{"web.", []string{"web.login.failure", "web.login.success"}},
{"web.*", []string{"web.login.failure", "web.login.success"}},
{"web.login.failure", []string{"web.login.failure"}},
{"remote.*", []string{"remote.screen.start"}},
}
for _, tc := range cases {
res := runAuditQuery(t, path, auditQueryRequest{Event: tc.filter, Limit: 100})
got := eventNames(res)
if strings.Join(got, ",") != strings.Join(tc.want, ",") {
t.Errorf("filter %q → %v, want %v", tc.filter, got, tc.want)
}
}
}
func TestAuditQueryFieldFilters(t *testing.T) {
path := writeAuditFixture(t, auditFixtureRecords())
from, _ := time.Parse(time.RFC3339, "2026-10-18T10:01:00Z")
to, _ := time.Parse(time.RFC3339, "2026-10-18T10:02:00Z")
cases := []struct {
name string
q auditQueryRequest
want []string
}{
{"actor case-insensitive", auditQueryRequest{Actor: "ALICE", Limit: 100}, []string{"web.login.failure"}},
{"ip", auditQueryRequest{IP: "203.0.113.2", Limit: 100}, []string{"web.login.failure"}},
{"device", auditQueryRequest{DeviceID: "dev1", Limit: 100}, []string{"remote.screen.start"}},
{"warn only", auditQueryRequest{WarnOnly: true, Limit: 100}, []string{"web.login.failure"}},
{"keyword target", auditQueryRequest{Keyword: "BOB", Limit: 100}, []string{"admin.user.delete"}},
{"time range", auditQueryRequest{
From: from.Format(time.RFC3339), To: to.Format(time.RFC3339), Limit: 100,
}, []string{"remote.screen.start", "web.login.failure"}},
}
for _, tc := range cases {
res := runAuditQuery(t, path, tc.q)
got := eventNames(res)
if strings.Join(got, ",") != strings.Join(tc.want, ",") {
t.Errorf("%s → %v, want %v", tc.name, got, tc.want)
}
}
}
func TestAuditQueryOffsetAndLimit(t *testing.T) {
path := writeAuditFixture(t, auditFixtureRecords())
res := runAuditQuery(t, path, auditQueryRequest{Limit: 2, Offset: 1})
if res.Total != 4 {
t.Fatalf("total = %d, want 4", res.Total)
}
got := eventNames(res)
want := []string{"remote.screen.start", "web.login.failure"}
if strings.Join(got, ",") != strings.Join(want, ",") {
t.Fatalf("events = %v, want %v", got, want)
}
// Offsetting past the end yields no events but keeps the total.
res = runAuditQuery(t, path, auditQueryRequest{Limit: 2, Offset: 4})
if res.Total != 4 || len(res.Events) != 0 {
t.Fatalf("offset past end: total=%d events=%v", res.Total, eventNames(res))
}
}
func TestAuditQuerySkipsNonAuditAndTornLines(t *testing.T) {
path := filepath.Join(t.TempDir(), "audit.log")
content := `{"event":"device.online","actor":"x"}
not json at all
{"level":"info","time":"2026-10-18T10:00:00Z","audit":true,"event":"web.login.success","actor":"admin"}`
if err := os.WriteFile(path, []byte(content), 0o644); err != nil {
t.Fatal(err)
}
res := runAuditQuery(t, path, auditQueryRequest{Limit: 100})
if res.Total != 1 || len(res.Events) != 1 {
t.Fatalf("total=%d events=%v, want the single valid record", res.Total, eventNames(res))
}
}
func TestAuditQueryMissingFile(t *testing.T) {
res := runAuditQuery(t, filepath.Join(t.TempDir(), "does-not-exist.log"), auditQueryRequest{Limit: 10})
if res.FileExists {
t.Error("FileExists = true for a missing file")
}
if res.Total != 0 || len(res.Events) != 0 {
t.Errorf("total=%d events=%v, want empty", res.Total, eventNames(res))
}
if res.Events == nil {
t.Error("Events is nil; JSON would encode null instead of []")
}
}
func TestAuditQueryClampsPaging(t *testing.T) {
if got := clampAuditLimit(0); got != auditQueryDefaultLimit {
t.Errorf("limit(0) = %d, want default %d", got, auditQueryDefaultLimit)
}
if got := clampAuditLimit(-3); got != auditQueryDefaultLimit {
t.Errorf("limit(-3) = %d, want default %d", got, auditQueryDefaultLimit)
}
if got := clampAuditLimit(9999); got != auditQueryMaxLimit {
t.Errorf("limit(9999) = %d, want max %d", got, auditQueryMaxLimit)
}
if got := clampAuditLimit(50); got != 50 {
t.Errorf("limit(50) = %d, want 50", got)
}
if got := clampAuditOffset(-5); got != 0 {
t.Errorf("offset(-5) = %d, want 0", got)
}
if got := clampAuditOffset(1 << 30); got != auditQueryMaxOffset {
t.Errorf("offset(huge) = %d, want max %d", got, auditQueryMaxOffset)
}
}
func TestQueryAuditHandlerAdminOnly(t *testing.T) {
wh, _, _ := auditTestHub(t)
viewer, tok := auditTestClient(wh, "viewer")
@@ -265,7 +85,7 @@ func TestQueryAuditHandlerReturnsEvents(t *testing.T) {
var names []string
for _, e := range events {
if m, ok := e.(map[string]any); ok {
names = append(names, auditStringField(m, "event"))
names = append(names, auditquery.StringField(m, "event"))
}
}
joined := strings.Join(names, ",")