mirror of
https://github.com/runkids/skillshare.git
synced 2026-11-19 02:17:09 +00:00
* fix(plugins): honor native OMP marketplace builds Resolve OMP entries from their native marketplace when present and inspect package.json extension-only plugins. Keep target-specific source paths, marketplace identities and components so Claude adoption and hybrid manifests remain valid.\n\nShow separate builds in text discovery without changing logical JSON selection, and cover native precedence, invalid catalogs, manifestless and hybrid packages, global/project materialization and CLI output with regression tests. Update the plugin docs and existing translations.\n\nFixes #587 * fix(plugins): preserve native build metadata across consumers Keep OMP catalog versions in target discovery metadata and materialized marketplace entries so previews, cache guards, and native installs use the same version, including legacy catalog fallback. Cover catalog versions that differ from package manifests. Show each dashboard discovery target's own version, components, and source path instead of presenting a merged candidate as one build. * fix(plugins): avoid ambiguous shared build versions Derive candidate versions from agreement across supported targets and recompute after catalog overrides. No-Agent records and lists no longer inherit an arbitrary native build version; equal versions remain available and unknown versions stay unknown. Keep Cursor and Antigravity inventory target-specific when manifests disagree. Cover no-Agent preview and persistence, equal and unknown versions, catalog overrides, and mixed-manifest local inventories. Align English and translated plugin references. * fix(plugins): accept Pi extension manifests for OMP catalogs Reuse the existing OMP extension detector instead of requiring an OMP-specific manifest key. Native OMP accepts Pi extension manifests too, so the extra gate rejected supported native catalog entries. Cover Pi-only discovery with scoped package names and global/project materialization. Align the English plugin references and all existing translations.
614 lines
25 KiB
Go
614 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 != "" || !openCode2(h.Version)) {
|
|
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 market := c.TargetInfo[agent].Marketplace; market != "" && change.Action == "install" {
|
|
if native, ok := find(target, c.Name+"@"+market); 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")
|
|
}
|
|
// An import follows what is installed; a source binding keeps the version Skillshare reviewed.
|
|
if old.Source == "" {
|
|
old.Version = installed.Version
|
|
}
|
|
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 := s.discoveries
|
|
if discoveries == nil {
|
|
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
|
|
}
|