Files
skillshare/internal/server/handler_skills_batch_test.go
T
Willie 0cc1c25d67 fix(server): keep local edits when the dashboard updates an agent (#967)
Updating an agent from the dashboard replaced the file with the remote
version even when the user had edited it since install. Skills were already
protected: update skips them and offers a forced retry. Agents had the
recorded file hash to compare against, but the update never looked at it.

An agent whose file no longer matches its recorded hash is now skipped with
the same message as a skill, so the Updates tab offers Force Retry and the
agent's own page asks before overwriting. The check runs only once a newer
version is about to be written, so an edited agent that is already at the
remote version still reports up to date.

Assigning targets to an agent from the dashboard rewrites its frontmatter.
That rewrite now carries the recorded hash, as it does for skills, so it is
not mistaken for a local edit.

The confirmation on the agent's page no longer tries to list the local
changes: that list is served for skills only and showed a load error.
2026-11-20 17:23:26 +08:00

521 lines
18 KiB
Go

package server
import (
"bytes"
"encoding/json"
"fmt"
"net/http"
"net/http/httptest"
"os"
"path/filepath"
"testing"
"skillshare/internal/install"
ssync "skillshare/internal/sync"
"skillshare/internal/utils"
)
// addSkillWithTargets creates a skill with an existing targets field in frontmatter.
func addSkillWithTargets(t *testing.T, sourceDir, name string, targets []string) {
t.Helper()
skillDir := filepath.Join(sourceDir, name)
os.MkdirAll(skillDir, 0755)
targetYAML := ""
if len(targets) > 0 {
targetYAML = "\nmetadata:\n targets:\n"
for _, tgt := range targets {
targetYAML += " - " + tgt + "\n"
}
}
content := "---\nname: " + name + targetYAML + "\n---\n# " + name
os.WriteFile(filepath.Join(skillDir, "SKILL.md"), []byte(content), 0644)
}
// addSkillNested creates a skill in a subdirectory (e.g. "folder/skill-name").
func addSkillNested(t *testing.T, sourceDir, relPath string) {
t.Helper()
skillDir := filepath.Join(sourceDir, filepath.FromSlash(relPath))
os.MkdirAll(skillDir, 0755)
name := filepath.Base(relPath)
os.WriteFile(filepath.Join(skillDir, "SKILL.md"), []byte("---\nname: "+name+"\n---\n# "+name), 0644)
}
// --- Batch endpoint tests ---
func TestHandleBatchSetTargets_SetSingleTarget(t *testing.T) {
s, src := newTestServer(t)
addSkillNested(t, src, "frontend/skill-a")
addSkillNested(t, src, "frontend/skill-b")
body := `{"folder":"frontend","target":"claude"}`
req := httptest.NewRequest(http.MethodPost, "/api/resources/batch/targets", bytes.NewBufferString(body))
rr := httptest.NewRecorder()
s.handler.ServeHTTP(rr, req)
if rr.Code != http.StatusOK {
t.Fatalf("expected 200, got %d: %s", rr.Code, rr.Body.String())
}
var resp batchSetTargetsResponse
if err := json.Unmarshal(rr.Body.Bytes(), &resp); err != nil {
t.Fatalf("failed to decode response: %v", err)
}
if resp.Updated != 2 {
t.Errorf("expected updated=2, got %d", resp.Updated)
}
if resp.Skipped != 0 {
t.Errorf("expected skipped=0, got %d", resp.Skipped)
}
if len(resp.Errors) != 0 {
t.Errorf("expected no errors, got %v", resp.Errors)
}
// Verify SKILL.md was modified for both skills
for _, name := range []string{"frontend/skill-a", "frontend/skill-b"} {
skillMD := filepath.Join(src, filepath.FromSlash(name), "SKILL.md")
targets := utils.ParseFrontmatterList(skillMD, "targets")
if len(targets) != 1 || targets[0] != "claude" {
t.Errorf("skill %s: expected targets=[claude], got %v", name, targets)
}
}
}
// A target edit rewrites SKILL.md. The skill's recorded hashes must follow
// that edit, so skillshare's own change is not reported as modified, but must
// not absorb an edit the user made before, or update would overwrite it.
func TestSetTargets_KeepsLocalChangeStateOfRemoteSkill(t *testing.T) {
for _, endpoint := range []string{"folder", "skill"} {
for _, edited := range []bool{false, true} {
t.Run(fmt.Sprintf("%s/edited=%t", endpoint, edited), func(t *testing.T) {
s, src := newTestServer(t)
addSkillNested(t, src, "frontend/skill-a")
dir := filepath.Join(src, "frontend", "skill-a")
hashes, err := install.ComputeFileHashes(dir)
if err != nil {
t.Fatal(err)
}
s.skillsStore = install.NewMetadataStore()
s.skillsStore.Set("frontend/skill-a", &install.MetadataEntry{Source: "org/repo/skill-a", RepoURL: "https://github.com/org/repo.git", FileHashes: hashes})
if err := s.skillsStore.Save(src); err != nil {
t.Fatal(err)
}
if edited {
if err := os.WriteFile(filepath.Join(dir, "notes.md"), []byte("mine\n"), 0644); err != nil {
t.Fatal(err)
}
}
rr := httptest.NewRecorder()
if endpoint == "folder" {
s.handler.ServeHTTP(rr, httptest.NewRequest(http.MethodPost, "/api/resources/batch/targets", bytes.NewBufferString(`{"folder":"frontend","target":"claude"}`)))
} else {
req := httptest.NewRequest(http.MethodPatch, "/api/resources/skill-a/targets", bytes.NewBufferString(`{"target":"claude"}`))
req.SetPathValue("name", "skill-a")
s.handleSetSkillTargets(rr, req)
}
if rr.Code != http.StatusOK {
t.Fatalf("expected 200, got %d: %s", rr.Code, rr.Body.String())
}
if got := s.skillsStore.GetByPath("frontend/skill-a").LocallyModified(dir); got != edited {
t.Errorf("LocallyModified = %t, want %t", got, edited)
}
})
}
}
}
func TestHandleSetSkillTargets_KeepsLocalChangeStateOfRemoteAgent(t *testing.T) {
for _, edited := range []bool{false, true} {
t.Run(fmt.Sprintf("edited=%t", edited), func(t *testing.T) {
s, _ := newTestServer(t)
agentsDir := s.agentsSource()
if err := os.MkdirAll(agentsDir, 0755); err != nil {
t.Fatal(err)
}
file := filepath.Join(agentsDir, "tutor.md")
if err := os.WriteFile(file, []byte("---\nname: tutor\n---\n# Tutor\n"), 0644); err != nil {
t.Fatal(err)
}
hash, err := utils.FileHashFormatted(file)
if err != nil {
t.Fatal(err)
}
s.agentsStore = install.NewMetadataStore()
s.agentsStore.Set("tutor", &install.MetadataEntry{Source: "org/repo/agents/tutor.md", Kind: "agent", RepoURL: "https://github.com/org/repo.git", FileHashes: map[string]string{"tutor.md": hash}})
if err := s.agentsStore.Save(agentsDir); err != nil {
t.Fatal(err)
}
if edited {
if err := os.WriteFile(file, []byte("---\nname: tutor\n---\n# Mine\n"), 0644); err != nil {
t.Fatal(err)
}
}
rr := httptest.NewRecorder()
req := httptest.NewRequest(http.MethodPatch, "/api/resources/tutor.md/targets", bytes.NewBufferString(`{"target":"claude"}`))
req.SetPathValue("name", "tutor.md")
s.handleSetSkillTargets(rr, req)
if rr.Code != http.StatusOK {
t.Fatalf("expected 200, got %d: %s", rr.Code, rr.Body.String())
}
if got := s.agentsStore.GetByPath("tutor").AgentLocallyModified(file); got != edited {
t.Errorf("AgentLocallyModified = %t, want %t", got, edited)
}
})
}
}
func TestHandleBatchSetTargets_RemoveTargets(t *testing.T) {
s, src := newTestServer(t)
addSkillWithTargets(t, src, "skill-a", []string{"claude", "cursor"})
addSkillWithTargets(t, src, "skill-b", []string{"claude"})
// Set target="" to remove targets (root-level folder)
body := `{"folder":"","target":""}`
req := httptest.NewRequest(http.MethodPost, "/api/resources/batch/targets", bytes.NewBufferString(body))
rr := httptest.NewRecorder()
s.handler.ServeHTTP(rr, req)
if rr.Code != http.StatusOK {
t.Fatalf("expected 200, got %d: %s", rr.Code, rr.Body.String())
}
var resp batchSetTargetsResponse
if err := json.Unmarshal(rr.Body.Bytes(), &resp); err != nil {
t.Fatalf("failed to decode response: %v", err)
}
if resp.Updated != 2 {
t.Errorf("expected updated=2, got %d", resp.Updated)
}
// Verify targets were removed
for _, name := range []string{"skill-a", "skill-b"} {
skillMD := filepath.Join(src, name, "SKILL.md")
targets := utils.ParseFrontmatterList(skillMD, "targets")
if len(targets) != 0 {
t.Errorf("skill %s: expected no targets after removal, got %v", name, targets)
}
}
}
func TestHandleBatchSetTargets_PathTraversal(t *testing.T) {
s, _ := newTestServer(t)
body := `{"folder":"../../../etc","target":"claude"}`
req := httptest.NewRequest(http.MethodPost, "/api/resources/batch/targets", bytes.NewBufferString(body))
rr := httptest.NewRecorder()
s.handler.ServeHTTP(rr, req)
if rr.Code != http.StatusBadRequest {
t.Errorf("expected 400 for path traversal, got %d: %s", rr.Code, rr.Body.String())
}
}
func TestHandleBatchSetTargets_EmptyFolder_RootOnly(t *testing.T) {
s, src := newTestServer(t)
// Root-level skills
addSkill(t, src, "root-skill-a")
addSkill(t, src, "root-skill-b")
// Nested skill — should NOT be touched
addSkillNested(t, src, "nested-folder/deep-skill")
body := `{"folder":"","target":"cursor"}`
req := httptest.NewRequest(http.MethodPost, "/api/resources/batch/targets", bytes.NewBufferString(body))
rr := httptest.NewRecorder()
s.handler.ServeHTTP(rr, req)
if rr.Code != http.StatusOK {
t.Fatalf("expected 200, got %d: %s", rr.Code, rr.Body.String())
}
var resp batchSetTargetsResponse
if err := json.Unmarshal(rr.Body.Bytes(), &resp); err != nil {
t.Fatalf("failed to decode response: %v", err)
}
if resp.Updated != 2 {
t.Errorf("expected updated=2 (root only), got %d", resp.Updated)
}
// Nested skill must remain untouched
nestedMD := filepath.Join(src, "nested-folder", "deep-skill", "SKILL.md")
targets := utils.ParseFrontmatterList(nestedMD, "targets")
if len(targets) != 0 {
t.Errorf("nested skill should not be modified, but got targets %v", targets)
}
}
func TestMatchesFolder(t *testing.T) {
tests := []struct {
relPath string
folder string
want bool
}{
// Wildcard matches everything
{"skill-a", "*", true},
{"frontend/skill-a", "*", true},
// Empty folder = root-level only
{"skill-a", "", true},
{"frontend/skill-a", "", false},
// Exact folder match
{"frontend/skill-a", "frontend", true},
{"frontend/sub/skill-a", "frontend", true},
{"backend/skill-a", "frontend", false},
// No trailing slash confusion
{"frontend/skill-a", "frontend/", false}, // trailing slash should not match
}
for _, tt := range tests {
got := matchesFolder(tt.relPath, tt.folder)
if got != tt.want {
t.Errorf("matchesFolder(%q, %q) = %v, want %v", tt.relPath, tt.folder, got, tt.want)
}
}
}
func TestHandleBatchSetTargets_FolderTrailingSlash(t *testing.T) {
s, src := newTestServer(t)
addSkillNested(t, src, "frontend/skill-a")
addSkillNested(t, src, "frontend/skill-b")
// Trailing slash should still match (server cleans the input)
body := `{"folder":"frontend/","target":"claude"}`
req := httptest.NewRequest(http.MethodPost, "/api/resources/batch/targets", bytes.NewBufferString(body))
rr := httptest.NewRecorder()
s.handler.ServeHTTP(rr, req)
if rr.Code != http.StatusOK {
t.Fatalf("expected 200, got %d: %s", rr.Code, rr.Body.String())
}
var resp batchSetTargetsResponse
if err := json.Unmarshal(rr.Body.Bytes(), &resp); err != nil {
t.Fatalf("failed to decode response: %v", err)
}
if resp.Updated != 2 {
t.Errorf("expected updated=2 (trailing slash cleaned), got %d", resp.Updated)
}
}
// --- Single skill endpoint tests ---
func TestHandleSetSkillTargets_SetTarget(t *testing.T) {
s, src := newTestServer(t)
addSkill(t, src, "my-skill")
body := `{"target":"claude"}`
req := httptest.NewRequest(http.MethodPatch, "/api/resources/my-skill/targets", bytes.NewBufferString(body))
req.SetPathValue("name", "my-skill")
rr := httptest.NewRecorder()
s.handleSetSkillTargets(rr, req)
if rr.Code != http.StatusOK {
t.Fatalf("expected 200, got %d: %s", rr.Code, rr.Body.String())
}
var resp map[string]any
if err := json.Unmarshal(rr.Body.Bytes(), &resp); err != nil {
t.Fatalf("failed to decode response: %v", err)
}
if resp["success"] != true {
t.Errorf("expected success=true, got %v", resp["success"])
}
// Verify SKILL.md was updated
skillMD := filepath.Join(src, "my-skill", "SKILL.md")
targets := utils.ParseFrontmatterList(skillMD, "targets")
if len(targets) != 1 || targets[0] != "claude" {
t.Errorf("expected targets=[claude], got %v", targets)
}
}
func TestHandleSetSkillTargets_RemoveTarget(t *testing.T) {
s, src := newTestServer(t)
addSkillWithTargets(t, src, "my-skill", []string{"claude", "cursor"})
body := `{"target":""}`
req := httptest.NewRequest(http.MethodPatch, "/api/resources/my-skill/targets", bytes.NewBufferString(body))
req.SetPathValue("name", "my-skill")
rr := httptest.NewRecorder()
s.handleSetSkillTargets(rr, req)
if rr.Code != http.StatusOK {
t.Fatalf("expected 200, got %d: %s", rr.Code, rr.Body.String())
}
// Verify targets field was removed
skillMD := filepath.Join(src, "my-skill", "SKILL.md")
targets := utils.ParseFrontmatterList(skillMD, "targets")
if len(targets) != 0 {
t.Errorf("expected no targets after removal, got %v", targets)
}
}
func TestHandleSetSkillTargets_NotFound(t *testing.T) {
s, _ := newTestServer(t)
body := `{"target":"claude"}`
req := httptest.NewRequest(http.MethodPatch, "/api/resources/nonexistent/targets", bytes.NewBufferString(body))
req.SetPathValue("name", "nonexistent")
rr := httptest.NewRecorder()
s.handleSetSkillTargets(rr, req)
if rr.Code != http.StatusNotFound {
t.Errorf("expected 404, got %d: %s", rr.Code, rr.Body.String())
}
}
// --- Tracked-repo skills ---
const trackedSkillRel = "_caveman/plugins/caveman/skills/cavecrew"
// addTrackedRepoSkill creates a committed git repo "_caveman" holding one skill
// whose frontmatter targets cursor.
func addTrackedRepoSkill(t *testing.T, sourceDir string) string {
t.Helper()
repoDir := filepath.Join(sourceDir, "_caveman")
skillDir := filepath.Join(sourceDir, filepath.FromSlash(trackedSkillRel))
os.MkdirAll(skillDir, 0755)
os.WriteFile(filepath.Join(skillDir, "SKILL.md"), []byte("---\nname: cavecrew\nmetadata:\n targets:\n - cursor\n---\n# cavecrew"), 0644)
initGitRepo(t, repoDir)
return repoDir
}
// effectiveTargets returns the targets discovery reports for relPath.
func effectiveTargets(t *testing.T, sourceDir, relPath string) []string {
t.Helper()
skills, err := ssync.DiscoverSourceSkillsAll(sourceDir)
if err != nil {
t.Fatalf("discover: %v", err)
}
for _, d := range skills {
if d.RelPath == relPath {
return d.Targets
}
}
t.Fatalf("skill %s not discovered", relPath)
return nil
}
func setSkillTarget(t *testing.T, s *Server, name, target string) {
t.Helper()
req := httptest.NewRequest(http.MethodPatch, "/api/resources/"+name+"/targets", bytes.NewBufferString(`{"target":"`+target+`"}`))
req.SetPathValue("name", name)
rr := httptest.NewRecorder()
s.handleSetSkillTargets(rr, req)
if rr.Code != http.StatusOK {
t.Fatalf("expected 200, got %d: %s", rr.Code, rr.Body.String())
}
}
func TestHandleSetSkillTargets_TrackedRepoSkill_OverridesWithoutDirtyingRepo(t *testing.T) {
s, src := newTestServer(t)
repoDir := addTrackedRepoSkill(t, src)
setSkillTarget(t, s, "cavecrew", "claude")
if got := effectiveTargets(t, src, trackedSkillRel); len(got) != 1 || got[0] != "claude" {
t.Errorf("expected effective targets [claude], got %v", got)
}
if out := runGit(t, repoDir, "status", "--porcelain"); len(out) != 0 {
t.Errorf("expected clean tracked repo, got:\n%s", out)
}
}
func TestHandleSetSkillTargets_TrackedRepoSkill_EmptyTargetMeansAll(t *testing.T) {
s, src := newTestServer(t)
addTrackedRepoSkill(t, src)
setSkillTarget(t, s, "cavecrew", "")
// Must not fall back to the repo's frontmatter [cursor].
if got := effectiveTargets(t, src, trackedSkillRel); got != nil {
t.Errorf("expected all targets (nil), got %v", got)
}
}
func TestHandleBatchSetTargets_TrackedRepoSkills(t *testing.T) {
s, src := newTestServer(t)
repoDir := addTrackedRepoSkill(t, src)
req := httptest.NewRequest(http.MethodPost, "/api/resources/batch/targets", bytes.NewBufferString(`{"folder":"_caveman","target":"claude"}`))
rr := httptest.NewRecorder()
s.handler.ServeHTTP(rr, req)
if rr.Code != http.StatusOK {
t.Fatalf("expected 200, got %d: %s", rr.Code, rr.Body.String())
}
var resp batchSetTargetsResponse
if err := json.Unmarshal(rr.Body.Bytes(), &resp); err != nil {
t.Fatalf("failed to decode response: %v", err)
}
if resp.Updated != 1 || resp.Skipped != 0 {
t.Errorf("expected updated=1 skipped=0, got updated=%d skipped=%d", resp.Updated, resp.Skipped)
}
if got := effectiveTargets(t, src, trackedSkillRel); len(got) != 1 || got[0] != "claude" {
t.Errorf("expected effective targets [claude], got %v", got)
}
if out := runGit(t, repoDir, "status", "--porcelain"); len(out) != 0 {
t.Errorf("expected clean tracked repo, got:\n%s", out)
}
}
func TestHandleUninstallRepo_RemovesTargetOverrides(t *testing.T) {
s, src := newTestServer(t)
addTrackedRepoSkill(t, src)
setSkillTarget(t, s, "cavecrew", "claude")
s.skillsStore.SetTargetOverride("_other/skill", []string{"cursor"})
if err := s.skillsStore.Save(src); err != nil {
t.Fatal(err)
}
req := httptest.NewRequest(http.MethodDelete, "/api/repos/_caveman", nil)
req.SetPathValue("name", "_caveman")
rr := httptest.NewRecorder()
s.handleUninstallRepo(rr, req)
if rr.Code != http.StatusOK {
t.Fatalf("expected 200, got %d: %s", rr.Code, rr.Body.String())
}
overrides := install.LoadTargetOverrides(src)
if _, ok := overrides[trackedSkillRel]; ok {
t.Errorf("expected override for %s to be removed, got %v", trackedSkillRel, overrides)
}
if _, ok := overrides["_other/skill"]; !ok {
t.Errorf("expected override of another repo to survive, got %v", overrides)
}
}
func TestHandleBatchUninstall_RemovesTargetOverrides(t *testing.T) {
s, src := newTestServer(t)
addTrackedRepoSkill(t, src)
setSkillTarget(t, s, "cavecrew", "claude")
b, _ := json.Marshal(batchUninstallRequest{Names: []string{"_caveman"}, Force: true})
req := httptest.NewRequest(http.MethodPost, "/api/uninstall", bytes.NewReader(b))
rr := httptest.NewRecorder()
s.handleBatchUninstall(rr, req)
if rr.Code != http.StatusOK {
t.Fatalf("expected 200, got %d: %s", rr.Code, rr.Body.String())
}
if overrides := install.LoadTargetOverrides(src); len(overrides) != 0 {
t.Errorf("expected no target overrides after uninstall, got %v", overrides)
}
}
func TestHandleBatchSetTargets_SaveFailureReported(t *testing.T) {
s, src := newTestServer(t)
addTrackedRepoSkill(t, src)
// A directory at the metadata path makes the atomic rename in Save fail.
if err := os.MkdirAll(filepath.Join(src, install.MetadataFileName), 0755); err != nil {
t.Fatalf("block metadata file: %v", err)
}
req := httptest.NewRequest(http.MethodPost, "/api/resources/batch/targets", bytes.NewBufferString(`{"folder":"_caveman","target":"claude"}`))
rr := httptest.NewRecorder()
s.handler.ServeHTTP(rr, req)
if rr.Code != http.StatusInternalServerError {
t.Fatalf("expected 500, got %d: %s", rr.Code, rr.Body.String())
}
}