Files
skillshare/internal/plugin/service.go
T
Krishnaswamy SubramanianandWillie dabe06a297 feat(targets): support OpenCode config directory accounts (#594)
* feat(targets): support OpenCode config directory accounts

OpenCode v2 introduces support for custom configuration directories
via OPENCODE_CONFIG_DIR, storing opencode.json and agent directories.

Previously, skillshare rejected OpenCode accounts configured with a
custom config directory because OpenCode was missing config_dir and
was excluded from accountAgents in hooks and MCP services.

- Define default config_dir (~/.config/opencode) in targets.yaml
- Add OpenCode to account agents and register OPENCODE_CONFIG_DIR
  across hooks and MCP service handlers
- Route OpenCode account MCP configuration to opencode.json inside
  the account config directory

Resolves #593.

* fix(targets): add OpenCode to schemas, completions and docs

Add opencode to the targetConfig.agent enum and config_dir description
in schemas/config.schema.json so configurations containing OpenCode
account targets pass schema validation.

Include opencode in the target --agent completion scripts for Bash,
Zsh, Fish, PowerShell, and Nushell.

Update website documentation and built-in skill references to describe
OpenCode accounts and OPENCODE_CONFIG_DIR management alongside other
account agents.

* fix(targets): support plugin accounts and overlap

Add OpenCode account recognition and OPENCODE_CONFIG_DIR resolution to
the plugin service so plugin sync works for OpenCode account targets.

Introduce TargetScanPaths to resolve cross-runtime scan paths using
TargetConfig.Agent for account targets while retaining the account's
own primary directory. Update path overlap detection, doctor checks,
and LeakedSkills to warn about leaked skills for account targets.

Update localized docs (zh-Hans, zh-Hant, ja, ko) and plugin references
to document OpenCode account targets and OPENCODE_CONFIG_DIR. Update
the available targets handler test to expect OpenCode's configDir.

* fix(targets): isolate OpenCode accounts and scan paths

Reject OPENCODE_CONFIG overrides when operating on OpenCode accounts
and clear OPENCODE_CONFIG in the account execution environment so
plugin operations target the account directory.

In TargetScanPaths, remap config-root paths to the account directory
while preserving external scan paths like Codex's ~/.agents/skills.

* fix(plugins): use account target in OpenCode update probe

Pass c.Target instead of a hardcoded "opencode" when probing whether
OpenCode supports plugin updates, ensuring account-configured CLI
binaries and account environment variables are used during preview.

* test(mcp): isolate XDG_CONFIG_HOME in account test service

Isolate XDG_CONFIG_HOME to the temporary test directory in
agentAccountService to prevent runner environment variables from leaking
into TestAccountEnvOverrideDoesNotPruneDefaultHome when testing OpenCode
account shell overrides.

---------

Co-authored-by: Willie <egg358358@gmail.com>
2026-10-22 21:50:06 +08:00

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, c.Target, "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
}