Files
skillshare/internal/plugin/service.go
T
Willie 5338d6a4c1 feat(ui): check plugin updates on load and update them in one batch (#527)
* feat(ui): check plugin updates on load and update them in one batch

Updating plugins took four steps each: press Check updates, press Update
on one row, review a second preview, apply, then check again because the
list did not know the update had happened. Six plugins meant six rounds.

The page now checks once in the background when it opens, so rows show
their new version without a click. The header's Check updates button
becomes "Update N" when something is behind and opens one dialog: every
plugin with an update is ticked, a plugin on several Agents is one row
whose Agents can be left out, and imported installs Skillshare cannot
update sit apart. One button runs them in turn through the existing
preview and apply, so no new API is needed. Progress, results, errors
and per-Agent retry stay in the same dialog, and the applied results
update the page state, so nothing has to be checked again.

The count and the dialog both come from what is still behind after the
last check, limited to Agents that can be updated from here, so a
partial batch is not offered again and Agents with check but no update
(OMP, Antigravity CLI, Grok) do not inflate the count.

* fix(ui): keep batch plugin updates to what the user reviewed

Codex review of #527 found four ways the batch update could act on
something other than what the dialog showed:

- A source that moved between the background check and the click was
  installed straight from the fresh preview, so a newer version or new
  components went in unreviewed. The batch now compares each fresh plan
  with the version and commit the check showed, applies nothing when
  they differ, says so on the row, and runs a quiet check so the next
  dialog shows the new version for review.
- A retry of the failed Agents that failed again lost that subset, so a
  third try re-sent Agents that had already updated. A failed row now
  always keeps the Agents it failed on.
- An update the server skipped (its marketplace gone, say) counted as
  done: the row said updated and the plugin left the update count.
  Skipped outcomes now keep the Agent pending and show as skipped.
- A plugin removed after the check stayed in the update count and
  failed with "not found" when picked. Pending updates now drop any
  plugin or Agent binding the inventory no longer has.

* fix(ui): show a manual check's result and each Agent's own version move

Codex's second review of #527 found two gaps:

- A check the user pressed that found nothing to update from here (only
  imported installs, or everything current) opened nothing, so the
  "update inside the Agent" guidance and the up-to-date result never
  showed. The check now reports whether it came back, and a check the
  user asked for opens the dialog; the background check on load stays
  quiet.
- A plugin on several Agents showed one version move built from the
  first Agent's installed version and the first new version found, which
  can mix Agents that come from different sources. The row now shows one
  move only when every Agent makes the same one, and each Agent's own
  move otherwise.

* fix(plugin): carry the source digest on a check so a batch update can tell it moved

Codex's third review of #527: a local-directory plugin has no commit,
so when its files changed again after the check while the manifest
version stayed the same, the batch's version and commit comparison
passed and the fresh preview was applied without the user seeing it.

The check copied the installed binding, so its digest was the one
already installed, not the source's. It now sets the discovered digest
alongside the version and commit, as the update preview already does.
The dashboard keeps that digest with each update it found and refuses
to apply when the fresh preview's digest differs, marking the row as
changed since the check. An npm package has no digest and is unaffected.

* fix(ui): list blocked check results and drop unticked Agents from the batch

Codex's fourth review of #527:

- A check can mark an Agent blocked when the updated source no longer
  offers a compatible plugin for it. The update dialog listed only
  updatable, native-check and up-to-date results, so it hid the block
  and could say everything was current. Blocked results now get their
  own section with the reason, and the empty state says nothing can be
  updated from here rather than that everything is up to date.
- An Agent unticked after the check stayed in the pending updates;
  picking it produced a no-op that the batch reported as updated.
  Pending updates now skip bindings with sync off, as the row's own
  behind count already does.

* fix(ui): count partly skipped plugins as updated and surface a failed re-check

Codex's fifth review of #527:

- When one Agent of a plugin updated and another came back skipped, the
  row was marked skipped, the summary counted no update, and the Agent
  that did update was not shown. A row now names which Agents updated
  and which were skipped, and the summary counts any plugin with an
  updated Agent.
- After a source moved since the check, the follow-up check ran quietly,
  so if it failed the stale update stayed offered and every retry hit
  the same skip. The moved plugin now leaves the found updates, and the
  follow-up check reports its failure like any check the user started.
2026-10-11 22:19:14 +08:00

607 lines
25 KiB
Go

package plugin
import (
"context"
"crypto/sha256"
"encoding/hex"
"encoding/json"
"fmt"
"path/filepath"
"slices"
"strings"
)
func hash(data []byte) string { sum := sha256.Sum256(data); return hex.EncodeToString(sum[:]) }
func (s *Service) managedRoot() string {
p, _ := filepath.Abs(s.ConfigPath)
return filepath.Join(s.StateDir, "plugins", hash([]byte(p))[:16])
}
func (s *Service) validate(r Request) error {
switch r.Action {
case "add", "import", "sync", "remove", "update", "check", "enable", "disable":
default:
return fmt.Errorf("unknown plugin action %q", r.Action)
}
if r.Name != "" && !namePattern.MatchString(r.Name) {
return fmt.Errorf("invalid package name")
}
if r.Source != "" && r.Action != "add" {
return fmt.Errorf("source is only valid for add")
}
if r.SourceRef != "" && r.Action != "add" && r.Action != "update" {
return fmt.Errorf("source ref is only valid for add or update")
}
if r.Entry != "" && r.Action != "add" {
return fmt.Errorf("entry is only valid for add")
}
if r.From != "" && r.Action != "import" {
return fmt.Errorf("from is only valid for import")
}
if r.Plugin != "" && r.Action != "add" && r.Action != "import" {
return fmt.Errorf("plugin selector is only valid for add or import")
}
seen := map[string]bool{}
targets := s.targets()
for _, t := range r.Targets {
if !slices.Contains(targets, t) {
return fmt.Errorf("unsupported plugin target %q", t)
}
if seen[t] {
return fmt.Errorf("duplicate plugin target %q", t)
}
seen[t] = true
}
if r.Action == "add" && r.Source == "" {
return fmt.Errorf("add requires a source")
}
if r.Action == "add" && isNpmSource(r.Source) {
if !validNpmSource(r.Source) {
return fmt.Errorf("invalid npm source; use npm:<package> or npm:<package>@<version>")
}
if r.SourceRef != "" || r.Entry != "" || r.Plugin != "" {
return fmt.Errorf("an npm source takes no source ref, entry or plugin selector")
}
if len(r.Targets) == 0 {
return fmt.Errorf("npm packages are installed by Pi; choose a Pi target")
}
}
if r.Action == "import" && s.agentOf(r.From) == "omp" && !validID(r.Plugin) && ompPackageName.MatchString(r.Plugin) {
return agentError{key: "plugins.error.ompPackageImport", message: "This OMP plugin was installed by bun from npm, Git or a local link, which runs its install scripts; Skillshare manages OMP marketplace plugins only. Keep managing it in omp."}
}
if r.Action == "import" && (!slices.Contains(targets, r.From) || !validTargetID(s.agentOf(r.From), r.Plugin)) {
return fmt.Errorf("import requires --from <target> and a native plugin identifier")
}
if (r.Action == "remove" || r.Action == "update" || r.Action == "enable" || r.Action == "disable") && r.Name == "" {
return fmt.Errorf("%s requires a package name", r.Action)
}
return nil
}
func (s *Service) Preview(ctx context.Context, r Request) (*Plan, error) {
r.Targets = slices.Clone(r.Targets)
for i, target := range r.Targets {
r.Targets[i] = NormalizeTarget(target)
}
r.From = NormalizeTarget(r.From)
if err := s.validate(r); err != nil {
return nil, err
}
d, err := s.load()
if err != nil {
return nil, err
}
p := &Plan{Changes: []Change{}}
hosts := map[string]Host{}
host := func(target string) Host {
if h, ok := hosts[target]; ok {
return h
}
h := s.host(ctx, target)
hosts[target] = h
return h
}
// ownMarket reports whether the marketplace Skillshare registered for b is still in place.
ownMarket := func(target string, b Binding) bool {
_, market, _ := strings.Cut(b.ID, "@")
return marketplaceAgent(s.agentOf(target)) && b.Source != "" && slices.Contains(host(target).ManagedMarketplaces, market)
}
// mayOwnMarket also covers an Agent whose marketplace list could not be read, so a removal
// stays pending instead of dropping the binding before its cleanup.
mayOwnMarket := func(target string, b Binding) bool {
return ownMarket(target, b) || marketplaceAgent(s.agentOf(target)) && b.Source != "" && host(target).Marketplaces == nil
}
appendChange := func(c Change) {
h := host(c.Target)
agent := s.agentOf(c.Target)
if agent == "pi" && c.Binding.PiRegistration != "" && len(c.piRecord) == 0 && (c.Action == "install" || c.Action == "uninstall" || c.Action == "remove" || c.Action == "update") {
if err := s.preparePiRegistration(ctx, &c); err != nil {
c.Action, c.Message, c.MessageKey, c.MessageArgs = "blocked", err.Error(), "", nil
}
}
// A change already blocked keeps its own reason; the key always matches the message.
if h.Error != "" && c.Action != "blocked" {
c.Action = "blocked"
c.Message, c.MessageKey, c.MessageArgs = h.Error, h.ErrorKey, h.ErrorArgs
}
if c.Action != "blocked" && c.Action != "noop" && c.Action != "skip" && c.Action != "import" && c.Action != "update-available" && c.Action != "native-check" {
if err := s.verifyCommand(ctx, c.Target, c.Action, c.ID); err != nil {
c.Action = "blocked"
c.Message = err.Error()
}
}
// An update that cannot reach a target skips it, so the plugin's other Agents still update.
skip := func(key, message string, args map[string]string) {
c.Action = "skip"
c.Message, c.MessageKey, c.MessageArgs = message, key, args
}
// An import reinstalls and updates from its native marketplace. Once that is gone, only the
// native client, or adding the plugin again from a reviewed source, can bring it back.
if c.Binding.Source == "" && marketplaceAgent(agent) && (c.Action == "install" || c.Action == "update") && h.Marketplaces != nil {
_, market, _ := strings.Cut(c.ID, "@")
if _, ok := h.Marketplaces[market]; !ok {
skip("plugins.skip.marketplaceGone", fmt.Sprintf("The native marketplace %s is gone. Restore it in the native client, or remove this Agent and add the plugin again from its source.", market), map[string]string{"market": market})
}
}
// Claude reads a skill folder that has a plugin manifest as <name>@skills-dir, and loads
// only one plugin per name.
if c.Action == "install" && agent == "claude" && c.Message == "" {
name, _, _ := strings.Cut(c.ID, "@")
for _, item := range h.Installed {
if item.ID == name+"@skills-dir" {
c.Message = fmt.Sprintf("Claude's skills folder also has a %s plugin; Claude will load this plugin and skip that copy until one of them is renamed or removed.", name)
c.MessageKey, c.MessageArgs = "plugins.note.skillsDirClash", map[string]string{"name": name}
}
}
}
// omp copies a marketplace plugin without running it, but imports its extension modules
// and tools in-process at its next start; there is no native trust prompt to lean on.
if agent == "omp" && (c.Action == "install" || c.Action == "update") && c.Message == "" {
c.Message, c.MessageKey = "Installs the reviewed snapshot. If the plugin provides extensions or tools, OMP loads them at its next startup.", "plugins.note.ompRuntime"
}
if c.Action == "update" && agent == "antigravity-cli" {
skip("plugins.skip.keepEnablement", "Update in Antigravity CLI to preserve native enablement; automatic reinstall updates are not supported.", map[string]string{"agent": "Antigravity CLI"})
}
// pi update keeps an npm package pinned to an exact version.
if version := pinnedNpm(c.ID); c.Action == "update" && agent == "pi" && version != "" {
skip("plugins.skip.npmPinned", fmt.Sprintf("Pinned to %s; to use another version, add the package again with that version.", version), map[string]string{"version": version})
}
// pi update has no project scope, and OpenCode v1 has no update command. omp's upgrade
// would reinstall whatever the native marketplace holds, which Skillshare never reviewed.
if c.Action == "update" && c.Binding.Source == "" && (s.ProjectRoot != "" && agent == "pi" || agent == "omp") || c.Action == "update" && c.Binding.Source == "" && agent == "opencode" && (s.ProjectRoot != "" || !strings.HasPrefix(strings.TrimPrefix(h.Version, "v"), "2.")) {
skip("plugins.skip.imported", "Update imported packages in the native client; Skillshare updates reviewed source snapshots only.", nil)
}
if c.Action == "update" && agent == "opencode" && c.Binding.Source == "" {
help, err := s.run(ctx, "opencode", "plugin", "update", "--help")
if err != nil || !strings.Contains(string(help), "update") {
skip("plugins.skip.opencodeNoUpdate", "Installed OpenCode does not expose a verified plugin update command.", nil)
}
}
if c.Binding.Source == "" && commandTarget(agent) && c.Action == "install" {
c.Action = "blocked"
c.Message = "This imported plugin has no reviewed reinstall source; install or update in the native client."
}
if c.Binding.Source == "" && commandTarget(agent) && c.Action == "update" {
skip("plugins.skip.imported", "This imported plugin has no reviewed reinstall source; update it in the native client.", nil)
}
if c.Action == "update" && agent == "copilot" {
for _, item := range h.Installed {
if item.ID == c.ID && (!item.EnabledKnown || !item.Enabled) {
skip("plugins.skip.keepEnablement", "Update in Copilot to preserve native enablement.", map[string]string{"agent": "GitHub Copilot CLI"})
}
}
}
if c.Action == "update" && agent == "codex" && c.Binding.Source == "" {
// An imported plugin comes from a Codex marketplace, which Codex upgrades together
// with every plugin installed from it, as it also does when it starts.
_, market, _ := strings.Cut(c.ID, "@")
help, err := s.run(ctx, c.Target, "plugin", "marketplace", "--help")
if err != nil || !strings.Contains(string(help), "upgrade") {
skip("plugins.skip.codexNoUpgrade", "Installed Codex cannot upgrade marketplaces; update the plugin in Codex.", nil)
} else {
c.Message = fmt.Sprintf("Upgrades the Codex marketplace %s, which reinstalls every plugin installed from it.", market)
c.MessageKey, c.MessageArgs = "plugins.note.codexUpgrade", map[string]string{"market": market}
}
}
if c.Action == "update" && agent == "codex" && c.Binding.Source != "" {
for _, item := range h.Installed {
// Codex's add, which updates the plugin, always enables it.
if item.ID == c.ID && !item.Enabled {
skip("plugins.skip.codexDisabled", "Enable the plugin in Codex before updating it; updating would turn it back on.", nil)
}
}
}
// Skips above are not native commands; what is left for omp must not destroy a shared cache.
if agent == "omp" && h.Error == "" {
ompGuard(h, &c)
if c.Action == "install" {
s.prepareOMPInstall(ctx, h, &c)
}
if c.Action == "remove" || c.Action == "uninstall" || c.Action == "forget" {
s.prepareOMPRemoval(h, &c)
}
}
if c.Action == "blocked" {
p.Blocked = true
}
p.Changes = append(p.Changes, c)
}
find := func(target, id string) (Installed, bool) {
for _, i := range host(target).Installed {
if i.ID == id {
return i, true
}
}
return Installed{}, false
}
if r.Action == "add" && isNpmSource(r.Source) {
name := r.Name
if name == "" {
if name = logicalName(r.Source); name == "" {
return nil, fmt.Errorf("use --name to choose a package name for this npm source")
}
}
others := []string{}
for other := range d.packages {
if other != name {
others = append(others, other)
}
}
slices.Sort(others)
for _, target := range slices.Compact(slices.Sorted(slices.Values(r.Targets))) {
owner := ""
for _, other := range others {
if b, ok := d.packages[other].Bindings[target]; ok && sameNpmPackage(b.ID, r.Source) {
owner = other
break
}
}
old, bound := d.packages[name].Bindings[target]
c := s.npmChange(name, target, r.Source, owner, old, bound, host(target).Installed)
// An adopted entry with resource filters keeps them, as an import does. Installing
// another version over one keeps them too, so its new entry is recorded after the install.
filtered := func(id string) bool {
return slices.ContainsFunc(host(target).Installed, func(i Installed) bool { return i.Filtered && (i.ID == id || sameNpmPackage(i.ID, id)) })
}
if c.Action == "import" && filtered(c.ID) {
if err := s.preparePiRegistration(ctx, &c); err != nil {
c.Action, c.Message = "blocked", err.Error()
}
}
c.piRecordAfter = c.Action == "install" && filtered(c.ID)
appendChange(c)
}
} else if r.Action == "add" {
discovered, err := DiscoverOptions(ctx, r.Source, r.SourceRef, r.Entry)
if err != nil {
return nil, err
}
var candidate *Candidate
for _, c := range discovered.Candidates {
if c.Name == r.Plugin || (r.Plugin == "" && len(discovered.Candidates) == 1) {
cc := c
candidate = &cc
break
}
}
if candidate == nil {
return nil, fmt.Errorf("choose a plugin from this source using --plugin")
}
c := *candidate
name := r.Name
if name == "" {
name = c.Name
}
pack, exists := d.packages[name]
// The recorded source is where Agents are bound from later. It does not stop one Agent
// from using another distribution under the same name.
otherSource := pack.Source != "" && (pack.Source != discovered.Source || pack.Plugin != c.Name || pack.SourceRef != discovered.SourceRef)
if len(r.Targets) == 0 {
// Only record the package; Agents are bound later from the same source.
change := Change{Name: name, Action: "record", Components: c.Components, Message: "Add to Skillshare only; choose Agents later.", Binding: Binding{Source: discovered.Source, SourceRef: discovered.SourceRef, Plugin: c.Name, Entry: r.Entry, Version: c.Version}}
if slices.Contains(c.Targets, "codex") {
change.Logo = c.TargetInfo["codex"].Logo
}
if c.Problem != "" || len(c.Targets) == 0 {
change.Action = "blocked"
change.Message = c.Problem
if change.Message == "" {
change.Message = "No Agent can use this plugin."
}
} else if otherSource {
change.Action = "blocked"
change.Message = "Package already uses a different source; choose another name or remove it first."
} else if exists {
change.Action = "noop"
}
p.Blocked = change.Action == "blocked"
p.Changes = append(p.Changes, change)
}
for _, target := range slices.Compact(slices.Sorted(slices.Values(r.Targets))) {
agent := s.agentOf(target)
// Name the plugin so native marketplace lists show what Skillshare added.
digest := hash([]byte(s.ConfigPath + "\x00" + discovered.Source + "\x00" + c.Name + "\x00" + target))[:16]
market := "skillshare-" + marketUnsafe.ReplaceAllString(c.Name, "-") + "-" + digest
b := Binding{ID: c.Name + "@" + market, Source: discovered.Source, SourceRef: discovered.SourceRef, Commit: discovered.Commit, Plugin: c.Name, Digest: discovered.Digest, Version: c.TargetInfo[agent].Version, Components: c.TargetInfo[agent].Components}
switch agent {
case "cursor", "antigravity", "antigravity-cli", "copilot", "grok", "kimi", "hermes", "devin":
b.ID = c.Name
case "omp":
// omp caps marketplace names at 64 characters, so the plugin name is left out.
b.ID = c.Name + "@skillshare-" + digest
case "pi":
b.ID = filepath.Join(s.snapshotPath(b, target), "content", filepath.FromSlash(c.pathFor(agent)))
case "opencode":
b.Entry = c.Entry
b.ID = fileURL(filepath.Join(s.snapshotPath(b, target), "content", filepath.FromSlash(c.pathFor(agent)), c.Entry))
}
change := Change{Name: name, Target: target, ID: b.ID, Binding: b, Action: "install", Components: b.Components}
if c.Problem != "" || !slices.Contains(c.Targets, agent) {
change.Action = "blocked"
change.Message = c.Problem
if info, ok := c.TargetInfo[agent]; ok && info.Problem != "" {
change.Message = info.Problem
}
if change.Message == "" {
change.Message = "No native manifest for this target; plugin components will not be silently converted or omitted."
}
}
if old, ok := d.packages[name].Bindings[target]; ok {
if old.Source == b.Source && old.Plugin == b.Plugin && old.SourceRef == b.SourceRef {
change.Binding = old
change.ID = old.ID
if _, ok := find(target, old.ID); ok {
change.Action = "noop"
}
} else {
change.Action = "blocked"
change.Message = "Package already has a different binding for this target; choose another name or remove it first."
}
}
if c.Marketplace != "" && change.Action == "install" {
if native, ok := find(target, c.Name+"@"+c.Marketplace); ok {
change.Action = "import"
change.ID = native.ID
change.Binding = Binding{ID: native.ID, Version: native.Version}
change.Message = "Already installed natively; adopt without reinstalling."
}
}
if _, ok := find(target, change.ID); ok && change.Action == "install" {
change.Action = "blocked"
change.Message = "A native installation already uses this identity; import it explicitly instead of replacing it."
}
appendChange(change)
}
} else if r.Action == "import" {
installed, ok := find(r.From, r.Plugin)
if !ok {
return nil, fmt.Errorf("plugin is not installed in this scope, or native inventory is unavailable")
}
name := r.Name
if name == "" {
name = installed.Name
if name == "" {
name, _, _ = strings.Cut(installed.ID, "@")
}
if !namePattern.MatchString(name) {
return nil, fmt.Errorf("use --name to choose a logical package name for this native identifier")
}
}
if agent := s.agentOf(r.From); agent == "cursor" || agent == "antigravity" {
return nil, fmt.Errorf("Local directory plugins can be added from source; importing existing or marketplace installations is not supported")
}
if installed.Filtered && s.agentOf(r.From) != "pi" {
return nil, fmt.Errorf("this native entry has resource filters or options; manage it in the native client to preserve those settings")
}
b := Binding{ID: installed.ID, Version: installed.Version}
if old, ok := d.packages[name].Bindings[r.From]; ok {
if old.ID != b.ID {
return nil, fmt.Errorf("package already manages a different plugin")
}
b = old
}
change := Change{Name: name, Target: r.From, ID: b.ID, Binding: b, Action: "import", Message: "Record the existing native installation; leave its content and enabled state unchanged."}
if installed.Filtered {
if err := s.preparePiRegistration(ctx, &change); err != nil {
return nil, err
}
}
appendChange(change)
} else {
if r.Name != "" {
if _, ok := d.packages[r.Name]; !ok {
return nil, fmt.Errorf("plugin package %q not found", r.Name)
}
}
names := make([]string, 0, len(d.packages))
for name := range d.packages {
names = append(names, name)
}
slices.Sort(names)
discoveries := map[string]*Discovery{}
latests := map[string][]int{}
for _, name := range names {
if r.Name != "" && r.Name != name {
continue
}
for _, target := range s.targets() {
b, ok := d.packages[name].Bindings[target]
if !ok || (len(r.Targets) > 0 && !slices.Contains(r.Targets, target)) {
continue
}
agent := s.agentOf(target)
c := Change{Name: name, Target: target, ID: b.ID, Binding: b, Action: r.Action}
_, exists := find(target, b.ID)
switch r.Action {
case "sync":
if !b.Selected() {
c.Action = "uninstall"
if !exists && !ownMarket(target, b) && agent != "omp" {
c.Action = "noop"
}
break
}
c.Action = b.Pending
if c.Action == "" {
c.Action = "install"
if exists {
c.Action = "noop"
}
}
if c.Action == "install" && exists && b.PiRegistration == "" {
c.Action = "noop"
}
if c.Action == "remove" && !exists && host(target).Error == "" && !mayOwnMarket(target, b) {
c.Action = "forget"
}
if c.Action == "install" && b.Source == "" {
c.Message = "Reinstall using its existing native marketplace."
}
case "remove":
if !exists && host(target).Error == "" && !mayOwnMarket(target, b) {
c.Action = "forget"
}
case "enable", "disable":
selected := r.Action == "enable"
c.Binding.Sync = &selected
c.Binding.Pending = ""
c.Action = "selection"
c.Message = "Save sync selection only. Run sync to install or remove this managed target."
case "check", "update":
if !b.Selected() {
c.Action = "noop"
break
}
if b.Source == "" {
// An npm package has no source snapshot to compare; npm names its latest version instead.
installed, latest := s.npmVersions(ctx, target, b.ID, host(target), latests)
known := installed != nil && latest != nil
if known && slices.Compare(latest, installed) <= 0 {
c.Action = "noop"
break
}
if r.Action != "check" {
// No version is recorded: what Pi installed is read back from the package each time.
break
}
if known {
c.Action = "update-available"
c.Binding.Version = fmt.Sprintf("%d.%d.%d", latest[0], latest[1], latest[2])
break
}
c.Action = "native-check"
c.Message, c.MessageKey = "Imported installation: use the native marketplace to check releases.", "plugins.note.nativeCheck"
break
}
ref := b.SourceRef
if r.SourceRef != "" {
ref = r.SourceRef
}
discoveryKey := b.Source + "\x00" + ref + "\x00" + b.Entry
disc := discoveries[discoveryKey]
if disc == nil {
disc, err = DiscoverOptions(ctx, b.Source, ref, b.Entry)
if err != nil {
return nil, err
}
discoveries[discoveryKey] = disc
}
var candidate *Candidate
for _, x := range disc.Candidates {
if x.Name == b.Plugin {
xx := x
candidate = &xx
}
}
if candidate == nil {
return nil, fmt.Errorf("plugin %s no longer exists in source", b.Plugin)
}
if candidate.Problem != "" || !slices.Contains(candidate.Targets, agent) {
c.Action = "blocked"
c.Message = "Updated source no longer provides a compatible native plugin"
break
}
c.Components = candidate.TargetInfo[agent].Components
if disc.Digest == b.Digest && b.Pending == "" && ref == b.SourceRef {
c.Action = "noop"
} else if r.Action == "check" {
c.Action = "update-available"
c.Message, c.MessageKey = "Source content changed; review an update before applying.", "plugins.note.sourceChanged"
// Check is read-only; the binding carries the source's version, commit and digest so the change can show
// old → new and a later update can tell whether the source moved again since.
c.Binding.Version = candidate.TargetInfo[agent].Version
c.Binding.Commit = disc.Commit
c.Binding.Digest = disc.Digest
} else {
c.Binding.Digest = disc.Digest
c.Binding.Commit = disc.Commit
c.Binding.SourceRef = disc.SourceRef
c.Binding.Version = candidate.TargetInfo[agent].Version
c.Binding.Components = candidate.TargetInfo[agent].Components
}
}
if (c.Action == "uninstall" || c.Action == "remove") && !exists && ownMarket(target, b) {
c.Message, c.MessageKey = "The plugin is already gone; remove the marketplace Skillshare registered for it.", "plugins.note.marketplaceCleanup"
}
if c.Action == "install" && b.Source == "" && (agent == "antigravity" || agent == "cursor") {
c.Action = "blocked"
c.Message = "Imported installation has no reinstall source; install it in the native client, then sync again."
}
if c.Action == "forget" && agent != "omp" || c.Action == "selection" {
p.Changes = append(p.Changes, c)
} else {
appendChange(c)
}
}
if r.Action == "remove" && len(r.Targets) == 0 && len(d.packages[name].Bindings) == 0 {
p.Changes = append(p.Changes, Change{Name: name, Action: "forget", Message: "Remove from Skillshare; no Agent has it."})
}
}
}
// A native installation can have only one owner in this configuration.
for i := range p.Changes {
c := &p.Changes[i]
if c.Target == "" {
continue
}
for name, pack := range d.packages {
if name != c.Name && pack.Bindings[c.Target].ID == c.ID {
c.Action = "blocked"
c.Message = "This native plugin is already managed by package " + name
p.Blocked = true
}
}
}
// Bind previews to source bytes, selected operations, native versions/inventory,
// and config bytes. A changed selection or external edit invalidates approval.
ompRoots := map[string]string{}
for target, host := range hosts {
if host.ompCacheRoot != "" {
ompRoots[target] = host.ompCacheRoot
}
}
ompRemovals := map[string]string{}
ompRuntimePaths := map[string]string{}
for _, c := range p.Changes {
if c.ompRuntimePath != "" {
ompRuntimePaths[c.Target+"\x00"+c.ID] = c.ompRuntimePath
}
if c.ompRemoval != nil {
ompRemovals[c.Target+"\x00"+c.ID] = c.ompRemoval.revision
}
}
fingerprint, _ := json.Marshal(struct {
Request Request
Raw string
Changes []Change
Hosts map[string]Host
OMPCacheRoots map[string]string
OMPRemovals map[string]string
OMPRuntimePaths map[string]string
}{r, string(d.raw), p.Changes, hosts, ompRoots, ompRemovals, ompRuntimePaths})
p.Revision = hash(fingerprint)
return p, nil
}