Files
skillshare/internal/server/handler_sync.go
T
Willie 092fb14f8a feat: add web dashboard with embedded React SPA (skillshare ui)
Single-binary web UI for visual skill management — React 19 + Vite
frontend embedded via go:embed, Go net/http REST API backend (30+
endpoints). Includes dashboard, skills browser, targets, sync, collect,
search, install, config editor, backup/restore, and git sync pages.

Also adds Bitbucket/GitLab URL parsing for install, git operations
library, skill version checking, CI frontend build steps, Docker
sandbox support, and website docs for the ui command.
2026-02-08 05:08:30 +08:00

190 lines
4.8 KiB
Go

package server
import (
"encoding/json"
"net/http"
"os"
"path/filepath"
"strings"
ssync "skillshare/internal/sync"
"skillshare/internal/utils"
)
type syncTargetResult struct {
Target string `json:"target"`
Linked []string `json:"linked"`
Updated []string `json:"updated"`
Skipped []string `json:"skipped"`
Pruned []string `json:"pruned"`
}
func (s *Server) handleSync(w http.ResponseWriter, r *http.Request) {
s.mu.Lock()
defer s.mu.Unlock()
var body struct {
DryRun bool `json:"dryRun"`
Force bool `json:"force"`
}
if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
// Default to non-dry-run, non-force
}
globalMode := s.cfg.Mode
if globalMode == "" {
globalMode = "merge"
}
results := make([]syncTargetResult, 0)
for name, target := range s.cfg.Targets {
mode := target.Mode
if mode == "" {
mode = globalMode
}
res := syncTargetResult{
Target: name,
Linked: make([]string, 0),
Updated: make([]string, 0),
Skipped: make([]string, 0),
Pruned: make([]string, 0),
}
if mode == "merge" {
mergeResult, err := ssync.SyncTargetMerge(name, target, s.cfg.Source, body.DryRun, body.Force)
if err != nil {
writeError(w, http.StatusInternalServerError, "sync failed for "+name+": "+err.Error())
return
}
res.Linked = mergeResult.Linked
res.Updated = mergeResult.Updated
res.Skipped = mergeResult.Skipped
// Prune orphans
pruneResult, err := ssync.PruneOrphanLinks(target.Path, s.cfg.Source, body.DryRun)
if err == nil {
res.Pruned = pruneResult.Removed
}
} else {
err := ssync.SyncTarget(name, target, s.cfg.Source, body.DryRun)
if err != nil {
writeError(w, http.StatusInternalServerError, "sync failed for "+name+": "+err.Error())
return
}
res.Linked = []string{"(symlink mode)"}
}
results = append(results, res)
}
writeJSON(w, map[string]any{"results": results})
}
type diffItem struct {
Skill string `json:"skill"`
Action string `json:"action"` // "link", "update", "skip", "prune", "local"
Reason string `json:"reason"` // human-readable description
}
type diffTarget struct {
Target string `json:"target"`
Items []diffItem `json:"items"`
}
func (s *Server) handleDiff(w http.ResponseWriter, r *http.Request) {
filterTarget := r.URL.Query().Get("target")
globalMode := s.cfg.Mode
if globalMode == "" {
globalMode = "merge"
}
discovered, err := ssync.DiscoverSourceSkills(s.cfg.Source)
if err != nil {
writeError(w, http.StatusInternalServerError, err.Error())
return
}
diffs := make([]diffTarget, 0)
for name, target := range s.cfg.Targets {
if filterTarget != "" && filterTarget != name {
continue
}
mode := target.Mode
if mode == "" {
mode = globalMode
}
dt := diffTarget{Target: name, Items: make([]diffItem, 0)}
if mode != "merge" {
status := ssync.CheckStatus(target.Path, s.cfg.Source)
if status != ssync.StatusLinked {
dt.Items = append(dt.Items, diffItem{Skill: "(entire directory)", Action: "link", Reason: "missing"})
}
diffs = append(diffs, dt)
continue
}
// Merge mode: check each skill
for _, skill := range discovered {
targetSkillPath := filepath.Join(target.Path, skill.FlatName)
info, err := os.Lstat(targetSkillPath)
if err != nil {
if os.IsNotExist(err) {
dt.Items = append(dt.Items, diffItem{Skill: skill.FlatName, Action: "link", Reason: "missing"})
}
continue
}
if info.Mode()&os.ModeSymlink != 0 {
link, _ := os.Readlink(targetSkillPath)
absLink, _ := filepath.Abs(link)
absSource, _ := filepath.Abs(skill.SourcePath)
if !utils.PathsEqual(absLink, absSource) {
dt.Items = append(dt.Items, diffItem{Skill: skill.FlatName, Action: "update", Reason: "symlink points elsewhere"})
}
} else {
dt.Items = append(dt.Items, diffItem{Skill: skill.FlatName, Action: "skip", Reason: "local copy (sync --force to replace)"})
}
}
// Check for orphans
entries, _ := os.ReadDir(target.Path)
validNames := make(map[string]bool)
for _, skill := range discovered {
validNames[skill.FlatName] = true
}
for _, entry := range entries {
eName := entry.Name()
if utils.IsHidden(eName) {
continue
}
if !validNames[eName] {
info, err := os.Lstat(filepath.Join(target.Path, eName))
if err != nil {
continue
}
if info.Mode()&os.ModeSymlink != 0 {
link, _ := os.Readlink(filepath.Join(target.Path, eName))
absLink, _ := filepath.Abs(link)
absSource, _ := filepath.Abs(s.cfg.Source)
if strings.HasPrefix(absLink, absSource+string(filepath.Separator)) {
dt.Items = append(dt.Items, diffItem{Skill: eName, Action: "prune", Reason: "orphan symlink"})
}
} else {
dt.Items = append(dt.Items, diffItem{Skill: eName, Action: "local", Reason: "local only"})
}
}
}
diffs = append(diffs, dt)
}
writeJSON(w, map[string]any{"diffs": diffs})
}