Files
SimpleRemoter/server/go/mcp/filemgr.go
T
yuanyuanxianganddeepseek-flash 5e012019ba Fix(mcp): list the whole directory before paging list_files
list_files stopped parsing at 500 entries, so a larger directory reported
total=500 with hasMore=false and offsets past 500 returned nothing: the model
was told a false limit and could not reach the tail. Parse the full
TOKEN_FILE_LIST payload (100000 cap only to bound a pathological directory),
page over it, and report truncated=true plus a summary note when the cap hits.

Only an empty path now means list drives. Windows "." "/" "\" are normalized
to empty in BuildListFiles, while Linux/macOS "/" is a real root directory and
is listed; OnDriveList no longer keeps its own copy of the magic-path rule.

The file-manager channel carries GBK both ways (Windows FindFirstFileA;
common/FileManager.h runs gbkToUtf8 on incoming paths, utf8ToGbk on outgoing
names). The old CP_UTF8 choice for LNX/MAC decoded GBK names wrongly and sent
UTF-8 paths to a client that treats them as GBK. Paths now go out as GBK, or
as raw UTF-8 when GBK cannot represent them (the client's iconv then passes
the bytes through). Names decode GBK-first, UTF-8 on failure: UTF-8-first
misreads ~18% of common hanzi whose GBK bytes are also valid UTF-8.

Go's server gets the same contract: 100000 cap, truncated in
structuredContent, and the cap check after a real record so an exact-cap
listing with trailing padding is not called truncated. tools_minimal.json is
regenerated; the Go truncation test and the design doc are updated.

Debug server builds; check_platform_table, gen_go_tools --check and
go test ./... pass. The Release instance was not rebuilt or restarted.

Co-Authored-By: deepseek-flash
2026-11-13 12:13:20 +01:00

639 lines
21 KiB
Go

