Files
skillshare/internal/plugin/service.go
T
Willie a996a5bbfd feat(plugin): show version and Codex logo for plugins with no Agent
A plugin added without choosing an Agent has no binding, so the
dashboard had nowhere to read its version from and always drew the
default icon.

Record the source version on the package when it is added, and let
rows without one ask their source once. Read interface.logo from the
Codex manifest (inside the plugin, image types, 256KB max) and draw
it in the list and in the add preview, falling back to the default
icon.
2026-09-29 11:25:50 +08:00

425 lines
15 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 == "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
}
appendChange := func(c Change) {
h := host(c.Target)
agent := s.agentOf(c.Target)
if h.Error != "" {
c.Action = "blocked"
c.Message = h.Error
}
if c.Action != "blocked" && c.Action != "noop" && 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()
}
}
if c.Action == "update" && agent == "antigravity-cli" {
c.Action = "blocked"
c.Message = "Update in Antigravity CLI to preserve native enablement; automatic reinstall updates are not supported."
}
if c.Action == "update" && c.Binding.Source == "" && (agent == "pi" || (agent == "opencode" && (s.ProjectRoot != "" || !strings.HasPrefix(strings.TrimPrefix(h.Version, "v"), "2.")))) {
c.Action = "blocked"
c.Message = "Update imported packages in the native client; Skillshare updates reviewed source snapshots only."
}
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") {
c.Action = "blocked"
c.Message = "Installed OpenCode does not expose a verified plugin update command."
}
}
if c.Binding.Source == "" && commandTarget(agent) && (c.Action == "install" || c.Action == "update") {
c.Action = "blocked"
c.Message = "This imported plugin has no reviewed reinstall source; install or update in the native client."
}
if c.Action == "update" && agent == "copilot" {
for _, item := range h.Installed {
if item.ID == c.ID && (!item.EnabledKnown || !item.Enabled) {
c.Action = "blocked"
c.Message = "Update in Copilot to preserve native enablement."
}
}
}
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" {
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)
market := "skillshare-" + hash([]byte(s.ConfigPath + "\x00" + discovered.Source + "\x00" + c.Name + "\x00" + target))[:16]
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 "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 {
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
}
appendChange(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."})
} 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{}
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 {
c.Action = "noop"
}
break
}
c.Action = b.Pending
if c.Action == "" {
c.Action = "install"
if exists {
c.Action = "noop"
}
}
if c.Action == "install" && exists {
c.Action = "noop"
}
if c.Action == "remove" && !exists && host(target).Error == "" {
c.Action = "forget"
}
if c.Action == "install" && b.Source == "" {
c.Message = "Reinstall using its existing native marketplace."
}
case "remove":
if !exists && host(target).Error == "" {
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 == "" {
if r.Action == "check" {
c.Action = "native-check"
c.Message = "Imported installation: use the native marketplace to check releases."
}
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 = "Source content changed; review an update before applying."
// Check is read-only; the binding carries the source's version so the change can show old → new.
c.Binding.Version = candidate.TargetInfo[agent].Version
} 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 == "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" || 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.
fingerprint, _ := json.Marshal(struct {
Request Request
Raw string
Changes []Change
Hosts map[string]Host
}{r, string(d.raw), p.Changes, hosts})
p.Revision = hash(fingerprint)
return p, nil
}