Files
skillshare/internal/server/handler_mcp.go
T
Willie 36a314442b refactor(server): decode JSON request bodies through one size-limited helper
About 57 handlers decoded request bodies with no size limit, and the few
that had one each picked their own. They now go through decodeJSON with a
1 MiB default; handlers that need more keep their larger limit. An
oversized body gets 413 instead of whatever the handler returned for bad
JSON (MCP and plugin requests used to answer 400). Every other decode
error keeps the handler's existing status and message.
2026-09-30 02:25:42 +08:00

243 lines
6.6 KiB
Go

package server
import (
"encoding/json"
"errors"
"fmt"
"io"
"maps"
"net/http"
"os"
"path/filepath"
"reflect"
"slices"
"strings"
"time"
"skillshare/internal/config"
"skillshare/internal/mcp"
)
func (s *Server) mcpService() *mcp.Service {
return &mcp.Service{ConfigPath: s.configPath(), ProjectRoot: s.projectRoot, StateDir: config.StateDir(), ConfigDirs: mcp.ConfigDirsFromEnv()}
}
type mcpRequest struct {
Mutation mcp.Mutation `json:"mutation"`
Revision string `json:"revision"`
Sync bool `json:"sync"`
BackupID string `json:"backupId"`
Preview bool `json:"preview"`
// Root, with sync and no mutation, applies only that mcp.projects root's changes.
Root string `json:"root"`
}
func decodeMCPRequest(w http.ResponseWriter, r *http.Request, value any) bool {
var extra bool
err := decodeJSONWith(w, r, defaultJSONBodyLimit, func(d *json.Decoder) error {
d.DisallowUnknownFields()
if err := d.Decode(value); err != nil {
return err
}
extra = d.Decode(new(any)) != io.EOF
return nil
})
switch {
case errors.Is(err, errBodyTooLarge):
return false
case err != nil:
writeError(w, 400, "invalid MCP request")
return false
case extra:
writeError(w, 400, "expected one MCP request")
return false
}
return true
}
func (s *Server) handleMCPList(w http.ResponseWriter, r *http.Request) {
s.mu.RLock()
defer s.mu.RUnlock()
service := s.mcpService()
source, err := mcp.LoadSource(service.ConfigPath)
if err != nil {
writeError(w, 400, err.Error())
return
}
// Unresolvable paths are omitted; selected targets report them via previewError.
paths := service.ClientPaths()
maps.Copy(paths, service.AccountPaths(source.Accounts))
p, previewErr := service.Preview()
message := ""
if previewErr != nil {
message = previewErr.Error()
}
backups, err := service.Backups()
if err != nil {
writeError(w, 500, err.Error())
return
}
// A root with its own project config is managed from two places; the plan reports a
// conflict when both hold one entry, so the dashboard says so up front.
ownConfig := []string{}
for root := range source.Projects {
if _, err := os.Stat(filepath.Join(root, ".skillshare", "config.yaml")); err == nil {
ownConfig = append(ownConfig, root)
}
}
slices.Sort(ownConfig)
detected := service.DetectedClients(paths)
if !s.IsProjectMode() {
detected = append(detected, mcp.DetectedAccounts(source.Accounts)...)
}
writeJSON(w, map[string]any{"source": source, "paths": paths, "detected": detected, "plan": p, "previewError": message, "backups": backups, "projectConfigs": ownConfig, "unmanaged": service.FindUnmanaged(source)})
}
func (s *Server) handleMCPPreview(w http.ResponseWriter, r *http.Request) {
var body mcpRequest
if !decodeMCPRequest(w, r, &body) {
return
}
s.mu.RLock()
defer s.mu.RUnlock()
p, err := s.mcpService().PreviewMutation(body.Mutation)
if err != nil {
writeError(w, 400, err.Error())
return
}
writeJSON(w, p)
}
// handleMCPRender shows the server in the request as each of its targets would store it.
// It reads and writes nothing, so an unsaved form can ask.
func (s *Server) handleMCPRender(w http.ResponseWriter, r *http.Request) {
var body mcpRequest
if !decodeMCPRequest(w, r, &body) {
return
}
if body.Mutation.Server == nil {
writeError(w, 400, "server is required")
return
}
writeJSON(w, map[string]any{"rendered": s.mcpService().RenderNative(body.Mutation.Name, *body.Mutation.Server)})
}
func (s *Server) handleMCPConfigure(w http.ResponseWriter, r *http.Request) {
var body mcpRequest
if !decodeMCPRequest(w, r, &body) {
return
}
if body.Revision == "" {
writeError(w, 400, "preview the MCP changes before saving")
return
}
if body.Root != "" && (!body.Sync || !reflect.DeepEqual(body.Mutation, mcp.Mutation{})) {
writeError(w, 400, "a project sync takes no changes")
return
}
s.mu.Lock()
defer s.mu.Unlock()
start := time.Now()
var result *mcp.Result
var err error
logArgs := map[string]any{"scope": "ui"}
if body.Root != "" {
logArgs["project"] = body.Root
result, err = s.mcpService().ApplyProject(body.Revision, body.Root)
} else {
result, err = s.mcpService().Mutate(body.Mutation, body.Revision, body.Sync)
}
status := "ok"
if err != nil {
status = "error"
}
s.writeOpsLog("mcp configure", status, start, logArgs, "")
if errors.Is(err, mcp.ErrUnknownProject) {
writeError(w, 400, err.Error())
return
}
if err != nil {
writeMCPFailure(w, result, err)
return
}
if err := s.reloadConfig(); err != nil {
writeError(w, 500, "MCP saved, but config reload failed")
return
}
writeJSON(w, result)
}
func (s *Server) handleMCPImport(w http.ResponseWriter, r *http.Request) {
var body struct {
From string `json:"from"`
Content string `json:"content"`
Name string `json:"name"`
// Root reads the target's file in that mcp.projects root instead of this scope.
Root string `json:"root"`
}
if !decodeMCPRequest(w, r, &body) {
return
}
s.mu.RLock()
defer s.mu.RUnlock()
var candidates []mcp.Candidate
var err error
if body.Content != "" {
candidates, err = mcp.Import(body.From, []byte(body.Content), body.Name)
} else if body.Root != "" {
candidates, err = s.mcpService().ImportProjectClient(body.Root, body.From)
} else {
candidates, err = s.mcpService().ImportClient(body.From)
}
if err != nil {
writeError(w, 400, err.Error())
return
}
writeJSON(w, map[string]any{"candidates": candidates})
}
func (s *Server) handleMCPRestore(w http.ResponseWriter, r *http.Request) {
var body mcpRequest
if !decodeMCPRequest(w, r, &body) {
return
}
s.mu.Lock()
defer s.mu.Unlock()
service := s.mcpService()
if body.Preview {
p, err := service.PreviewRestore(body.BackupID)
if err != nil {
writeError(w, 400, err.Error())
return
}
writeJSON(w, p)
return
}
if body.Revision == "" {
writeError(w, 400, "preview before restoring")
return
}
start := time.Now()
result, err := service.Restore(body.BackupID, body.Revision)
status := "ok"
if err != nil {
status = "error"
}
s.writeOpsLog("mcp restore", status, start, map[string]any{"scope": "ui"}, "")
if err != nil {
writeMCPFailure(w, result, err)
return
}
writeJSON(w, result)
}
func writeMCPFailure(w http.ResponseWriter, result *mcp.Result, err error) {
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(http.StatusConflict)
message := err.Error()
if result != nil && len(result.Applied) > 0 {
message += fmt.Sprintf("; already applied: %s; backup IDs: %s", strings.Join(result.Applied, ", "), strings.Join(result.BackupIDs, ", "))
}
_ = json.NewEncoder(w).Encode(map[string]any{"error": message, "result": result})
}