Files
skillshare/internal/plugin/config.go
T
Willie f4c77d53c3 fix(config): refuse project config writes that leave the project
Saves follow a symlinked config.yaml to its target so dotfile links
survive. For a project config that also lets a cloned repository point
.skillshare/config.yaml at any file the user can write, including one
that does not exist yet, and every project save, plugin change, hooks
change, MCP change, or legacy migration would then rewrite or create it.

All five writers now resolve the destination through one helper,
utils.ConfigWritePath. A global config keeps writing through its link.
A project config must resolve inside its project; otherwise the save
fails and names the link so the user can replace it with a regular
file. The one-time legacy migration skips persisting instead, and the
next save reports the link.
2026-10-07 10:19:12 +08:00

213 lines
5.7 KiB
Go

package plugin
import (
"bytes"
"fmt"
"io"
"os"
"path/filepath"
"slices"
"strings"
"gopkg.in/yaml.v3"
"skillshare/internal/utils"
)
type document struct {
raw []byte
node yaml.Node
packages map[string]Package
}
func (s *Service) load() (*document, error) {
raw, err := os.ReadFile(s.ConfigPath)
if err != nil && !os.IsNotExist(err) {
return nil, err
}
return decodeDocument(raw, s.accountAgents())
}
// Validate checks plugin declarations without reading or writing native state. accounts
// maps each target that is another config directory of an Agent to that Agent, so a
// binding is validated by the Agent that would install it.
func Validate(raw []byte, accounts map[string]string) error {
_, err := decodeDocument(raw, accounts)
return err
}
// decodeDocument reads the plugin section. accounts maps each account to its Agent, or to
// "" where only the names are known.
func decodeDocument(raw []byte, accounts map[string]string) (*document, error) {
d := &document{raw: raw, packages: map[string]Package{}}
content := raw
if len(content) == 0 {
content = []byte("{}\n")
}
decoder := yaml.NewDecoder(bytes.NewReader(content))
if err := decoder.Decode(&d.node); err != nil {
return nil, err
}
if decoder.Decode(new(yaml.Node)) != io.EOF {
return nil, fmt.Errorf("configuration must contain one YAML document")
}
var check map[string]any
if err := d.node.Decode(&check); err != nil {
return nil, err
}
if len(d.node.Content) != 1 || d.node.Content[0].Kind != yaml.MappingNode {
return nil, fmt.Errorf("configuration must be a YAML mapping")
}
root := d.node.Content[0]
for i := 0; i < len(root.Content); i += 2 {
if root.Content[i].Value == "plugins" {
var body struct {
Packages map[string]Package `yaml:"packages"`
}
data, err := yaml.Marshal(root.Content[i+1])
if err != nil {
return nil, err
}
dec := yaml.NewDecoder(bytes.NewReader(data))
dec.KnownFields(true)
if err := dec.Decode(&body); err != nil {
return nil, fmt.Errorf("invalid plugins configuration: %w", err)
}
if body.Packages != nil {
d.packages = body.Packages
}
}
}
for name, p := range d.packages {
if !namePattern.MatchString(name) {
return nil, fmt.Errorf("invalid plugin package name %q", name)
}
p.Source = canonicalSource(p.Source)
for target, b := range p.Bindings {
b.Source = canonicalSource(b.Source)
p.Bindings[target] = b
agent, account := accounts[target]
if !account && !slices.Contains(Targets, target) {
return nil, fmt.Errorf("invalid plugin binding for %s", name)
}
if !account {
agent = target
}
if b.PiRegistration != "" && (agent != "pi" || !piRegistrationDigestOK(b.PiRegistration)) {
return nil, fmt.Errorf("invalid preserved Pi registration for %s", name)
}
if !validTargetID(agent, b.ID) {
return nil, fmt.Errorf("invalid plugin binding for %s", name)
}
}
d.packages[name] = p
}
return d, nil
}
// canonicalSource spells a local source the way add records it, so ~/plug and
// /home/me/plug name the same snapshot and owner. It expands every form
// utils.FoldHomePathWith writes: ~, ~/..., and ~\... on Windows.
func canonicalSource(source string) string {
if source == "~" || strings.HasPrefix(source, "~/") || strings.HasPrefix(source, "~"+string(filepath.Separator)) {
if home, err := os.UserHomeDir(); err == nil {
return filepath.Join(home, source[1:])
}
}
if filepath.IsAbs(source) {
return filepath.Clean(source)
}
return source
}
// foldSources returns packages with local sources under home written as ~/...
func foldSources(packages map[string]Package) map[string]Package {
home, err := os.UserHomeDir()
if err != nil {
return packages
}
out := make(map[string]Package, len(packages))
for name, p := range packages {
p.Source = utils.FoldHomePathWith(p.Source, home)
bindings := make(map[string]Binding, len(p.Bindings))
for target, b := range p.Bindings {
b.Source = utils.FoldHomePathWith(b.Source, home)
bindings[target] = b
}
p.Bindings = bindings
out[name] = p
}
return out
}
func (s *Service) save(d *document) error {
current, err := os.ReadFile(s.ConfigPath)
if err != nil && !os.IsNotExist(err) {
return err
}
if !bytes.Equal(current, d.raw) {
return fmt.Errorf("configuration changed; preview again")
}
packages := d.packages
var opts struct {
PreserveTilde bool `yaml:"preserve_tilde_on_save"`
}
if d.node.Decode(&opts) == nil && opts.PreserveTilde {
packages = foldSources(packages)
}
var n yaml.Node
if err := n.Encode(struct {
Packages map[string]Package `yaml:"packages"`
}{packages}); err != nil {
return err
}
root := d.node.Content[0]
found := false
for i := 0; i < len(root.Content); i += 2 {
if root.Content[i].Value == "plugins" {
root.Content[i+1] = &n
found = true
}
}
if !found {
root.Content = append(root.Content, &yaml.Node{Kind: yaml.ScalarNode, Tag: "!!str", Value: "plugins"}, &n)
}
data, err := utils.MarshalYAML(&d.node)
if err != nil {
return err
}
// Dotfile managers often symlink config.yaml; write its target so the link survives.
path, err := utils.ConfigWritePath(s.ConfigPath, s.ProjectRoot != "")
if err != nil {
return err
}
if err := os.MkdirAll(filepath.Dir(path), 0755); err != nil {
return err
}
f, err := os.CreateTemp(filepath.Dir(path), ".plugins-*")
if err != nil {
return err
}
defer os.Remove(f.Name())
mode := os.FileMode(0600)
if info, err := os.Stat(path); err == nil {
mode = info.Mode().Perm()
}
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
}
if err = os.Rename(f.Name(), path); err == nil {
d.raw = data
}
return err
}