mirror of
https://github.com/runkids/skillshare.git
synced 2026-11-18 18:04:17 +00:00
* 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>
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, 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
|
|
}
|