mirror of
https://github.com/runkids/skillshare.git
synced 2026-11-19 02:17:09 +00:00
createLink always tried `mklink /J` first. mklink does not check the source type, so agents, single-file extras such as a shared AGENTS.md, and per-file extras links became directory junctions that point at a file: Explorer shows a folder and tools cannot read it. Sync then compared only the link destination and kept the broken junction forever. Files now get real symlinks only. When the OS cannot create them (Windows without Developer Mode, non-elevated), file-based link modes fall back to copies at the mode level, so status, doctor, the API and later syncs all see an effective `copy` mode. Fallback copies are tracked by hash so they keep updating and pruning without touching the user's own files, and turn back into links once links work. Single-file extras remember what they last wrote, so an unedited copy is replaced silently instead of producing a drift backup on every source edit, and switching a target back to import restores the user's attach-time content plus the import block. Includes a Windows runbook and script, verified on a Windows 11 ARM64 VM with and without symlink rights. Refs #299
891 lines
26 KiB
Go
891 lines
26 KiB
Go
package sync
|
|
|
|
import (
|
|
"bytes"
|
|
"fmt"
|
|
"io"
|
|
"os"
|
|
"path/filepath"
|
|
"sort"
|
|
"strings"
|
|
|
|
"skillshare/internal/utils"
|
|
)
|
|
|
|
// ExtraResult holds the result of an extras sync operation.
|
|
type ExtraResult struct {
|
|
Synced int // Files synced (new + already correct)
|
|
Skipped int // Files skipped (local conflict, no --force)
|
|
Pruned int // Orphan files removed
|
|
Errors []string // Non-fatal error messages
|
|
Warnings []string // Non-fatal warnings (e.g. flatten collisions)
|
|
}
|
|
|
|
// reservedMetadataFile is skillshare's per-directory install-tracking store
|
|
// (mirrors install.MetadataFileName, duplicated here to avoid an import cycle).
|
|
// It is internal bookkeeping, not user content, so it must never be synced or
|
|
// transformed into a target directory.
|
|
const reservedMetadataFile = ".metadata.json"
|
|
|
|
// DiscoverExtraFiles recursively walks sourcePath and returns relative paths
|
|
// of all regular files. Directories named ".git" and skillshare's reserved
|
|
// .metadata.json bookkeeping file are skipped. Results are sorted for
|
|
// deterministic output.
|
|
func DiscoverExtraFiles(sourcePath string) ([]string, error) {
|
|
info, err := os.Stat(sourcePath)
|
|
if err != nil {
|
|
if os.IsNotExist(err) {
|
|
return nil, fmt.Errorf("extras source directory does not exist: %s", sourcePath)
|
|
}
|
|
return nil, fmt.Errorf("failed to stat extras source: %w", err)
|
|
}
|
|
if !info.IsDir() {
|
|
return nil, fmt.Errorf("extras source is not a directory: %s", sourcePath)
|
|
}
|
|
|
|
var files []string
|
|
err = filepath.Walk(sourcePath, func(path string, fi os.FileInfo, walkErr error) error {
|
|
if walkErr != nil {
|
|
return nil // skip inaccessible paths
|
|
}
|
|
if fi.IsDir() {
|
|
if fi.Name() == ".git" {
|
|
return filepath.SkipDir
|
|
}
|
|
return nil
|
|
}
|
|
if fi.Name() == reservedMetadataFile {
|
|
return nil // skillshare's internal tracking store, never sync it
|
|
}
|
|
rel, relErr := filepath.Rel(sourcePath, path)
|
|
if relErr != nil {
|
|
return nil
|
|
}
|
|
files = append(files, rel)
|
|
return nil
|
|
})
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to walk extras source: %w", err)
|
|
}
|
|
|
|
sort.Strings(files)
|
|
return files, nil
|
|
}
|
|
|
|
// SyncExtra synchronises extra files from sourcePath into targetPath.
|
|
//
|
|
// Supported modes:
|
|
// - "merge" (default): per-file symlink from target to source
|
|
// - "copy": per-file copy
|
|
// - "symlink": entire directory symlink
|
|
//
|
|
// When spec is non-nil, the sync is routed through syncExtraTransform
|
|
// (transform/extension mode). When spec is nil, behavior is unchanged.
|
|
// When dryRun is true the function counts what would happen but makes no
|
|
// filesystem changes.
|
|
func SyncExtra(sourcePath, targetPath, mode string, dryRun, force, flatten bool, projectRoot string, spec *ExtensionSpec) (*ExtraResult, error) {
|
|
if spec != nil {
|
|
// Transform extensions emit generated files into the target, so only
|
|
// copy semantics apply. Reject merge/symlink here so the API and the
|
|
// CLI (validateExtensionMode) enforce the same contract.
|
|
if mode != "" && mode != "copy" {
|
|
return nil, fmt.Errorf("extension %q requires copy mode, got %q", spec.Name, mode)
|
|
}
|
|
return syncExtraTransform(sourcePath, targetPath, spec, dryRun, force, flatten)
|
|
}
|
|
if mode == "" {
|
|
mode = "merge"
|
|
}
|
|
if flatten && mode == "symlink" {
|
|
return nil, fmt.Errorf("flatten cannot be used with symlink mode")
|
|
}
|
|
|
|
switch mode {
|
|
case "symlink":
|
|
return syncExtraSymlinkMode(sourcePath, targetPath, dryRun, force, projectRoot)
|
|
case "merge", "copy":
|
|
return syncExtraPerFile(sourcePath, targetPath, mode, dryRun, force, flatten, projectRoot)
|
|
default:
|
|
return nil, fmt.Errorf("unsupported extras sync mode: %q", mode)
|
|
}
|
|
}
|
|
|
|
// syncExtraTransform applies an extension to every source file and writes the
|
|
// transformed output into targetPath using copy semantics. Output files are
|
|
// renamed per spec.OutputExt. It does not prune output-looking orphans because
|
|
// copy targets do not carry ownership metadata.
|
|
func syncExtraTransform(sourcePath, targetPath string, spec *ExtensionSpec, dryRun, force, flatten bool) (*ExtraResult, error) {
|
|
result := &ExtraResult{}
|
|
|
|
files, err := DiscoverExtraFiles(sourcePath)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
absSrc, err := filepath.Abs(sourcePath)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to resolve source path: %w", err)
|
|
}
|
|
|
|
seen := make(map[string]string) // flatten: basename → original rel
|
|
for _, rel := range files {
|
|
srcFile := filepath.Join(absSrc, rel)
|
|
tgtRel := rel
|
|
if flatten {
|
|
base := filepath.Base(rel)
|
|
if prev, ok := seen[base]; ok {
|
|
result.Skipped++
|
|
result.Warnings = append(result.Warnings,
|
|
fmt.Sprintf("flatten conflict: %s skipped (%s already synced from %s)", rel, base, prev))
|
|
continue
|
|
}
|
|
seen[base] = rel
|
|
tgtRel = base
|
|
}
|
|
tgtRel = ApplyOutputExt(tgtRel, spec.OutputExt)
|
|
tgtFile := filepath.Join(targetPath, tgtRel)
|
|
|
|
// Dry-run reports the outcome without spawning the extension and without
|
|
// touching the filesystem. The transformed output can only be produced by
|
|
// a subprocess, and a preview must never execute arbitrary extension code,
|
|
// so content can't be compared here. An existing real file or directory is
|
|
// therefore conservatively reported as a conflict requiring --force —
|
|
// matching the non-dry-run skip path below — while a missing target, a
|
|
// leftover symlink, or --force would be (re)written and counts as synced.
|
|
if dryRun {
|
|
if info, lstatErr := os.Lstat(tgtFile); lstatErr == nil &&
|
|
!utils.IsLinkMode(tgtFile, info.Mode()) && !force {
|
|
result.Skipped++
|
|
} else {
|
|
result.Synced++
|
|
}
|
|
continue
|
|
}
|
|
|
|
env := map[string]string{
|
|
"SS_SRC_PATH": srcFile,
|
|
"SS_REL_PATH": rel,
|
|
"SS_TARGET_DIR": targetPath,
|
|
"SS_MODE": "sync",
|
|
}
|
|
|
|
out, runErr := runExtension(spec, srcFile, env)
|
|
if runErr != nil {
|
|
result.Errors = append(result.Errors, fmt.Sprintf("%s: %v", rel, runErr))
|
|
continue
|
|
}
|
|
|
|
// Conflict/force contract, mirroring syncOneExtraFile copy semantics:
|
|
// only leftover symlinks auto-replace; real files and directories are
|
|
// never destroyed without --force.
|
|
if info, lstatErr := os.Lstat(tgtFile); lstatErr == nil {
|
|
switch {
|
|
case utils.IsLinkMode(tgtFile, info.Mode()):
|
|
// Leftover symlink from a different mode: safe to replace.
|
|
// os.Remove drops the link itself without following it.
|
|
if rmErr := os.Remove(tgtFile); rmErr != nil {
|
|
result.Errors = append(result.Errors, fmt.Sprintf("%s: failed to remove conflicting symlink: %v", rel, rmErr))
|
|
continue
|
|
}
|
|
case info.IsDir():
|
|
// A real directory is never silently destroyed; require --force,
|
|
// then replace it wholesale with the generated file.
|
|
if !force {
|
|
result.Skipped++
|
|
continue
|
|
}
|
|
if rmErr := os.RemoveAll(tgtFile); rmErr != nil {
|
|
result.Errors = append(result.Errors, fmt.Sprintf("%s: failed to remove conflicting directory: %v", rel, rmErr))
|
|
continue
|
|
}
|
|
default:
|
|
// Regular file: idempotent if identical, otherwise needs --force.
|
|
if existing, readErr := os.ReadFile(tgtFile); readErr == nil && bytes.Equal(existing, out) {
|
|
result.Synced++
|
|
continue
|
|
}
|
|
if !force {
|
|
result.Skipped++
|
|
continue
|
|
}
|
|
// With --force, WriteFile overwrites the file in place below.
|
|
}
|
|
}
|
|
|
|
if mkErr := os.MkdirAll(filepath.Dir(tgtFile), 0755); mkErr != nil {
|
|
result.Errors = append(result.Errors, fmt.Sprintf("%s: create target dir: %v", rel, mkErr))
|
|
continue
|
|
}
|
|
if wErr := os.WriteFile(tgtFile, out, 0644); wErr != nil {
|
|
result.Errors = append(result.Errors, fmt.Sprintf("%s: write target: %v", rel, wErr))
|
|
continue
|
|
}
|
|
result.Synced++
|
|
}
|
|
|
|
return result, nil
|
|
}
|
|
|
|
// syncExtraSymlinkMode symlinks the entire source directory to the target path.
|
|
func syncExtraSymlinkMode(sourcePath, targetPath string, dryRun, force bool, projectRoot string) (*ExtraResult, error) {
|
|
result := &ExtraResult{}
|
|
|
|
absSrc, err := filepath.Abs(sourcePath)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to resolve source path: %w", err)
|
|
}
|
|
|
|
// Check existing target
|
|
info, lstatErr := os.Lstat(targetPath)
|
|
if lstatErr == nil {
|
|
// Something exists at targetPath
|
|
if utils.IsLinkMode(targetPath, info.Mode()) {
|
|
// Already a symlink — check if correct
|
|
dest, readErr := os.Readlink(targetPath)
|
|
if readErr == nil {
|
|
absDest := resolveReadlink(dest, targetPath)
|
|
if absDest == absSrc {
|
|
relative := shouldUseRelative(projectRoot, absSrc, targetPath)
|
|
if !linkNeedsReformat(dest, relative) {
|
|
result.Synced = 1
|
|
return result, nil
|
|
}
|
|
// Correct target but wrong format (abs↔rel) — recreate
|
|
if dryRun {
|
|
result.Synced = 1
|
|
return result, nil
|
|
}
|
|
if err := reformatLink(targetPath, absSrc, relative); err != nil {
|
|
return nil, fmt.Errorf("failed to reformat directory symlink: %w", err)
|
|
}
|
|
result.Synced = 1
|
|
return result, nil
|
|
}
|
|
}
|
|
// Wrong symlink
|
|
if !force {
|
|
result.Skipped = 1
|
|
return result, nil
|
|
}
|
|
if !dryRun {
|
|
if err := os.Remove(targetPath); err != nil {
|
|
return nil, fmt.Errorf("failed to remove wrong symlink: %w", err)
|
|
}
|
|
}
|
|
} else {
|
|
// Real file/dir
|
|
if !force {
|
|
result.Skipped = 1
|
|
return result, nil
|
|
}
|
|
if !dryRun {
|
|
os.RemoveAll(targetPath)
|
|
}
|
|
}
|
|
}
|
|
|
|
if dryRun {
|
|
result.Synced = 1
|
|
return result, nil
|
|
}
|
|
|
|
if err := os.MkdirAll(filepath.Dir(targetPath), 0755); err != nil {
|
|
return nil, fmt.Errorf("failed to create parent directory: %w", err)
|
|
}
|
|
relative := shouldUseRelative(projectRoot, absSrc, targetPath)
|
|
if err := createLink(targetPath, absSrc, relative); err != nil {
|
|
return nil, fmt.Errorf("failed to create directory symlink: %w", err)
|
|
}
|
|
result.Synced = 1
|
|
return result, nil
|
|
}
|
|
|
|
// syncExtraPerFile handles merge (symlink) and copy modes on a per-file basis.
|
|
// Merge copies instead when file links are unavailable; those copies are
|
|
// tracked so later syncs keep them updated and pruned like links.
|
|
func syncExtraPerFile(sourcePath, targetPath, mode string, dryRun, force, flatten bool, projectRoot string) (*ExtraResult, error) {
|
|
result := &ExtraResult{}
|
|
|
|
var copies *copyTracker
|
|
if mode == "merge" {
|
|
copies = loadCopyTracker(targetPath)
|
|
if !canCreateFileLink() {
|
|
mode = "copy"
|
|
result.Warnings = append(result.Warnings, FileLinkFallbackWarning)
|
|
}
|
|
}
|
|
|
|
files, err := DiscoverExtraFiles(sourcePath)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
absSrc, err := filepath.Abs(sourcePath)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to resolve source path: %w", err)
|
|
}
|
|
|
|
seen := make(map[string]string) // basename → original rel path (flatten only)
|
|
|
|
// Compute once for entire batch — all files share the same source/target root.
|
|
relative := shouldUseRelative(projectRoot, sourcePath, targetPath)
|
|
|
|
for _, rel := range files {
|
|
srcFile := filepath.Join(absSrc, rel)
|
|
tgtRel := rel
|
|
if flatten {
|
|
base := filepath.Base(rel)
|
|
if prev, exists := seen[base]; exists {
|
|
result.Skipped++
|
|
result.Warnings = append(result.Warnings,
|
|
fmt.Sprintf("flatten conflict: %s skipped (%s already synced from %s)", rel, base, prev))
|
|
continue
|
|
}
|
|
seen[base] = rel
|
|
tgtRel = base
|
|
}
|
|
tgtFile := filepath.Join(targetPath, tgtRel)
|
|
|
|
synced, skipped, syncErr := syncOneExtraFile(srcFile, tgtFile, mode, dryRun, force, relative, copies, tgtRel)
|
|
if syncErr != nil {
|
|
result.Errors = append(result.Errors, fmt.Sprintf("%s: %v", rel, syncErr))
|
|
continue
|
|
}
|
|
result.Synced += synced
|
|
result.Skipped += skipped
|
|
}
|
|
|
|
// Prune merge-mode symlink orphans (only when not dry-run). Copy targets do
|
|
// not carry ownership metadata, so sync must not delete local files that are
|
|
// absent from the current source set.
|
|
if !dryRun {
|
|
sourceSet := make(map[string]bool, len(files))
|
|
if flatten {
|
|
for base := range seen {
|
|
sourceSet[base] = true
|
|
}
|
|
} else {
|
|
for _, f := range files {
|
|
sourceSet[f] = true
|
|
}
|
|
}
|
|
if mode == "merge" {
|
|
pruned, pruneErrors := pruneExtraOrphans(targetPath, sourceSet, mode)
|
|
result.Pruned = pruned
|
|
result.Errors = append(result.Errors, pruneErrors...)
|
|
}
|
|
if copies != nil {
|
|
for _, rel := range copies.pruneOrphans(sourceSet, false) {
|
|
cleanEmptyParents(filepath.Dir(filepath.Join(targetPath, rel)), targetPath)
|
|
result.Pruned++
|
|
}
|
|
if err := copies.save(); err != nil {
|
|
result.Errors = append(result.Errors, fmt.Sprintf("failed to update manifest: %v", err))
|
|
}
|
|
}
|
|
}
|
|
|
|
return result, nil
|
|
}
|
|
|
|
// syncOneExtraFile syncs a single file. Returns (synced, skipped, error).
|
|
// copies, when set, tracks copies made in place of merge-mode links under
|
|
// the target-relative name tgtRel.
|
|
func syncOneExtraFile(srcFile, tgtFile, mode string, dryRun, force, relative bool, copies *copyTracker, tgtRel string) (int, int, error) {
|
|
// Ensure parent directory exists
|
|
if !dryRun {
|
|
if err := os.MkdirAll(filepath.Dir(tgtFile), 0755); err != nil {
|
|
return 0, 0, fmt.Errorf("failed to create parent dir: %w", err)
|
|
}
|
|
}
|
|
|
|
// Check if target already exists
|
|
info, lstatErr := os.Lstat(tgtFile)
|
|
if lstatErr == nil {
|
|
isSymlink := utils.IsSymlinkOrJunction(tgtFile)
|
|
|
|
// Already correct? → skip (idempotent)
|
|
if mode == "merge" && isSymlink && fileLinkUsable(tgtFile) {
|
|
dest, readErr := os.Readlink(tgtFile)
|
|
if readErr == nil {
|
|
absDest := resolveReadlink(dest, tgtFile)
|
|
if absDest == srcFile {
|
|
if !linkNeedsReformat(dest, relative) {
|
|
return 1, 0, nil
|
|
}
|
|
// Correct target but wrong format — recreate
|
|
if !dryRun {
|
|
if err := reformatLink(tgtFile, srcFile, relative); err != nil {
|
|
return 0, 0, fmt.Errorf("failed to reformat symlink: %w", err)
|
|
}
|
|
}
|
|
return 1, 0, nil
|
|
}
|
|
}
|
|
}
|
|
if mode == "copy" && !isSymlink && !info.IsDir() {
|
|
srcInfo, srcErr := os.Stat(srcFile)
|
|
if srcErr == nil && srcInfo.Size() == info.Size() && contentEqual(srcFile, tgtFile) {
|
|
if copies != nil && !dryRun {
|
|
copies.record(tgtRel)
|
|
}
|
|
return 1, 0, nil
|
|
}
|
|
}
|
|
|
|
// Symlinks left over from a different mode are safe to replace, and so
|
|
// are unedited copies made in place of merge-mode links.
|
|
autoReplace := isSymlink || (copies != nil && !info.IsDir() && copies.owns(tgtRel))
|
|
if !autoReplace && !force {
|
|
return 0, 1, nil
|
|
}
|
|
|
|
if !dryRun {
|
|
if err := os.Remove(tgtFile); err != nil {
|
|
return 0, 0, fmt.Errorf("failed to remove conflicting file: %w", err)
|
|
}
|
|
}
|
|
}
|
|
|
|
if dryRun {
|
|
return 1, 0, nil
|
|
}
|
|
|
|
switch mode {
|
|
case "merge":
|
|
if err := createLink(tgtFile, srcFile, relative); err != nil {
|
|
return 0, 0, fmt.Errorf("failed to create symlink: %w", err)
|
|
}
|
|
if copies != nil {
|
|
copies.forget(tgtRel)
|
|
}
|
|
case "copy":
|
|
if err := copyFile(srcFile, tgtFile); err != nil {
|
|
return 0, 0, fmt.Errorf("failed to copy file: %w", err)
|
|
}
|
|
if copies != nil {
|
|
copies.record(tgtRel)
|
|
}
|
|
}
|
|
|
|
return 1, 0, nil
|
|
}
|
|
|
|
// pruneExtraOrphans walks the target directory and removes files that have no
|
|
// corresponding source. In merge mode only symlinks are pruned; user-created
|
|
// local files are preserved. Empty parent directories are cleaned up.
|
|
// Hidden files (names starting with ".") are skipped.
|
|
func pruneExtraOrphans(targetPath string, sourceFiles map[string]bool, mode string) (pruned int, errors []string) {
|
|
// Collect paths to prune (walk first, delete after to avoid mutation during walk)
|
|
var toRemove []string
|
|
|
|
_ = filepath.Walk(targetPath, func(path string, info os.FileInfo, walkErr error) error {
|
|
if walkErr != nil {
|
|
return nil
|
|
}
|
|
if info.IsDir() {
|
|
if info.Name() == ".git" {
|
|
return filepath.SkipDir
|
|
}
|
|
// A directory occupying a claimed output path is a skipped conflict
|
|
// (the source wanted a file there but we refused to clobber it).
|
|
// Leave its contents entirely untouched — never prune inside it.
|
|
if rel, relErr := filepath.Rel(targetPath, path); relErr == nil && sourceFiles[rel] {
|
|
return filepath.SkipDir
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Skip hidden files
|
|
if strings.HasPrefix(info.Name(), ".") {
|
|
return nil
|
|
}
|
|
|
|
rel, relErr := filepath.Rel(targetPath, path)
|
|
if relErr != nil {
|
|
return nil
|
|
}
|
|
|
|
// Check if corresponding source file exists
|
|
if sourceFiles[rel] {
|
|
return nil // source exists, keep it
|
|
}
|
|
|
|
// Source doesn't exist — candidate for pruning
|
|
if mode == "merge" {
|
|
// In merge mode, only prune symlinks (don't delete user's local files)
|
|
if !utils.IsLinkMode(path, info.Mode()) {
|
|
return nil
|
|
}
|
|
}
|
|
|
|
toRemove = append(toRemove, path)
|
|
return nil
|
|
})
|
|
|
|
for _, path := range toRemove {
|
|
if err := os.Remove(path); err != nil {
|
|
errors = append(errors, fmt.Sprintf("prune %s: %v", path, err))
|
|
continue
|
|
}
|
|
pruned++
|
|
|
|
// Clean empty parent directories up to targetPath
|
|
cleanEmptyParents(filepath.Dir(path), targetPath)
|
|
}
|
|
|
|
return pruned, errors
|
|
}
|
|
|
|
// PruneExtraTarget removes all skillshare-managed files from a single extra
|
|
// target directory. It is used when a target is removed from an extra: in
|
|
// merge mode only symlinks are deleted (the user's own files are preserved);
|
|
// in copy mode callers should prefer PruneExtraTargetFiles with a managed file
|
|
// set. Empty parent directories are cleaned up. An empty mode is treated as
|
|
// "merge".
|
|
func PruneExtraTarget(targetPath, mode string) (pruned int, errors []string) {
|
|
if mode == "" {
|
|
mode = "merge"
|
|
}
|
|
// An empty source set means "nothing should remain" — every managed file
|
|
// under the target is an orphan and gets pruned.
|
|
return pruneExtraOrphans(targetPath, map[string]bool{}, mode)
|
|
}
|
|
|
|
// PruneExtraTargetFiles removes the files known to be managed in a removed
|
|
// target. Copy targets use the managed file set so local files in the same
|
|
// directory survive. Merge targets keep the existing symlink-only pruning
|
|
// behavior. Symlink targets remove only the target symlink itself.
|
|
func PruneExtraTargetFiles(targetPath, mode string, managedFiles map[string]bool) (pruned int, errors []string) {
|
|
if mode == "" {
|
|
mode = "merge"
|
|
}
|
|
|
|
switch mode {
|
|
case "merge":
|
|
return PruneExtraTarget(targetPath, mode)
|
|
case "copy":
|
|
return pruneExtraManagedFiles(targetPath, managedFiles)
|
|
case "symlink":
|
|
return pruneExtraSymlinkTarget(targetPath)
|
|
default:
|
|
return 0, []string{fmt.Sprintf("unsupported extras sync mode: %q", mode)}
|
|
}
|
|
}
|
|
|
|
func pruneExtraManagedFiles(targetPath string, managedFiles map[string]bool) (pruned int, errors []string) {
|
|
if len(managedFiles) == 0 {
|
|
return 0, nil
|
|
}
|
|
if _, err := os.Lstat(targetPath); err != nil {
|
|
if os.IsNotExist(err) {
|
|
return 0, nil
|
|
}
|
|
return 0, []string{fmt.Sprintf("prune %s: %v", targetPath, err)}
|
|
}
|
|
|
|
var toRemove []string
|
|
_ = filepath.Walk(targetPath, func(path string, info os.FileInfo, walkErr error) error {
|
|
if walkErr != nil {
|
|
errors = append(errors, fmt.Sprintf("prune %s: %v", path, walkErr))
|
|
return nil
|
|
}
|
|
if info.IsDir() {
|
|
if info.Name() == ".git" {
|
|
return filepath.SkipDir
|
|
}
|
|
if rel, relErr := filepath.Rel(targetPath, path); relErr == nil && managedFiles[rel] {
|
|
return filepath.SkipDir
|
|
}
|
|
return nil
|
|
}
|
|
if strings.HasPrefix(info.Name(), ".") {
|
|
return nil
|
|
}
|
|
rel, relErr := filepath.Rel(targetPath, path)
|
|
if relErr != nil {
|
|
return nil
|
|
}
|
|
if managedFiles[rel] {
|
|
toRemove = append(toRemove, path)
|
|
}
|
|
return nil
|
|
})
|
|
|
|
for _, path := range toRemove {
|
|
if err := os.Remove(path); err != nil {
|
|
errors = append(errors, fmt.Sprintf("prune %s: %v", path, err))
|
|
continue
|
|
}
|
|
pruned++
|
|
cleanEmptyParents(filepath.Dir(path), targetPath)
|
|
}
|
|
|
|
return pruned, errors
|
|
}
|
|
|
|
func pruneExtraSymlinkTarget(targetPath string) (pruned int, errors []string) {
|
|
info, err := os.Lstat(targetPath)
|
|
if err != nil {
|
|
if os.IsNotExist(err) {
|
|
return 0, nil
|
|
}
|
|
return 0, []string{fmt.Sprintf("prune %s: %v", targetPath, err)}
|
|
}
|
|
if !utils.IsLinkMode(targetPath, info.Mode()) {
|
|
return 0, []string{fmt.Sprintf("prune %s: target is not a symlink", targetPath)}
|
|
}
|
|
if err := os.Remove(targetPath); err != nil {
|
|
return 0, []string{fmt.Sprintf("prune %s: %v", targetPath, err)}
|
|
}
|
|
return 1, nil
|
|
}
|
|
|
|
// contentEqual returns true if two files have identical content.
|
|
func contentEqual(a, b string) bool {
|
|
fa, err := os.Open(a)
|
|
if err != nil {
|
|
return false
|
|
}
|
|
defer fa.Close()
|
|
|
|
fb, err := os.Open(b)
|
|
if err != nil {
|
|
return false
|
|
}
|
|
defer fb.Close()
|
|
|
|
bufA := make([]byte, 4096)
|
|
bufB := make([]byte, 4096)
|
|
for {
|
|
nA, errA := fa.Read(bufA)
|
|
nB, errB := fb.Read(bufB)
|
|
if !bytes.Equal(bufA[:nA], bufB[:nB]) {
|
|
return false
|
|
}
|
|
if errA == io.EOF && errB == io.EOF {
|
|
return true
|
|
}
|
|
if errA != nil || errB != nil {
|
|
return false
|
|
}
|
|
}
|
|
}
|
|
|
|
// EffectiveMode returns the mode to use for sync, defaulting to "merge".
|
|
func EffectiveMode(mode string) string {
|
|
if mode == "" {
|
|
return "merge"
|
|
}
|
|
return mode
|
|
}
|
|
|
|
// FlattenRel returns the target-relative path for a source file under flatten mode.
|
|
// When flatten is true, it uses only the basename and tracks seen basenames to skip
|
|
// collisions (first-wins, matching sync behavior). Returns ("", false) for collisions.
|
|
func FlattenRel(rel string, flatten bool, seen map[string]bool) (tgtRel string, ok bool) {
|
|
if !flatten {
|
|
return rel, true
|
|
}
|
|
base := filepath.Base(rel)
|
|
if seen[base] {
|
|
return "", false
|
|
}
|
|
seen[base] = true
|
|
return base, true
|
|
}
|
|
|
|
// CheckSyncStatus compares source files against the target directory and
|
|
// returns a status string: "synced" or "drift". When outputExt is non-empty a
|
|
// transform extension is in effect, so the expected target file carries the
|
|
// transformed extension (e.g. foo.md → foo.toml) instead of the source name.
|
|
func CheckSyncStatus(sourceFiles []string, sourceDir, targetDir, mode string, flatten bool, outputExt string) string {
|
|
seen := make(map[string]bool)
|
|
for _, rel := range sourceFiles {
|
|
tgtRel, ok := FlattenRel(rel, flatten, seen)
|
|
if !ok {
|
|
continue
|
|
}
|
|
tgtRel = ApplyOutputExt(tgtRel, outputExt)
|
|
targetFile := filepath.Join(targetDir, tgtRel)
|
|
sourceFile := filepath.Join(sourceDir, rel)
|
|
|
|
tInfo, err := os.Lstat(targetFile)
|
|
if err != nil {
|
|
return "drift"
|
|
}
|
|
|
|
switch mode {
|
|
case "symlink", "merge":
|
|
if utils.IsSymlinkOrJunction(targetFile) {
|
|
link, readErr := os.Readlink(targetFile)
|
|
if readErr != nil || filepath.Clean(resolveReadlink(link, targetFile)) != filepath.Clean(sourceFile) || !fileLinkUsable(targetFile) {
|
|
return "drift"
|
|
}
|
|
} else {
|
|
return "drift"
|
|
}
|
|
case "copy":
|
|
if !tInfo.Mode().IsRegular() {
|
|
return "drift"
|
|
}
|
|
if outputExt == "" && !contentEqual(sourceFile, targetFile) {
|
|
return "drift"
|
|
}
|
|
}
|
|
}
|
|
return "synced"
|
|
}
|
|
|
|
// cleanEmptyParents removes empty directories from dir up to (but not
|
|
// including) stopAt.
|
|
func cleanEmptyParents(dir, stopAt string) {
|
|
for dir != stopAt && dir != filepath.Dir(dir) {
|
|
entries, err := os.ReadDir(dir)
|
|
if err != nil || len(entries) > 0 {
|
|
break
|
|
}
|
|
os.Remove(dir)
|
|
dir = filepath.Dir(dir)
|
|
}
|
|
}
|
|
|
|
// ExtraCollectResult holds results from collecting extra files.
|
|
type ExtraCollectResult struct {
|
|
Collected int
|
|
Skipped int
|
|
Errors []string
|
|
}
|
|
|
|
// CollectExtraFiles scans targetDir for non-symlink local files,
|
|
// copies them to sourceDir, and replaces originals with symlinks.
|
|
// In copy mode the target files are left in place, since copy-mode
|
|
// targets hold real files rather than symlinks.
|
|
// When force is true, files that already exist in source are overwritten
|
|
// (identical content is still skipped).
|
|
// When flatten is true, collected files are placed in the source root
|
|
// (basename only) rather than preserving the target subdirectory structure.
|
|
func CollectExtraFiles(sourceDir, targetDir, mode string, dryRun, force, flatten bool, projectRoot string) (*ExtraCollectResult, error) {
|
|
result := &ExtraCollectResult{}
|
|
// Without file links the collected files stay in place, as copies.
|
|
if !canCreateFileLink() {
|
|
mode = "copy"
|
|
}
|
|
|
|
if _, err := os.Stat(targetDir); os.IsNotExist(err) {
|
|
return nil, fmt.Errorf("target directory does not exist: %s", targetDir)
|
|
}
|
|
|
|
// Ensure source directory exists
|
|
if !dryRun {
|
|
if err := os.MkdirAll(sourceDir, 0755); err != nil {
|
|
return nil, fmt.Errorf("failed to create source directory: %w", err)
|
|
}
|
|
}
|
|
|
|
// Source paths claimed this run: with flatten, two target files can share
|
|
// a basename, and the second must not overwrite the first.
|
|
claimed := make(map[string]bool)
|
|
|
|
err := filepath.Walk(targetDir, func(path string, info os.FileInfo, walkErr error) error {
|
|
if walkErr != nil {
|
|
return nil
|
|
}
|
|
|
|
// Skip directories and .git
|
|
if info.IsDir() {
|
|
if info.Name() == ".git" {
|
|
return filepath.SkipDir
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// filepath.Walk follows symlinks, so check via Lstat to detect them
|
|
linfo, err := os.Lstat(path)
|
|
if err != nil {
|
|
return nil
|
|
}
|
|
if utils.IsLinkMode(path, linfo.Mode()) {
|
|
result.Skipped++
|
|
return nil
|
|
}
|
|
if info.Name() == ManifestFile {
|
|
return nil // skillshare's copy tracking, not user content
|
|
}
|
|
|
|
rel, err := filepath.Rel(targetDir, path)
|
|
if err != nil {
|
|
result.Errors = append(result.Errors, fmt.Sprintf("cannot compute relative path: %s", path))
|
|
return nil
|
|
}
|
|
|
|
destRel := rel
|
|
if flatten {
|
|
destRel = filepath.Base(rel)
|
|
}
|
|
destPath := filepath.Join(sourceDir, destRel)
|
|
if claimed[destPath] {
|
|
result.Errors = append(result.Errors, fmt.Sprintf("skipped %s: %s already collected from another file", rel, destRel))
|
|
return nil
|
|
}
|
|
|
|
content, err := os.ReadFile(path)
|
|
if err != nil {
|
|
result.Errors = append(result.Errors, fmt.Sprintf("read failed: %v", err))
|
|
return nil
|
|
}
|
|
|
|
// Skip if already exists in source, unless forcing a changed file
|
|
if _, err := os.Stat(destPath); err == nil {
|
|
existing, readErr := os.ReadFile(destPath)
|
|
if !force || (readErr == nil && bytes.Equal(existing, content)) {
|
|
result.Skipped++
|
|
return nil
|
|
}
|
|
}
|
|
|
|
claimed[destPath] = true
|
|
if dryRun {
|
|
result.Collected++
|
|
return nil
|
|
}
|
|
|
|
// Create parent directory
|
|
if err := os.MkdirAll(filepath.Dir(destPath), 0755); err != nil {
|
|
result.Errors = append(result.Errors, fmt.Sprintf("mkdir failed: %v", err))
|
|
return nil
|
|
}
|
|
|
|
// Write to source dir
|
|
if err := os.WriteFile(destPath, content, info.Mode().Perm()); err != nil {
|
|
result.Errors = append(result.Errors, fmt.Sprintf("write failed: %v", err))
|
|
return nil
|
|
}
|
|
|
|
if mode == "copy" {
|
|
result.Collected++
|
|
return nil
|
|
}
|
|
|
|
// Remove original and create symlink
|
|
if err := os.Remove(path); err != nil {
|
|
result.Errors = append(result.Errors, fmt.Sprintf("remove original failed: %v", err))
|
|
return nil
|
|
}
|
|
|
|
relative := shouldUseRelative(projectRoot, destPath, path)
|
|
if err := createLink(path, destPath, relative); err != nil {
|
|
result.Errors = append(result.Errors, fmt.Sprintf("symlink failed: %v", err))
|
|
return nil
|
|
}
|
|
|
|
result.Collected++
|
|
return nil
|
|
})
|
|
|
|
if err != nil {
|
|
return result, fmt.Errorf("walk error: %w", err)
|
|
}
|
|
|
|
return result, nil
|
|
}
|