package mcp
import (
"context"
"encoding/binary"
"encoding/json"
"errors"
"fmt"
"strconv"
"strings"
"sync"
"time"
"github.com/yuanyuanxiang/SimpleRemoter/server/go/connection"
"github.com/yuanyuanxiang/SimpleRemoter/server/go/hub"
"github.com/yuanyuanxiang/SimpleRemoter/server/go/protocol"
)
// list_files drives the client's file-manager sub-connection (design §5.3):
//
// main conn : COMMAND_LIST_DRIVE(1)
// └─ client opens a sub-conn, sends TOKEN_CONN_AUTH then
// TOKEN_DRIVE_LIST(103) — the sub-conn stays open
// that sub : COMMAND_LIST_FILES(2) [path\0]
// └─ TOKEN_FILE_LIST(104) or TOKEN_FILE_LIST_ERROR(171)
// then the server closes the sub-conn (COMMAND_BYE + 500 ms)
//
// The sub-conn carries ConnAuth, so handleConnAuth has already pinned the
// device's ClientID on its ctx and no pending-connection bookkeeping is needed
// (design §5.3); the pending request is keyed by device and remembers which
// ctx answered, which is also how late packets from a previous sub-conn are
// told apart from the current one.
const (
// fileListMaxEntries is the parse cap shared with the Win32 server: the
// directory is parsed in full and paged afterwards, so total/hasMore stay
// true; only a pathological directory is cut here, and structuredContent
// then carries truncated=true and the summary says so.
fileListMaxEntries = 100000
// fileRecordFixedLen is attr(1) + size(8) + FILETIME(8).
fileRecordFixedLen = 17
// driveRecordFixedLen is letter(1) + type(1) + totalMB(4) + freeMB(4).
driveRecordFixedLen = 10
// filetimeEpochDiff converts FILETIME (100 ns ticks since 1601-01-01) to
// Unix seconds once divided by filetimeTicksPerSec.
filetimeTicksPerSec = 10000000
filetimeEpochDiffSec = 11644473600
errorAccessDenied = 5
errorFileNotFound = 2
errorPathNotFound = 3
batchUnsupportedHint = "batch (ids) is not implemented by this server build; call list_files once per id"
)
// fileListTimeout bounds one list_files round trip, including the sub-conn
// handshake. A variable only so tests can shorten it.
var fileListTimeout = 10 * time.Second
// fileRetireDelay is how long the sub-conn stays open after COMMAND_BYE, so the
// client's read loop sees the goodbye before FIN (the hub uses the same 500 ms
// for screen sub-conns).
var fileRetireDelay = 500 * time.Millisecond
// fileEventKind distinguishes the three packets a list_files call can receive.
type fileEventKind byte
const (
fileEventDriveList fileEventKind = iota + 1 // TOKEN_DRIVE_LIST
fileEventFileList // TOKEN_FILE_LIST
fileEventError // TOKEN_FILE_LIST_ERROR
)
// fileEvent is one packet handed from the TCP read loop to the waiting call.
// ctx identifies the sub-conn it arrived on; payload bytes are copied because
// the read buffer is not ours to keep.
type fileEvent struct {
kind fileEventKind
ctx *connection.Context
payload []byte // drive records or file records (token byte removed)
win32err uint32 // fileEventError only
}
// fileRequest is one in-flight list_files call. ch is buffered so the read loop
// never blocks; sub records which sub-conn answered the drive-list phase and
// rejects packets from any other connection for the same device. abandoned is
// set by cancel so a packet that loses the race with the call's own return is
// not queued into a channel nobody reads.
type fileRequest struct {
ch chan fileEvent
mu sync.Mutex
sub *connection.Context
abandoned bool
}
func (r *fileRequest) subConn() *connection.Context {
r.mu.Lock()
defer r.mu.Unlock()
return r.sub
}
// fileTable holds the single pending list_files per device. The per-device
// call lock already serialises tools, so more than one entry cannot normally
// exist; the table rejects it anyway rather than mis-routing replies.
type fileTable struct {
mu sync.Mutex
byDevice map[string]*fileRequest
}
func newFileTable() *fileTable {
return &fileTable{byDevice: make(map[string]*fileRequest)}
}
func (t *fileTable) begin(deviceID string) (*fileRequest, bool) {
t.mu.Lock()
defer t.mu.Unlock()
if _, ok := t.byDevice[deviceID]; ok {
return nil, false
}
r := &fileRequest{ch: make(chan fileEvent, 2)}
t.byDevice[deviceID] = r
return r, true
}
// cancel ends the request and returns the sub-conn it learned about, if any.
// The caller retires that sub-conn: this is the single retirement point, so a
// call that gives up while its drive-list packet is already queued (the timer
// and the channel being ready at the same time, or the MCP request cancelled)
// still closes the client's file-manager thread instead of leaking it.
func (t *fileTable) cancel(deviceID string, r *fileRequest) *connection.Context {
t.mu.Lock()
if t.byDevice[deviceID] == r {
delete(t.byDevice, deviceID)
}
t.mu.Unlock()
r.mu.Lock()
r.abandoned = true
sub := r.sub
r.mu.Unlock()
return sub
}
// deliver routes one event to the pending call. It reports whether the event
// was accepted; a packet from a connection other than the one that answered
// the drive-list phase is a late packet from an earlier sub-conn and must be
// ignored (the client sends a legacy one-byte TOKEN_FILE_LIST right after
// TOKEN_FILE_LIST_ERROR, and back-to-back calls can overlap with it).
func (t *fileTable) deliver(deviceID string, ev fileEvent) bool {
t.mu.Lock()
r := t.byDevice[deviceID]
t.mu.Unlock()
if r == nil {
return false
}
r.mu.Lock()
if r.abandoned {
// The call already returned; let OnFilePacket treat the packet as an
// orphan (a drive list) instead of queueing it for nobody.
r.mu.Unlock()
return false
}
switch ev.kind {
case fileEventDriveList:
if r.sub != nil && r.sub != ev.ctx {
r.mu.Unlock()
return false
}
if r.sub == nil {
r.sub = ev.ctx
}
case fileEventError:
// No client answers COMMAND_LIST_DRIVE with an error, but if one ever
// does, adopt the connection and let the call translate the code
// instead of dropping the packet and timing out.
if r.sub == nil {
r.sub = ev.ctx
}
if r.sub != ev.ctx {
r.mu.Unlock()
return false
}
default:
if r.sub != ev.ctx {
r.mu.Unlock()
return false
}
}
r.mu.Unlock()
select {
case r.ch <- ev:
default:
// The current phase already has an event queued; a duplicate is only
// noise (the legacy empty TOKEN_FILE_LIST after an error packet).
}
return true
}
func (s *Server) registerFileTools() {
s.handlers["list_files"] = s.callListFiles
s.handlers["read_file"] = s.callReadFile
}
// OnFilePacket feeds one file-manager packet from a sub-connection to the
// pending list_files call. It reports whether the packet belongs to this
// protocol at all; cmd/main.go forwards only the three file-manager tokens.
func (s *Server) OnFilePacket(ctx *connection.Context, data []byte) bool {
if s == nil || len(data) == 0 {
return false
}
switch data[0] {
case protocol.TokenDriveList, protocol.TokenFileList, protocol.TokenFileListError:
default:
return false
}
deviceID := ctx.GetInfo().ClientID
if deviceID == "" {
return true
}
if s.cfg.Hub != nil {
if main := s.cfg.Hub.MainConn(deviceID); main == ctx {
// File-manager packets only ever arrive on the dedicated sub-conn;
// a token that looks like one on the main connection is not ours.
return true
}
}
ev := fileEvent{ctx: ctx}
switch data[0] {
case protocol.TokenDriveList:
ev.kind = fileEventDriveList
ev.payload = append([]byte(nil), data[1:]...)
case protocol.TokenFileList:
ev.kind = fileEventFileList
ev.payload = append([]byte(nil), data[1:]...)
case protocol.TokenFileListError:
ev.kind = fileEventError
if len(data) >= 5 {
ev.win32err = binary.LittleEndian.Uint32(data[1:5])
}
}
if s.files.deliver(deviceID, ev) {
return true
}
// Nothing is waiting for this sub-conn: the call it belonged to already
// timed out or finished. Retire it so the client does not leak its
// file-manager thread, but only once the sub-conn has announced itself.
// A live read_file keeps its file-manager sub-conn registered in the
// transfer table (POSIX clients stream on it), so never close that one.
if ev.kind == fileEventDriveList && !s.transfers.owns(ctx) {
s.retireFileConn(ctx)
}
return true
}
// retireFileConn closes a file-manager sub-conn the way the hub retires screen
// sub-conns: COMMAND_BYE so the client's IOCP loop exits through its clean
// path, then a delayed Close so the goodbye is not overtaken by FIN.
func (s *Server) retireFileConn(ctx *connection.Context) {
if ctx == nil {
return
}
if s.cfg.Hub != nil {
_ = s.cfg.Hub.SendToConn(ctx, []byte{protocol.CommandBye})
}
// Read the delay before spawning: tests shorten it between calls.
delay := fileRetireDelay
go func(c *connection.Context) {
time.Sleep(delay)
_ = c.Close()
}(ctx)
}
// ----- get_screenshot-style argument / result shapes -------------------------
// listFilesArgs is the published inputSchema as Go. ids is advertised by the
// Win32 server for batch reads; this server rejects it explicitly.
type listFilesArgs struct {
ID string `json:"id"`
IDs []string `json:"ids"`
Path string `json:"path"`
Limit int `json:"limit"`
Offset int `json:"offset"`
}
type driveEntry struct {
Drive string `json:"drive"`
Type uint64 `json:"type"`
TypeName string `json:"typeName"`
FileSystem string `json:"fileSystem"`
TotalMB uint64 `json:"totalMB"`
FreeMB uint64 `json:"freeMB"`
}
type fileEntry struct {
Name string `json:"name"`
IsDir bool `json:"isDir"`
Size uint64 `json:"size"`
Mtime int64 `json:"mtime"`
}
// openFileManagerConn asks the device for its file-manager sub-connection
// (COMMAND_LIST_DRIVE on the main connection) and waits for the drive list.
// On success it returns the sub-connection, the still-pending request (later
// packets are matched against it) and the parsed drives; the caller owns both
// and must call closeFileManagerConn when done. Every failure path retires the
// sub-connection here, so a timed-out or rejected handshake leaves no orphan
// file-manager thread on the client.
func (s *Server) openFileManagerConn(ctx context.Context, deviceID string) (*connection.Context, *fileRequest, []driveEntry, *rpcError) {
req, ok := s.files.begin(deviceID)
if !ok {
return nil, nil, nil, errf(CodeBusy, "Device busy: another file request is already pending for host %s", deviceID)
}
keep := false
defer func() {
if !keep {
if sub := s.files.cancel(deviceID, req); sub != nil {
s.retireFileConn(sub)
}
}
}()
if err := s.cfg.Hub.SendToDevice(deviceID, []byte{protocol.CommandListDrive}); err != nil {
if errors.Is(err, hub.ErrDeviceOffline) {
return nil, nil, nil, errf(CodeOffline, "Host not found or offline: %s", deviceID)
}
return nil, nil, nil, errf(CodeSendFailed, "Failed to ask the host for its file-manager channel: %v", err)
}
timer := time.NewTimer(fileListTimeout)
defer timer.Stop()
select {
case ev := <-req.ch:
switch ev.kind {
case fileEventDriveList:
keep = true
return ev.ctx, req, parseDriveList(ev.payload), nil
case fileEventError:
return nil, nil, nil, errf(win32ErrorCode(ev.win32err),
"Failed to open the file-manager channel on host %s (win32=%d)", deviceID, ev.win32err)
default:
return nil, nil, nil, errf(CodeInternal, "Unexpected file-manager reply while listing drives")
}
case <-timer.C:
return nil, nil, nil, errf(CodeTimeout,
"Timeout waiting for the host to open a file-manager channel (%s). Older clients that do not implement file browsing stay silent; retrying will not help.",
fileListTimeout)
case <-ctx.Done():
return nil, nil, nil, errf(CodeTimeout, "Request cancelled while waiting for the host's file-manager channel")
}
}
// closeFileManagerConn ends the request and retires the sub-connection it
// learned about. It is the single retirement point for that sub-conn: the
// cancel below also covers a call that gave up while its drive-list packet was
// already queued (the select taking the timer branch with both ready).
func (s *Server) closeFileManagerConn(deviceID string, req *fileRequest) {
if sub := s.files.cancel(deviceID, req); sub != nil {
s.retireFileConn(sub)
}
}
// callListFiles lists drives (no path) or one directory level.
func (s *Server) callListFiles(ctx context.Context, raw json.RawMessage) (any, *rpcError) {
if s.cfg.Hub == nil {
return nil, errf(CodeInternal, "server device registry is not configured")
}
var args listFilesArgs
if rerr := decodeArgs(raw, &args); rerr != nil {
return nil, rerr
}
if len(args.IDs) > 0 {
return nil, errf(CodeUnsupported, "%s", batchUnsupportedHint)
}
if args.ID == "" {
return nil, errf(CodeInvalidParams, "Missing required parameter: id")
}
if !isDecimalID(args.ID) {
return nil, errf(CodeInvalidParams, "Invalid id: expected a decimal host id string")
}
// NUL and newlines would truncate or split the client's C string field.
if strings.ContainsAny(args.Path, "\x00\r\n") {
return nil, errf(CodeInvalidParams, "Invalid path: NUL and line breaks are not allowed")
}
if s.cfg.Hub.MainConn(args.ID) == nil {
return nil, errf(CodeOffline, "Host not found or offline: %s", args.ID)
}
path := args.Path
// The published contract (tools.json) is: no path lists drives, any path
// lists that directory. MFC also folds "." and "/" into the drive list,
// but that makes a POSIX root listing unreachable, so this server follows
// the documented rule instead.
listDrives := path == ""
pathGBK := protocol.UTF8ToGBK(path)
if len(pathGBK) >= 250 {
// The client copies the path into a MAX_PATH buffer and appends "\\*.*".
return nil, errf(CodeInvalidParams,
"Path too long: %d bytes after conversion to the client's GBK encoding (limit 249)", len(pathGBK))
}
sub, req, drives, rerr := s.openFileManagerConn(ctx, args.ID)
if rerr != nil {
return nil, rerr
}
defer s.closeFileManagerConn(args.ID, req)
if listDrives {
return listFilesResult(args, drives, nil, false), nil
}
// Phase 2: reuse the same sub-conn for the directory itself.
pkt := make([]byte, 0, 2+len(pathGBK))
pkt = append(pkt, protocol.CommandListFiles)
pkt = append(pkt, pathGBK...)
pkt = append(pkt, 0)
if err := s.cfg.Hub.SendToConn(sub, pkt); err != nil {
return nil, errf(CodeSendFailed, "Failed to send the directory request on the file-manager channel: %v", err)
}
timer := time.NewTimer(fileListTimeout)
defer timer.Stop()
select {
case ev := <-req.ch:
switch ev.kind {
case fileEventFileList:
files, truncated := parseFileList(ev.payload)
return listFilesResult(args, nil, files, truncated), nil
case fileEventError:
return nil, fileWin32Error(ev.win32err, path)
default:
return nil, errf(CodeInternal, "Unexpected file-manager reply while listing a directory")
}
case <-timer.C:
return nil, errf(CodeTimeout,
"Timeout waiting for the directory listing of %q (%s). If the path does not exist, an older client stays silent instead of reporting an error — list the parent directory first.",
path, fileListTimeout)
case <-ctx.Done():
return nil, errf(CodeTimeout, "Request cancelled while waiting for the directory listing")
}
}
// win32ErrorCode maps a client-reported Win32 error onto an MCP code the same
// way the Win32 server does: 5 is a permission problem, 2/3 mean "no such
// target", everything else is an internal failure carrying the raw code.
func win32ErrorCode(win32err uint32) int {
switch win32err {
case errorAccessDenied:
return CodePermission
case errorFileNotFound, errorPathNotFound:
return CodeNotFound
default:
return CodeInternal
}
}
// fileWin32Error maps the client's win32 error onto MCP codes the same way the
// Win32 server does: 5 is a permission problem, 2/3 mean "no such target",
// everything else is an internal failure carrying the raw code.
func fileWin32Error(win32err uint32, path string) *rpcError {
subject := fmt.Sprintf("Failed to list %q", path)
switch win32err {
case errorAccessDenied:
return errf(CodePermission, "%s: access denied (win32=%d)", subject, win32err)
case errorFileNotFound, errorPathNotFound:
return errf(CodeNotFound, "%s: target not found (win32=%d)", subject, win32err)
default:
return errf(CodeInternal, "%s: the host reported a failure (win32=%d)", subject, win32err)
}
}
// parseDriveList decodes [letter][type][totalMB:4 LE][freeMB:4 LE][typeName\0][fs\0]
// records until a zero letter (the client's end marker) or a truncated record.
// Names are GBK on the wire for every platform.
func parseDriveList(p []byte) []driveEntry {
out := make([]driveEntry, 0, 8)
off := 0
for off+driveRecordFixedLen <= len(p) && p[off] != 0 {
letter := p[off]
dtype := uint64(p[off+1])
total := uint64(binary.LittleEndian.Uint32(p[off+2:]))
free := uint64(binary.LittleEndian.Uint32(p[off+6:]))
off += driveRecordFixedLen
typeName, n, ok := cString(p[off:])
if !ok {
break
}
off += n + 1
fs, n, ok := cString(p[off:])
if !ok {
break
}
off += n + 1
// Windows letters become "C:\". The POSIX clients report '/' as their
// single root "drive"; return it as "/" so it can be passed straight
// back as a path (MFC renders "/:\", which also works after the
// client's path conversion, but "/" is the friendlier form).
drive := string(letter) + ":\\"
if letter == '/' {
drive = "/"
}
out = append(out, driveEntry{
Drive: drive,
Type: dtype,
TypeName: protocol.GbkToUTF8(typeName),
FileSystem: protocol.GbkToUTF8(fs),
TotalMB: total,
FreeMB: free,
})
}
return out
}
// parseFileList decodes [attr][name\0][sizeHi:4][sizeLo:4][ftLo:4][ftHi:4]
// records. An empty name is the client's trailing zero padding; reaching the
// entry cap stops the parse and reports truncation.
func parseFileList(p []byte) ([]fileEntry, bool) {
out := make([]fileEntry, 0, 64)
off := 0
for off < len(p) {
attr := p[off]
off++
name, n, ok := cString(p[off:])
if !ok || n == 0 {
break
}
// Cap check after a real record is seen: trailing zero padding (an empty
// name) must not report truncation when the listing is exactly at the cap.
if len(out) >= fileListMaxEntries {
return out, true
}
off += n + 1
if off+fileRecordFixedLen-1 > len(p) {
break
}
sizeHigh := uint64(binary.LittleEndian.Uint32(p[off:]))
sizeLow := uint64(binary.LittleEndian.Uint32(p[off+4:]))
ftLow := uint64(binary.LittleEndian.Uint32(p[off+8:]))
ftHigh := uint64(binary.LittleEndian.Uint32(p[off+12:]))
off += 16
ft := ftHigh<<32 | ftLow
var mtime int64
if ft != 0 {
mtime = int64(ft/filetimeTicksPerSec) - filetimeEpochDiffSec
if mtime < 0 {
mtime = 0
}
}
out = append(out, fileEntry{
Name: protocol.GbkToUTF8(name),
IsDir: attr&0x10 != 0,
Size: sizeHigh<<32 | sizeLow,
Mtime: mtime,
})
}
return out, false
}
// cString returns the NUL-terminated field at the start of p. ok is false when
// p runs out before the terminator (a truncated packet).
func cString(p []byte) (name []byte, n int, ok bool) {
for i, b := range p {
if b == 0 {
return p[:i], i, true
}
}
return nil, 0, false
}
// listFilesResult applies the limit/offset window and builds the MCP envelope.
// Only one of drives/files is non-nil; total/totalAll/hasMore describe the
// full listing, not the returned page. truncated reports that the directory
// held more entries than the parse cap, so the model is not told "that is all
// there is".
func listFilesResult(args listFilesArgs, drives []driveEntry, files []fileEntry, truncated bool) toolResult {
limit := clampPageLimit(args.Limit)
offset := max(args.Offset, 0)
var structured map[string]any
var text string
var header []string
var rows [][]string
if drives != nil {
total := len(drives)
begin := min(offset, total)
end := min(begin+limit, total)
structured = map[string]any{
"drives": drives[begin:end],
"total": total,
"totalAll": total,
"limit": limit,
"offset": offset,
"hasMore": end < total,
}
text = pageSummary(total, limit, offset, "个驱动器")
header = []string{"drive", "typeName", "fileSystem", "totalMB", "freeMB"}
rows = make([][]string, 0, end-begin)
for _, d := range drives[begin:end] {
rows = append(rows, []string{
d.Drive, d.TypeName, d.FileSystem,
strconv.FormatUint(d.TotalMB, 10), strconv.FormatUint(d.FreeMB, 10),
})
}
} else {
total := len(files)
begin := min(offset, total)
end := min(begin+limit, total)
structured = map[string]any{
"files": files[begin:end],
"total": total,
"totalAll": total,
"limit": limit,
"offset": offset,
"hasMore": end < total,
"truncated": truncated,
}
text = pageSummary(total, limit, offset, "个条目")
header = []string{"name", "isDir", "size", "mtime"}
rows = make([][]string, 0, end-begin)
for _, f := range files[begin:end] {
rows = append(rows, []string{
f.Name, strconv.FormatBool(f.IsDir),
strconv.FormatUint(f.Size, 10), strconv.FormatInt(f.Mtime, 10),
})
}
}
if truncated {
text += fmt.Sprintf("目录条目超过 %d 条,total 只是上限内的数量,请缩小目录范围。", fileListMaxEntries)
}
text = appendRows(text, header, rows)
return newToolResult(text, structured)
}