mirror of
https://github.com/runkids/skillshare.git
synced 2026-11-19 02:17:09 +00:00
Since Go 1.23, os.Lstat reports NTFS junctions as irregular files instead of symlinks (winsymlink, active for go 1.25 in go.mod). Every check that looked only at os.ModeSymlink therefore missed the junctions skillshare itself creates on Windows: linked skills could be treated as local folders, backed up, copied through, or left behind on prune. Detect links through utils.IsLinkMode, which also asks the OS about the reparse tag of irregular entries, and count only real symlinks and junctions as links so OneDrive placeholders and deduplicated files stay regular files. restore.go also used os.Stat for its link check, which follows the link and never matched. Refs #299
229 lines
5.8 KiB
Go
229 lines
5.8 KiB
Go
package plugin
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
"os"
|
|
"path/filepath"
|
|
"slices"
|
|
"strings"
|
|
|
|
"github.com/gofrs/flock"
|
|
|
|
"skillshare/internal/utils"
|
|
)
|
|
|
|
type cursorOwner struct {
|
|
Config string `json:"config"`
|
|
Digest string `json:"digest"`
|
|
}
|
|
|
|
func (s *Service) localRoot(target string) (string, error) {
|
|
if target == "antigravity" && s.ProjectRoot != "" {
|
|
hidden := filepath.Join(s.ProjectRoot, ".agents", "plugins")
|
|
visible := filepath.Join(s.ProjectRoot, "_agents", "plugins")
|
|
_, hErr := os.Lstat(hidden)
|
|
_, vErr := os.Lstat(visible)
|
|
if hErr == nil && vErr == nil {
|
|
return "", fmt.Errorf("both .agents/plugins and _agents/plugins exist; consolidate before syncing")
|
|
}
|
|
if vErr == nil {
|
|
return visible, nil
|
|
}
|
|
return hidden, nil
|
|
}
|
|
home, err := os.UserHomeDir()
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
if target == "antigravity" {
|
|
return filepath.Join(home, ".gemini", "config", "plugins"), nil
|
|
}
|
|
return filepath.Join(home, ".cursor", "plugins", "local"), nil
|
|
}
|
|
|
|
// Native configuration and installation paths must not redirect writes elsewhere.
|
|
func noSymlink(path string) error {
|
|
for p := filepath.Clean(path); ; p = filepath.Dir(p) {
|
|
info, err := os.Lstat(p)
|
|
if err != nil && !os.IsNotExist(err) {
|
|
return err
|
|
}
|
|
if err == nil && utils.IsLinkMode(p, info.Mode()) {
|
|
return fmt.Errorf("refusing to modify symlinked native path: %s", p)
|
|
}
|
|
parent := filepath.Dir(p)
|
|
if parent == p {
|
|
break
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (s *Service) localInventory(target string) ([]Installed, string, error) {
|
|
result := []Installed{}
|
|
root, err := s.localRoot(target)
|
|
if err != nil {
|
|
return nil, "", err
|
|
}
|
|
if err = noSymlink(root); err != nil {
|
|
return nil, "", err
|
|
}
|
|
entries, err := os.ReadDir(root)
|
|
if os.IsNotExist(err) {
|
|
return result, hash(nil), nil
|
|
}
|
|
if err != nil {
|
|
return nil, "", err
|
|
}
|
|
var fingerprint []byte
|
|
for _, entry := range entries {
|
|
if !entry.IsDir() || strings.HasPrefix(entry.Name(), ".") {
|
|
continue
|
|
}
|
|
dir := filepath.Join(root, entry.Name())
|
|
candidate, err := inspect(dir)
|
|
if err != nil {
|
|
return nil, "", fmt.Errorf("inspect local plugin %s: %w", entry.Name(), err)
|
|
}
|
|
if !slices.Contains(candidate.Targets, target) {
|
|
continue
|
|
}
|
|
digest, err := treeDigest(dir)
|
|
if err != nil {
|
|
return nil, "", err
|
|
}
|
|
marker, _ := os.ReadFile(filepath.Join(root, ".skillshare-"+entry.Name()+".json"))
|
|
fingerprint = append(fingerprint, []byte(entry.Name()+"\x00"+digest)...)
|
|
fingerprint = append(fingerprint, marker...)
|
|
// Only canonical directory names can be safely managed; other local installs
|
|
// remain visible under their directory identity and cannot be imported.
|
|
result = append(result, Installed{ID: entry.Name(), Name: candidate.Name, Version: candidate.Version, Scope: "user", Installed: true, Enabled: true})
|
|
}
|
|
return result, hash(fingerprint), nil
|
|
}
|
|
|
|
func (s *Service) applyLocal(c Change, b Binding, source string) error {
|
|
target := c.Target
|
|
root, err := s.localRoot(target)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
dest := filepath.Join(root, b.ID)
|
|
if err = noSymlink(dest); err != nil {
|
|
return err
|
|
}
|
|
if err = os.MkdirAll(root, 0755); err != nil {
|
|
return err
|
|
}
|
|
lock := flock.New(filepath.Join(root, ".skillshare.lock"))
|
|
if err = lock.Lock(); err != nil {
|
|
return err
|
|
}
|
|
defer lock.Unlock()
|
|
marker := filepath.Join(root, ".skillshare-"+b.ID+".json")
|
|
if err = noSymlink(marker); err != nil {
|
|
return err
|
|
}
|
|
config, err := filepath.Abs(s.ConfigPath)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
existed := false
|
|
if _, err = os.Lstat(dest); err == nil {
|
|
existed = true
|
|
data, readErr := os.ReadFile(marker)
|
|
var owner cursorOwner
|
|
if readErr != nil || json.Unmarshal(data, &owner) != nil || owner.Config != config {
|
|
return fmt.Errorf("Local plugin directory is not owned by this Skillshare configuration")
|
|
}
|
|
digest, err := treeDigest(dest)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if digest != owner.Digest {
|
|
return fmt.Errorf("Local plugin files were edited locally; preserve those changes before syncing")
|
|
}
|
|
} else if !os.IsNotExist(err) {
|
|
return err
|
|
}
|
|
remove := c.Action == "remove" || c.Action == "uninstall"
|
|
if remove {
|
|
if !existed {
|
|
return nil
|
|
}
|
|
if err = os.RemoveAll(dest); err != nil {
|
|
return err
|
|
}
|
|
return os.Remove(marker)
|
|
}
|
|
if source == "" {
|
|
return fmt.Errorf("Local plugin requires a source")
|
|
}
|
|
temp, err := os.MkdirTemp(root, ".skillshare-copy-")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer os.RemoveAll(temp)
|
|
if err = copyTree(source, temp); err != nil {
|
|
return err
|
|
}
|
|
digest, err := treeDigest(temp)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
backup := filepath.Join(root, ".skillshare-previous-"+b.ID)
|
|
if _, err = os.Lstat(backup); err == nil {
|
|
return fmt.Errorf("unfinished local plugin replacement at %s; inspect before retrying", backup)
|
|
} else if !os.IsNotExist(err) {
|
|
return err
|
|
}
|
|
if existed {
|
|
if err = os.Rename(dest, backup); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if err = os.Rename(temp, dest); err != nil {
|
|
if existed {
|
|
_ = os.Rename(backup, dest)
|
|
}
|
|
return err
|
|
}
|
|
data, _ := json.Marshal(cursorOwner{Config: config, Digest: digest})
|
|
if err = atomicNativeWrite(marker, data, 0600); err != nil {
|
|
return fmt.Errorf("Plugin files copied but ownership recording failed; inspect %s before retrying: %w", dest, err)
|
|
}
|
|
if existed {
|
|
return os.RemoveAll(backup)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func atomicNativeWrite(path string, data []byte, mode os.FileMode) error {
|
|
if err := noSymlink(path); err != nil {
|
|
return err
|
|
}
|
|
if err := os.MkdirAll(filepath.Dir(path), 0755); err != nil {
|
|
return err
|
|
}
|
|
f, err := os.CreateTemp(filepath.Dir(path), ".skillshare-write-")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer os.Remove(f.Name())
|
|
if err = f.Chmod(mode); err == nil {
|
|
_, err = f.Write(data)
|
|
}
|
|
if err == nil {
|
|
err = f.Sync()
|
|
}
|
|
closeErr := f.Close()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if closeErr != nil {
|
|
return closeErr
|
|
}
|
|
return os.Rename(f.Name(), path)
|
|
}
|