feat(server): let tracked-repo skills take dashboard targets

Setting targets on a skill inside a tracked repo used to be refused,
because writing its SKILL.md leaves the clone dirty and `update` then
skips the repo (or `--force` throws the setting away).

Store those targets in the source's .metadata.json instead, keyed by
the skill's path, and apply them at discovery over the frontmatter.
The clone stays clean, `update` keeps working, and the setting survives
it. Uninstalling a repo or skill drops its entries.

Overrides are saved in the same lock section that writes them: every
API request reloads the store from disk, so saving after unlocking
could lose them, and saving outside the lock raced with other writers.

Refs #295
This commit is contained in:
Willie
2026-09-26 21:02:28 +08:00
parent e259d3c116
commit bc01ff1b3e
14 changed files with 391 additions and 21 deletions
+8
View File
@@ -29,6 +29,11 @@ type MetadataStore struct {
// accepted via --force. Kept outside Entries so it survives entry rewrites
// and works for tracked repos that have no entry of their own.
AuditAccepted map[string][]string `json:"audit_accepted,omitempty"`
// TargetOverrides maps the source-relative path of a skill inside a tracked
// repo to the targets set from the dashboard. Stored here so the repo's
// SKILL.md stays untouched and the clone stays clean for update. An empty
// list means "all targets"; a missing key falls back to the frontmatter.
TargetOverrides map[string][]string `json:"target_overrides,omitempty"`
}
// MetadataEntry merges the old SkillMeta + RegistryEntry fields.
@@ -154,6 +159,9 @@ func (e *MetadataEntry) EffectiveKind() string {
// Handles direct key matches, full-path matches (group/name), and group membership.
// Works with both legacy basename keys and full-path keys.
func (s *MetadataStore) RemoveByNames(names map[string]bool) {
for name := range names {
s.RemoveTargetOverrides(name)
}
for _, key := range s.List() {
entry := s.Get(key)
fullName := KeyToRelPath(key, entry)
+40
View File
@@ -0,0 +1,40 @@
package install
import (
"path/filepath"
"strings"
)
// SetTargetOverride records the targets for a skill inside a tracked repo,
// keyed by its source-relative path. An empty list is kept as an explicit
// "all targets" override so it still replaces the repo's frontmatter.
func (s *MetadataStore) SetTargetOverride(relPath string, targets []string) {
if s.TargetOverrides == nil {
s.TargetOverrides = make(map[string][]string)
}
if targets == nil {
targets = []string{}
}
s.TargetOverrides[filepath.ToSlash(relPath)] = targets
}
// RemoveTargetOverrides drops the override for relPath and every skill below
// it, e.g. all skills of a tracked repo when the repo is uninstalled.
func (s *MetadataStore) RemoveTargetOverrides(relPath string) {
relPath = filepath.ToSlash(relPath)
for key := range s.TargetOverrides {
if key == relPath || strings.HasPrefix(key, relPath+"/") {
delete(s.TargetOverrides, key)
}
}
}
// LoadTargetOverrides reads the target overrides from dir's .metadata.json
// without migrating or rewriting the file. Returns nil when there are none.
func LoadTargetOverrides(dir string) map[string][]string {
store, err := loadMetadataFile(dir)
if err != nil {
return nil
}
return store.TargetOverrides
}
+32
View File
@@ -0,0 +1,32 @@
package install
import "testing"
func TestTargetOverrides_EmptyListSurvivesSave(t *testing.T) {
dir := t.TempDir()
store := NewMetadataStore()
store.SetTargetOverride("_repo/skill", nil)
if err := store.Save(dir); err != nil {
t.Fatal(err)
}
targets, ok := LoadTargetOverrides(dir)["_repo/skill"]
if !ok || len(targets) != 0 {
t.Errorf("want explicit empty override, got %v (present=%v)", targets, ok)
}
}
func TestRemoveByNames_RemovesRepoTargetOverrides(t *testing.T) {
store := NewMetadataStore()
store.SetTargetOverride("_repo/skills/a", []string{"claude"})
store.SetTargetOverride("_repo-other/b", []string{"cursor"})
store.RemoveByNames(map[string]bool{"_repo": true})
if _, ok := store.TargetOverrides["_repo/skills/a"]; ok {
t.Error("override of the uninstalled repo must be removed")
}
if _, ok := store.TargetOverrides["_repo-other/b"]; !ok {
t.Error("override of a sibling repo with a shared prefix must survive")
}
}
+2
View File
@@ -440,6 +440,8 @@ func (s *Server) handleUninstallRepo(w http.ResponseWriter, r *http.Request) {
}
}
s.skillsStore.RemoveTargetOverrides(repoName)
if err := s.skillsStore.Save(s.cfg.EffectiveSkillsSource()); err != nil {
log.Printf("warning: failed to save metadata after repo uninstall: %v", err)
}
+51 -21
View File
@@ -79,6 +79,12 @@ func (s *Server) handleBatchSetTargets(w http.ResponseWriter, r *http.Request) {
path string
}
var updatedSkills []updatedSkill
overridden := false
var values []string
if req.Target != "" {
values = []string{req.Target}
}
// Acquire write lock only for the file-write loop.
s.mu.Lock()
@@ -88,18 +94,22 @@ func (s *Server) handleBatchSetTargets(w http.ResponseWriter, r *http.Request) {
continue
}
// Skip disabled skills and tracked-repo members
if d.Disabled || d.IsInRepo {
// Skip disabled skills
if d.Disabled {
skipped++
continue
}
skillMDPath := filepath.Join(d.SourcePath, "SKILL.md")
var values []string
if req.Target != "" {
values = []string{req.Target}
// Tracked-repo members keep their SKILL.md untouched so the clone
// stays clean for update; the targets live in .metadata.json.
if d.IsInRepo {
s.skillsStore.SetTargetOverride(relPath, values)
overridden = true
updated++
continue
}
skillMDPath := filepath.Join(d.SourcePath, "SKILL.md")
if err := utils.SetFrontmatterList(skillMDPath, "metadata.targets", values); err != nil {
errors = append(errors, d.FlatName+": "+err.Error())
continue
@@ -111,14 +121,22 @@ func (s *Server) handleBatchSetTargets(w http.ResponseWriter, r *http.Request) {
})
updated++
}
// Save the overrides before unlocking: every API request reloads skillsStore
// from disk, so an override left unsaved here can be dropped by the next one.
if overridden {
s.skillsStore.Save(s.cfg.EffectiveSkillsSource()) //nolint:errcheck
}
s.mu.Unlock()
// Recompute file hashes outside the lock so reads aren't blocked.
for _, sk := range updatedSkills {
s.skillsStore.RefreshHashes(sk.name, sk.path)
}
// Save reads TargetOverrides, which other requests write under the lock.
if len(updatedSkills) > 0 {
s.mu.Lock()
s.skillsStore.Save(s.cfg.EffectiveSkillsSource()) //nolint:errcheck
s.mu.Unlock()
}
s.writeOpsLog("batch-set-targets", "ok", start, map[string]any{
@@ -172,29 +190,41 @@ func (s *Server) handleSetSkillTargets(w http.ResponseWriter, r *http.Request) {
continue
}
if d.IsInRepo {
writeError(w, http.StatusBadRequest, "cannot set target on tracked-repo skill; manage targets on the repo instead")
return
}
skillMDPath := filepath.Join(d.SourcePath, "SKILL.md")
var values []string
if req.Target != "" {
values = []string{req.Target}
}
s.mu.Lock()
err := utils.SetFrontmatterList(skillMDPath, "metadata.targets", values)
s.mu.Unlock()
if d.IsInRepo {
// Tracked-repo members keep their SKILL.md untouched so the clone
// stays clean for update; the targets live in .metadata.json.
s.mu.Lock()
s.skillsStore.SetTargetOverride(d.RelPath, values)
err := s.skillsStore.Save(s.cfg.EffectiveSkillsSource())
s.mu.Unlock()
if err != nil {
writeError(w, http.StatusInternalServerError, "failed to update skill: "+err.Error())
return
if err != nil {
writeError(w, http.StatusInternalServerError, "failed to update skill: "+err.Error())
return
}
} else {
skillMDPath := filepath.Join(d.SourcePath, "SKILL.md")
s.mu.Lock()
err := utils.SetFrontmatterList(skillMDPath, "metadata.targets", values)
s.mu.Unlock()
if err != nil {
writeError(w, http.StatusInternalServerError, "failed to update skill: "+err.Error())
return
}
s.skillsStore.RefreshHashes(d.RelPath, d.SourcePath)
s.mu.Lock()
s.skillsStore.Save(s.cfg.EffectiveSkillsSource()) //nolint:errcheck
s.mu.Unlock()
}
s.skillsStore.RefreshHashes(d.RelPath, d.SourcePath)
s.skillsStore.Save(s.cfg.EffectiveSkillsSource()) //nolint:errcheck
s.writeOpsLog("set-skill-targets", "ok", start, map[string]any{
"name": name,
"target": req.Target,
@@ -9,6 +9,8 @@ import (
"path/filepath"
"testing"
"skillshare/internal/install"
ssync "skillshare/internal/sync"
"skillshare/internal/utils"
)
@@ -274,3 +276,139 @@ func TestHandleSetSkillTargets_NotFound(t *testing.T) {
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)
}
}
+3
View File
@@ -305,6 +305,9 @@ func (s *Server) handleBatchUninstallSkills(w http.ResponseWriter, body batchUni
s.skillsStore.Remove(name)
}
}
for rp := range removedPaths {
s.skillsStore.RemoveTargetOverrides(rp)
}
if err := s.skillsStore.Save(s.cfg.EffectiveSkillsSource()); err != nil {
log.Printf("warning: failed to save metadata: %v", err)
@@ -0,0 +1,75 @@
package sync
import (
"path/filepath"
"reflect"
"testing"
"skillshare/internal/install"
)
// setupTrackedSkills creates a tracked-repo skill and a regular skill, both
// targeting cursor in frontmatter, plus the given overrides in .metadata.json.
func setupTrackedSkills(t *testing.T, overrides map[string][]string) string {
t.Helper()
src := t.TempDir()
fm := "---\nname: s\nmetadata:\n targets:\n - cursor\n---\n# s"
writeSkillMD(t, filepath.Join(src, "_repo", "skills", "tracked"), fm)
writeSkillMD(t, filepath.Join(src, "local"), fm)
if overrides != nil {
store := install.NewMetadataStore()
for rel, targets := range overrides {
store.SetTargetOverride(rel, targets)
}
if err := store.Save(src); err != nil {
t.Fatal(err)
}
}
return src
}
func discoveredTargets(t *testing.T, src string) map[string][]string {
t.Helper()
skills, err := DiscoverSourceSkills(src)
if err != nil {
t.Fatal(err)
}
got := map[string][]string{}
for _, s := range skills {
got[s.RelPath] = s.Targets
}
return got
}
func TestDiscover_TargetOverrideReplacesTrackedFrontmatter(t *testing.T) {
src := setupTrackedSkills(t, map[string][]string{"_repo/skills/tracked": {"claude"}})
got := discoveredTargets(t, src)
if !reflect.DeepEqual(got["_repo/skills/tracked"], []string{"claude"}) {
t.Errorf("tracked skill: want [claude], got %v", got["_repo/skills/tracked"])
}
}
func TestDiscover_EmptyTargetOverrideMeansAllTargets(t *testing.T) {
src := setupTrackedSkills(t, map[string][]string{"_repo/skills/tracked": nil})
if got := discoveredTargets(t, src)["_repo/skills/tracked"]; got != nil {
t.Errorf("tracked skill: want nil (all targets), got %v", got)
}
}
func TestDiscover_NoTargetOverrideUsesFrontmatter(t *testing.T) {
src := setupTrackedSkills(t, nil)
if got := discoveredTargets(t, src)["_repo/skills/tracked"]; !reflect.DeepEqual(got, []string{"cursor"}) {
t.Errorf("tracked skill: want [cursor], got %v", got)
}
}
func TestDiscover_TargetOverrideIgnoredForRegularSkill(t *testing.T) {
src := setupTrackedSkills(t, map[string][]string{"local": {"claude"}})
if got := discoveredTargets(t, src)["local"]; !reflect.DeepEqual(got, []string{"cursor"}) {
t.Errorf("regular skill: want frontmatter [cursor], got %v", got)
}
}
+32
View File
@@ -9,6 +9,7 @@ import (
"sync"
"skillshare/internal/config"
"skillshare/internal/install"
"skillshare/internal/skillignore"
"skillshare/internal/utils"
)
@@ -323,5 +324,36 @@ func discoverSourceSkillsInternal(sourcePath string, opts discoverOptions) ([]Di
return nil, nil, nil, fmt.Errorf("failed to walk source directory: %w", err)
}
if opts.parseFrontmatter || opts.collectContext {
applyTargetOverrides(skills, walkRoot)
}
return skills, trackedRepos, stats, nil
}
// applyTargetOverrides replaces the frontmatter targets of tracked-repo skills
// with the overrides stored in the source's .metadata.json, so every consumer
// of discovery sees the same effective targets. An empty override means all
// targets.
func applyTargetOverrides(skills []DiscoveredSkill, sourceDir string) {
var overrides map[string][]string
loaded := false
for i := range skills {
if !skills[i].IsInRepo {
continue
}
if !loaded {
overrides = install.LoadTargetOverrides(sourceDir)
loaded = true
}
targets, ok := overrides[skills[i].RelPath]
if !ok {
continue
}
if len(targets) == 0 {
skills[i].Targets = nil
} else {
skills[i].Targets = append([]string(nil), targets...)
}
}
}
+2
View File
@@ -67,6 +67,8 @@ targets: [claude, cursor]
**Behavior:** Whitelist — the skill only syncs to the listed targets. Omitting the field means sync to all targets. If both `metadata.targets` and top-level `targets` are present, `metadata.targets` wins.
**Tracked repos:** targets set in the dashboard for a skill inside a tracked repo are stored in the source's `.metadata.json` instead of its SKILL.md, so the clone stays clean and `update` keeps working. That setting takes precedence over the skill's `metadata.targets`.
**Aliases:** Target names support aliases. `claude` matches a target configured as `claude-code`. See [Supported Targets](/docs/reference/targets/supported-targets).
📖 [Skill format — targets field](/docs/understand/skill-format#targets)
@@ -77,6 +77,8 @@ targets: [claude, cursor]
省略すると、すべての Target に Sync されます。`metadata.targets` とトップレベルの `targets` の両方が
存在する場合、`metadata.targets` が優先されます。
**Tracked repo:** dashboard で tracked repo 内の Skill に設定した targets は、その SKILL.md ではなく source の `.metadata.json` に保存される。そのため clone はクリーンなままで、`update` も通常どおり動作する。この設定は Skill の `metadata.targets` より優先される。
**エイリアス:** Target 名はエイリアスに対応しています。`claude` は `claude-code` として設定された
Target に一致します。[対応する Target](/docs/reference/targets/supported-targets) を参照してください。
@@ -67,6 +67,8 @@ targets: [claude, cursor]
**동작:** 화이트리스트 — 해당 Skill은 나열된 Target에만 Sync됩니다. 필드를 생략하면 모든 Target에 Sync됩니다. `metadata.targets`와 최상위 `targets`가 모두 존재하는 경우 `metadata.targets`가 우선합니다.
**Tracked repo:** dashboard에서 tracked repo 안의 skill에 설정한 targets는 해당 SKILL.md가 아니라 source의 `.metadata.json`에 저장됩니다. 그래서 clone은 깨끗하게 유지되고 `update`도 정상적으로 동작합니다. 이 설정은 skill의 `metadata.targets`보다 우선합니다.
**별칭(Alias):** Target 이름은 별칭을 지원합니다. `claude`는 `claude-code`로 설정된 Target과도 일치합니다. [Supported Targets](/docs/reference/targets/supported-targets)를 참고하세요.
📖 [Skill format — targets field](/docs/understand/skill-format#targets)
@@ -67,6 +67,8 @@ targets: [claude, cursor]
**行为:** 白名单——该 Skill 只会 sync 到列出的 Target。省略此字段表示 sync 到所有 Target。如果 `metadata.targets` 与顶层 `targets` 同时存在,`metadata.targets` 优先。
**Tracked repos:** 在 dashboard 中为 tracked repo 内的 skill 设置的 targets 存储在 source 的 `.metadata.json` 中,而不是它的 SKILL.md,因此 clone 保持干净,`update` 也能照常运行。该设置优先于 skill 的 `metadata.targets`。
**别名:** Target 名称支持别名。`claude` 会匹配配置为 `claude-code` 的 Target。参见 [Supported Targets](/docs/reference/targets/supported-targets)。
📖 [Skill format — targets 字段](/docs/understand/skill-format#targets)
@@ -67,6 +67,8 @@ targets: [claude, cursor]
**行為:** 白名單機制 — 該 skill 只會 sync 到列出的 targets。省略此欄位表示 sync 到所有 targets。若 `metadata.targets` 與頂層的 `targets` 同時存在,以 `metadata.targets` 為準。
**Tracked repos:** 在 dashboard 為 tracked repo 內的 skill 設定的 targets 會存在 source 的 `.metadata.json`,而不是它的 SKILL.md,因此 clone 保持乾淨,`update` 也能照常運作。這個設定優先於 skill 的 `metadata.targets`。
**別名:** Target 名稱支援別名。`claude` 會符合設定為 `claude-code` 的 target。參見 [Supported Targets](/docs/reference/targets/supported-targets)。
📖 [Skill format — targets field](/docs/understand/skill-format#targets)