mirror of
https://github.com/runkids/skillshare.git
synced 2026-11-19 02:17:09 +00:00
The dashboard check reimplemented the CLI's per-repo check but fetched without the HTTPS token and ignored git status errors. Private tracked repos could fail in the dashboard while `skillshare check` worked, and a repo whose status could not be read showed as up to date. Both check endpoints now call check.ParallelCheckRepos, the same code the CLI uses. The JSON and SSE response shape does not change. Batch uninstall treated a failed dirty check as clean and moved the repo to trash. Without force, that item now fails with the git error instead. This is stricter than the CLI, which only warns and continues. Batch target updates ignored metadata save failures and still reported success, so an override could silently disappear on the next reload. They now return 500.
432 lines
14 KiB
Go
432 lines
14 KiB
Go
package server
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/json"
|
|
"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)
|
|
}
|
|
}
|
|
}
|
|
|
|
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"})
|
|
|
|
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())
|
|
}
|
|
}
|