Files
skillshare/internal/plugin/lifecycle.go
T
Willie 19cdc1c72e fix(plugin): let an imported Claude plugin update to what its marketplace holds (#536)
An imported plugin's native marketplace decides the version an update installs, so the update check now applies only to bindings with a reviewed source and an import records the version installed. Importing an imported plugin again also records the installed version; a source binding keeps the version Skillshare reviewed.

Refs #535
2026-10-12 17:04:52 +08:00

190 lines
6.5 KiB
Go

package plugin
import (
"context"
"errors"
"fmt"
"os"
"path/filepath"
)
func (s *Service) Apply(ctx context.Context, r Request, revision string) (*Result, error) {
if revision == "" {
return nil, fmt.Errorf("preview the plugin changes before applying")
}
unlock, err := s.Lock()
if err != nil {
return nil, err
}
defer unlock()
p, err := s.Preview(ctx, r)
if err != nil {
return nil, err
}
if p.Revision != revision {
return nil, fmt.Errorf("plugin state changed since preview; preview again")
}
return s.applyPlan(ctx, r, p)
}
// Lock serializes CLI and UI mutations across processes, not just HTTP requests.
func (s *Service) Lock() (unlock func(), err error) {
if err := os.MkdirAll(filepath.Dir(s.ConfigPath), 0755); err != nil {
return nil, err
}
lock, err := os.OpenFile(s.ConfigPath+".plugins.lock", os.O_WRONLY|os.O_CREATE|os.O_EXCL, 0600)
if err != nil {
return nil, fmt.Errorf("another plugin operation is running (lock: %s.plugins.lock)", s.ConfigPath)
}
_ = lock.Close()
return func() { _ = os.Remove(s.ConfigPath + ".plugins.lock") }, nil
}
// applyPlan carries out a plan previewed under the lock the caller holds.
func (s *Service) applyPlan(ctx context.Context, r Request, p *Plan) (*Result, error) {
if p.Blocked {
return nil, fmt.Errorf("resolve blocked plugin targets before applying")
}
if r.Action == "check" {
return nil, fmt.Errorf("check is read-only")
}
d, err := s.load()
if err != nil {
return nil, err
}
// Preserve private entries before writing references to them into config.
for _, c := range p.Changes {
if c.Action != "skip" && c.Action != "noop" {
if err := s.savePiRegistration(c); err != nil {
return nil, err
}
}
}
result := &Result{Results: []Outcome{}}
changed := false
for _, c := range p.Changes {
if c.Action == "skip" {
// Unlike noop, a skipped update stays pending for a later sync.
result.Results = append(result.Results, Outcome{Name: c.Name, Target: c.Target, Status: "skipped", Message: c.Message, MessageKey: c.MessageKey, MessageArgs: c.MessageArgs})
continue
}
if c.Action == "noop" {
result.Results = append(result.Results, Outcome{Name: c.Name, Target: c.Target, Status: "unchanged"})
if r.Action == "sync" && d.packages[c.Name].Bindings[c.Target].Pending != "" {
changed = true
pack := d.packages[c.Name]
b := pack.Bindings[c.Target]
b.Pending = ""
pack.Bindings[c.Target] = b
d.packages[c.Name] = pack
}
continue
}
changed = true
pack := d.packages[c.Name]
if pack.Bindings == nil {
pack.Bindings = map[string]Binding{}
}
if c.Target == "" {
if c.Action == "forget" {
delete(d.packages, c.Name)
} else {
pack.Source, pack.SourceRef, pack.Plugin, pack.Entry, pack.Version = c.Binding.Source, c.Binding.SourceRef, c.Binding.Plugin, c.Binding.Entry, c.Binding.Version
d.packages[c.Name] = pack
}
continue
}
if r.Action == "add" && pack.Source == "" && c.Binding.Source != "" {
pack.Source, pack.SourceRef, pack.Plugin, pack.Entry = c.Binding.Source, c.Binding.SourceRef, c.Binding.Plugin, r.Entry
}
b := c.Binding
b.Pending = c.Action
if c.Action == "import" || c.Action == "selection" {
b.Pending = ""
}
pack.Bindings[c.Target] = b
d.packages[c.Name] = pack
}
if !changed {
return result, nil
}
if err := s.save(d); err != nil {
return result, err
}
var failures []error
// Receipts are private to this Apply, and record only bytes our restore wrote.
piRestores := map[string]piRestoreReceipt{}
for _, c := range p.Changes {
if c.Action == "noop" || c.Action == "skip" {
continue
}
if c.Target == "" {
outcome := Outcome{Name: c.Name, Status: "saved", Message: "Added to Skillshare. Choose Agents when you want to install it."}
if c.Action == "forget" {
outcome.Status, outcome.Message = "removed", "Removed from Skillshare."
}
result.Results = append(result.Results, outcome)
continue
}
b := d.packages[c.Name].Bindings[c.Target]
c.piRestores = piRestores
applyErr := s.applyChange(ctx, c, &b)
outcome := Outcome{Name: c.Name, Target: c.Target, Status: "installed", Message: "Native installation recorded. Reload the Agent and complete any required login or hook trust."}
if applyErr != nil {
outcome.Status = "failed"
outcome.Message = applyErr.Error()
outcome.MessageKey, outcome.MessageArgs = ErrorKey(applyErr)
failures = append(failures, applyErr)
} else {
pack := d.packages[c.Name]
if c.Action == "remove" || c.Action == "forget" {
delete(pack.Bindings, c.Target)
outcome.Status = "removed"
outcome.Message = "Native plugin removed; shared marketplaces are retained."
if s.agentOf(c.Target) == "omp" {
outcome.Message, outcome.MessageKey = "Removed from this scope; shared cache, marketplaces and plugin settings were retained.", "plugins.outcome.ompRemoved"
}
if c.Action == "forget" && s.agentOf(c.Target) == "omp" {
outcome.Message = "Removed from Skillshare; the native plugin was already absent. Shared marketplaces are retained."
}
} else {
b.Pending = ""
if c.piRecordAfter {
if err := s.recordPiEntry(ctx, c.Target, &b); err != nil {
outcome.Message = "Installed, but its extension settings could not be recorded to restore on a later reinstall: " + err.Error()
}
}
pack.Bindings[c.Target] = b
if c.Action == "selection" {
outcome.Status = "saved"
outcome.Message = "Sync selection saved. Run sync to apply installation changes."
}
if c.Action == "uninstall" {
outcome.Status = "excluded"
outcome.Message = "Removed from this target; plugin definition retained."
if s.agentOf(c.Target) == "omp" {
outcome.Message, outcome.MessageKey = "Removed from this scope; shared cache, marketplaces and plugin settings were retained.", "plugins.outcome.ompRemoved"
}
}
if c.Action == "import" {
outcome.Status = "imported"
outcome.Message = "Existing installation adopted without changing its enabled state."
}
}
// A package with a recorded source stays managed without Agents until it is removed whole.
if len(pack.Bindings) == 0 && (pack.Source == "" || (r.Action == "remove" && len(r.Targets) == 0)) {
delete(d.packages, c.Name)
} else {
d.packages[c.Name] = pack
}
if err := s.save(d); err != nil {
outcome.Status = "failed"
outcome.Message = "Native operation completed, but recording its result failed; inspect status before retrying."
failures = append(failures, err)
}
}
result.Results = append(result.Results, outcome)
}
return result, errors.Join(failures...)
}