Files
skillshare/internal/server/handler_sync_matrix.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

238 lines
7.5 KiB
Go

package server
import (
"errors"
"net/http"
"strings"
"skillshare/internal/config"
"skillshare/internal/resource"
ssync "skillshare/internal/sync"
)
type syncMatrixEntry struct {
Skill string `json:"skill"`
Target string `json:"target"`
Status string `json:"status"`
Reason string `json:"reason"`
ReasonCode string `json:"reasonCode,omitempty"`
ReasonParams map[string]string `json:"reasonParams,omitempty"`
Kind string `json:"kind,omitempty"`
}
func syncMatrixReason(status, reason string) (string, map[string]string) {
if reason == "symlink mode — filters not applicable" {
return "sync_matrix.symlink_filters_not_applicable", nil
}
switch status {
case "synced":
return "sync_matrix.synced", nil
case "excluded":
return "sync_matrix.excluded", map[string]string{"pattern": reason}
case "not_included":
return "sync_matrix.not_included", nil
case "skill_target_mismatch":
return "sync_matrix.skill_target_mismatch", nil
default:
return "", nil
}
}
// agentFilterName is the name agent filter patterns match against, mirroring ssync.FilterAgents.
func agentFilterName(flatName string) string {
return strings.TrimSuffix(flatName, ".md")
}
func newSyncMatrixEntry(skill, target, status, reason, kind string) syncMatrixEntry {
reasonCode, reasonParams := syncMatrixReason(status, reason)
return syncMatrixEntry{
Skill: skill,
Target: target,
Status: status,
Reason: reason,
ReasonCode: reasonCode,
ReasonParams: reasonParams,
Kind: kind,
}
}
func (s *Server) handleSyncMatrix(w http.ResponseWriter, r *http.Request) {
// Snapshot config under RLock, then release before I/O.
s.mu.RLock()
source := s.cfg.EffectiveSkillsSource()
agentsSource := s.agentsSource()
targets := s.cloneTargets()
s.mu.RUnlock()
skills, err := ssync.DiscoverSourceSkills(source)
if err != nil {
writeError(w, http.StatusInternalServerError, "failed to discover skills: "+err.Error())
return
}
var agents []resource.DiscoveredResource
if agentsSource != "" {
discovered, _ := resource.AgentKind{}.Discover(agentsSource)
agents = resource.ActiveAgents(discovered)
}
var builtinAgents map[string]config.TargetConfig
if s.IsProjectMode() {
builtinAgents = config.ProjectAgentTargets()
} else {
builtinAgents = config.DefaultAgentTargets()
}
targetFilter := r.URL.Query().Get("target")
var entries []syncMatrixEntry
for name, target := range targets {
if targetFilter != "" && name != targetFilter {
continue
}
// Skills
sc := target.SkillsConfig()
if !sc.IsEnabled() {
for _, skill := range skills {
entries = append(entries, newSyncMatrixEntry(skill.FlatName, name, "na", "skills off for this target", ""))
}
} else if sc.Mode == "symlink" {
for _, skill := range skills {
entries = append(entries, newSyncMatrixEntry(skill.FlatName, name, "na", "symlink mode — filters not applicable", ""))
}
} else {
for _, skill := range skills {
status, reason := ssync.ClassifySkillForTarget(skill.FlatName, skill.Targets, name, sc.Include, sc.Exclude)
entries = append(entries, newSyncMatrixEntry(skill.FlatName, name, status, reason, ""))
}
}
// Agents — resolve path from user config or builtin defaults
ac := target.AgentsConfig()
agentPath := ac.Path
if agentPath == "" {
if builtin, ok := builtinAgents[name]; ok {
agentPath = builtin.Path
}
}
if agentPath == "" || len(agents) == 0 {
continue
}
agentMode := ac.Mode
if agentMode == "" {
agentMode = "merge"
}
if agentMode == "symlink" {
for _, agent := range agents {
entries = append(entries, newSyncMatrixEntry(agent.FlatName, name, "na", "symlink mode — filters not applicable", "agent"))
}
} else {
for _, agent := range agents {
status, reason := ssync.ClassifySkillForTarget(agentFilterName(agent.FlatName), agent.Targets, name, ac.Include, ac.Exclude)
entries = append(entries, newSyncMatrixEntry(agent.FlatName, name, status, reason, "agent"))
}
}
}
writeJSON(w, map[string]any{"entries": entries})
}
func (s *Server) handleSyncMatrixPreview(w http.ResponseWriter, r *http.Request) {
// Snapshot config under RLock, then release before I/O.
s.mu.RLock()
source := s.cfg.EffectiveSkillsSource()
agentsSource := s.agentsSource()
targets := s.cloneTargets()
s.mu.RUnlock()
var body struct {
Target string `json:"target"`
Include []string `json:"include"`
Exclude []string `json:"exclude"`
AgentInclude []string `json:"agent_include"`
AgentExclude []string `json:"agent_exclude"`
}
if err := decodeJSON(w, r, &body, defaultJSONBodyLimit); err != nil {
if !errors.Is(err, errBodyTooLarge) {
writeError(w, http.StatusBadRequest, "invalid JSON: "+err.Error())
}
return
}
if body.Target == "" {
writeError(w, http.StatusBadRequest, "target is required")
return
}
// Validate skill patterns
if _, err := ssync.FilterSkills(nil, body.Include, nil); err != nil {
writeError(w, http.StatusBadRequest, err.Error())
return
}
if _, err := ssync.FilterSkills(nil, nil, body.Exclude); err != nil {
writeError(w, http.StatusBadRequest, err.Error())
return
}
// Validate agent patterns
if _, err := ssync.FilterSkills(nil, body.AgentInclude, nil); err != nil {
writeError(w, http.StatusBadRequest, "invalid agent include pattern: "+err.Error())
return
}
if _, err := ssync.FilterSkills(nil, nil, body.AgentExclude); err != nil {
writeError(w, http.StatusBadRequest, "invalid agent exclude pattern: "+err.Error())
return
}
skills, err := ssync.DiscoverSourceSkills(source)
if err != nil {
writeError(w, http.StatusInternalServerError, "failed to discover skills: "+err.Error())
return
}
var entries []syncMatrixEntry
for _, skill := range skills {
status, reason := ssync.ClassifySkillForTarget(skill.FlatName, skill.Targets, body.Target, body.Include, body.Exclude)
entries = append(entries, newSyncMatrixEntry(skill.FlatName, body.Target, status, reason, ""))
}
// Agents — resolve path from config or builtin defaults
target, ok := targets[body.Target]
_, projectTool, isProject := config.SplitProjectTarget(body.Target)
if (ok || isProject) && agentsSource != "" {
ac := target.AgentsConfig()
agentPath := ac.Path
if agentPath == "" {
var previewBuiltin map[string]config.TargetConfig
if s.IsProjectMode() {
previewBuiltin = config.ProjectAgentTargets()
} else {
previewBuiltin = config.DefaultAgentTargets()
}
if builtin, found := previewBuiltin[body.Target]; found {
agentPath = builtin.Path
}
// A project's draft can turn agents on before the project is saved.
if builtin, found := config.LookupProjectAgentTarget(projectTool); isProject && found {
agentPath = builtin.Path
}
}
if agentPath != "" {
discovered, _ := resource.AgentKind{}.Discover(agentsSource)
agents := resource.ActiveAgents(discovered)
agentMode := ac.Mode
if agentMode == "" {
agentMode = "merge"
}
if agentMode == "symlink" {
for _, agent := range agents {
entries = append(entries, newSyncMatrixEntry(agent.FlatName, body.Target, "na", "symlink mode — filters not applicable", "agent"))
}
} else {
for _, agent := range agents {
status, reason := ssync.ClassifySkillForTarget(agentFilterName(agent.FlatName), agent.Targets, body.Target, body.AgentInclude, body.AgentExclude)
entries = append(entries, newSyncMatrixEntry(agent.FlatName, body.Target, status, reason, "agent"))
}
}
}
}
writeJSON(w, map[string]any{"entries": entries})
}