mirror of
https://github.com/runkids/skillshare.git
synced 2026-11-19 02:17:09 +00:00
Users link a checkout directly under the skills source (e.g. skills/_dev-skills -> ~/code/dev-skills) and expect it to behave like any other first-level entry. sourcewalk resolved only the root, so these links were invisible to discovery, sync, update, and the dashboard. follow_source_links (global and project config, default false) enables a per-operation sourcewalk.Follow policy. Walk, WalkDir, and ReadDir report a followed link under its own name as a directory and descend into its target, so names, RelPath, FlatName, SourcePath, tracked-repo detection, and metadata keys stay logical. Only entries directly under the source root are followed. The policy is built from config and passed explicitly to every discovery caller in the CLI, server, and reconcile, so counts agree; the server keeps a per-instance snapshot refreshed on config load and save instead of a process-global flag. A link is skipped, with one warning per operation, when its target is missing or unreadable, is the source or a parent of it, or overlaps an active skills target. A missing or unreadable target marks the operation incomplete: sync then skips pruning and copy-orphan deletion, and reconcile keeps metadata, so an unmounted drive or a re-clone in progress cannot erase target entries or install records. A link to an existing file is not a directory link and stays an ordinary entry; treating it as incomplete would disable pruning for anyone sharing a file such as .skillignore. doctor keeps raw link identity: with the key off it still says the link is not followed and names follow_source_links: true; with it on it reports followed links and skipped links with the reason. The raw-walk allowlist gains entries for the policy path in Walk and WalkDir: the source root walk with a policy, and the walk of a validated link target whose paths are remapped to the logical link path. Both live in sourcewalk itself, the package that owns source traversal. Refs #274
241 lines
8.6 KiB
Go
241 lines
8.6 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.FilterSkills(discovered, sc.Include, sc.Exclude)
|
|
if err != nil {
|
|
return dt
|
|
}
|
|
filtered = ssync.FilterSkillsByTarget(filtered, name)
|
|
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()
|
|
legacyNames := resolution.LegacyFlatNames()
|
|
|
|
if mode == "copy" {
|
|
manifest, _ := ssync.ReadManifest(sc.Path)
|
|
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 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 {
|
|
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 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)
|
|
manifest, _ := ssync.ReadManifest(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
|
|
}
|