mirror of
https://github.com/runkids/skillshare.git
synced 2026-11-19 02:17:09 +00:00
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.
379 lines
11 KiB
Go
379 lines
11 KiB
Go
package server
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"net/http"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"time"
|
|
|
|
"skillshare/internal/git"
|
|
"skillshare/internal/install"
|
|
"skillshare/internal/resource"
|
|
"skillshare/internal/sync"
|
|
)
|
|
|
|
// skillContentRequest is the JSON body for PUT /api/resources/{name}/content
|
|
type skillContentRequest struct {
|
|
Content string `json:"content"`
|
|
}
|
|
|
|
// skillContentResponse is the JSON response on successful save.
|
|
type skillContentResponse struct {
|
|
BytesWritten int `json:"bytesWritten"`
|
|
Path string `json:"path"`
|
|
ContentType string `json:"contentType"`
|
|
SavedAt string `json:"savedAt"`
|
|
}
|
|
|
|
// handlePutSkillContent saves the SKILL.md (or agent markdown) content to disk.
|
|
// Request body: {"content": "..."}
|
|
// Writes atomically via <file>.tmp + rename.
|
|
func (s *Server) handlePutSkillContent(w http.ResponseWriter, r *http.Request) {
|
|
start := time.Now()
|
|
|
|
s.mu.RLock()
|
|
source := s.cfg.EffectiveSkillsSource()
|
|
agentsSource := s.agentsSource()
|
|
s.mu.RUnlock()
|
|
|
|
name := r.PathValue("name")
|
|
kind := r.URL.Query().Get("kind")
|
|
if kind != "" && kind != "skill" && kind != "agent" {
|
|
writeError(w, http.StatusBadRequest, "invalid kind: "+kind)
|
|
return
|
|
}
|
|
|
|
var req skillContentRequest
|
|
if err := decodeJSON(w, r, &req, defaultJSONBodyLimit); err != nil {
|
|
if !errors.Is(err, errBodyTooLarge) {
|
|
writeError(w, http.StatusBadRequest, "invalid JSON body: "+err.Error())
|
|
}
|
|
return
|
|
}
|
|
|
|
// Reject writes above a conservative ceiling to guard against accidents.
|
|
const maxBytes = 2 * 1024 * 1024 // 2 MiB
|
|
if len(req.Content) > maxBytes {
|
|
writeError(w, http.StatusRequestEntityTooLarge, fmt.Sprintf("content exceeds %d bytes", maxBytes))
|
|
return
|
|
}
|
|
|
|
targetPath, resolvedKind, err := s.resolveEditableSkillPath(source, agentsSource, name, kind)
|
|
if err != nil {
|
|
writeError(w, http.StatusNotFound, err.Error())
|
|
return
|
|
}
|
|
|
|
if err := writeFileAtomic(targetPath, []byte(req.Content), 0o644); err != nil {
|
|
writeError(w, http.StatusInternalServerError, "failed to save: "+err.Error())
|
|
return
|
|
}
|
|
|
|
s.writeOpsLog("skill.edit", "ok", start, map[string]any{
|
|
"name": name,
|
|
"kind": resolvedKind,
|
|
"path": targetPath,
|
|
"length": len(req.Content),
|
|
}, "")
|
|
|
|
writeJSON(w, skillContentResponse{
|
|
BytesWritten: len(req.Content),
|
|
Path: targetPath,
|
|
ContentType: "text/markdown",
|
|
SavedAt: time.Now().UTC().Format(time.RFC3339),
|
|
})
|
|
}
|
|
|
|
// patchSourceRequest is the JSON body for PATCH /api/resources/{name}/source.
|
|
type patchSourceRequest struct {
|
|
Source string `json:"source"`
|
|
}
|
|
|
|
// handlePatchSkillSource updates the source URL for a tracked skill or agent.
|
|
// It updates the metadata store entry and, for tracked repos with a .git directory,
|
|
// also updates the git remote origin URL.
|
|
func (s *Server) handlePatchSkillSource(w http.ResponseWriter, r *http.Request) {
|
|
start := time.Now()
|
|
name := r.PathValue("name")
|
|
kind := r.URL.Query().Get("kind") // optional: "skill" or "agent"
|
|
|
|
var req patchSourceRequest
|
|
if err := decodeJSON(w, r, &req, defaultJSONBodyLimit); err != nil {
|
|
if !errors.Is(err, errBodyTooLarge) {
|
|
writeError(w, http.StatusBadRequest, "invalid JSON body: "+err.Error())
|
|
}
|
|
return
|
|
}
|
|
req.Source = strings.TrimSpace(req.Source)
|
|
if req.Source == "" {
|
|
writeError(w, http.StatusBadRequest, "source cannot be empty")
|
|
return
|
|
}
|
|
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
|
|
parsed, parseErr := install.ParseSourceWithOptions(req.Source, s.parseOpts())
|
|
if parseErr != nil {
|
|
writeError(w, http.StatusBadRequest, "invalid source: "+parseErr.Error())
|
|
return
|
|
}
|
|
|
|
newRepoURL := req.Source
|
|
if parsed.IsGit() {
|
|
newRepoURL = parsed.CloneURL
|
|
}
|
|
|
|
source := s.cfg.EffectiveSkillsSource()
|
|
agentsSource := s.agentsSource()
|
|
|
|
m := s.findMetadataEntry(name, kind, source, agentsSource)
|
|
if m == nil {
|
|
writeError(w, http.StatusNotFound, "resource not found: "+name)
|
|
return
|
|
}
|
|
entry := m.Entry
|
|
if entry == nil {
|
|
entry = &install.MetadataEntry{}
|
|
}
|
|
|
|
// Detect tracked repo by walking up for .git, bounded by storeDir.
|
|
// This handles both direct tracked repos (IsInRepo=true) and --into repos.
|
|
repoRoot := findRepoRoot(m.SourcePath, m.StoreDir)
|
|
isTracked := repoRoot != ""
|
|
|
|
// For tracked repos with missing metadata, infer RepoURL from git remote.
|
|
oldRepoURL := entry.RepoURL
|
|
if oldRepoURL == "" && isTracked {
|
|
if remoteURL, err := git.GetRemoteURL(repoRoot); err == nil && remoteURL != "" {
|
|
oldRepoURL = remoteURL
|
|
}
|
|
}
|
|
|
|
oldSource := entry.Source
|
|
updated := 0
|
|
|
|
// Update git remote origin before persisting metadata so the API does not
|
|
// report success while the on-disk repository still points at the old URL.
|
|
if repoRoot != "" {
|
|
if err := git.SetRemoteURL(repoRoot, newRepoURL); err != nil {
|
|
s.writeOpsLog("skill.source", "error", start, map[string]any{
|
|
"name": name,
|
|
"kind": m.Kind,
|
|
"oldSource": oldSource,
|
|
"newSource": req.Source,
|
|
}, err.Error())
|
|
writeError(w, http.StatusInternalServerError, "failed to update git remote URL: "+err.Error())
|
|
return
|
|
}
|
|
}
|
|
|
|
if m.Entry == nil {
|
|
m.Store.Set(m.RelPath, entry)
|
|
}
|
|
|
|
// For tracked repos, update ALL skills sharing the same git repo.
|
|
if oldRepoURL != "" && isTracked {
|
|
oldBase := strings.TrimSuffix(oldRepoURL, ".git")
|
|
newBase := strings.TrimSuffix(newRepoURL, ".git")
|
|
for _, key := range m.Store.List() {
|
|
e := m.Store.Get(key)
|
|
if e == nil || e.RepoURL != oldRepoURL {
|
|
continue
|
|
}
|
|
e.RepoURL = newRepoURL
|
|
if oldBase != newBase {
|
|
e.Source = strings.Replace(e.Source, oldBase, newBase, 1)
|
|
}
|
|
updated++
|
|
}
|
|
// Also update the entry itself if it was freshly created (no RepoURL yet).
|
|
if entry.RepoURL != newRepoURL {
|
|
entry.Source = req.Source
|
|
entry.RepoURL = newRepoURL
|
|
updated++
|
|
}
|
|
} else {
|
|
entry.Source = req.Source
|
|
entry.RepoURL = newRepoURL
|
|
updated = 1
|
|
}
|
|
|
|
if err := m.Store.Save(m.StoreDir); err != nil {
|
|
writeError(w, http.StatusInternalServerError, "failed to save metadata: "+err.Error())
|
|
return
|
|
}
|
|
|
|
s.writeOpsLog("skill.source", "ok", start, map[string]any{
|
|
"name": name,
|
|
"kind": m.Kind,
|
|
"oldSource": oldSource,
|
|
"newSource": req.Source,
|
|
"updated": updated,
|
|
}, "")
|
|
|
|
writeJSON(w, map[string]any{
|
|
"success": true,
|
|
"source": entry.Source,
|
|
"repoUrl": entry.RepoURL,
|
|
"updated": updated,
|
|
})
|
|
}
|
|
|
|
// metadataLookup holds the result of findMetadataEntry.
|
|
type metadataLookup struct {
|
|
Store *install.MetadataStore
|
|
StoreDir string
|
|
Entry *install.MetadataEntry // nil if resource exists on disk but has no metadata
|
|
RelPath string
|
|
SourcePath string
|
|
IsInRepo bool
|
|
Kind string // "skill" or "agent"
|
|
}
|
|
|
|
// findMetadataEntry looks up a metadata entry by name across skills and agents stores.
|
|
func (s *Server) findMetadataEntry(name, kind, source, agentsSource string) *metadataLookup {
|
|
if kind != "agent" && source != "" {
|
|
discovered, err := sync.DiscoverSourceSkillsAll(source)
|
|
if err == nil {
|
|
for _, d := range discovered {
|
|
if d.FlatName != name && filepath.Base(d.SourcePath) != name {
|
|
continue
|
|
}
|
|
return &metadataLookup{
|
|
Store: s.skillsStore, StoreDir: source,
|
|
Entry: s.skillsStore.GetByPath(d.RelPath),
|
|
RelPath: d.RelPath, SourcePath: d.SourcePath,
|
|
IsInRepo: d.IsInRepo, Kind: "skill",
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if kind != "skill" && agentsSource != "" {
|
|
agents, _ := resource.AgentKind{}.Discover(agentsSource)
|
|
for _, d := range agents {
|
|
if d.FlatName != name && d.Name != name {
|
|
continue
|
|
}
|
|
agentKey := strings.TrimSuffix(d.RelPath, ".md")
|
|
return &metadataLookup{
|
|
Store: s.agentsStore, StoreDir: agentsSource,
|
|
Entry: s.agentsStore.GetByPath(agentKey),
|
|
RelPath: agentKey, SourcePath: filepath.Dir(d.SourcePath),
|
|
IsInRepo: d.IsInRepo, Kind: "agent",
|
|
}
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// findRepoRoot walks up from path looking for a tracked-skill .git directory,
|
|
// strictly BELOW root. The source root itself is never a tracked repo (it holds
|
|
// many skills from different sources), and it may legitimately be a GitSync repo
|
|
// — treating it as a tracked repo would rewrite that repo's origin. Returns the
|
|
// directory containing .git, or "" if none found.
|
|
func findRepoRoot(path, root string) string {
|
|
cleanRoot := filepath.Clean(root)
|
|
prefix := cleanRoot + string(filepath.Separator)
|
|
for dir := filepath.Clean(path); dir != filepath.Dir(dir); dir = filepath.Dir(dir) {
|
|
// Stop once we reach the source root (or step outside it): a tracked
|
|
// skill's .git always lives in a subdirectory, never at root itself.
|
|
if dir == cleanRoot || !strings.HasPrefix(dir, prefix) {
|
|
break
|
|
}
|
|
if fi, err := os.Stat(filepath.Join(dir, ".git")); err == nil && fi.IsDir() {
|
|
return dir
|
|
}
|
|
}
|
|
return ""
|
|
}
|
|
|
|
// resolveEditableSkillPath locates the on-disk markdown file for a skill or agent.
|
|
// For skills this is <skillDir>/SKILL.md; for agents this is the agent's single .md file.
|
|
// Returns (absPath, resolvedKind, error).
|
|
func (s *Server) resolveEditableSkillPath(source, agentsSource, name, kind string) (string, string, error) {
|
|
if kind != "agent" && source != "" {
|
|
discovered, err := sync.DiscoverSourceSkillsAll(source)
|
|
if err == nil {
|
|
for _, d := range discovered {
|
|
baseName := filepath.Base(d.SourcePath)
|
|
if d.FlatName != name && baseName != name {
|
|
continue
|
|
}
|
|
skillMd := filepath.Join(d.SourcePath, "SKILL.md")
|
|
if !withinDir(skillMd, d.SourcePath) {
|
|
return "", "", fmt.Errorf("invalid skill path")
|
|
}
|
|
return skillMd, "skill", nil
|
|
}
|
|
}
|
|
}
|
|
|
|
if kind != "skill" && agentsSource != "" {
|
|
agents, _ := resource.AgentKind{}.Discover(agentsSource)
|
|
for _, d := range agents {
|
|
if !matchesAgentName(d, name) {
|
|
continue
|
|
}
|
|
if !withinDir(d.SourcePath, agentsSource) {
|
|
return "", "", fmt.Errorf("invalid agent path")
|
|
}
|
|
return d.SourcePath, "agent", nil
|
|
}
|
|
}
|
|
|
|
return "", "", fmt.Errorf("skill not found: %s", name)
|
|
}
|
|
|
|
// withinDir reports whether path is inside (or equal to) dir.
|
|
// Uses filepath.Rel for correctness on case-insensitive filesystems.
|
|
func withinDir(path, dir string) bool {
|
|
rel, err := filepath.Rel(filepath.Clean(dir), filepath.Clean(path))
|
|
if err != nil {
|
|
return false
|
|
}
|
|
return rel == "." || (!strings.HasPrefix(rel, "..") && !filepath.IsAbs(rel))
|
|
}
|
|
|
|
// writeFileAtomic writes data to a temp file in the same directory, then renames it
|
|
// into place. This prevents partial writes if the process is killed mid-write.
|
|
func writeFileAtomic(path string, data []byte, perm os.FileMode) error {
|
|
dir := filepath.Dir(path)
|
|
tmp, err := os.CreateTemp(dir, ".skillshare-"+filepath.Base(path)+".*")
|
|
if err != nil {
|
|
return fmt.Errorf("create temp: %w", err)
|
|
}
|
|
tmpPath := tmp.Name()
|
|
cleanup := func() { _ = os.Remove(tmpPath) }
|
|
|
|
if _, err := tmp.Write(data); err != nil {
|
|
_ = tmp.Close()
|
|
cleanup()
|
|
return fmt.Errorf("write temp: %w", err)
|
|
}
|
|
if err := tmp.Chmod(perm); err != nil {
|
|
_ = tmp.Close()
|
|
cleanup()
|
|
return fmt.Errorf("chmod temp: %w", err)
|
|
}
|
|
if err := tmp.Sync(); err != nil {
|
|
_ = tmp.Close()
|
|
cleanup()
|
|
return fmt.Errorf("sync temp: %w", err)
|
|
}
|
|
if err := tmp.Close(); err != nil {
|
|
cleanup()
|
|
return fmt.Errorf("close temp: %w", err)
|
|
}
|
|
if err := os.Rename(tmpPath, path); err != nil {
|
|
cleanup()
|
|
return fmt.Errorf("rename temp: %w", err)
|
|
}
|
|
return nil
|
|
}
|