Files
skillshare/internal/plugin/lifecycle.go
T
Willie bcb8c6c781 fix(plugin): skip Agents an update cannot reach instead of blocking it
A plugin installed on several Agents could not be updated anywhere when
one of them could not take the update: a plugin disabled in Codex or
Copilot, or an imported package, blocked the whole plan, so Claude
stayed behind too. These targets are now skipped with the reason, and
the rest update. A skipped update stays pending, where the previous
noop cleared it and left Skillshare believing a stale Agent was current.

Two of those were not real limits: an imported Codex plugin now updates
through `codex plugin marketplace upgrade`, and an imported Pi package
in global mode through `pi update`, which keeps its settings entry.

Skip reasons carry a message key so the dashboard translates them, and
a plugin whose Agents hold different versions shows each instead of
none.

Refs #309
2026-10-01 17:11:20 +08:00

151 lines
4.9 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")
}
// Serialize CLI and UI mutations across processes, not just HTTP requests.
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()
defer os.Remove(s.ConfigPath + ".plugins.lock")
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")
}
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
}
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
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]
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()
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."
} else {
b.Pending = ""
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 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...)
}