Files
skillshare/internal/server/handler_diff_stream.go
T
Willie 2ff8bdeb59 fix(diff): report a copy recorded under another naming as modified
Sync re-copies a managed copy whose recorded naming differs from the
current one, for example after a migration stopped between the rename
and the re-copy. Diff skipped it on the mtime fast path and reported the
target in sync while its SKILL.md kept the old name. Check the recorded
naming first in both the CLI and the dashboard diff.
2026-10-09 12:10:08 +08:00

247 lines
9.3 KiB
Go

package server
import (
"maps"
"net/http"
"os"
"path/filepath"
"skillshare/internal/config"
ssync "skillshare/internal/sync"
"skillshare/internal/utils"
)
// handleDiffStream serves an SSE endpoint that streams diff computation progress.
// Events:
// - "discovering" → {"phase":"..."} immediately on connect
// - "start" → {"total": N} after discovery (N = target count)
// - "result" → diffTarget per-target diff result
// - "done" → {"diffs":[...]} final payload (same shape as GET /api/diff)
func (s *Server) handleDiffStream(w http.ResponseWriter, r *http.Request) {
safeSend, ok := initSSE(w)
if !ok {
return
}
ctx := r.Context()
// Snapshot config under RLock, then release before slow I/O.
s.mu.RLock()
source := s.cfg.EffectiveSkillsSource()
agentsSource := s.agentsSource()
globalMode := s.cfg.Mode
ignorePatterns := ssync.EffectiveFileIgnorePatterns(s.cfg.Ignore)
targets := s.cloneTargets()
s.mu.RUnlock()
if globalMode == "" {
globalMode = "merge"
}
safeSend("discovering", map[string]string{"phase": "scanning source directory"})
discovered, ignoreStats, err := ssync.DiscoverSourceSkillsWithStats(source, s.skillsWalk())
if err != nil {
safeSend("error", map[string]string{"error": err.Error()})
return
}
safeSend("start", map[string]int{"total": len(targets)})
var diffs []diffTarget
checked := 0
for name, target := range targets {
select {
case <-ctx.Done():
return
default:
}
dt := s.computeTargetDiff(name, target, discovered, globalMode, source, ignorePatterns)
diffs = append(diffs, dt)
checked++
safeSend("result", map[string]any{
"diff": dt,
"checked": checked,
})
}
diffs = s.appendAgentDiffs(diffs, targets, agentsSource, "")
donePayload := map[string]any{"diffs": diffs}
maps.Copy(donePayload, ignorePayload(ignoreStats))
maps.Copy(donePayload, agentIgnorePayload(agentsSource, nil))
safeSend("done", donePayload)
}
// computeTargetDiff computes the diff for a single target.
// Extracted from handleDiff to share logic with the stream handler.
func (s *Server) computeTargetDiff(name string, target config.TargetConfig, discovered []ssync.DiscoveredSkill, globalMode, source string, ignorePatterns []string) diffTarget {
sc := target.SkillsConfig()
mode := sc.Mode
if mode == "" {
mode = globalMode
}
dt := diffTarget{Target: name, Items: make([]diffItem, 0)}
if !sc.IsEnabled() {
return dt // skills off: nothing is synced, so nothing differs
}
if mode == "symlink" {
status := ssync.CheckStatus(sc.Path, source)
if status != ssync.StatusLinked {
dt.Items = append(dt.Items, diffItem{Skill: "(entire directory)", Action: "link", Reason: "source only", Kind: kindSkill})
}
return dt
}
filtered, err := ssync.SelectTargetSkills(discovered, name, sc)
if err != nil {
return dt
}
resolution, err := ssync.ResolveTargetSkillsForTarget(name, config.ResourceTargetConfig{
Path: sc.Path,
TargetNaming: sc.TargetNaming,
}, filtered)
if err != nil {
dt.Items = append(dt.Items, diffItem{Skill: "(target naming)", Action: "skip", Reason: err.Error(), Kind: kindSkill})
return dt
}
// Surface collision/validation stats so the UI can show why skills were skipped
dt.CollisionCount = len(resolution.Collisions)
dt.SkippedCount = len(filtered) - len(resolution.Skills)
validNames := resolution.ValidTargetNames()
manifest, _ := ssync.ReadManifest(sc.Path)
legacyNames := resolution.LegacyNames(mode, sc.Path, manifest)
renamedFrom := ssync.RenamedFrom(legacyNames)
if mode == "copy" {
for _, resolved := range resolution.Skills {
skill := resolved.Skill
oldChecksum, isManaged := manifest.Managed[resolved.TargetName]
targetSkillPath := filepath.Join(sc.Path, resolved.TargetName)
if !isManaged {
if info, statErr := os.Stat(targetSkillPath); statErr == nil {
if info.IsDir() {
dt.Items = append(dt.Items, diffItem{Skill: resolved.TargetName, Action: "skip", Reason: "local copy (sync --force to replace)", Kind: kindSkill})
} else {
dt.Items = append(dt.Items, diffItem{Skill: resolved.TargetName, Action: "update", Reason: "target entry is not a directory", Kind: kindSkill})
}
} else if old, ok := renamedFrom[resolved.TargetName]; ok && os.IsNotExist(statErr) {
dt.Items = append(dt.Items, diffItem{Skill: resolved.TargetName, Action: "update", Reason: ssync.RenameReason(old), Kind: kindSkill})
} else if os.IsNotExist(statErr) {
dt.Items = append(dt.Items, diffItem{Skill: resolved.TargetName, Action: "link", Reason: "source only", Kind: kindSkill})
} else {
dt.Items = append(dt.Items, diffItem{Skill: resolved.TargetName, Action: "update", Reason: "cannot access target entry", Kind: kindSkill})
}
} else {
targetInfo, statErr := os.Stat(targetSkillPath)
if os.IsNotExist(statErr) {
dt.Items = append(dt.Items, diffItem{Skill: resolved.TargetName, Action: "link", Reason: "missing (deleted from target)", Kind: kindSkill})
} else if statErr != nil {
dt.Items = append(dt.Items, diffItem{Skill: resolved.TargetName, Action: "update", Reason: "cannot access target entry", Kind: kindSkill})
} else if !targetInfo.IsDir() {
dt.Items = append(dt.Items, diffItem{Skill: resolved.TargetName, Action: "update", Reason: "target entry is not a directory", Kind: kindSkill})
} else if recorded := manifest.Naming[resolved.TargetName]; recorded != "" && recorded != resolution.Naming {
// A copy made under another naming carries another name:, so sync re-copies it.
dt.Items = append(dt.Items, diffItem{Skill: resolved.TargetName, Action: "update", Reason: ssync.NamingChangedReason, Kind: kindSkill})
} else {
oldMtime := manifest.Mtimes[resolved.TargetName]
currentMtime, mtimeErr := ssync.DirMaxMtimeWithIgnore(skill.SourcePath, ignorePatterns)
if mtimeErr == nil && oldMtime > 0 && currentMtime == oldMtime {
continue
}
srcChecksum, checksumErr := ssync.DirChecksumWithIgnore(skill.SourcePath, ignorePatterns)
if checksumErr != nil {
dt.Items = append(dt.Items, diffItem{Skill: resolved.TargetName, Action: "update", Reason: "cannot compute checksum", Kind: kindSkill})
} else if srcChecksum != oldChecksum {
dt.Items = append(dt.Items, diffItem{Skill: resolved.TargetName, Action: "update", Reason: "content changed", Kind: kindSkill})
}
}
}
}
for managedName := range manifest.Managed {
if _, keepLegacy := legacyNames[managedName]; keepLegacy {
continue
}
if !validNames[managedName] {
dt.Items = append(dt.Items, diffItem{Skill: managedName, Action: "prune", Reason: "orphan copy", Kind: kindSkill})
}
}
return dt
}
// Merge mode
for _, resolved := range resolution.Skills {
skill := resolved.Skill
targetSkillPath := filepath.Join(sc.Path, resolved.TargetName)
_, err := os.Lstat(targetSkillPath)
if err != nil {
if old, ok := renamedFrom[resolved.TargetName]; ok && os.IsNotExist(err) {
dt.Items = append(dt.Items, diffItem{Skill: resolved.TargetName, Action: "update", Reason: ssync.RenameReason(old), Kind: kindSkill})
} else if os.IsNotExist(err) {
dt.Items = append(dt.Items, diffItem{Skill: resolved.TargetName, Action: "link", Reason: "source only", Kind: kindSkill})
}
continue
}
if utils.IsSymlinkOrJunction(targetSkillPath) {
absLink, linkErr := utils.ResolveLinkTarget(targetSkillPath)
if linkErr != nil {
dt.Items = append(dt.Items, diffItem{Skill: resolved.TargetName, Action: "update", Reason: "link target unreadable", Kind: kindSkill})
continue
}
absSource, _ := filepath.Abs(skill.SourcePath)
if !utils.PathsEqual(absLink, absSource) {
dt.Items = append(dt.Items, diffItem{Skill: resolved.TargetName, Action: "update", Reason: "symlink points elsewhere", Kind: kindSkill})
}
} else {
dt.Items = append(dt.Items, diffItem{Skill: resolved.TargetName, Action: "skip", Reason: "local copy (sync --force to replace)", Kind: kindSkill})
}
}
// Orphan check
entries, _ := os.ReadDir(sc.Path)
for _, entry := range entries {
eName := entry.Name()
if manifest.SkipsHidden(eName) {
continue
}
if _, keepLegacy := legacyNames[eName]; keepLegacy {
continue
}
entryPath := filepath.Join(sc.Path, eName)
if !validNames[eName] {
info, statErr := os.Lstat(entryPath)
if statErr != nil {
continue
}
if utils.IsSymlinkOrJunction(entryPath) {
absLink, linkErr := utils.ResolveLinkTarget(entryPath)
if linkErr != nil {
continue
}
absSource, _ := filepath.Abs(source)
if utils.PathHasPrefix(absLink, absSource+string(filepath.Separator)) {
dt.Items = append(dt.Items, diffItem{Skill: eName, Action: "prune", Reason: "orphan symlink", Kind: kindSkill})
}
} else if info.IsDir() {
if _, inManifest := manifest.Managed[eName]; inManifest {
dt.Items = append(dt.Items, diffItem{Skill: eName, Action: "prune", Reason: "orphan managed directory (manifest)", Kind: kindSkill})
} else {
if resolution.Naming == "flat" && (utils.HasNestedSeparator(eName) || utils.IsTrackedRepoDir(eName)) {
dt.Items = append(dt.Items, diffItem{Skill: eName, Action: "prune", Reason: "orphan managed directory", Kind: kindSkill})
} else {
dt.Items = append(dt.Items, diffItem{Skill: eName, Action: "local", Reason: "local only", Kind: kindSkill})
}
}
}
}
}
return dt
}