mirror of
https://github.com/runkids/skillshare.git
synced 2026-11-19 02:17:09 +00:00
DashboardPage: add Agents stat card with Bot icon and accent color, linking to /skills?kind=agent. SkillsPage: add Skills/Agents filter tabs alongside existing filters. KindBadge displayed on each skill card. matchFilter supports kind-based filtering with accurate filter counts. handler_collect: add kind field to localSkillItem response. handler_uninstall: add kind field to batch request and result structs.
183 lines
4.5 KiB
Go
183 lines
4.5 KiB
Go
package server
|
|
|
|
import (
|
|
"encoding/json"
|
|
"net/http"
|
|
"os"
|
|
"path/filepath"
|
|
"time"
|
|
|
|
ssync "skillshare/internal/sync"
|
|
)
|
|
|
|
// --- Scan types ---
|
|
|
|
type localSkillItem struct {
|
|
Name string `json:"name"`
|
|
Kind string `json:"kind,omitempty"`
|
|
Path string `json:"path"`
|
|
TargetName string `json:"targetName"`
|
|
Size int64 `json:"size"`
|
|
ModTime string `json:"modTime"`
|
|
}
|
|
|
|
type scanTarget struct {
|
|
TargetName string `json:"targetName"`
|
|
Skills []localSkillItem `json:"skills"`
|
|
}
|
|
|
|
// --- Collect types ---
|
|
|
|
type collectSkillRef struct {
|
|
Name string `json:"name"`
|
|
TargetName string `json:"targetName"`
|
|
}
|
|
|
|
// handleCollectScan scans targets for local (non-symlinked) skills.
|
|
// GET /api/collect/scan?target=<name> (optional filter)
|
|
func (s *Server) handleCollectScan(w http.ResponseWriter, r *http.Request) {
|
|
// Snapshot config under RLock, then release before I/O.
|
|
s.mu.RLock()
|
|
source := s.cfg.Source
|
|
globalMode := s.cfg.Mode
|
|
targets := s.cloneTargets()
|
|
s.mu.RUnlock()
|
|
|
|
filterTarget := r.URL.Query().Get("target")
|
|
|
|
var scanTargets []scanTarget
|
|
totalCount := 0
|
|
|
|
for name, target := range targets {
|
|
if filterTarget != "" && filterTarget != name {
|
|
continue
|
|
}
|
|
|
|
sc := target.SkillsConfig()
|
|
mode := ssync.EffectiveMode(sc.Mode)
|
|
if sc.Mode == "" && globalMode != "" {
|
|
mode = globalMode
|
|
}
|
|
locals, err := ssync.FindLocalSkills(sc.Path, source, mode)
|
|
if err != nil {
|
|
writeError(w, http.StatusInternalServerError, "scan failed for "+name+": "+err.Error())
|
|
return
|
|
}
|
|
|
|
items := make([]localSkillItem, 0, len(locals))
|
|
for _, sk := range locals {
|
|
items = append(items, localSkillItem{
|
|
Name: sk.Name,
|
|
Kind: "skill",
|
|
Path: sk.Path,
|
|
TargetName: name,
|
|
Size: ssync.CalculateDirSize(sk.Path),
|
|
ModTime: sk.ModTime.Format(time.RFC3339),
|
|
})
|
|
}
|
|
|
|
totalCount += len(items)
|
|
scanTargets = append(scanTargets, scanTarget{
|
|
TargetName: name,
|
|
Skills: items,
|
|
})
|
|
}
|
|
|
|
if scanTargets == nil {
|
|
scanTargets = []scanTarget{}
|
|
}
|
|
|
|
writeJSON(w, map[string]any{
|
|
"targets": scanTargets,
|
|
"totalCount": totalCount,
|
|
})
|
|
}
|
|
|
|
// handleCollect pulls selected local skills from targets to source.
|
|
// POST /api/collect { skills: [{name, targetName}], force: bool }
|
|
func (s *Server) handleCollect(w http.ResponseWriter, r *http.Request) {
|
|
start := time.Now()
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
|
|
var body struct {
|
|
Skills []collectSkillRef `json:"skills"`
|
|
Force bool `json:"force"`
|
|
}
|
|
if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
|
|
writeError(w, http.StatusBadRequest, "invalid request body: "+err.Error())
|
|
return
|
|
}
|
|
|
|
if len(body.Skills) == 0 {
|
|
writeError(w, http.StatusBadRequest, "no skills specified")
|
|
return
|
|
}
|
|
|
|
// Resolve each skill ref to a LocalSkillInfo
|
|
var resolved []ssync.LocalSkillInfo
|
|
for _, ref := range body.Skills {
|
|
target, ok := s.cfg.Targets[ref.TargetName]
|
|
if !ok {
|
|
writeError(w, http.StatusBadRequest, "unknown target: "+ref.TargetName)
|
|
return
|
|
}
|
|
|
|
skillPath := filepath.Join(target.SkillsConfig().Path, ref.Name)
|
|
info, err := os.Lstat(skillPath)
|
|
if err != nil {
|
|
writeError(w, http.StatusBadRequest, "skill not found: "+ref.Name+" in "+ref.TargetName)
|
|
return
|
|
}
|
|
if info.Mode()&os.ModeSymlink != 0 {
|
|
writeError(w, http.StatusBadRequest, "skill is a symlink (not local): "+ref.Name)
|
|
return
|
|
}
|
|
if !info.IsDir() {
|
|
writeError(w, http.StatusBadRequest, "skill is not a directory: "+ref.Name)
|
|
return
|
|
}
|
|
|
|
resolved = append(resolved, ssync.LocalSkillInfo{
|
|
Name: ref.Name,
|
|
Path: skillPath,
|
|
TargetName: ref.TargetName,
|
|
})
|
|
}
|
|
|
|
result, err := ssync.PullSkills(resolved, s.cfg.Source, ssync.PullOptions{
|
|
Force: body.Force,
|
|
})
|
|
if err != nil {
|
|
writeError(w, http.StatusInternalServerError, "collect failed: "+err.Error())
|
|
return
|
|
}
|
|
|
|
// Convert Failed map to string values for JSON
|
|
failed := make(map[string]string, len(result.Failed))
|
|
for k, v := range result.Failed {
|
|
failed[k] = v.Error()
|
|
}
|
|
|
|
status := "ok"
|
|
msg := ""
|
|
if len(result.Failed) > 0 {
|
|
status = "partial"
|
|
msg = "some skills failed to collect"
|
|
}
|
|
s.writeOpsLog("collect", status, start, map[string]any{
|
|
"skills_selected": len(body.Skills),
|
|
"skills_pulled": len(result.Pulled),
|
|
"skills_skipped": len(result.Skipped),
|
|
"skills_failed": len(result.Failed),
|
|
"force": body.Force,
|
|
"scope": "ui",
|
|
}, msg)
|
|
|
|
writeJSON(w, map[string]any{
|
|
"pulled": result.Pulled,
|
|
"skipped": result.Skipped,
|
|
"failed": failed,
|
|
})
|
|
}
|